DeepSpeed এবং অন্যান্য Libraries Integration

DeepSpeed এবং অন্যান্য Libraries Integration

DeepSpeed হলো একটি শক্তিশালী ফ্রেমওয়ার্ক যা ডিপ লার্নিং মডেল Training এবং ইনফারেন্সকে দ্রুত এবং কার্যকর করতে সহায়ক। এটি PyTorch এর উপর ভিত্তি করে তৈরি হয়েছে এবং বিভিন্ন লাইব্রেরির সাথে সংযুক্ত হয়ে কাজ করতে সক্ষম। নিচে DeepSpeed এর বিভিন্ন লাইব্রেরির সাথে ইন্টিগ্রেশন পদ্ধতি আলোচনা করা হলো।

১. DeepSpeed এবং PyTorch

DeepSpeed মূলত PyTorch এর জন্য ডিজাইন করা হয়েছে, তাই এটি PyTorch মডেলের সাথে সহজেই ইন্টিগ্রেট করা যায়। উদাহরণস্বরূপ, DeepSpeed ব্যবহার করে PyTorch মডেল Training করতে নিচের ধাপগুলি অনুসরণ করতে হবে:

উদাহরণ কোড:

import torch
import torch.nn as nn
import deepspeed

# সিম্পল নিউরাল নেটওয়ার্ক মডেল তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(50, 2)

    def forward(self, x):
        x = self.relu(self.fc1(x))
        return self.fc2(x)

# DeepSpeed কনফিগারেশন ফাইল
ds_config = "ds_config.json"

# মডেল তৈরি এবং DeepSpeed ইনিশিয়ালাইজেশন
model = SimpleNN()
model_engine, optimizer, _, _ = deepspeed.initialize(model=model, config=ds_config)

# Training Loop
# ... Training Loop Code ...

২. DeepSpeed এবং Hugging Face Transformers

DeepSpeed Hugging Face Transformers লাইব্রেরির সাথে সহজে সংযুক্ত করা যায়, যা বড় ভাষা মডেল (যেমন BERT, GPT-2) Training এবং ইনফারেন্সে ব্যবহার করা হয়।

উদাহরণ কোড:

from transformers import BertForSequenceClassification, Trainer, TrainingArguments
import deepspeed

# মডেল তৈরি
model = BertForSequenceClassification.from_pretrained("bert-base-uncased")

# DeepSpeed কনফিগারেশন
deepspeed_config = {
    "train_batch_size": 32,
    "fp16": {"enabled": True},
    "zero_optimization": {"stage": 2},
}

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    gradient_accumulation_steps=2,
    evaluation_strategy="epoch",
    deepspeed=deepspeed_config,
)

trainer = Trainer(
    model=model,
    args=training_args,
)

# Training শুরু করা
trainer.train()

৩. DeepSpeed এবং TensorFlow

DeepSpeed মূলত PyTorch এর জন্য তৈরি হলেও, TensorFlow-এর সাথে ইন্টিগ্রেট করার জন্য কিছু কার্যকরী পদ্ধতি রয়েছে। TensorFlow মডেলকে ONNX (Open Neural Network Exchange) ফরম্যাটে রূপান্তর করে DeepSpeed ব্যবহার করা যেতে পারে।

উদাহরণ কোড:

import tensorflow as tf
import onnx
import tf2onnx
from deepspeed import init

# TensorFlow মডেল তৈরি
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(10,)),
    tf.keras.layers.Dense(2, activation='softmax')
])

# ONNX মডেলে রূপান্তর করা
onnx_model = tf2onnx.convert.from_keras(model)

# DeepSpeed INtegration (এই অংশে DeepSpeed ব্যবহার করে ONNX মডেল রান করা হবে)
# DeepSpeed-এর ONNX Runtime ব্যবহার করে মডেল রান করুন।

৪. DeepSpeed এবং Horovod

Horovod একটি ডিস্ট্রিবিউটেড Training লাইব্রেরি যা TensorFlow এবং PyTorch-এর জন্য ডিজাইন করা হয়েছে। DeepSpeed এর সাথে Horovod ব্যবহার করে একাধিক GPU বা নোডে Training পরিচালনা করা যায়।

উদাহরণ কোড:

import deepspeed
import horovod.torch as hvd

# Horovod শুরু করা
hvd.init()

# মডেল তৈরি
model = SimpleNN()
model_engine, optimizer, _, _ = deepspeed.initialize(model=model)

