Machine Learning Distributed Training এর উদাহরণ গাইড ও নোট

Distributed Training হল মেশিন লার্নিং এবং ডিপ লার্নিং মডেল প্রশিক্ষণের একটি প্রক্রিয়া, যেখানে প্রশিক্ষণ কাজটি একাধিক ডিভাইস (CPU বা GPU) বা মেশিনে বিভক্ত হয়ে কাজ করে। এটি মডেল প্রশিক্ষণের গতি এবং দক্ষতা উল্লেখযোগ্যভাবে বৃদ্ধি করে, বিশেষত যখন ডেটাসেটটি খুব বড় হয় বা মডেলটি খুব জটিল হয়।

ডিস্ট্রিবিউটেড প্রশিক্ষণের দুটি প্রধান পদ্ধতি:

1. Data Parallelism: এখানে, প্রশিক্ষণ ডেটা একাধিক ডিভাইসে ভাগ করা হয় এবং প্রতিটি ডিভাইসে আলাদাভাবে প্রশিক্ষণ করা হয়।
2. Model Parallelism: এখানে, মডেলটি একাধিক ডিভাইসে ভাগ করা হয় এবং প্রতিটি ডিভাইসে মডেলের একটি অংশ প্রশিক্ষিত হয়।

এখানে আমরা Data Parallelism নিয়ে উদাহরণ দেখাব, যা সাধারণত বেশি ব্যবহৃত হয় এবং জনপ্রিয় মেশিন লার্নিং ফ্রেমওয়ার্কগুলোতে সহজেই সমর্থিত।

Distributed Training এর উদাহরণ: MXNet

MXNet একটি শক্তিশালী এবং স্কেলেবল ডিপ লার্নিং ফ্রেমওয়ার্ক যা ডিস্ট্রিবিউটেড প্রশিক্ষণ সমর্থন করে। MXNet-এ data parallelism বা multi-GPU প্রশিক্ষণ পরিচালনা করা যেতে পারে। এখানে একটি উদাহরণ দেখানো হবে যেখানে একটি মডেলকে একাধিক GPU-তে প্রশিক্ষণ দেয়া হবে।

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

প্রথমে, আপনার সিস্টেমে mxnet ইনস্টল থাকতে হবে (যদি না থাকে):

pip install mxnet-cu112  # CUDA 11.2 এর জন্য GPU সমর্থিত MXNet ইনস্টল করা

ধাপ ২: মডেল তৈরি এবং ডিস্ট্রিবিউটেড প্রশিক্ষণ প্রস্তুতি

এখানে একটি সিম্পল Fully Connected Neural Network তৈরি করা হবে এবং Distributed Data Parallelism ব্যবহার করে প্রশিক্ষণ দেয়া হবে।

import mxnet as mx
from mxnet import gluon, autograd, nd
from mxnet.gluon import nn
from mxnet.gluon.data import DataLoader, ArrayDataset
from mxnet import cpu, gpu

# 1. মডেল তৈরি
class SimpleNN(nn.Block):
    def __init__(self, num_hidden=128, num_classes=10, **kwargs):
        super(SimpleNN, self).__init__(**kwargs)
        self.dense1 = nn.Dense(num_hidden, activation='relu')
        self.dense2 = nn.Dense(num_classes)  # 10 ক্লাস আউটপুট (যেমন MNIST)

    def forward(self, x):
        x = self.dense1(x)
        return self.dense2(x)

# 2. ডেটা প্রস্তুতি
# এখানে একটি ছোট ডামি ডেটাসেট তৈরি করা হয়েছে (MNIST ডেটাসেট ব্যবহার করার সুপারিশ করা হয় বাস্তবে)
data = nd.random.uniform(shape=(1000, 784))  # 1000 টেনসরের ইনপুট (MNIST এর মত)
labels = nd.random.randint(0, 10, shape=(1000,))  # 1000 লেবেল (10 ক্লাস)

dataset = ArrayDataset(data, labels)
train_data = DataLoader(dataset, batch_size=64, shuffle=True)

# 3. মডেল ইনিশিয়ালাইজ করা
ctx = [mx.gpu(0), mx.gpu(1)]  # দুইটি GPU ব্যবহার (যদি দুটি GPU থাকে)
model = SimpleNN()
model.initialize(ctx=ctx)  # মডেলকে GPU তে ইনিশিয়ালাইজ করা

