এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

গুগল ক্লাউডে ওপেন সোর্স এলএলএম গুলি সূক্ষ্মভাবে সুরক্ষিত করুন

১. ভূমিকা

এই ল্যাবে, আপনি গুগল কুবারনেটিস ইঞ্জিন (GKE) ব্যবহার করে জনপ্রিয় ওপেন-সোর্স ল্যাঙ্গুয়েজ মডেল লামা ২ (Llama 2)-এর জন্য একটি সম্পূর্ণ, প্রোডাকশন-গ্রেড ফাইন-টিউনিং পাইপলাইন তৈরি করতে শিখবেন। আপনি আর্কিটেকচারাল সিদ্ধান্ত, সাধারণ সুবিধা-অসুবিধা এবং এমন সব কম্পোনেন্ট সম্পর্কে জানবেন যা বাস্তব জগতের মেশিন লার্নিং অপারেশনস (MLOps) ওয়ার্কফ্লোকে প্রতিফলিত করে।

আপনি একটি GKE ক্লাস্টার প্রস্তুত করবেন, LoRA (Low-Rank Adaptation) ব্যবহার করে একটি কন্টেইনারাইজড ট্রেনিং পাইপলাইন তৈরি করবেন এবং GKE-তে আপনার ট্রেনিং জবটি চালাবেন।

স্থাপত্যের সংক্ষিপ্ত বিবরণ

আজ আমরা যা তৈরি করব তা হলো:

GPU নোড, GCS বাকেট এবং মডেল সার্ভিং সহ GKE ক্লাস্টারের আর্কিটেকচার দেখানো হচ্ছে।

স্থাপত্যের অন্তর্ভুক্ত বিষয়গুলো হলো:

GKE ক্লাস্টার : আমাদের কম্পিউটিং রিসোর্স পরিচালনা করে
জিপিইউ নোড পুল : প্রশিক্ষণের জন্য ১টি এল৪ জিপিইউ ( স্পট )
GCS Bucket : মডেল এবং ডেটাসেট সংরক্ষণ করে
ওয়ার্কলোড আইডেন্টিটি : K8s এবং GCS এর মধ্যে সুরক্ষিত অ্যাক্সেস

আপনি যা শিখবেন

এমএল ওয়ার্কলোডের জন্য অপ্টিমাইজ করা বৈশিষ্ট্যসহ একটি জিকেই ক্লাস্টার প্রোভিশন ও কনফিগার করুন।
Workload Identity ব্যবহার করে GKE থেকে অন্যান্য Google Cloud পরিষেবাগুলিতে নিরাপদ, কী-বিহীন অ্যাক্সেস বাস্তবায়ন করুন।
ডকার ব্যবহার করে একটি কন্টেইনারাইজড প্রশিক্ষণ পাইপলাইন তৈরি করুন।
LoRA-এর প্যারামিটার-এফিশিয়েন্ট ফাইন-টিউনিং (PEFT) ব্যবহার করে একটি ওপেন-সোর্স মডেলকে দক্ষতার সাথে ফাইন-টিউন করুন।

২. প্রজেক্ট সেটআপ

গুগল অ্যাকাউন্ট

যদি আপনার আগে থেকে কোনো ব্যক্তিগত গুগল অ্যাকাউন্ট না থাকে, তাহলে আপনাকে অবশ্যই একটি গুগল অ্যাকাউন্ট তৈরি করতে হবে।

কর্মক্ষেত্র বা শিক্ষা প্রতিষ্ঠানের অ্যাকাউন্টের পরিবর্তে ব্যক্তিগত অ্যাকাউন্ট ব্যবহার করুন ।

আপনার ব্যক্তিগত গুগল অ্যাকাউন্ট ব্যবহার করে গুগল ক্লাউড কনসোলে সাইন-ইন করুন।

একটি প্রকল্প তৈরি করুন (ঐচ্ছিক)

এই ল্যাবের জন্য ব্যবহার করার মতো আপনার যদি কোনো চলমান প্রজেক্ট না থাকে, তাহলে এখানে একটি নতুন প্রজেক্ট তৈরি করুন ।

৩. ক্লাউড শেল এডিটর খুলুন

সরাসরি ক্লাউড শেল এডিটর- এ যেতে এই লিঙ্কে ক্লিক করুন।
আজ যেকোনো সময়ে অনুমোদনের জন্য অনুরোধ করা হলে, চালিয়ে যাওয়ার জন্য 'অনুমোদন করুন' (Authorize) বোতামে ক্লিক করুন।
যদি স্ক্রিনের নিচে টার্মিনালটি দেখা না যায়, তাহলে এটি খুলুন:
- ভিউ ক্লিক করুন
- টার্মিনালে ক্লিক করুন
টার্মিনালে এই কমান্ডটি দিয়ে আপনার প্রজেক্ট সেট করুন:
```
gcloud config set project [PROJECT_ID]
```
- উদাহরণ:
```
gcloud config set project lab-project-id-example
```
- আপনি যদি আপনার প্রজেক্ট আইডি মনে রাখতে না পারেন, তাহলে নিম্নলিখিত উপায়ে আপনার সমস্ত প্রজেক্ট আইডি তালিকাভুক্ত করতে পারেন:
```
gcloud projects list
```
আপনি এই বার্তাটি দেখতে পাবেন:
```
Updated property [core/project].
```
যদি আপনি একটি WARNING দেখতে পান এবং আপনাকে Do you want to continue (Y/n)? জিজ্ঞাসা করা হয়, তাহলে সম্ভবত আপনি প্রজেক্ট আইডি ভুলভাবে প্রবেশ করিয়েছেন। n চাপুন, Enter চাপুন এবং gcloud config set project কমান্ডটি আবার চালানোর চেষ্টা করুন।

