HuggingFace Transformers

Clore.ai पर NLP, विज़न और ऑडियो के लिए HuggingFace Transformers का उपयोग करें

GPU पर NLP, विज़न और ऑडियो के लिए Transformers लाइब्रेरी का उपयोग करें।

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

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

1. पर जाएँ CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (निश्चित दर) या स्पॉट (बिड प्राइस)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTC, या USDT/USDC

6. ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

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

• कनेक्शन विवरण में खोजें मेरे ऑर्डर

• वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

Transformers क्या है?

Hugging Face Transformers प्रदान करता है:

• 100,000+ प्रीट्रेंड मॉडल

• आसान मॉडल लोडिंग और इनफरेंस

• फाइन-ट्यूनिंग समर्थन

• मल्टी-मॉडल क्षमताएं

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

Docker इमेज:

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

पोर्ट:

22/tcp

कमांड:

pip install transformers accelerate datasets huggingface_hub

इंस्टॉलेशन

pip install transformers[torch]
pip install accelerate  # बड़े मॉडल के लिए
pip install datasets    # प्रशिक्षण डेटा के लिए

टेक्स्ट जेनरेशन

मूल जनरेशन

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "mistralai/Mistral-7B-Instruct-v0.2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

prompt = "सरल शब्दों में क्वांटम कंप्यूटिंग को समझाइए:"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.7,
    do_sample=True
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

चैट मॉडल

from transformers import pipeline

pipe = pipeline(
    "text-generation",
    model="meta-llama/Llama-2-7b-chat-hf",
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [
    {"role": "user", "content": "मशीन लर्निंग क्या है?"}
]

outputs = pipe(
    messages,
    max_new_tokens=256,
    do_sample=True,
    temperature=0.7
)

print(outputs[0]["generated_text"][-1]["content"])

स्ट्रीमिंग

from transformers import TextStreamer

streamer = TextStreamer(tokenizer)

model.generate(
    **inputs,
    max_new_tokens=200,
    streamer=streamer
)

क्वांटाइज़ेशन

4-बिट क्वांटाइज़ेशन

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-13b-hf",
    quantization_config=bnb_config,
    device_map="auto"
)

8-बिट क्वांटाइज़ेशन

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_8bit=True,
    device_map="auto"
)

एम्बेडिंग्स

from transformers import AutoModel, AutoTokenizer
import torch

model_name = "sentence-transformers/all-MiniLM-L6-v2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name).cuda()

def get_embedding(text):
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True).to("cuda")
    with torch.no_grad():
        outputs = model(**inputs)
    # मीन पूलिंग
    embedding = outputs.last_hidden_state.mean(dim=1)
    return embedding

emb = get_embedding("Hello, world!")
print(f"Embedding shape: {emb.shape}")

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

from transformers import pipeline
from PIL import Image

classifier = pipeline("image-classification", model="google/vit-base-patch16-224", device=0)

image = Image.open("cat.jpg")
results = classifier(image)

for result in results:
    print(f"{result['label']}: {result['score']:.4f}")

ऑब्जेक्ट डिटेक्शन

from transformers import pipeline
from PIL import Image

detector = pipeline("object-detection", model="facebook/detr-resnet-50", device=0)

image = Image.open("street.jpg")
results = detector(image)

for result in results:
    print(f"{result['label']}: {result['score']:.4f} at {result['box']}")

इमेज सेगमेंटेशन

from transformers import pipeline
from PIL import Image

segmenter = pipeline("image-segmentation", model="facebook/maskformer-swin-base-ade", device=0)

image = Image.open("scene.jpg")
results = segmenter(image)

for segment in results:
    print(f"{segment['label']}: score {segment['score']:.4f}")

स्पीच रिकॉग्निशन

from transformers import pipeline

transcriber = pipeline(
    "automatic-speech-recognition",
    model="openai/whisper-large-v3",
    device=0
)

result = transcriber("audio.mp3")
print(result["text"])

टेक्स्ट-से-स्पीच

from transformers import pipeline
import scipy

synthesizer = pipeline("text-to-speech", model="microsoft/speecht5_tts", device=0)

speech = synthesizer("Hello, this is a test of text to speech.")

scipy.io.wavfile.write("output.wav", rate=speech["sampling_rate"], data=speech["audio"])

फाइन-ट्यूनिंग

डेटासेट तैयार करें

from datasets import load_dataset

dataset = load_dataset("imdb")
train_dataset = dataset["train"].select(range(1000))
eval_dataset = dataset["test"].select(range(200))

प्रशिक्षण

from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    TrainingArguments,
    Trainer
)

model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_train = train_dataset.map(tokenize_function, batched=True)
tokenized_eval = eval_dataset.map(tokenize_function, batched=True)

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
    fp16=True,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train,
    eval_dataset=tokenized_eval,
)

trainer.train()

पाइपलाइन टास्क

कार्य	पाइपलाइन का नाम
टेक्स्ट जेनरेशन	text-generation
Fill Mask	fill-mask
Summarization	summarization
Translation	translation
Question Answering	question-answering
Sentiment Analysis	sentiment-analysis
इमेज क्लासीफ़िकेशन	image-classification
ऑब्जेक्ट डिटेक्शन	object-detection
स्पीच रिकॉग्निशन	automatic-speech-recognition
टेक्स्ट-से-स्पीच	text-to-speech

मल्टी-GPU

from transformers import AutoModelForCausalLM

# ऑटोमैटिक डिवाइस प्लेसमेंट
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-70b-hf",
    device_map="auto",
    torch_dtype=torch.float16
)

# मैनुअल डिवाइस मैप
device_map = {
    "model.embed_tokens": 0,
    "model.layers.0": 0,
    "model.layers.1": 0,
    # ...
    "model.layers.39": 1,
    "model.norm": 1,
    "lm_head": 1
}

model = AutoModelForCausalLM.from_pretrained(
    "model_name",
    device_map=device_map
)

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

# फ्लैश अटेंशन 2
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    torch_dtype=torch.float16,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

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

मॉडल हब

मॉडल डाउनलोड करें

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="meta-llama/Llama-2-7b-hf",
    local_dir="./llama-2-7b"
)

मॉडल अपलोड करें

from huggingface_hub import HfApi

api = HfApi()
api.upload_folder(
    folder_path="./my_model",
    repo_id="username/my-model",
    repo_type="model"
)

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

सुझाव	प्रभाव
उपयोग करें torch_dtype=torch.float16	50% कम मेमोरी
फ्लैश अटेंशन 2 सक्षम करें	2x तेज़ अटेंशन
क्वांटाइज़ेशन का उपयोग करें	75% कम मेमोरी
बैच इनफरेंस	उच्च थ्रूपुट

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

लागत अनुमान

सामान्य 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 टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• vLLM Inference - प्रोडक्शन सर्विंग

• LLMs को फाइन-ट्यून करें - LoRA प्रशिक्षण

• DeepSpeed प्रशिक्षण - वितरित प्रशिक्षण