# Training Loop (Horovod ব্যবহার করে)
for epoch in range(num_epochs):
    for batch_data, batch_labels in train_loader:
        optimizer.zero_grad()
        outputs = model_engine(batch_data)
        loss = criterion(outputs, batch_labels)
        loss.backward()
        optimizer.step()

সারসংক্ষেপ

• DeepSpeed এবং PyTorch: PyTorch মডেলের জন্য সহজে ইন্টিগ্রেশন।
• DeepSpeed এবং Hugging Face Transformers: বড় ভাষা মডেল Training এবং ইনফারেন্সের জন্য কার্যকরী।
• DeepSpeed এবং TensorFlow: ONNX ব্যবহার করে TensorFlow মডেলের জন্য ইন্টিগ্রেশন।
• DeepSpeed এবং Horovod: ডিস্ট্রিবিউটেড Training সহজতর করার জন্য।

DeepSpeed বিভিন্ন লাইব্রেরির সাথে ইন্টিগ্রেট করা যায়, যা মডেল Training এবং ইনফারেন্সের জন্য একটি শক্তিশালী সমাধান প্রদান করে।

PyTorch এবং DeepSpeed একসাথে ব্যবহার করা যেতে পারে বড় মডেলগুলোকে দ্রুত, দক্ষ এবং সাশ্রয়ীভাবে প্রশিক্ষণ দেওয়ার জন্য। DeepSpeed একটি ওপেন-সোর্স লাইব্রেরি যা বড় মডেল প্রশিক্ষণের জন্য বিভিন্ন অপ্টিমাইজেশন প্রযুক্তি সরবরাহ করে, যেমন ZeRO (Zero Redundancy Optimizer), Mixed Precision Training, এবং Activation Checkpointing। PyTorch ব্যবহার করে DeepSpeed এর ক্ষমতা অর্জন করতে হলে কিছু ধাপ অনুসরণ করতে হবে।

PyTorch এবং DeepSpeed সংযোগের প্রক্রিয়া

নিচে PyTorch এবং DeepSpeed সংযোগের ধাপগুলো আলোচনা করা হলো:

ধাপ ১: ইনস্টলেশন

প্রথমে আপনাকে PyTorch এবং DeepSpeed ইনস্টল করতে হবে। PyTorch ইনস্টল করার জন্য আপনার সিস্টেমের CUDA ভার্সন অনুযায়ী নির্দেশনা অনুসরণ করতে হবে।

# PyTorch ইনস্টলেশন উদাহরণ (CUDA 11.3)
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113

# DeepSpeed ইনস্টল করা
pip install deepspeed

ধাপ ২: মডেল এবং ডেটাসেট তৈরি করা

একটি কাস্টম মডেল তৈরি করুন এবং ডেটাসেট প্রস্তুত করুন। উদাহরণ হিসেবে, আমরা একটি সিম্পল নিউরাল নেটওয়ার্ক তৈরি করব।

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# সিম্পল ডেটাসেট তৈরি
X = torch.randn(1000, 10)  # 1000 নমুনা, 10 বৈশিষ্ট্য
y = torch.randint(0, 2, (1000,))  # 0 বা 1 এর লেবেল

dataset = TensorDataset(X, y)
train_loader = DataLoader(dataset, batch_size=32, shuffle=True)

# কাস্টম মডেল তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 2)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = SimpleNN()

ধাপ ৩: DeepSpeed কনফিগারেশন তৈরি করা

একটি DeepSpeed কনফিগারেশন ফাইল তৈরি করুন যেখানে ZeRO অপ্টিমাইজার এবং অন্যান্য প্যারামিটারগুলো নির্ধারণ করা হবে।

{
    "train_batch_size": 32,
    "gradient_accumulation_steps": 2,
    "fp16": {
        "enabled": true  # FP16 Mixed Precision Training
    },
    "zero_optimization": {
        "stage": 2  # ZeRO Stage 2
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": 0.001
        }
    }
}

ধাপ ৪: DeepSpeed ব্যবহার করে মডেল ইনিশিয়ালাইজ করা

DeepSpeed ব্যবহার করে মডেল এবং অপ্টিমাইজার ইনিশিয়ালাইজ করুন।

import deepspeed

# DeepSpeed কনফিগারেশন লোড করা
deepspeed_config = "deepspeed_config.json"

# DeepSpeed ইনিশিয়ালাইজ করা
model_engine, optimizer, _, _ = deepspeed.initialize(
    config=deepspeed_config,
    model=model,
    model_parameters=model.parameters()
)

