বাস্তব উদাহরণ এবং প্রজেক্ট ডেমো

থিয়ানো (Theano) দিয়ে মডেল টিউনিং এর বাস্তব উদাহরণ এবং প্রজেক্ট ডেমো তৈরি করা যেতে পারে যা ডিপ লার্নিং বা মেশিন লার্নিং ক্ষেত্রে বেশ উপকারী। আমি এখানে একটি নিউরাল নেটওয়ার্ক তৈরি এবং মডেল টিউনিং প্রক্রিয়া দেখাব, যেখানে আপনি থিয়ানো ব্যবহার করে লিনিয়ার রিগ্রেশন বা লস ফাংশন অপটিমাইজেশন করতে পারবেন।

বাস্তব উদাহরণ: লিনিয়ার রিগ্রেশন মডেল টিউনিং

এটি একটি লিনিয়ার রিগ্রেশন মডেল যেখানে ইনপুট এবং টার্গেট আউটপুট এর মধ্যে সম্পর্ক শিখে, আমরা সঠিক গ্রেডিয়েন্ট বের করে মডেলটিকে টিউন করতে পারব।

১. থিয়ানো ইনস্টলেশন:

এটি নিশ্চিত করতে হবে যে Theano আপনার সিস্টেমে ইনস্টল করা আছে। যদি না থাকে, তাহলে এটি ইনস্টল করতে:

pip install theano

২. মডেল তৈরি করা (লিনিয়ার রিগ্রেশন):

এটি একটি সিম্পল লিনিয়ার রিগ্রেশন মডেল, যেখানে আমরা একটি ইনপুট (X) থেকে আউটপুট (Y) অনুমান করার চেষ্টা করব। এখানে W (ওজন) এবং b (বায়াস) হল আমাদের মডেলের প্যারামিটার।

import theano
import theano.tensor as T
import numpy as np

# ইনপুট ভেরিয়েবল তৈরি
x = T.dmatrix('x')  # ইনপুট ফিচার
y = T.dmatrix('y')  # টার্গেট আউটপুট

# মডেলের প্যারামিটার (ওজন এবং বায়াস)
W = theano.shared(np.random.randn(1), name="W")
b = theano.shared(np.random.randn(1), name="b")

# লিনিয়ার রিগ্রেশন মডেল
output = T.dot(x, W) + b

# লস ফাংশন (Mean Squared Error)
loss = T.mean((y - output)**2)

# গ্রেডিয়েন্ট বের করা
grad_W = T.grad(loss, W)
grad_b = T.grad(loss, b)

# গ্রেডিয়েন্ট ডেসেন্ট আপডেট
learning_rate = 0.01
update_W = W - learning_rate * grad_W
update_b = b - learning_rate * grad_b

# মডেল ফাংশন তৈরি করা
train_model = theano.function(
    inputs=[x, y], 
    outputs=loss, 
    updates=[(W, update_W), (b, update_b)]
)

৩. ডেটা প্রস্তুতি:

এখন, আমাদের কিছু ডেটা তৈরি করতে হবে। এটি খুব সাধারণ একটি ডেটাসেট যেখানে আমরা এক্স (input features) এবং ওয়াই (target outputs) তৈরি করব।

# ডেটাসেট তৈরি
x_data = np.array([[1], [2], [3], [4], [5]])  # ইনপুট ফিচার
y_data = np.array([[2], [4], [6], [8], [10]])  # টার্গেট আউটপুট

৪. মডেল প্রশিক্ষণ করা:

এখন, train_model ফাংশন ব্যবহার করে আমাদের মডেল প্রশিক্ষণ করতে হবে।

# মডেল প্রশিক্ষণ
for epoch in range(1000):  # 1000 এপোচে প্রশিক্ষণ করা
    loss_value = train_model(x_data, y_data)  # মডেল ট্রেনিং
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {loss_value}")

৫. মডেল টিউনিং (Hyperparameter Tuning):

এখানে, আমরা হাইপারপ্যারামিটার টিউনিং করবো, যেমন লার্নিং রেট এবং এপোচ সংখ্যা এর বিভিন্ন মান পরীক্ষা করে দেখতে পারি যে কোনটি সবচেয়ে ভালো পারফর্ম করে।

learning_rates = [0.1, 0.01, 0.001]
epochs = [500, 1000, 1500]

for lr in learning_rates:
    for ep in epochs:
        print(f"Training with Learning Rate: {lr} and Epochs: {ep}")
        
        # লিনিয়ার রিগ্রেশন মডেল টিউনিং
        W.set_value(np.random.randn(1))
        b.set_value(np.random.randn(1))
        
        for epoch in range(ep):
            loss_value = train_model(x_data, y_data)
            if epoch % 100 == 0:
                print(f"Epoch {epoch}, Loss: {loss_value}")