৪. এপিআই সক্রিয় করুন

GKE এবং অন্যান্য পরিষেবা ব্যবহার করার জন্য, আপনাকে আপনার গুগল ক্লাউড প্রজেক্টে প্রয়োজনীয় API-গুলো সক্রিয় করতে হবে।

টার্মিনালে, এপিআইগুলো সক্রিয় করুন:

gcloud services enable container.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    iam.googleapis.com \
    compute.googleapis.com \
    iamcredentials.googleapis.com \
    storage.googleapis.com

এপিআইগুলো চালু করা হচ্ছে

গুগল কুবারনেটিস ইঞ্জিন এপিআই ( container.googleapis.com ) আপনাকে আপনার অ্যাপ্লিকেশন চালনাকারী GKE ক্লাস্টার তৈরি এবং পরিচালনা করার সুযোগ দেয়।
আর্টিফ্যাক্ট রেজিস্ট্রি এপিআই ( artifactregistry.googleapis.com ) আপনার কন্টেইনার ইমেজ সংরক্ষণের জন্য একটি নিরাপদ ও ব্যক্তিগত রিপোজিটরি প্রদান করে।
ক্লাউডে আপনার কন্টেইনার ইমেজ তৈরি করার জন্য gcloud builds submit কমান্ডটি Cloud Build API ( cloudbuild.googleapis.com ) ব্যবহার করে।
আইএএম এপিআই ( iam.googleapis.com ) আপনাকে আপনার গুগল ক্লাউড রিসোর্সসমূহের অ্যাক্সেস কন্ট্রোল এবং পরিচয় ব্যবস্থাপনার সুযোগ দেয়।
কম্পিউট ইঞ্জিন এপিআই ( compute.googleapis.com ) গুগলের পরিকাঠামোতে চালিত নিরাপদ এবং কাস্টমাইজযোগ্য ভার্চুয়াল মেশিন সরবরাহ করে।
আইএএম সার্ভিস অ্যাকাউন্ট ক্রেডেনশিয়ালস এপিআই ( iamcredentials.googleapis.com ) সার্ভিস অ্যাকাউন্টগুলোর জন্য স্বল্পস্থায়ী ক্রেডেনশিয়াল তৈরি করার সুযোগ দেয়।
ক্লাউড স্টোরেজ এপিআই ( storage.googleapis.com ) আপনাকে ক্লাউডে ডেটা সংরক্ষণ এবং পুনরুদ্ধার করার সুযোগ দেয়, যা এখানে মডেল এবং ডেটাসেট সংরক্ষণের জন্য ব্যবহৃত হয়েছে।

৫. প্রকল্পের পরিবেশ তৈরি করুন

একটি ওয়ার্কিং ডিরেক্টরি তৈরি করুন

টার্মিনালে আপনার প্রোজেক্টের জন্য একটি ডিরেক্টরি তৈরি করুন এবং সেটির ভেতরে প্রবেশ করুন।
```
mkdir llama-finetuning
cd llama-finetuning
```

পরিবেশ ভেরিয়েবল সেট আপ করুন