ধাপ ৫: কাস্টম ট্রেইনিং লুপ তৈরি করা

এখন, আমরা কাস্টম ট্রেইনিং লুপ তৈরি করবো যেখানে DeepSpeed এর সুবিধাগুলো অন্তর্ভুক্ত থাকবে।

# Training Loop
num_epochs = 10
for epoch in range(num_epochs):
    model_engine.train()  # Training মোডে মডেল সেট করা
    running_loss = 0.0

    for inputs, labels in train_loader:
        inputs, labels = inputs.to(model_engine.local_rank), labels.to(model_engine.local_rank)

        # Optimizer গ্র্যাডিয়েন্ট রিসেট করা
        optimizer.zero_grad()

        # Forward pass
        outputs = model_engine(inputs)
        loss = nn.CrossEntropyLoss()(outputs, labels)

        # Backward pass
        model_engine.backward(loss)
        model_engine.step()  # Optimizer স্টেপ

        running_loss += loss.item()

    epoch_loss = running_loss / len(train_loader)
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}')

ধাপ ৬: মডেল মূল্যায়ন করা

Training সম্পন্ন হলে, মডেলটি একটি validation dataset এ মূল্যায়ন করুন।

def evaluate_model(model_engine, dataloader):
    model_engine.eval()  # Evaluation মোডে মডেল সেট করা
    total_loss = 0.0
    total_correct = 0

    with torch.no_grad():
        for inputs, labels in dataloader:
            inputs, labels = inputs.to(model_engine.local_rank), labels.to(model_engine.local_rank)
            outputs = model_engine(inputs)
            loss = nn.CrossEntropyLoss()(outputs, labels)
            total_loss += loss.item()
            total_correct += (outputs.argmax(dim=1) == labels).sum().item()

    avg_loss = total_loss / len(dataloader)
    accuracy = total_correct / len(dataloader.dataset)
    print(f'Validation Loss: {avg_loss:.4f}, Accuracy: {accuracy:.4f}')

# Validation ডেটাসেট তৈরি করা (ডামি)
val_dataset = TensorDataset(X, y)  # একই ডেটাসেট ব্যবহার করা
val_loader = DataLoader(val_dataset, batch_size=32)

evaluate_model(model_engine, val_loader)

উপসংহার

PyTorch এবং DeepSpeed একসঙ্গে ব্যবহৃত হলে বড় মডেল প্রশিক্ষণের জন্য অত্যন্ত কার্যকরী। DeepSpeed এর মাধ্যমে ZeRO optimization, mixed precision training এবং অন্যান্য memory optimization techniques ব্যবহার করে training efficiency এবং scalability বৃদ্ধি করা যায়। উপরিউক্ত উদাহরণটি PyTorch এবং DeepSpeed এর সাথে একটি সিম্পল নিউরাল নেটওয়ার্ক প্রশিক্ষণের পুরো প্রক্রিয়া দেখায়।

Transformer Libraries এর সাথে DeepSpeed ব্যবহার

DeepSpeed একটি শক্তিশালী লাইব্রেরি যা ডিপ লার্নিং মডেল Training এবং ইনফারেন্সকে দ্রুত এবং কার্যকরী করে। বিশেষ করে Transformers লাইব্রেরির সাথে DeepSpeed ব্যবহার করলে বড় ভাষা মডেলগুলোর Training প্রক্রিয়া আরও সহজ এবং দক্ষ হয়। নিচে Transformers লাইব্রেরি, বিশেষ করে Hugging Face-এর Transformers লাইব্রেরির সাথে DeepSpeed-এর ব্যবহার কিভাবে করা যায় তার উদাহরণ সহ আলোচনা করা হলো।

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

প্রথমে প্রয়োজনীয় লাইব্রেরিগুলি ইমপোর্ট করতে হবে। এখানে আমরা Hugging Face-এর Transformers এবং DeepSpeed ব্যবহার করব।

import torch
from transformers import AutoModelForSequenceClassification, Trainer, TrainingArguments
import deepspeed

২. মডেল এবং ডেটাসেট তৈরি করা

Hugging Face-এর Transformers লাইব্রেরি ব্যবহার করে একটি মডেল এবং ডেটাসেট তৈরি করতে হবে। নিচে BERT মডেল ব্যবহার করার একটি উদাহরণ দেওয়া হলো।

# BERT মডেল লোড করা
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)