৬. ফলাফল মূল্যায়ন:

এখন, আমরা প্রশিক্ষণের পর মডেলের প্যারামিটার (ওজন এবং বায়াস) দেখে নিতে পারি।

# প্রশিক্ষণ শেষে ওজন এবং বায়াস দেখা
print(f"Trained W: {W.get_value()}")
print(f"Trained b: {b.get_value()}")

৭. প্রেডিকশন করা:

মডেল প্রশিক্ষিত হওয়ার পর, আপনি নতুন ইনপুটের জন্য প্রেডিকশন করতে পারবেন:

# নতুন ইনপুটের জন্য প্রেডিকশন
new_input = np.array([[6]])
predicted_output = (new_input.dot(W.get_value())) + b.get_value()
print(f"Predicted output for input {new_input}: {predicted_output}")

সারাংশ:

এই প্রজেক্টটি থিয়ানো দিয়ে লিনিয়ার রিগ্রেশন মডেল তৈরি এবং হাইপারপ্যারামিটার টিউনিং এর একটি বাস্তব উদাহরণ। এখানে গ্রেডিয়েন্ট ডেসেন্ট পদ্ধতি ব্যবহার করে লস ফাংশন (Mean Squared Error) অপটিমাইজ করা হয়েছে এবং লিনিয়ার রিগ্রেশন মডেলটি প্রশিক্ষণ করা হয়েছে। এছাড়াও, লার্নিং রেট এবং এপোচ সংখ্যা টিউন করা হয়েছে।

এই পদ্ধতিটি ডিপ লার্নিং মডেল টিউনিং এর জন্য খুবই কার্যকরী এবং Theano ব্যবহার করে বিভিন্ন মডেলেও এই পদ্ধতি প্রয়োগ করা যেতে পারে।

CNN (Convolutional Neural Networks) এবং RNN (Recurrent Neural Networks) দুটি শক্তিশালী নিউরাল নেটওয়ার্ক আর্কিটেকচার যা বিভিন্ন ধরণের ডেটা (যেমন চিত্র এবং সিকুয়েন্স ডেটা) মডেল করতে ব্যবহৃত হয়।

এখানে আমরা Image Data এবং Sequence Data এর জন্য CNN এবং RNN ব্যবহার করে মডেল তৈরি করার জন্য উদাহরণ দেখাবো।

১. CNN দিয়ে Image Data মডেল তৈরি:

CNN (Convolutional Neural Networks) বিশেষভাবে চিত্র (Image) ডেটা মডেল করার জন্য ডিজাইন করা হয়েছে। এটি বিভিন্ন কনভোলিউশনাল লেয়ার ব্যবহার করে ইনপুট চিত্রের বৈশিষ্ট্য বের করে এবং ফিচার ম্যাপ তৈরি করে।

CNN মডেল তৈরি করার ধাপ:

1. Data Preprocessing:
   • ডেটা প্রিপ্রসেসিং এর মধ্যে চিত্র আকার সমন্বয়, স্কেলিং এবং নরমালাইজেশন অন্তর্ভুক্ত।
2. Model Definition:
   • কনভোলিউশনাল লেয়ার, পুলিং লেয়ার এবং ডেন্স লেয়ার ব্যবহার করে মডেল তৈরির প্রক্রিয়া।
3. Compile and Train the Model:
   • মডেল কম্পাইল করা, হার্বল ফাংশন সেট করা এবং মডেলটি প্রশিক্ষিত করা।

Example (CNN for Image Classification using Keras):

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from keras.datasets import cifar10
from keras.utils import to_categorical

# ডেটা লোড এবং প্রিপ্রসেসিং
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # Normalize images to [0, 1]
y_train, y_test = to_categorical(y_train, 10), to_categorical(y_test, 10)

# মডেল তৈরি
model = Sequential()

# কনভোলিউশনাল লেয়ার
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))

# আরেকটি কনভোলিউশনাল লেয়ার
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# ফ্ল্যাটেন লেয়ার
model.add(Flatten())

# ডেন্স লেয়ার
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))  # 10 কেটেগরি

# মডেল কম্পাইল
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# মডেল প্রশিক্ষণ
model.fit(x_train, y_train, epochs=10, batch_size=64, validation_data=(x_test, y_test))

# মডেল মূল্যায়ন
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc}")

Explanation:

