Jupyter ML प्रशिक्षण

Clore.ai पर ML प्रशिक्षण के लिए GPU समर्थन के साथ JupyterLab सेट अप करें

मशीन लर्निंग प्रयोगों और मॉडल प्रशिक्षण के लिए GPU समर्थन के साथ JupyterLab सेटअप करें।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

सर्वर आवश्यकताएँ

पैरामीटर

न्यूनतम

अनुशंसित

RAM

16GB

32GB+

VRAM

8GB

16GB+

नेटवर्क

200Mbps

500Mbps+

स्टार्टअप समय

2-3 मिनट

JupyterLab स्वयं हल्का होता है। अपने प्रशिक्षण कार्यभार आवश्यकताओं के आधार पर GPU और RAM चुनें।

त्वरित तैनाती

Docker इमेज:

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

पोर्ट:

22/tcp
8888/http
6006/http

पर्यावरण:

JUPYTER_TOKEN=your_secure_token_here

कमांड:

pip install jupyterlab tensorboard && \
jupyter lab --ip=0.0.0.0 --port=8888 --allow-root --NotebookApp.token='your_secure_token_here'

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें http_pub URL में मेरे ऑर्डर:

जाएँ मेरे ऑर्डर पृष्ठ
अपने ऑर्डर पर क्लिक करें
खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए उदाहरणों में।

जांचें कि यह काम कर रहा है

# जांचें कि JupyterLab सुलभ है या नहीं
curl https://your-http-pub.clorecloud.net/

# टोकन के साथ पहुँचें
# https://your-http-pub.clorecloud.net/?token=your_secure_token_here

यदि आपको HTTP 502 मिलता है, तो 2-3 मिनट प्रतीक्षा करें - सेवा निर्भरताओं को इंस्टॉल कर रही है।

CLORE.AI पर किराये पर लेना

पर जाएँ CLORE.AI मार्केटप्लेस
GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें
चुनें ऑन-डिमांड (निश्चित दर) या स्पॉट (बिड प्राइस)
अपना ऑर्डर कॉन्फ़िगर करें:
- Docker इमेज चुनें
- पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
- यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें
- स्टार्टअप कमांड दर्ज करें
भुगतान चुनें: CLORE, BTC, या USDT/USDC
ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

अपने सर्वर तक पहुँचें

कनेक्शन विवरण में खोजें मेरे ऑर्डर
वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें
SSH: ssh -p <port> root@<proxy-address>

Jupyter तक पहुँचें

डिप्लॉयमेंट का इंतजार करें
पोर्ट 8888 मैपिंग खोजें
खोलें: http://<proxy>:<port>?token=your_secure_token_here

प्री-कॉन्फ़िगर किया गया ML इमेज

पूर्ण ML वातावरण के लिए:

इमेज:

jupyter/pytorch-notebook:cuda12-pytorch-2.1.0

या कस्टम बनाएं:

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

RUN pip install --no-cache-dir \
    jupyterlab \
    numpy pandas matplotlib seaborn \
    scikit-learn \
    transformers datasets accelerate \
    tensorboard wandb \
    opencv-python pillow \
    tqdm rich

EXPOSE 8888 6006

CMD ["jupyter", "lab", "--ip=0.0.0.0", "--allow-root"]

आवश्यक पुस्तकालय

Jupyter में स्थापित करें

!pip install transformers datasets accelerate bitsandbytes
!pip install wandb tensorboard
!pip install scikit-learn xgboost lightgbm
!pip install opencv-python albumentations

requirements.txt बनाएं


# ML फ्रेमवर्क
torch>=2.1.0
torchvision
torchaudio

# NLP
transformers>=4.36.0
datasets
tokenizers
sentencepiece

# प्रशिक्षण
accelerate
bitsandbytes
peft
trl

# निगरानी
wandb
tensorboard

# डेटा
numpy
pandas
matplotlib
seaborn
scikit-learn

# कंप्यूटर विज़न
opencv-python
pillow
albumentations

प्रशिक्षण उदाहरण

PyTorch इमेज क्लासिफिकेशन

import torch
import torch.nn as nn
import torchvision
from torchvision import transforms
from torch.utils.data import DataLoader