# উদাহরণ ডেটাসেট তৈরি (এখানে synthetic ডেটা ব্যবহার করা হচ্ছে)
train_texts = ["This is a positive example.", "This is a negative example."]
train_labels = [1, 0]

# Tokenization
from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
train_encodings = tokenizer(train_texts, truncation=True, padding=True)

# PyTorch Dataset তৈরি
import torch
class CustomDataset(torch.utils.data.Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

    def __len__(self):
        return len(self.labels)

train_dataset = CustomDataset(train_encodings, train_labels)

৩. DeepSpeed কনফিগারেশন তৈরি করা

DeepSpeed কনফিগারেশন ফাইল তৈরি করতে হবে। এখানে আমরা JSON ফরম্যাটে কিছু প্যারামিটার নির্ধারণ করব।

{
  "train_batch_size": 16,
  "gradient_accumulation_steps": 2,
  "steps_per_print": 10,
  "fp16": {
    "enabled": true
  },
  "zero_optimization": {
    "stage": 2
  }
}

৪. TrainingArguments এবং Trainer তৈরি করা

Hugging Face-এর Trainer ক্লাস ব্যবহার করে TrainingArguments সেট করতে হবে, যেখানে DeepSpeed কনফিগারেশন যুক্ত করা হবে।

# TrainingArguments সেটআপ করা
training_args = TrainingArguments(
    output_dir='./results',
    evaluation_strategy="epoch",
    per_device_train_batch_size=8,
    save_total_limit=1,
    num_train_epochs=3,
    logging_dir='./logs',
    deepspeed='ds_config.json'  # DeepSpeed কনফিগারেশন ফাইল পাথ
)

# Trainer তৈরি করা
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
)

৫. Training প্রক্রিয়া চালানো

সবকিছু প্রস্তুত হয়ে গেলে, মডেল Training শুরু করা যায়।

# Training শুরু করা
trainer.train()

সারসংক্ষেপ

• DeepSpeed: বড় মডেল Training এবং ইনফারেন্সের জন্য দ্রুততর এবং কার্যকরী সমাধান প্রদান করে।
• Transformers লাইব্রেরি: Hugging Face-এর Transformers লাইব্রেরি ব্যবহার করে বড় ভাষা মডেল সহজেই ব্যবহার করা যায়।
• Integration: DeepSpeed এর সাথে Transformers লাইব্রেরি ব্যবহারে Mixed Precision Training, ZeRO Optimization ইত্যাদি সুবিধা পাওয়া যায়।

DeepSpeed ব্যবহার করে Transformer লাইব্রেরির মডেলগুলোকে Training করা একটি কার্যকরী পদ্ধতি, যা মেমোরি ব্যবস্থাপনা এবং Training স্পিড উভয়কেই উন্নত করে।

Hugging Face এবং DeepSpeed এর ইন্টিগ্রেশন মডেল প্রশিক্ষণের সময় দক্ষতা এবং দ্রুততার সাথে প্রশিক্ষণ দেওয়ার জন্য অত্যন্ত কার্যকরী। Hugging Face এর Transformers লাইব্রেরি ডীপ লার্নিং মডেল তৈরিতে ব্যবহৃত হয় এবং DeepSpeed এর অপ্টিমাইজেশন ফিচারগুলি মডেল প্রশিক্ষণকে আরো উন্নত করে। এখানে আমরা দেখব কিভাবে Hugging Face এর মডেলকে DeepSpeed এর সাথে ইন্টিগ্রেট করা যায়।

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

প্রথমে, আপনাকে Hugging Face এবং DeepSpeed এর জন্য প্রয়োজনীয় লাইব্রেরিগুলো ইনস্টল করতে হবে।

pip install transformers deepspeed

ধাপ ২: মডেল এবং ডেটাসেট লোড করা

Hugging Face থেকে একটি মডেল এবং ডেটাসেট লোড করুন। এখানে আমরা BERT মডেল ব্যবহার করব।

from transformers import BertForSequenceClassification, BertTokenizer
from datasets import load_dataset

# BERT মডেল এবং টোকেনাইজার লোড করা
model_name = "bert-base-uncased"
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = BertTokenizer.from_pretrained(model_name)

# ডেটাসেট লোড করা
dataset = load_dataset("glue", "mrpc")  # MRPC dataset

ধাপ ৩: ডেটা প্রিপ্রসেসিং

ডেটা প্রিপ্রসেসিং করে ডেটাসেট তৈরি করুন।