• Conv2D: এটি একটি কনভোলিউশনাল লেয়ার যা চিত্রের বৈশিষ্ট্য বের করে।
• MaxPooling2D: এটি পুলিং অপারেশন যা চিত্রের রেজল্যুশন কমিয়ে আনে।
• Flatten: এটি 2D আউটপুটকে 1D আউটপুটে রূপান্তরিত করে ডেন্স লেয়ারকে ইনপুট হিসেবে দেয়।
• Dense: একটি সাধারণ ডেন্স লেয়ার যা ফাইনাল আউটপুট (softmax) প্রদান করে।

এই মডেলটি CIFAR-10 ডেটাসেটের ১০টি কেটেগরি চিত্র শ্রেণীবিভাগের জন্য প্রশিক্ষিত হবে।

২. RNN দিয়ে Sequence Data মডেল তৈরি:

RNN (Recurrent Neural Networks) সাধারণত সিকুয়েন্স ডেটা (যেমন টেক্সট, সময়ের সাথে পরিবর্তিত ডেটা, বা সিকুয়েন্স) মডেল করার জন্য ব্যবহৃত হয়। RNN তার পূর্ববর্তী স্টেট (hidden state) ব্যবহার করে সিকুয়েন্সের তথ্য শিখতে পারে।

RNN মডেল তৈরি করার ধাপ:

1. Data Preprocessing:
   • সিকুয়েন্স ডেটার জন্য টোকেনাইজেশন এবং প্যাডিং।
2. Model Definition:
   • RNN, LSTM (Long Short-Term Memory), বা GRU (Gated Recurrent Unit) লেয়ার ব্যবহার।
3. Compile and Train the Model:
   • মডেল কম্পাইল এবং ট্রেনিং প্রক্রিয়া।

Example (RNN for Text Classification using Keras):

from keras.models import Sequential
from keras.layers import SimpleRNN, Embedding, Dense
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split

# সিকুয়েন্স ডেটা প্রস্তুতি (উদাহরণ হিসেবে কিছু টেক্সট ডেটা)
texts = ["I love machine learning", "Deep learning is great", "I love coding", "Python is awesome"]
labels = [1, 1, 1, 0]  # 1: Positive, 0: Negative

# টোকেনাইজেশন
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)

# প্যাডিং
X = pad_sequences(sequences, maxlen=10)
y = labels

# ডেটা ট্রেন এবং টেস্টে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

# RNN মডেল তৈরি
model = Sequential()
model.add(Embedding(input_dim=1000, output_dim=64, input_length=10))  # Embedding layer for text input
model.add(SimpleRNN(64))  # Simple RNN layer
model.add(Dense(1, activation='sigmoid'))  # Sigmoid for binary classification

# মডেল কম্পাইল
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# মডেল প্রশিক্ষণ
model.fit(X_train, y_train, epochs=10, batch_size=2, validation_data=(X_test, y_test))

# মডেল মূল্যায়ন
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Test accuracy: {test_acc}")

Explanation:

• Tokenizer: টেক্সট ডেটাকে টোকেনাইজ করে ইনডেক্স নেয় এবং তারপর সিকুয়েন্সে রূপান্তরিত করা হয়।
• Embedding: টেক্সট ডেটাকে ইনপুট হিসেবে embedding layer দিয়ে রূপান্তরিত করা হয়।
• SimpleRNN: RNN লেয়ার, যা সিকুয়েন্স ডেটা থেকে তথ্য শিখে এবং পরবর্তী আউটপুট তৈরি করে।
• Dense: ফাইনাল লেয়ার, যা আউটপুট হিসেবে sigmoid (binary classification) ব্যবহার করে।

এই মডেলটি টেক্সট ক্লাসিফিকেশন এর জন্য প্রশিক্ষিত হবে, যেখানে 1 হল পজিটিভ এবং 0 হল নেগেটিভ।

সারাংশ:

• CNN (Convolutional Neural Networks) চিত্র ডেটা মডেল করার জন্য ব্যবহার করা হয়। এটি কনভোলিউশনাল লেয়ার ব্যবহার করে চিত্রের বৈশিষ্ট্য বের করে এবং শ্রেণীবিভাগ বা অন্য কাজ করে।
• RNN (Recurrent Neural Networks) সিকুয়েন্স ডেটা মডেল করার জন্য ব্যবহৃত হয়, যেখানে পূর্ববর্তী স্টেট ব্যবহার করে ডেটার লুকানো প্যাটার্ন শিখে। LSTM এবং GRU এর মতো উন্নত আর্কিটেকচার সিকুয়েন্স ডেটা পরিচালনায় আরও দক্ষ।
• Image Classification এর জন্য CNN ব্যবহার করা হয় এবং Text Classification এর জন্য RNN বা LSTM ব্যবহার করা হয়।