টার্মিনালে , আপনার এনভায়রনমেন্ট ভেরিয়েবলগুলো সংরক্ষণ করার জন্য env.sh নামে একটি ফাইল তৈরি করুন। এর ফলে, আপনার সেশন সংযোগ বিচ্ছিন্ন হয়ে গেলেও আপনি সহজেই সেগুলো পুনরায় লোড করতে পারবেন।
```
cat <<EOF > env.sh
export PROJECT_ID=$(gcloud config get-value project)
export CLUSTER_NAME="ml-gke"
export GPU_NODE_POOL_NAME="gpu-pool"
export MACHINE_TYPE="e2-standard-4"
export GPU_MACHINE_TYPE="g2-standard-16"
export GPU_TYPE="nvidia-l4"
export GPU_COUNT=1
export REGION="asia-southeast1"
export NODE_LOCATIONS="asia-southeast1-a,asia-southeast1-b"
EOF
```
আপনার বর্তমান সেশনে ভেরিয়েবলগুলো লোড করতে ফাইলটি সোর্স করুন:
```
source env.sh
```
দ্রষ্টব্য: আপনার ক্লাউড শেল সেশন রিফ্রেশ হলে বা আপনি একটি নতুন টার্মিনাল ট্যাব খুললে, এই ভেরিয়েবলগুলি পুনরায় লোড করতে source env.sh চালান।
দ্রষ্টব্য: L4 GPU-গুলির চাহিদা অনেক বেশি এবং কিছু অঞ্চলে এগুলির প্রাপ্যতা সীমিত হতে পারে। এই ল্যাবটি $REGION (যেমন, asia-southeast1 ) ব্যবহার করে, যেখানে সাধারণত ধারণক্ষমতা উপলব্ধ থাকে।
যদি আপনি ZONE_RESOURCE_POOL_EXHAUSTED বা অন্য কোনো ধারণক্ষমতা সংক্রান্ত ত্রুটির সম্মুখীন হন:
- কয়েক মিনিট অপেক্ষা করে আবার চেষ্টা করুন। ধারণক্ষমতা ঘন ঘন ওঠানামা করে।
- অন্য কোনো অঞ্চল/জোন ব্যবহার করে দেখুন (যেমন, us-central1 , us-west1 , europe-west4 )। এর মাধ্যমে প্রাপ্যতা যাচাই করুন: gcloud compute accelerator-types list --filter="name=nvidia-l4"

৬. GKE ক্লাস্টার সরবরাহ করুন

টার্মিনালে , ডিফল্ট নোড পুল ব্যবহার করে GKE ক্লাস্টারটি তৈরি করুন। এতে প্রায় ৫ মিনিট সময় লাগবে।

gcloud container clusters create $CLUSTER_NAME \
    --project=$PROJECT_ID \
    --region=$REGION \
    --release-channel=rapid \
    --machine-type=$MACHINE_TYPE \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --addons=GcsFuseCsiDriver,HttpLoadBalancing \
    --enable-image-streaming \
    --enable-ip-alias \
    --num-nodes=1 \
    --enable-autoscaling \
    --min-nodes=1 \
    --max-nodes=3

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

gcloud container node-pools create $GPU_NODE_POOL_NAME \
    --project=$PROJECT_ID \
    --cluster=$CLUSTER_NAME \
    --region=$REGION \
    --machine-type=$GPU_MACHINE_TYPE \
    --accelerator type=$GPU_TYPE,count=$GPU_COUNT,gpu-driver-version=latest \
    --ephemeral-storage-local-ssd=count=1 \
    --enable-autoscaling \
    --enable-image-streaming \
    --num-nodes=0 \
    --min-nodes=0 \
    --max-nodes=1 \
    --location-policy=ANY \
    --node-taints=nvidia.com/gpu=present:NoSchedule \
    --node-locations=$NODE_LOCATIONS \
    --spot

অবশেষে, আপনার নতুন ক্লাস্টারের ক্রেডেনশিয়ালগুলো সংগ্রহ করুন এবং যাচাই করুন যে আপনি সেটিতে সংযোগ করতে পারছেন।
```
gcloud container clusters get-credentials $CLUSTER_NAME --region=$REGION

kubectl get nodes
```

৭. হাগিং ফেস অ্যাক্সেস কনফিগার করুন

আপনার পরিকাঠামো প্রস্তুত হয়ে গেলে, এখন আপনার মডেল এবং ডেটা অ্যাক্সেস করার জন্য প্রজেক্টকে প্রয়োজনীয় ক্রেডেনশিয়াল সরবরাহ করতে হবে। এই টাস্কে, আপনি প্রথমে একটি হাগিং ফেস টোকেন পাবেন।

একটি আলিঙ্গনের মুখের টোকেন পান

আপনার যদি হাগিং ফেস অ্যাকাউন্ট না থাকে, তাহলে একটি নতুন ব্রাউজার ট্যাবে huggingface.co/join- এ যান এবং নিবন্ধন প্রক্রিয়াটি সম্পূর্ণ করুন।
একবার নিবন্ধিত এবং লগ-ইন করার পর, huggingface.co/meta-llama/Llama-2-7b-hf -এ যান।
লাইসেন্সের শর্তাবলী পড়ুন এবং সেগুলি গ্রহণ করতে বোতামটিতে ক্লিক করুন।
আপনার Hugging Face অ্যাক্সেস টোকেন পেজে যেতে huggingface.co/settings/tokens -এ যান।
নতুন টোকেন- এ ক্লিক করুন।
ভূমিকার জন্য, পঠন নির্বাচন করুন।
Name এর জায়গায় একটি বর্ণনামূলক নাম লিখুন (যেমন, finetuning-lab)।
টোকেন তৈরি করুন -এ ক্লিক করুন।
তৈরি হওয়া টোকেনটি আপনার ক্লিপবোর্ডে কপি করুন। পরবর্তী ধাপে এটি আপনার প্রয়োজন হবে।

পরিবেশ ভেরিয়েবল আপডেট করুন

