HuggingFace Transformers

Используйте HuggingFace Transformers для NLP, зрения и аудио на Clore.ai

Используйте библиотеку Transformers для NLP, компьютерного зрения и аудио на GPU.

Все примеры можно запускать на GPU-серверах, арендуемых через CLORE.AI Marketplace.

Аренда на CLORE.AI

1. Посетите CLORE.AI Marketplace

2. Отфильтруйте по типу GPU, объему VRAM и цене

3. Выберите On-Demand (фиксированная ставка) или Spot (цена по ставке)

4. Настройте ваш заказ:

   • Выберите Docker-образ

   • Установите порты (TCP для SSH, HTTP для веб-интерфейсов)

   • Добавьте переменные окружения при необходимости

   • Введите команду запуска

5. Выберите способ оплаты: CLORE, BTC, или USDT/USDC

6. Создайте заказ и дождитесь развертывания

Доступ к вашему серверу

• Найдите данные для подключения в Моих заказах

• Веб-интерфейсы: используйте URL HTTP-порта

• 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"])

Потоковая передача (Streaming)

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: {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()

Задачи Pipeline

Задача	Название Pipeline
Генерация текста	text-generation
Заполнение маски	fill-mask
Суммаризация	summarization
Перевод	translation
Ответы на вопросы	question-answering
Анализ настроений	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
)

Оптимизация памяти

# Flash Attention 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()

Model Hub

Загрузка моделей

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% меньше памяти
Включить Flash Attention 2	Внимание в 2 раза быстрее
Использовать квантование	На 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 Marketplace для текущих тарифов.

Экономьте деньги:

• Используйте Spot рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)

• Платите с помощью CLORE токенов

• Сравнивайте цены у разных провайдеров

Дальнейшие шаги

• vLLM Inference - Продакшен-сервинг

• Тонкая настройка LLM - Обучение LoRA

• Обучение с DeepSpeed - Распределенное обучение