Generative Adversarial Networks (GANs) হলো একটি শক্তিশালী ডিপ লার্নিং আর্কিটেকচার যা নতুন ডেটা (যেমন, চিত্র, টেক্সট) তৈরি করার জন্য ব্যবহৃত হয়। GANs একটি দ্বৈত-সংঘাত (adversarial) কাঠামোতে কাজ করে, যেখানে দুটি নিউরাল নেটওয়ার্ক (একটি জেনারেটর এবং একটি ডিসক্রিমিনেটর) একে অপরের বিরুদ্ধে প্রশিক্ষিত হয়। এই দুটি মডেল একে অপরের সাথে লড়াই করে এবং ফলস্বরূপ একটি ভালো মানের নতুন ডেটা তৈরি হয়।

এই প্রজেক্টে আমরা GAN ব্যবহার করে চিত্র (image) জেনারেশন করবো। উদাহরণস্বরূপ, আমরা একটি DCGAN (Deep Convolutional GAN) ব্যবহার করবো, যা চিত্র তৈরি করতে সহায়ক।

GAN দিয়ে Image Generation প্রজেক্ট:

এখানে আমরা DCGAN (Deep Convolutional Generative Adversarial Network) ব্যবহার করবো। DCGAN সাধারণত Convolutional Layers ব্যবহার করে এবং চিত্র তৈরি করার জন্য খুবই জনপ্রিয়।

ধাপ ১: প্রয়োজনীয় লাইব্রেরি ইম্পোর্ট করা

প্রথমে আমরা প্রয়োজনীয় লাইব্রেরি ইম্পোর্ট করবো:

import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

ধাপ ২: ডেটাসেট লোড করা

আমরা MNIST ডেটাসেট ব্যবহার করব, যা 28x28 পিক্সেলের হ্যান্ডরিটেন ডিজিট চিত্রের একটি জনপ্রিয় ডেটাসেট।

# MNIST ডেটাসেট লোড করা
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()

# চিত্রগুলিকে  [-1, 1] পরিসরে রিস্কেল করা
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype("float32")
train_images = (train_images - 127.5) / 127.5

ধাপ ৩: GAN এর দুটি অংশ তৈরি করা

1. জেনারেটর (Generator): এটি একরকম র্যান্ডম নোইস ইনপুট নিয়ে নতুন চিত্র তৈরি করবে।

def build_generator():
    model = tf.keras.Sequential()

    model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    model.add(layers.Reshape((7, 7, 256)))
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding="same", use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding="same", use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding="same", use_bias=False, activation="tanh"))

    return model

2. ডিসক্রিমিনেটর (Discriminator): এটি জেনারেটরের তৈরি চিত্রগুলো যাচাই করে, তা আসল নাকি তৈরি করা।

def build_discriminator():
    model = tf.keras.Sequential()

    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding="same", input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dropout(0.3))

    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding="same"))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dropout(0.3))

    model.add(layers.Flatten())
    model.add(layers.Dense(1))

    return model

ধাপ ৪: GAN মডেল তৈরি করা

এখন আমরা দুটি মডেল একত্রিত করবো এবং হাবার loss (যথেষ্ট ট্রেনিং এর পরে, আমরা ডিসক্রিমিনেটরের ভুল ধারণা থেকে জেনারেটরকে শেখাবো) দিয়ে একে প্রশিক্ষিত করবো।

# জেনারেটর এবং ডিসক্রিমিনেটর তৈরি করা
generator = build_generator()
discriminator = build_discriminator()

# ডিসক্রিমিনেটরের গ্রেডিয়েন্ট আপডেটের জন্য ওয়াস প্লাস (real/fake) গ্রাউন্ড ট্রুথ লেবেল তৈরি করা
def compile_models():
    discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy', metrics=['accuracy'])
    discriminator.trainable = False
    gan = tf.keras.Sequential([generator, discriminator])
    gan.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
    return gan

ধাপ ৫: প্রশিক্ষণ ফাংশন তৈরি করা

এখন আমরা জেনারেটর এবং ডিসক্রিমিনেটর প্রশিক্ষণের জন্য একটি ফাংশন তৈরি করবো। এখানে আমরা বায়াসের কারণে কোনো ভ্যালিডেশন বা টেস্ট ডেটাসেট ব্যবহার করবো না। আমরা শুধু জেনারেটর এবং ডিসক্রিমিনেটর এর মধ্যে বিরোধ সৃষ্টি করবো (adversarial training)।