# GPU जांचें
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# डेटा लोड करें
transform = transforms.Compose([
    transforms.Resize(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

train_data = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=transform
)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True, num_workers=4)

# मॉडल
model = torchvision.models.resnet18(pretrained=True)
model.fc = nn.Linear(512, 10)
model = model.cuda()

# प्रशिक्षण
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
    model.train()
    for images, labels in train_loader:
        images, labels = images.cuda(), labels.cuda()

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

# मॉडल सहेजें
torch.save(model.state_dict(), 'model.pth')

HuggingFace टेक्स्ट क्लासिफिकेशन

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import TrainingArguments, Trainer
from datasets import load_dataset
import numpy as np

# डेटासेट लोड करें
dataset = load_dataset("imdb")

# मॉडल लोड करें
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# टोकनाइज़ करें
def tokenize(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized = dataset.map(tokenize, batched=True)

# प्रशिक्षण
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=100,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized["train"],
    eval_dataset=tokenized["test"],
)

trainer.train()
trainer.save_model("./best_model")

LLM Fine-tuning with LoRA

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset
from trl import SFTTrainer
import torch

# 4-बिट क्वांटाइजेशन के साथ मॉडल लोड करें
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
)

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    quantization_config=bnb_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
tokenizer.pad_token = tokenizer.eos_token

# LoRA कॉन्फ़िगर करें
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)

# डेटासेट लोड करें
dataset = load_dataset("timdettmers/openassistant-guanaco")

# ट्रेन
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    dataset_text_field="text",
    max_seq_length=512,
    tokenizer=tokenizer,
    args=TrainingArguments(
        output_dir="./lora_output",
        num_train_epochs=1,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=10,
        save_steps=100,
    ),
)

trainer.train()
trainer.save_model("./final_lora")

TensorBoard एकीकरण

TensorBoard शुरू करें

%load_ext tensorboard
%tensorboard --logdir ./logs --port 6006 --bind_all

या टर्मिनल के माध्यम से:

tensorboard --logdir ./logs --port 6006 --bind_all &

प्रशिक्षण मेट्रिक्स लॉग करें

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('./logs')

for epoch in range(epochs):
    # ... प्रशिक्षण लूप ...
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Loss/val', val_loss, epoch)
    writer.add_scalar('Accuracy/val', accuracy, epoch)

writer.close()

Weights & Biases एकीकरण

import wandb

wandb.init(project="my-project", name="experiment-1")

# मेट्रिक्स लॉग करें
wandb.log({"loss": loss, "accuracy": acc})

# मॉडल लॉग करें
wandb.save("model.pth")

# समाप्त करें
wandb.finish()

डेटा प्रबंधन

डेटासेट डाउनलोड करें


# HuggingFace datasets
from datasets import load_dataset
dataset = load_dataset("squad")

# Kaggle datasets
!pip install kaggle
!kaggle datasets download -d username/dataset-name

# सीधे डाउनलोड
!wget https://example.com/data.zip
!unzip data.zip

क्लाउड स्टोरेज माउंट करें


# S3
!pip install boto3
import boto3
s3 = boto3.client('s3')
s3.download_file('bucket', 'key', 'local_path')

# Google Cloud
!pip install google-cloud-storage
from google.cloud import storage
client = storage.Client()
bucket = client.bucket('my-bucket')
blob = bucket.blob('data.zip')
blob.download_to_filename('data.zip')

काम सहेजना

बाहरी स्टोरेज पर सहेजें


# मॉडल को S3 पर सहेजें
import boto3
s3 = boto3.client('s3',
    aws_access_key_id='YOUR_KEY',
    aws_secret_access_key='YOUR_SECRET'
)
s3.upload_file('model.pth', 'my-bucket', 'models/model.pth')

सत्र समाप्त करने से पहले


# महत्वपूर्ण फाइलें डाउनलोड करें
scp -P <port> root@<host>:/workspace/model.pth ./
scp -P <port> -r root@<host>:/workspace/results/ ./results/

मल्टी-GPU प्रशिक्षण

import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel

# GPU जांचें
print(f"Available GPUs: {torch.cuda.device_count()}")

# DataParallel (सरल)
model = nn.DataParallel(model)

# DistributedDataParallel (बेहतर)