এখন, আপনার env.sh ফাইলে আপনার Hugging Face টোকেন এবং আপনার GCS বাকেটের জন্য একটি নাম যোগ করুন। [your-hf-token] এর জায়গায় আপনি এইমাত্র কপি করা টোকেনটি বসান।

টার্মিনালে , নতুন ভেরিয়েবলগুলো env.sh এ যুক্ত করুন এবং সেগুলো রিলোড করুন:
```
cat <<EOF >> env.sh
export HF_TOKEN="[your-hf-token]"
export BUCKET_NAME="\${PROJECT_ID}-llama-fine-tuning"
EOF

source env.sh
```

৮. ওয়ার্কলোড আইডেন্টিটি কনফিগার করুন

এরপরে, আপনাকে ওয়ার্কলোড আইডেন্টিটি (Workload Identity) সেট আপ করতে হবে, যা GKE-তে চলমান অ্যাপ্লিকেশনগুলিকে স্ট্যাটিক সার্ভিস অ্যাকাউন্ট কী (static service account keys) পরিচালনা করার প্রয়োজন ছাড়াই গুগল ক্লাউড পরিষেবাগুলি অ্যাক্সেস করার অনুমতি দেওয়ার জন্য প্রস্তাবিত উপায়। আপনি ওয়ার্কলোড আইডেন্টিটি ডকুমেন্টেশনে এ বিষয়ে আরও জানতে পারবেন।

প্রথমে, একটি গুগল সার্ভিস অ্যাকাউন্ট (GSA) তৈরি করুন। টার্মিনালে , নিম্নলিখিত কমান্ডটি চালান:
```
cat <<EOF >> env.sh
export GSA_NAME="llama-fine-tuning"
EOF
source env.sh

gcloud iam service-accounts create $GSA_NAME \
  --display-name="Llama Fine-tuning Service Account"
```

এরপরে, GCS বাকেটটি তৈরি করুন এবং GSA-কে এটি অ্যাক্সেস করার অনুমতি দিন:

gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID --location=$REGION
gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \
    --member=serviceAccount:${GSA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com \
    --role=roles/storage.admin

এখন, একটি Kubernetes Service Account (KSA) তৈরি করুন:

cat <<EOF >> env.sh
export KSA_NAME="llama-workload-sa"
export NAMESPACE="ml-workloads"
EOF
source env.sh

kubectl create namespace $NAMESPACE
kubectl create serviceaccount $KSA_NAME --namespace $NAMESPACE

অবশেষে, GSA এবং KSA-এর মধ্যে IAM পলিসি বাইন্ডিং তৈরি করুন:

gcloud iam service-accounts add-iam-policy-binding ${GSA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:${PROJECT_ID}.svc.id.goog[${NAMESPACE}/${KSA_NAME}]"

kubectl annotate serviceaccount $KSA_NAME --namespace $NAMESPACE \
    iam.gke.io/gcp-service-account=${GSA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com

৯. বেস মডেলটি সাজান

প্রোডাকশন এমএল পাইপলাইনে, লামা ২ (~১৩ জিবি)-এর মতো বড় মডেলগুলো সাধারণত ট্রেনিংয়ের সময় ডাউনলোড না করে ক্লাউড স্টোরেজে আগে থেকেই প্রস্তুত রাখা হয়। এই পদ্ধতিটি আরও ভালো নির্ভরযোগ্যতা, দ্রুত অ্যাক্সেস প্রদান করে এবং নেটওয়ার্ক সমস্যা এড়াতে সাহায্য করে। গুগল ক্লাউড পাবলিক জিসিএস বাকেটে জনপ্রিয় মডেলগুলোর আগে থেকে ডাউনলোড করা সংস্করণ সরবরাহ করে, যা আপনি এই ল্যাবের জন্য ব্যবহার করবেন।

প্রথমে, চলুন যাচাই করে নেওয়া যাক যে আপনি গুগল-প্রদত্ত লামা ২ মডেলটি ব্যবহার করতে পারবেন কিনা:
```
gcloud storage ls gs://vertex-model-garden-public-us-central1/llama2/llama2-7b-hf/
```
gcloud storage কমান্ড ব্যবহার করে এই পাবলিক বাকেট থেকে Llama 2 মডেলটি আপনার নিজের প্রোজেক্টের বাকেটে কপি করুন। এই স্থানান্তরটি গুগলের দ্রুতগতির অভ্যন্তরীণ নেটওয়ার্ক ব্যবহার করে এবং এতে মাত্র এক বা দুই মিনিট সময় লাগা উচিত।
```
gcloud storage cp -r gs://vertex-model-garden-public-us-central1/llama2/llama2-7b-hf \
  gs://${BUCKET_NAME}/llama2-7b/
```
আপনার বাকেটের বিষয়বস্তু তালিকাভুক্ত করে মডেল ফাইলগুলো সঠিকভাবে কপি করা হয়েছে কিনা তা যাচাই করুন।
```
gcloud storage ls --recursive --long gs://${BUCKET_NAME}/llama2-7b/llama2-7b-hf/
```

১০. প্রশিক্ষণ কোডটি প্রস্তুত করুন।

এখন আপনি কন্টেইনারাইজড অ্যাপ্লিকেশনটি তৈরি করবেন যা মডেলটিকে ফাইন-টিউন করবে। এই কাজটি LoRA (Low-Rank Adaptation) ব্যবহার করে, যা একটি প্যারামিটার-দক্ষ ফাইন-টিউনিং (PEFT) কৌশল। এটি পুরো মডেলের পরিবর্তে শুধুমাত্র ছোট 'অ্যাডাপ্টার' লেয়ারগুলোকে প্রশিক্ষণ দিয়ে মেমরির প্রয়োজনীয়তা ব্যাপকভাবে কমিয়ে দেয়।

এখন, ট্রেনিং পাইপলাইনের জন্য পাইথন স্ক্রিপ্টগুলো তৈরি করুন।

টার্মিনালে train.py ফাইলটি খোলার জন্য নিম্নলিখিত কমান্ডটি চালান:
```
cloudshell edit train.py
```
নিম্নলিখিত কোডটি train.py ফাইলে পেস্ট করুন:

#!/usr/bin/env python3
"""Fine-tune Llama 2 with LoRA on American Stories dataset """

import os
import torch
import logging

from pathlib import Path
from datasets import load_dataset, concatenate_datasets
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    Trainer,
    TrainingArguments,
    DataCollatorForLanguageModeling
)
from peft import get_peft_model, LoraConfig

os.environ["TOKENIZERS_PARALLELISM"] = "false"
os.environ["NCCL_DEBUG"] = "INFO"

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class SimpleTextDataset(torch.utils.data.Dataset):
    def __init__(self, input_ids, attention_mask):
        self.input_ids = input_ids
        self.attention_mask = attention_mask
    
    def __len__(self):
        return len(self.input_ids)
    
    def __getitem__(self, idx):
        return {
            'input_ids': self.input_ids[idx],
            'attention_mask': self.attention_mask[idx],
            'labels': self.input_ids[idx].clone()
        }

def get_lora_config():
    config = {
       "r": 16,
       "lora_alpha": 32,
       "target_modules": [
          "q_proj", "k_proj", "v_proj", "o_proj",
          "gate_proj", "up_proj", "down_proj"
       ],
       "lora_dropout": 0.05,
       "task_type": "CAUSAL_LM",
    }
    return LoraConfig(**config)

def load_model_and_tokenizer(model_path):
    logger.info("Loading tokenizer...")
    tokenizer = AutoTokenizer.from_pretrained(model_path)
    
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    tokenizer.padding_side = "left"
    
    logger.info("Loading model...")

    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
        use_cache=False
    )
    
    return model, tokenizer

def prepare_dataset(tokenizer, max_length=512):
    logger.info("Loading American Stories dataset...")
     We recommend using o
    dataset = load_dataset(
        "dell-research-harvard/AmericanStories",
        "subset_years",
        year_list=["1809", "1810", "1811", "1812", "1813", "1814", "1815"],
        trust_remote_code=True
    )
    
    all_articles = []
    for year_data in dataset.values():
        all_articles.extend(year_data["article"])
    
    logger.info(f"Total articles collected: {len(all_articles)}")
    
    batch_size = 1000
    all_input_ids = []
    all_attention_masks = []
    
    for i in range(0, len(all_articles), batch_size):
        batch_articles = all_articles[i:i+batch_size]
        logger.info(f"Processing batch {i//batch_size + 1}/{(len(all_articles) + batch_size - 1)//batch_size}")
        
        encodings = tokenizer(
            batch_articles,
            padding="max_length",
            truncation=True,
            max_length=max_length,
            return_tensors="pt"
        )
        
        all_input_ids.append(encodings['input_ids'])
        all_attention_masks.append(encodings['attention_mask'])
    
    # Concatenate all batches
    input_ids = torch.cat(all_input_ids, dim=0)
    attention_mask = torch.cat(all_attention_masks, dim=0)
    
    logger.info(f"Total tokenized examples: {len(input_ids)}")
    
    # Create simple dataset
    dataset = SimpleTextDataset(input_ids, attention_mask)
    
    return dataset

def train_model(model, tokenizer, train_dataset, output_dir):
    logger.info(f"Train dataset size: {len(train_dataset)}")
    
    n_gpus = torch.cuda.device_count()
    logger.info(f"Available GPUs: {n_gpus}")
    
    # For multi-GPU, we can increase batch size
    per_device_batch_size = 2 if n_gpus > 1 else 1
    gradient_accumulation_steps = 2 if n_gpus > 1 else 4
    
    # Training for 250 steps
    max_steps = 250
    
    training_args = TrainingArguments(
        output_dir=output_dir,
        max_steps=max_steps,
        per_device_train_batch_size=per_device_batch_size,
        gradient_accumulation_steps=gradient_accumulation_steps,
        learning_rate=2e-4,
        warmup_steps=20,
        fp16=True,
        gradient_checkpointing=True,
        logging_steps=10,
        evaluation_strategy="no",
        save_strategy="no",
        optim="adamw_torch",
        ddp_find_unused_parameters=False,
        dataloader_num_workers=0,
        remove_unused_columns=False,
        report_to=[],
        disable_tqdm=False,
        logging_first_step=True,
    )
    
    # Create trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset,
        tokenizer=tokenizer,
        data_collator=DataCollatorForLanguageModeling(
            tokenizer=tokenizer,
            mlm=False,
            pad_to_multiple_of=8
        )
    )
    
    # Train
    logger.info(f"Starting training on {n_gpus} GPU(s)...")
    logger.info(f"Training for {max_steps} steps - approximately {(max_steps * 2.5 / 60):.1f} minutes")
    
    try:
        trainer.train()
        logger.info("Training completed successfully!")
    except Exception as e:
        logger.error(f"Training error: {e}")
        logger.info("Attempting to save model despite error...")
    
    logger.info("Saving model...")
    try:
        trainer.save_model(output_dir)
        tokenizer.save_pretrained(output_dir)
        logger.info(f"Model saved successfully to {output_dir}!")

        if not output_dir.startswith("/gcs-mount"):
            logger.info("Copying artifacts to GCS bucket...")
            gcs_target = "/gcs-mount/llama2-7b-american-stories"
            os.makedirs(gcs_target, exist_ok=True)
            return_code = os.system(f"cp -r {output_dir}/* {gcs_target}/")
            if return_code != 0:
                raise RuntimeError(f"Failed to copy model to GCS: cp command returned {return_code}")
            logger.info(f"Copied to {gcs_target}")

    except Exception as e:
        logger.error(f"Error saving model or copying to GCS: {e}")
        raise