def train_gan(epochs, batch_size=128):
    batch_count = train_images.shape[0] // batch_size

    for epoch in range(epochs):
        for _ in range(batch_count):
            noise = np.random.normal(0, 1, (batch_size, 100))

            # র্যান্ডম স্যাম্পল করা আসল চিত্রগুলি (real images)
            real_images = train_images[np.random.randint(0, train_images.shape[0], batch_size)]

            # জেনারেটরের মাধ্যমে নতুন (fake) চিত্র তৈরি করা
            fake_images = generator.predict(noise)

            # ডিসক্রিমিনেটরের ট্রেনিং (real vs fake)
            d_loss_real = discriminator.train_on_batch(real_images, np.ones((batch_size, 1)))
            d_loss_fake = discriminator.train_on_batch(fake_images, np.zeros((batch_size, 1)))
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

            # GAN মডেল ট্রেনিং (generator এর ট্রেনিং)
            g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))

        # প্রতি epoch এ কিছু রেজাল্ট প্রদর্শন করা
        if epoch % 10 == 0:
            print(f"Epoch {epoch}/{epochs} - D Loss: {d_loss[0]} - G Loss: {g_loss}")

            # প্রতি epoch শেষে ছবি দেখানো
            if epoch % 100 == 0:
                plot_generated_images(epoch)

# চিত্র প্রজেকশন (Plot) ফাংশন
def plot_generated_images(epoch, examples=10, dim=(1, 10), figsize=(10, 1)):
    noise = np.random.normal(0, 1, (examples, 100))
    generated_images = generator.predict(noise)
    plt.figure(figsize=figsize)
    for i in range(examples):
        plt.subplot(dim[0], dim[1], i+1)
        plt.imshow(generated_images[i], interpolation='nearest', cmap='gray')
        plt.axis('off')
    plt.tight_layout()
    plt.savefig(f'generated_image_{epoch}.png')
    plt.close()

# মডেল কম্পাইল
gan = compile_models()

# প্রশিক্ষণ শুরু
train_gan(epochs=5000, batch_size=128)

ধাপ ৬: আউটপুট

প্রশিক্ষণ চলাকালে প্রতি epoch এর শেষে আপনি একটি চিত্র দেখতে পাবেন, যা আপনার GAN মডেল দ্বারা তৈরি চিত্র। generated_image_epoch.png ফাইলে এই চিত্রগুলি সংরক্ষিত হবে।

সারাংশ:

এই প্রজেক্টে, আমরা DCGAN (Deep Convolutional GAN) ব্যবহার করে চিত্র সৃষ্টি করেছি। এখানে জেনারেটর এবং ডিসক্রিমিনেটর মডেল তৈরি করা হয়েছে, যেগুলি একে অপরের বিরুদ্ধে প্রশিক্ষিত হয়েছে, যা সঠিকভাবে চিত্র জেনারেশন করতে সাহায্য করে। GAN প্রশিক্ষণের মধ্যে ডিসক্রিমিনেটর আসল এবং তৈরি করা চিত্রগুলির মধ্যে পার্থক্য করতে শেখে এবং জেনারেটর সেই তথ্য ব্যবহার করে আরও ভাল চিত্র তৈরি করে।

Model Deployment এবং API Integration হল ডিপ লার্নিং মডেল বা মেশিন লার্নিং মডেলকে প্রোডাকশন এনভায়রনমেন্টে নিয়ে আসার প্রক্রিয়া। এই প্রক্রিয়া সফলভাবে সম্পন্ন হলে, মডেলটি অন্য অ্যাপ্লিকেশন বা ব্যবহারকারীদের সাথে ইন্টারঅ্যাক্ট করতে পারে। এখানে একটি পূর্ণাঙ্গ Model Deployment এবং API Integration এর উদাহরণ দেওয়া হলো যেখানে Flask ব্যবহার করে একটি TensorFlow মডেল ডিপ্লয় এবং API ইন্টিগ্রেশন করা হয়েছে।

Model Deployment এবং API Integration উদাহরণ:

আমরা এখানে একটি সিম্পল TensorFlow/Keras মডেল তৈরি করব, সেটিকে Flask API মাধ্যমে সার্ভ করব, এবং শেষে সেই API টির সাথে Frontend Application (যেমন React) ইন্টিগ্রেট করব।

ধাপ ১: মডেল তৈরি এবং সংরক্ষণ (Save Model)

প্রথমে একটি সহজ TensorFlow মডেল তৈরি করি এবং তা সংরক্ষণ করব। এই মডেলটি একটি Binary Classification মডেল হবে।