# 4. হাইপারপ্যারামিটারস এবং লস ফাংশন
loss_fn = gluon.loss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(model.collect_params(), 'adam')

# 5. প্রশিক্ষণ লুপ
for epoch in range(10):  # 10 ইপোক্সের জন্য প্রশিক্ষণ
    cumulative_loss = 0
    for i, (data_batch, label_batch) in enumerate(train_data):
        data_batch = data_batch.as_in_context(ctx[0])  # প্রথম GPU তে ডেটা পাঠানো
        label_batch = label_batch.as_in_context(ctx[0])  # প্রথম GPU তে লেবেল পাঠানো
        
        with autograd.record():
            output = model(data_batch)
            loss = loss_fn(output, label_batch)
        loss.backward()
        trainer.step(data_batch.shape[0])

        cumulative_loss += loss.mean().asscalar()
    
    print(f"Epoch {epoch}, Loss: {cumulative_loss / len(train_data)}")

ব্যাখ্যা:

1. মডেল: এখানে একটি Fully Connected Neural Network তৈরি করা হয়েছে।
2. DataLoader: একটি ডেটাসেট তৈরি করা হয়েছে, যা প্রাথমিকভাবে 1000 ইনপুট এবং লেবেল নিয়ে কাজ করছে।
3. ctx: এখানে, দুটি GPU (GPU 0 এবং GPU 1) এর জন্য প্রশিক্ষণ পরিচালনার জন্য context সেট করা হয়েছে।
4. Trainer: Adam optimizer ব্যবহার করা হয়েছে মডেলটিকে প্রশিক্ষিত করার জন্য।
5. Distributed Training: ডিস্ট্রিবিউটেড প্রশিক্ষণের জন্য, মডেলটি multiple GPUs-এ প্রশিক্ষিত হচ্ছে। এখানে, প্রথম GPU-তে ডেটা এবং লেবেল পাঠানো হচ্ছে।

ধাপ ৩: Distributed Data Parallelism

MXNet এর Data Parallelism ব্যবহার করার জন্য DataParallel API ব্যবহার করা হয়, যা মডেল এবং ডেটাকে একাধিক ডিভাইসে ভাগ করে।

from mxnet.gluon import data as gdata

# মডেল এবং ডেটা ডিস্ট্রিবিউটেড ট্রেনিংয়ের জন্য DataParallel API ব্যবহার
from mxnet.gluon import nn
from mxnet import model

# মডেল Parallelism
model = nn.Sequential()
model.add(nn.Dense(128, activation='relu'))
model.add(nn.Dense(10))  # Classification for 10 classes
model.initialize(ctx=ctx)

# প্রশিক্ষণ চলাকালীন প্রতিটি GPU তে ডেটা পার্শ্ববর্তীভাবে ভাগ করা হবে।
trainer = gluon.Trainer(model.collect_params(), 'adam')

সারাংশ:

Distributed Training ডিপ লার্নিং মডেলগুলিকে স্কেল করতে এবং প্রশিক্ষণের গতি দ্রুত করতে ব্যবহৃত হয়। Data Parallelism এবং Model Parallelism এর মধ্যে ডেটা বা মডেলকে একাধিক ডিভাইসে ভাগ করে প্রশিক্ষণ কার্যক্রম পরিচালিত হয়। MXNet এর DataParallel এবং multi-GPU সমর্থন এর মাধ্যমে এটি সহজে করা যায়।

• Data Parallelism ব্যবহার করে একাধিক GPU তে ডেটা বিভক্ত করা হয়, এবং প্রতিটি GPU আলাদাভাবে ব্যাচের উপর প্রশিক্ষণ দেয়।
• Model Parallelism মডেলটির বিভিন্ন অংশকে একাধিক ডিভাইসে ভাগ করে, যা বৃহৎ মডেলগুলোর জন্য উপযুক্ত।

এই ধরনের প্রশিক্ষণ বৃহৎ ডেটাসেট এবং মডেলগুলির জন্য কার্যকর, যেমন ImageNet বা BERT-এর মতো মডেল।