# ডেটাসেট টোকেনাইজেশন
def tokenize_function(examples):
    return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

# Train-test split করা
train_dataset = tokenized_datasets["train"].shuffle(seed=42).select([i for i in list(range(200))])  # উদাহরণস্বরূপ কিছু ডেটা ব্যবহার করা
test_dataset = tokenized_datasets["validation"].shuffle(seed=42)

ধাপ ৪: DeepSpeed কনফিগারেশন ফাইল তৈরি করা

একটি কনফিগারেশন ফাইল তৈরি করুন যেখানে আপনি DeepSpeed এর অপ্টিমাইজেশন সেটিংস উল্লেখ করবেন।

{
    "train_batch_size": 32,
    "fp16": {
        "enabled": true  # Mixed Precision Training
    },
    "zero_optimization": {
        "stage": 2  # ZeRO Stage 2
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": 5e-5
        }
    }
}

ধাপ ৫: DeepSpeed ব্যবহার করে মডেল ট্রেনিং করা

Hugging Face ট্রেনিং লুপ এবং DeepSpeed এর সংযোগের মাধ্যমে মডেল ট্রেনিং করুন।

import deepspeed
import torch
from transformers import Trainer, TrainingArguments

# DeepSpeed কনফিগারেশন ফাইল লোড করা
deepspeed_config = "deepspeed_config.json"

# Training arguments তৈরি করা
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=5e-5,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=64,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    deepspeed=deepspeed_config  # DeepSpeed কনফিগারেশন যুক্ত করা
)

# Trainer তৈরি করা
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset
)

# মডেল ট্রেনিং করা
trainer.train()

ধাপ ৬: মডেল মূল্যায়ন করা

মডেল প্রশিক্ষণের পর, মূল্যায়ন করুন।

# মূল্যায়ন করা
results = trainer.evaluate()
print(f"Evaluation results: {results}")

উপসংহার

Hugging Face এবং DeepSpeed এর সংযোগ বড় মডেলগুলোর প্রশিক্ষণকে আরও কার্যকরী এবং দক্ষ করে তোলে। এই ইন্টিগ্রেশন এর মাধ্যমে বড় ডেটাসেট এবং মডেলগুলোকে সহজে এবং দ্রুত প্রশিক্ষণ দেওয়া যায়, যা compute resources এর সঠিক ব্যবহার নিশ্চিত করে।

এখন আপনি Hugging Face এর মডেলগুলোর সাথে DeepSpeed এর অপ্টিমাইজেশন সুবিধাগুলো ব্যবহার করতে পারবেন, যা প্রশিক্ষণের সময় memory efficiency এবং training speed বৃদ্ধি করবে।

DeepSpeed একটি শক্তিশালী লাইব্রেরি যা বড় মডেল এবং ডেটাসেটগুলোর প্রশিক্ষণে উন্নত দক্ষতা এবং গতি নিয়ে আসে। এটি বেশ কয়েকটি জনপ্রিয় ডীপ লার্নিং লাইব্রেরির সাথে ইন্টিগ্রেট করা যায়। এখানে আমরা PyTorch, Hugging Face Transformers, এবং TensorFlow এর মতো লাইব্রেরিগুলোর সাথে DeepSpeed এর ব্যবহার দেখাব।

১. DeepSpeed এর সাথে PyTorch

PyTorch এর সাথে DeepSpeed ব্যবহার করে একটি সিম্পল নিউরাল নেটওয়ার্ক প্রশিক্ষণের উদাহরণ।

উদাহরণ: PyTorch এর সাথে DeepSpeed

import torch
import torch.nn as nn
import torch.optim as optim
import deepspeed

# মডেল তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 64)
        self.fc2 = nn.Linear(64, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

# DeepSpeed কনফিগারেশন
deepspeed_config = {
    "train_batch_size": 32,
    "fp16": {
        "enabled": True  # Mixed Precision Training
    },
    "zero_optimization": {
        "stage": 2  # ZeRO Stage 2
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": 0.001
        }
    }
}

# মডেল এবং ডেটাসেট প্রস্তুত
model = SimpleNN()
data = torch.randn(1000, 10)
labels = torch.randn(1000, 1)

# DeepSpeed ইনিশিয়ালাইজ করা
model_engine, optimizer, _, _ = deepspeed.initialize(
    config=deepspeed_config,
    model=model,
    model_parameters=model.parameters()
)