# इसे लॉन्च करें: torchrun --nproc_per_node=4 train.py
dist.init_process_group("nccl")
model = DistributedDataParallel(model)

प्रदर्शन सुझाव

मेमोरी अनुकूलन


# ग्रेडिएंट चेकपॉइंटिंग
model.gradient_checkpointing_enable()

# मिक्स्ड प्रिसिशन
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()

with autocast():
    output = model(input)
    loss = criterion(output, target)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

डेटा लोडिंग


# तेज़ डेटा लोडिंग
loader = DataLoader(
    dataset,
    batch_size=64,
    num_workers=8,      # कई वर्कर्स का उपयोग करें
    pin_memory=True,    # GPU ट्रांसफ़र के लिए तेज़
    prefetch_factor=2   # बैचेस प्रीफ़ेटच करें
)

समस्याओं का निवारण

लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

GPU

घंटात्मक दर

दैनिक दर

4-घंटे सत्र

RTX 3060

~$0.03

~$0.70

~$0.12

RTX 3090

~$0.06

~$1.50

~$0.25

RTX 4090

~$0.10

~$2.30

~$0.40

A100 40GB

~$0.17

~$4.00

~$0.70

A100 80GB

~$0.25

~$6.00

~$1.00

कीमतें प्रदाता और मांग के अनुसार बदलती हैं। जाँच करें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
भुगतान करें CLORE टोकन के साथ
विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

Previousअवलोकन NextDreamBooth

Last updated 1 day ago

Was this helpful?

hashtagसर्वर आवश्यकताएँ

hashtagत्वरित तैनाती

hashtagअपनी सेवा तक पहुँचना

hashtagजांचें कि यह काम कर रहा है

hashtagCLORE.AI पर किराये पर लेना

hashtagअपने सर्वर तक पहुँचें

hashtagJupyter तक पहुँचें

hashtagप्री-कॉन्फ़िगर किया गया ML इमेज

hashtagआवश्यक पुस्तकालय

hashtagJupyter में स्थापित करें

hashtagrequirements.txt बनाएं

hashtagप्रशिक्षण उदाहरण

hashtagPyTorch इमेज क्लासिफिकेशन

hashtagHuggingFace टेक्स्ट क्लासिफिकेशन

hashtagLLM Fine-tuning with LoRA

hashtagTensorBoard एकीकरण

hashtagTensorBoard शुरू करें

hashtagप्रशिक्षण मेट्रिक्स लॉग करें

hashtagWeights & Biases एकीकरण

hashtagडेटा प्रबंधन

hashtagडेटासेट डाउनलोड करें

hashtagक्लाउड स्टोरेज माउंट करें

hashtagकाम सहेजना

hashtagबाहरी स्टोरेज पर सहेजें

hashtagसत्र समाप्त करने से पहले

hashtagमल्टी-GPU प्रशिक्षण

hashtagप्रदर्शन सुझाव

hashtagमेमोरी अनुकूलन

hashtagडेटा लोडिंग

hashtagसमस्याओं का निवारण

hashtagलागत अनुमान

सर्वर आवश्यकताएँ

त्वरित तैनाती

अपनी सेवा तक पहुँचना

जांचें कि यह काम कर रहा है

CLORE.AI पर किराये पर लेना

अपने सर्वर तक पहुँचें

Jupyter तक पहुँचें

प्री-कॉन्फ़िगर किया गया ML इमेज

आवश्यक पुस्तकालय

Jupyter में स्थापित करें

requirements.txt बनाएं

प्रशिक्षण उदाहरण

PyTorch इमेज क्लासिफिकेशन

HuggingFace टेक्स्ट क्लासिफिकेशन

LLM Fine-tuning with LoRA

TensorBoard एकीकरण

TensorBoard शुरू करें

प्रशिक्षण मेट्रिक्स लॉग करें

Weights & Biases एकीकरण

डेटा प्रबंधन

डेटासेट डाउनलोड करें

क्लाउड स्टोरेज माउंट करें

काम सहेजना

बाहरी स्टोरेज पर सहेजें

सत्र समाप्त करने से पहले

मल्टी-GPU प्रशिक्षण

प्रदर्शन सुझाव

मेमोरी अनुकूलन

डेटा लोडिंग

समस्याओं का निवारण

लागत अनुमान