def run_inference(model, tokenizer):
    logger.info("Running inference test...")
    
    prompt = "The year was 1812, and the"
    
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    model.eval()
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs, 
            max_new_tokens=50, 
            do_sample=True, 
            temperature=0.7,
            pad_token_id=tokenizer.pad_token_id
        )
    
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    logger.info("-" * 50)
    logger.info(f"Input Prompt: {prompt}")
    logger.info(f"Generated Text: {generated_text}")
    logger.info("-" * 50)

def main():
    if torch.cuda.is_available():
        for i in range(torch.cuda.device_count()):
            logger.info(f"GPU {i}: {torch.cuda.get_device_name(i)}")
    
    model_path = os.getenv('MODEL_PATH', '/gcs-mount/llama2-7b/llama2-7b-hf')
    output_path = os.getenv('OUTPUT_PATH', '/gcs-mount/llama2-7b-american-stories')
    
    # Load model and tokenizer
    model, tokenizer = load_model_and_tokenizer(model_path)
    model.enable_input_require_grads()

    # Apply LoRA
    logger.info("Applying LoRA configuration...")
    lora_config = get_lora_config()
    model = get_peft_model(model, lora_config)
    model.train()
    
    # Prepare dataset
    train_dataset = prepare_dataset(tokenizer)
    
    # Train
    train_model(model, tokenizer, train_dataset, output_path)
    
    # Run Inference
    run_inference(model, tokenizer)
    
    logger.info("Training and inference complete!")

if __name__ == "__main__":
    main()

১১. প্রশিক্ষণ কোডটি বুঝুন।

train.py স্ক্রিপ্টটি সূক্ষ্ম সমন্বয়ের প্রক্রিয়াটি পরিচালনা করে। চলুন এর মূল উপাদানগুলো বিশ্লেষণ করা যাক।

কনফিগারেশন

স্ক্রিপ্টটি লো-র‍্যাঙ্ক অ্যাডাপটেশন সেটিংস নির্ধারণ করতে LoraConfig ব্যবহার করে। LoRA প্রশিক্ষণযোগ্য প্যারামিটারের সংখ্যা উল্লেখযোগ্যভাবে হ্রাস করে, যার ফলে আপনি ছোট GPU-তেও বড় মডেল ফাইন-টিউন করতে পারেন।

def get_lora_config():
    config = {
       "r": 16,
       "lora_alpha": 32,
       "target_modules": ["q_proj", "k_proj", "v_proj", "o_proj", ...],
       "lora_dropout": 0.05,
       "task_type": "CAUSAL_LM",
    }
    return LoraConfig(**config)

ডেটাসেট প্রস্তুত করুন

prepare_dataset ফাংশনটি 'American Stories' ডেটাসেটটি লোড করে এবং সেটিকে টোকেনাইজড খণ্ডে প্রক্রিয়াজাত করে। এটি ইনপুট টেনসরগুলোকে দক্ষতার সাথে পরিচালনা করার জন্য একটি কাস্টম SimpleTextDataset ব্যবহার করে।

def prepare_dataset(tokenizer, max_length=512):
    dataset = load_dataset("dell-research-harvard/AmericanStories", ...)
    # ... tokenization logic ...
    return SimpleTextDataset(input_ids, attention_mask)