import tensorflow as tf
import numpy as np

# সিম্পল ডেটা তৈরি
X_train = np.random.rand(100, 10)  # 100 উদাহরণ, 10 ফিচার
y_train = np.random.randint(2, size=100)  # 100 টার্গেট লেবেল (0 অথবা 1)

# মডেল তৈরি
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_dim=10),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# মডেল কম্পাইল
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# মডেল প্রশিক্ষণ
model.fit(X_train, y_train, epochs=10)

# মডেল সংরক্ষণ
model.save('my_model.h5')

এখন আপনার my_model.h5 নামের মডেলটি সংরক্ষিত আছে।

ধাপ ২: Flask API তৈরি এবং মডেল সার্ভিং

এখন আমরা Flask ব্যবহার করে একটি API তৈরি করব যা এই মডেলটিকে ব্যবহার করবে।

Flask API তৈরি:

1. Flask ইনস্টল করা: প্রথমে Flask ইনস্টল করতে হবে:

   pip install Flask tensorflow
   

2. Flask API কোড: Flask ব্যবহার করে মডেলটি API মাধ্যমে এক্সপোজ করার কোড:

from flask import Flask, request, jsonify
import tensorflow as tf
import numpy as np

# Flask অ্যাপ্লিকেশন তৈরি
app = Flask(__name__)

# মডেল লোড করা
model = tf.keras.models.load_model('my_model.h5')

# /predict রুটে POST রিকোয়েস্ট গ্রহণ করা
@app.route('/predict', methods=['POST'])
def predict():
    try:
        # JSON ডেটা থেকে ইনপুট নেয়া
        data = request.get_json(force=True)
        
        # ইনপুট থেকে ফিচার তৈরি করা (এই ক্ষেত্রে 10 ফিচারের জন্য)
        input_data = np.array(data['input']).reshape(1, -1)
        
        # প্রেডিকশন করা
        prediction = model.predict(input_data)
        
        # আউটপুট রিটার্ন করা
        return jsonify({'prediction': prediction[0][0]})
    
    except Exception as e:
        return jsonify({'error': str(e)})

# অ্যাপ্লিকেশন চালানো
if __name__ == '__main__':
    app.run(debug=True)

ব্যাখ্যা:

• Flask অ্যাপ তৈরি করা হয়েছে যা POST রিকোয়েস্ট নেয় এবং ইনপুট ডেটা থেকে মডেল থেকে প্রেডিকশন প্রদান করে।
• Model.load() ব্যবহার করে আমরা সংরক্ষিত মডেলটিকে লোড করেছি এবং predict() ফাংশন ব্যবহার করে নতুন ইনপুটের জন্য প্রেডিকশন করেছি।

ধাপ ৩: API টেস্ট করা

Flask অ্যাপটি চালু করতে python app.py কমান্ড ব্যবহার করুন। এটি একটি লোকাল সার্ভারে চালু হবে, সাধারণত http://127.0.0.1:5000 এ।

এখন, আপনি API টেস্ট করার জন্য Postman বা cURL ব্যবহার করতে পারেন। উদাহরণস্বরূপ:

cURL দিয়ে API টেস্ট করা:

curl -X POST -H "Content-Type: application/json" -d '{"input": [0.5, 0.6, 0.7, 0.1, 0.3, 0.8, 0.4, 0.9, 0.6, 0.5]}' http://127.0.0.1:5000/predict

এটি একটি JSON অবজেক্ট পাঠাবে, যেখানে input একটি 10 ফিচারের লিস্ট থাকবে।

Postman দিয়ে API টেস্ট করা:

1. Method: POST
2. URL: http://127.0.0.1:5000/predict

3. Body: JSON ফরম্যাটে:

   {
       "input": [0.5, 0.6, 0.7, 0.1, 0.3, 0.8, 0.4, 0.9, 0.6, 0.5]
   }
   

ধাপ ৪: Frontend (React) সাথে API Integration

এখন, আপনি এই API-কে React বা অন্য কোনো ফ্রন্টএন্ড ফ্রেমওয়ার্কের মাধ্যমে ব্যবহার করতে পারেন।

React এর মাধ্যমে API Integration:

1. React অ্যাপ তৈরি করুন:

   npx create-react-app my-api-app
   cd my-api-app
   npm start
   