# Training Loop
for epoch in range(5):
    for i in range(len(data) // 32):
        inputs = data[i*32:(i+1)*32]
        target = labels[i*32:(i+1)*32]
        
        inputs, target = inputs.to(model_engine.local_rank), target.to(model_engine.local_rank)
        
        optimizer.zero_grad()
        
        outputs = model_engine(inputs)
        loss = nn.MSELoss()(outputs, target)

        model_engine.backward(loss)
        model_engine.step()

    print(f'Epoch {epoch + 1} completed')

২. DeepSpeed এর সাথে Hugging Face Transformers

Hugging Face এর সাথে DeepSpeed ব্যবহারের মাধ্যমে একটি প্রাক-প্রশিক্ষিত ভাষা মডেল প্রশিক্ষণ করুন।

উদাহরণ: Hugging Face Transformers এর সাথে DeepSpeed

from transformers import BertForSequenceClassification, BertTokenizer, Trainer, TrainingArguments
import deepspeed

# BERT মডেল এবং টোকেনাইজার লোড
model_name = "bert-base-uncased"
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = BertTokenizer.from_pretrained(model_name)

# ডেটাসেট লোড করা (উদাহরণস্বরূপ)
from datasets import load_dataset
dataset = load_dataset("glue", "mrpc")

# টোকেনাইজেশন
def tokenize_function(examples):
    return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

# Training arguments তৈরি করা
deepspeed_config = "deepspeed_config.json"
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=5e-5,
    per_device_train_batch_size=32,
    num_train_epochs=3,
    deepspeed=deepspeed_config  # DeepSpeed কনফিগারেশন যুক্ত করা
)

# Trainer তৈরি করা
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"]
)

# মডেল ট্রেনিং করা
trainer.train()

৩. DeepSpeed এর সাথে TensorFlow

TensorFlow এর সাথে DeepSpeed ব্যবহার করে প্রশিক্ষণের উদাহরণ।

উদাহরণ: TensorFlow এর সাথে DeepSpeed

import tensorflow as tf
from transformers import TFAutoModelForSequenceClassification, AutoTokenizer

# মডেল এবং টোকেনাইজার লোড করা
model_name = "distilbert-base-uncased"
model = TFAutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# ডেটাসেট লোড করা
from datasets import load_dataset
dataset = load_dataset("glue", "mrpc")

# টোকেনাইজেশন
def tokenize_function(examples):
    return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

# TensorFlow Dataset তৈরি করা
train_dataset = tf.data.Dataset.from_tensor_slices((
    dict(tokenized_datasets["train"]),
    tokenized_datasets["train"]["label"]
)).batch(32)

# DeepSpeed কনফিগারেশন
deepspeed_config = {
    "train_batch_size": 32,
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": 5e-5
        }
    },
    "fp16": {
        "enabled": True
    }
}

# TensorFlow কোডে DeepSpeed ব্যবহারের জন্য `deepspeed` প্যাকেজ ইম্পোর্ট করুন
import deepspeed.tensorflow as deepspeed_tf

# Model.compile() এ DeepSpeed ব্যবহার করে কম্পাইল করুন
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=5e-5),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=['accuracy'],
    steps_per_execution=100,
)

# মডেল ট্রেনিং করা
model.fit(train_dataset, epochs=3)

উপসংহার

DeepSpeed বিভিন্ন লাইব্রেরির সাথে ব্যবহারের মাধ্যমে বড় মডেলগুলোর প্রশিক্ষণকে দ্রুত, কার্যকরী এবং দক্ষ করে তোলে।

• PyTorch ব্যবহার করে একটি সিম্পল নিউরাল নেটওয়ার্ক প্রশিক্ষণ দেওয়ার মাধ্যমে তার সুবিধা গুলো প্রকাশ পায়।
• Hugging Face Transformers এর মাধ্যমে বিভিন্ন NLP মডেলের প্রশিক্ষণে DeepSpeed এর কার্যকরীতা স্পষ্ট হয়।
• TensorFlow এর সাথে DeepSpeed ব্যবহার করে মডেল প্রশিক্ষণের জন্য একটি সহজ এবং কার্যকরী উপায় তৈরি হয়।

এই উদাহরণগুলো থেকে আপনি শিখতে পারবেন কিভাবে DeepSpeed ইন্টিগ্রেট করে বড় মডেল এবং ডেটাসেটের প্রশিক্ষণকে আরও কার্যকরী ও দ্রুত করা যায়।