ট্রেন

train_model ফাংশনটি এই ওয়ার্কলোডের জন্য অপ্টিমাইজ করা নির্দিষ্ট আর্গুমেন্ট সহ Trainer সেট আপ করে। মূল প্যারামিটারগুলো হলো:

gradient_accumulation_steps : মেমরি ব্যবহার না বাড়িয়েই একটি বৃহত্তর ব্যাচ সাইজ অনুকরণ করতে সাহায্য করে।
fp16=True : মেমরি কমাতে ও গতি বাড়াতে মিক্সড প্রিসিশন ট্রেনিং ব্যবহার করে।
gradient_checkpointing=True : ব্যাকওয়ার্ড পাসের সময় অ্যাক্টিভেশনগুলো সংরক্ষণ না করে পুনরায় গণনা করার মাধ্যমে মেমরি সাশ্রয় করে।
optim="adamw_torch" : পাইটর্চ (PyTorch) থেকে স্ট্যান্ডার্ড AdamW অপটিমাইজার ইমপ্লিমেন্টেশন ব্যবহার করে।

training_args = TrainingArguments(
    per_device_train_batch_size=per_device_batch_size,
    gradient_accumulation_steps=gradient_accumulation_steps,
    fp16=True,
    gradient_checkpointing=True,
    optim="adamw_torch",
)

অনুমান

run_inference ফাংশনটি একটি নমুনা প্রম্পট ব্যবহার করে ফাইন-টিউন করা মডেলটির একটি দ্রুত পরীক্ষা চালায়। এটি নিশ্চিত করে যে মডেলটি ইভ্যালুয়েশন মোডে আছে এবং অ্যাডাপ্টারগুলো সঠিকভাবে কাজ করছে কিনা তা যাচাই করার জন্য টেক্সট তৈরি করে।

def run_inference(model, tokenizer):
    prompt = "The year was 1812, and the"
    # ... generation logic ...
    logger.info(f"Generated Text: {generated_text}")

১২. অ্যাপ্লিকেশনটিকে কন্টেইনারাইজ করুন

এখন, ডকার ব্যবহার করে ট্রেনিং কন্টেইনার ইমেজটি তৈরি করুন এবং গুগল আর্টিফ্যাক্ট রেজিস্ট্রি- তে পুশ করুন।

টার্মিনালে Dockerfile ফাইলটি খোলার জন্য নিম্নলিখিত কমান্ডটি চালান:
```
cloudshell edit Dockerfile
```
নিম্নলিখিত কোডটি Dockerfile ফাইলে পেস্ট করুন:

FROM pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

WORKDIR /app

# Install required packages
RUN pip install --no-cache-dir \
    transformers==4.46.0 \
    datasets==3.1.0 \
    pyarrow==15.0.0 \
    peft==0.13.2 \
    accelerate==1.1.0 \
    tensorboard==2.18.0 \
    nvidia-ml-py==12.535.161 \
    scipy==1.13.1

# Copy training scripts
COPY train.py /app/

# Run training
CMD ["python", "train.py"]

কন্টেইনারটি তৈরি করুন এবং ধাক্কা দিন

আর্টিফ্যাক্ট রেজিস্ট্রি রিপোজিটরি তৈরি করুন:

gcloud artifacts repositories create gke-finetune \
    --repository-format=docker \
    --location=$REGION \
    --description="Docker repository for Llama fine-tuning"

ক্লাউড বিল্ড ব্যবহার করে ইমেজটি তৈরি ও পুশ করুন:
```
gcloud builds submit --tag ${REGION}-docker.pkg.dev/${PROJECT_ID}/gke-finetune/llama-trainer:latest .
```

১৩. ফাইন-টিউনিং কাজটি ডিপ্লয় করুন।

ফাইন-টিউনিং জবটি শুরু করার জন্য কুবারনেটিস জব ম্যানিফেস্ট তৈরি করুন। টার্মিনালে , চালান:
```
cloudshell edit training_job.yaml
```
নিম্নলিখিত কোডটি training_job.yaml ফাইলে পেস্ট করুন:

apiVersion: batch/v1
kind: Job
metadata:
  name: llama-fine-tuning
  namespace: ml-workloads