2. API কল করা:

   App.js ফাইলে API কল করার জন্য Axios ব্যবহার করতে পারেন:

   npm install axios
   

   এরপর App.js ফাইলে API কল করুন:

   import React, { useState } from 'react';
   import axios from 'axios';
   
   function App() {
     const [prediction, setPrediction] = useState(null);
     const [inputData, setInputData] = useState([0.5, 0.6, 0.7, 0.1, 0.3, 0.8, 0.4, 0.9, 0.6, 0.5]);
   
     const handleSubmit = async () => {
       try {
         const response = await axios.post('http://127.0.0.1:5000/predict', {
           input: inputData
         });
         setPrediction(response.data.prediction);
       } catch (error) {
         console.error("Error making prediction:", error);
       }
     };
   
     return (
       <div>
         <h1>Model Prediction</h1>
         <button onClick={handleSubmit}>Get Prediction</button>
         {prediction !== null && <h2>Prediction: {prediction}</h2>}
       </div>
     );
   }
   
   export default App;
   

React অ্যাপ চালানো:

এখন, React অ্যাপ চালানোর জন্য:

npm start

আপনি ব্রাউজারে http://localhost:3000 এ React অ্যাপ দেখতে পাবেন, যেখানে আপনি মডেল থেকে প্রেডিকশন পেতে পারবেন।

সারাংশ:

• Model Deployment: আপনার মডেলটি Flask API ব্যবহার করে সার্ভ করা হয়েছে। এখানে TensorFlow মডেলটি লোড করা হয়েছে এবং POST রিকোয়েস্টের মাধ্যমে প্রেডিকশন প্রদান করা হয়েছে।
• API Integration: React অ্যাপ থেকে API কল করার জন্য Axios ব্যবহার করা হয়েছে এবং প্রেডিকশন টেক্সট হিসেবে ফ্রন্টএন্ডে দেখানো হয়েছে।

Model Deployment এবং API Integration হল ডিপ লার্নিং মডেল বা মেশিন লার্নিং মডেলকে প্রোডাকশন এনভায়রনমেন্টে নিয়ে আসার প্রক্রিয়া। এই প্রক্রিয়া সফলভাবে সম্পন্ন হলে, মডেলটি অন্য অ্যাপ্লিকেশন বা ব্যবহারকারীদের সাথে ইন্টারঅ্যাক্ট করতে পারে। এখানে একটি পূর্ণাঙ্গ Model Deployment এবং API Integration এর উদাহরণ দেওয়া হলো যেখানে Flask ব্যবহার করে একটি TensorFlow মডেল ডিপ্লয় এবং API ইন্টিগ্রেশন করা হয়েছে।

Model Deployment এবং API Integration উদাহরণ:

আমরা এখানে একটি সিম্পল TensorFlow/Keras মডেল তৈরি করব, সেটিকে Flask API মাধ্যমে সার্ভ করব, এবং শেষে সেই API টির সাথে Frontend Application (যেমন React) ইন্টিগ্রেট করব।

ধাপ ১: মডেল তৈরি এবং সংরক্ষণ (Save Model)

প্রথমে একটি সহজ TensorFlow মডেল তৈরি করি এবং তা সংরক্ষণ করব। এই মডেলটি একটি Binary Classification মডেল হবে।

import tensorflow as tf
import numpy as np

# সিম্পল ডেটা তৈরি
X_train = np.random.rand(100, 10)  # 100 উদাহরণ, 10 ফিচার
y_train = np.random.randint(2, size=100)  # 100 টার্গেট লেবেল (0 অথবা 1)

# মডেল তৈরি
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_dim=10),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# মডেল কম্পাইল
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# মডেল প্রশিক্ষণ
model.fit(X_train, y_train, epochs=10)

# মডেল সংরক্ষণ
model.save('my_model.h5')

এখন আপনার my_model.h5 নামের মডেলটি সংরক্ষিত আছে।

ধাপ ২: Flask API তৈরি এবং মডেল সার্ভিং

এখন আমরা Flask ব্যবহার করে একটি API তৈরি করব যা এই মডেলটিকে ব্যবহার করবে।

Flask API তৈরি:

1. Flask ইনস্টল করা: প্রথমে Flask ইনস্টল করতে হবে:

   pip install Flask tensorflow
   

2. Flask API কোড: Flask ব্যবহার করে মডেলটি API মাধ্যমে এক্সপোজ করার কোড:

from flask import Flask, request, jsonify
import tensorflow as tf
import numpy as np

# Flask অ্যাপ্লিকেশন তৈরি
app = Flask(__name__)

# মডেল লোড করা
model = tf.keras.models.load_model('my_model.h5')

