টেন্সরফ্লো চিটশিট

import tensorflow as tf
 
# কনস্ট্যান্ট টেন্সর
a = tf.constant([[1, 2], [3, 4]])
print(a)
 
# ভেরিয়েবল টেন্সর
b = tf.Variable([1.0, 2.0])
print(b)

c = tf.add(a, a)  # যোগ
d = tf.matmul(a, a)  # ম্যাট্রিক্স গুণ
print(c, d)

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(10,)),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])
 
model.summary()

inputs = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
x = tf.keras.layers.Dense(32, activation='relu')(x)
outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
 
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model.summary()

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
 
# নরমালাইজেশন
x_train = x_train / 255.0
x_test = x_test / 255.0

dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

history = model.fit(
    x_train, y_train,
    epochs=10,
    batch_size=32,
    validation_data=(x_test, y_test)
)

loss, accuracy = model.evaluate(x_test, y_test)
print(f"টেস্ট নির্ভুলতা: {accuracy}")

class MyLayer(tf.keras.layers.Layer):
    def __init__(self, units):
        super(MyLayer, self).__init__()
        self.units = units
 
    def build(self, input_shape):
        self.kernel = self.add_weight("kernel", shape=[input_shape[-1], self.units])
 
    def call(self, inputs):
        return tf.matmul(inputs, self.kernel)
 
model = tf.keras.Sequential([MyLayer(64)])

optimizer = tf.keras.optimizers.Adam()
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()
 
@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        predictions = model(x, training=True)
        loss = loss_fn(y, predictions)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss
 
for epoch in range(5):
    for x_batch, y_batch in dataset:
        loss = train_step(x_batch, y_batch)
    print(f"ইপক {epoch}: লস = {loss}")

# সেভ
model.save('my_model')
 
# লোড
loaded_model = tf.keras.models.load_model('my_model')
 
# প্রেডিকশন
predictions = loaded_model.predict(x_test)

from tensorflow.keras.callbacks import TensorBoard
 
tensorboard = TensorBoard(log_dir='logs')
model.fit(x_train, y_train, epochs=10, callbacks=[tensorboard])
 
# TensorBoard চালানো
# tensorboard --logdir logs

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D((2, 2)),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])
 
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train.reshape(-1, 28, 28, 1), y_train, epochs=5)

model = tf.keras.Sequential([
    tf.keras.layers.LSTM(50, input_shape=(10, 1), return_sequences=True),
    tf.keras.layers.LSTM(50),
    tf.keras.layers.Dense(1)
])
 
model.compile(optimizer='adam', loss='mse')

import numpy as np
 
data = np.random.random((100, 10))
labels = np.random.randint(0, 2, (100,))
 
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32).shuffle(100).repeat()
 
model.fit(dataset, epochs=10, steps_per_epoch=3)

# মডেল কনভার্ট
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
 
# ফাইলে সেভ
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

import tensorflow as tf
from tensorflow.keras import layers
 
# ডেটা লোড
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
 
# মডেল তৈরি
model = tf.keras.Sequential([
    layers.Flatten(input_shape=(28, 28)),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])
 
# কম্পাইল
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
 
# ট্রেনিং
model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))
 
# ইভালুয়েশন
loss, acc = model.evaluate(x_test, y_test)
print(f"টেস্ট নির্ভুলতা: {acc}")
 
# প্রেডিকশন
predictions = model.predict(x_test[:5])
print("প্রথম ৫টি প্রেডিকশন:", tf.argmax(predictions, axis=1))