spec:
  template:
    metadata:
      annotations:
        gke-gcsfuse/volumes: "true"
        gke-gcsfuse/memory-limit: "4Gi"
    spec:
      serviceAccountName: llama-workload-sa
      restartPolicy: OnFailure
      tolerations:
        - key: nvidia.com/gpu
          operator: Exists
          effect: NoSchedule
        - key: cloud.google.com/gke-spot
          operator: Exists
          effect: NoSchedule
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4

      containers:
        - name: training
          image: ${REGION}-docker.pkg.dev/${PROJECT_ID}/gke-finetune/llama-trainer:latest
          env:
            - name: MODEL_PATH
              value: "/gcs-mount/llama2-7b/llama2-7b-hf"
            - name: OUTPUT_PATH
              value: "/tmp/llama2-7b-american-stories"
            - name: NCCL_DEBUG
              value: "INFO"
          resources:
            requests:
              nvidia.com/gpu: 1
              cpu: "8"
              memory: "32Gi"
            limits:
              nvidia.com/gpu: 1

          volumeMounts:
            - name: gcs-fuse
              mountPath: /gcs-mount
            - name: shm
              mountPath: /dev/shm
      volumes:
        - name: gcs-fuse
          csi:
            driver: gcsfuse.csi.storage.gke.io
            volumeAttributes:
              bucketName: ${BUCKET_NAME}
              mountOptions: "implicit-dirs"
        - name: shm
          emptyDir:
            medium: Memory
            sizeLimit: 32Gi

অবশেষে, আপনার GKE ক্লাস্টারে ফাইন-টিউনিং কাজটি শুরু করতে Kubernetes জব ম্যানিফেস্টটি প্রয়োগ করুন।
```
envsubst < training_job.yaml | kubectl apply -f -
```

১৪. প্রশিক্ষণ কার্যক্রম পর্যবেক্ষণ করুন

আপনি গুগল ক্লাউড কনসোলে আপনার প্রশিক্ষণ কাজের অগ্রগতি পর্যবেক্ষণ করতে পারেন।

Kubernetes Engine > Workloads পৃষ্ঠায় যান।
GKE ওয়ার্কলোডগুলি দেখুন
llama-fine-tuning জবটির বিস্তারিত দেখতে সেটির উপর ক্লিক করুন।
ডিফল্টরূপে Details ট্যাবটি প্রদর্শিত হয়। আপনি Resources বিভাগে GPU ব্যবহারের মেট্রিকগুলো দেখতে পারেন।
প্রশিক্ষণের লগগুলো দেখতে লগস ট্যাবে ক্লিক করুন। আপনি প্রশিক্ষণের অগ্রগতি দেখতে পাবেন, যার মধ্যে লস এবং লার্নিং রেট অন্তর্ভুক্ত থাকবে।

১৫. পরিষ্কার করুন

এই টিউটোরিয়ালে ব্যবহৃত রিসোর্সগুলোর জন্য আপনার গুগল ক্লাউড অ্যাকাউন্টে চার্জ হওয়া এড়াতে, হয় রিসোর্সগুলো যে প্রজেক্টে রয়েছে সেটি ডিলিট করে দিন, অথবা প্রজেক্টটি রেখে দিয়ে আলাদা আলাদা রিসোর্সগুলো ডিলিট করে দিন।

GKE ক্লাস্টারটি মুছে ফেলুন

gcloud container clusters delete $CLUSTER_NAME --region $REGION --quiet

আর্টিফ্যাক্ট রেজিস্ট্রি রিপোজিটরিটি মুছে ফেলুন

gcloud artifacts repositories delete gke-finetune --location $REGION --quiet

GCS বালতিটি মুছে ফেলুন

gcloud storage rm -r gs://${BUCKET_NAME}

১৬. অভিনন্দন!

আপনি GKE-তে একটি ওপেন-সোর্স LLM সফলভাবে ফাইন-টিউন করেছেন!

পুনরালোচনা

এই ল্যাবে, আপনি:

GPU অ্যাক্সিলারেশন সহ একটি GKE ক্লাস্টার স্থাপন করা হয়েছে।
গুগল ক্লাউড পরিষেবাগুলিতে নিরাপদ অ্যাক্সেসের জন্য ওয়ার্কলোড আইডেন্টিটি কনফিগার করা হয়েছে।
ডকার এবং আর্টিফ্যাক্ট রেজিস্ট্রি ব্যবহার করে একটি পাইটর্চ ট্রেনিং জবকে কন্টেইনারাইজ করা হয়েছে।
Llama 2-কে একটি নতুন ডেটাসেটের সাথে খাপ খাইয়ে নিতে LoRA ব্যবহার করে একটি ফাইন-টিউনিং জব ডেপ্লয় করা হয়েছে।

এরপর কী?

GKE-তে AI সম্পর্কে আরও জানুন।
ভার্টেক্স এআই মডেল গার্ডেন অন্বেষণ করুন।
অন্যান্য ডেভেলপারদের সাথে সংযোগ স্থাপন করতে গুগল ক্লাউড কমিউনিটিতে যোগ দিন।

গুগল ক্লাউড লার্নিং পাথ

এই ল্যাবটি ‘প্রোডাকশন-রেডি এআই উইথ গুগল ক্লাউড’ লার্নিং পাথের একটি অংশ। প্রোটোটাইপ থেকে প্রোডাকশনের মধ্যবর্তী ধাপটি সম্পন্ন করতে সম্পূর্ণ কারিকুলামটি অন্বেষণ করুন ।

#ProductionReadyAI হ্যাশট্যাগটি ব্যবহার করে আপনার অগ্রগতি শেয়ার করুন।