# /predict রুটে POST রিকোয়েস্ট গ্রহণ করা
@app.route('/predict', methods=['POST'])
def predict():
    try:
        # JSON ডেটা থেকে ইনপুট নেয়া
        data = request.get_json(force=True)
        
        # ইনপুট থেকে ফিচার তৈরি করা (এই ক্ষেত্রে 10 ফিচারের জন্য)
        input_data = np.array(data['input']).reshape(1, -1)
        
        # প্রেডিকশন করা
        prediction = model.predict(input_data)
        
        # আউটপুট রিটার্ন করা
        return jsonify({'prediction': prediction[0][0]})
    
    except Exception as e:
        return jsonify({'error': str(e)})

# অ্যাপ্লিকেশন চালানো
if __name__ == '__main__':
    app.run(debug=True)

ব্যাখ্যা:

• Flask অ্যাপ তৈরি করা হয়েছে যা POST রিকোয়েস্ট নেয় এবং ইনপুট ডেটা থেকে মডেল থেকে প্রেডিকশন প্রদান করে।
• Model.load() ব্যবহার করে আমরা সংরক্ষিত মডেলটিকে লোড করেছি এবং predict() ফাংশন ব্যবহার করে নতুন ইনপুটের জন্য প্রেডিকশন করেছি।

ধাপ ৩: API টেস্ট করা

Flask অ্যাপটি চালু করতে python app.py কমান্ড ব্যবহার করুন। এটি একটি লোকাল সার্ভারে চালু হবে, সাধারণত http://127.0.0.1:5000 এ।

এখন, আপনি API টেস্ট করার জন্য Postman বা cURL ব্যবহার করতে পারেন। উদাহরণস্বরূপ:

cURL দিয়ে API টেস্ট করা:

curl -X POST -H "Content-Type: application/json" -d '{"input": [0.5, 0.6, 0.7, 0.1, 0.3, 0.8, 0.4, 0.9, 0.6, 0.5]}' http://127.0.0.1:5000/predict

এটি একটি JSON অবজেক্ট পাঠাবে, যেখানে input একটি 10 ফিচারের লিস্ট থাকবে।

Postman দিয়ে API টেস্ট করা:

1. Method: POST
2. URL: http://127.0.0.1:5000/predict

3. Body: JSON ফরম্যাটে:

   {
       "input": [0.5, 0.6, 0.7, 0.1, 0.3, 0.8, 0.4, 0.9, 0.6, 0.5]
   }
   

ধাপ ৪: Frontend (React) সাথে API Integration

এখন, আপনি এই API-কে React বা অন্য কোনো ফ্রন্টএন্ড ফ্রেমওয়ার্কের মাধ্যমে ব্যবহার করতে পারেন।

React এর মাধ্যমে API Integration:

1. React অ্যাপ তৈরি করুন:

   npx create-react-app my-api-app
   cd my-api-app
   npm start
   

2. API কল করা:

   App.js ফাইলে API কল করার জন্য Axios ব্যবহার করতে পারেন:

   npm install axios
   

   এরপর App.js ফাইলে API কল করুন:

   import React, { useState } from 'react';
   import axios from 'axios';
   
   function App() {
     const [prediction, setPrediction] = useState(null);
     const [inputData, setInputData] = useState([0.5, 0.6, 0.7, 0.1, 0.3, 0.8, 0.4, 0.9, 0.6, 0.5]);
   
     const handleSubmit = async () => {
       try {
         const response = await axios.post('http://127.0.0.1:5000/predict', {
           input: inputData
         });
         setPrediction(response.data.prediction);
       } catch (error) {
         console.error("Error making prediction:", error);
       }
     };
   
     return (
       <div>
         <h1>Model Prediction</h1>
         <button onClick={handleSubmit}>Get Prediction</button>
         {prediction !== null && <h2>Prediction: {prediction}</h2>}
       </div>
     );
   }
   
   export default App;
   

React অ্যাপ চালানো:

এখন, React অ্যাপ চালানোর জন্য:

npm start

আপনি ব্রাউজারে http://localhost:3000 এ React অ্যাপ দেখতে পাবেন, যেখানে আপনি মডেল থেকে প্রেডিকশন পেতে পারবেন।

সারাংশ:

• Model Deployment: আপনার মডেলটি Flask API ব্যবহার করে সার্ভ করা হয়েছে। এখানে TensorFlow মডেলটি লোড করা হয়েছে এবং POST রিকোয়েস্টের মাধ্যমে প্রেডিকশন প্রদান করা হয়েছে।
• API Integration: React অ্যাপ থেকে API কল করার জন্য Axios ব্যবহার করা হয়েছে এবং প্রেডিকশন টেক্সট হিসেবে ফ্রন্টএন্ডে দেখানো হয়েছে।