Cum îți antrenezi propriul AI pe calculator: ghid practic pentru începători

Situatie

Învață pas cu pas cum să antrenezi local un model AI: ce hardware ai nevoie, ce instalezi și cum rulezi primul fine-tuning pe datele tale.

Solutie

Poți antrena local modele mici sau face fine-tuning pe modele pre-antrenate folosind un PC obișnuit. Ideal ai un GPU NVIDIA cu 6–12 GB VRAM, dar merge și pe CPU (mai lent). Instalezi Python + PyTorch, folosești Hugging Face transformers pentru text, îți pregătești datele (train/val/test) și rulezi un script de fine-tuning. Pentru LLM-uri mari, folosește LoRA/QLoRA ca să reduci memoria.

De ce să antrenezi local (și nu în cloud)?

Confidențialitate: datele tale nu părăsesc calculatorul.
Costuri controlate: zero taxare orară de GPU din cloud.
Învățare reală: înțelegi cap-coadă procesul, de la date la model.

Ce poți antrena realist pe un PC?

ML clasic (CPU-friendly): logistic regression, random forest — excelent pentru date tabelare.
Fine-tuning pe modele pre-antrenate:
- Text (NLP): BERT/DistilBERT pentru clasificare, NER, etc.
- Imagini: MobileNet/ResNet, YOLO pentru detecție.
LLM-uri prin LoRA/QLoRA: ajustezi câteva straturi → consum mic de VRAM, rezultate surprinzător de bune.

Antrenamentul “de la zero” pentru modele mari (tip GPT) nu este practic pe hardware consumer.

Hardware minim recomandat

CPU: generație modernă (quad-core+).
RAM: 16 GB (8 GB e limita minimă).
GPU (opțional, ideal): NVIDIA cu 6–12 GB VRAM.
Stocare: 20–100 GB liberi (date + modele + checkpoint-uri).
OS: Windows (ideal cu WSL2), macOS sau Linux.

Setup rapid (Windows/macOS/Linux)

Instalează Python 3.10+
Creează un mediu izolat (Conda sau venv)
Instalează PyTorch (CPU sau CUDA, în funcție de GPU)
Biblioteci utile: transformers, datasets, scikit-learn, pandas, matplotlib, tensorboard

Pregătirea datelor (cheia reușitei)

Format simplu: CSV cu două coloane: text, label.
Split corect: train/validation/test (de ex. 80/10/10).
Curățare: elimină dubluri, standardizează etichetele, verifică ortografia.
Echilibru: clase aproximativ egale sau folosește ponderi/tehnici anti-dezechilibru.
Legal & etică: verifică licențele și evită date sensibile.

Structură recomandată:

Exemplu practic: fine-tuning pentru clasificare de texte (DistilBERT)

Scop: învață un model să clasifice texte (ex. „pozitiv/negativ” sau „sport/tech/politică”).

# train.py

import os

from datasets import load_dataset

from transformers import (AutoTokenizer, AutoModelForSequenceClassification,

DataCollatorWithPadding, TrainingArguments, Trainer)

import numpy as np

from sklearn.metrics import accuracy_score, f1_score

MODEL_NAME = “distilbert-base-uncased” # pentru RO: “dumitrescustefan/bert-base-romanian-cased-v1”
DATA_DIR = “data”
OUTPUT_DIR = “outputs/distilbert-text-cls”

# 1) Încarcă CSV-urile
dataset = load_dataset(“csv”, data_files={
“train”: os.path.join(DATA_DIR, “train.csv”),
“validation”: os.path.join(DATA_DIR, “valid.csv”),
“test”: os.path.join(DATA_DIR, “test.csv”),
})

# 2) Mapare etichete
labels = sorted(list(set(dataset[“train”][“label”])))
label2id = {l: i for i, l in enumerate(labels)}
id2label = {i: l for l, i in label2id.items()}

def encode_labels(x):
x[“labels”] = label2id[x[“label”]]
return x

dataset = dataset.map(encode_labels)

# 3) Tokenizare
tok = AutoTokenizer.from_pretrained(MODEL_NAME)
def tokenize(batch): return tok(batch[“text”], truncation=True)
tokenized = dataset.map(tokenize, batched=True, remove_columns=[“text”,“label”])

# 4) Model
model = AutoModelForSequenceClassification.from_pretrained(
MODEL_NAME, num_labels=len(labels), id2label=id2label, label2id=label2id
)

# 5) Collator + metrici
collator = DataCollatorWithPadding(tokenizer=tok)
def compute_metrics(eval_pred):
logits, y_true = eval_pred
y_pred = np.argmax(logits, axis=-1)
return {“accuracy”: accuracy_score(y_true, y_pred),
“f1_macro”: f1_score(y_true, y_pred, average=“macro”)}

# 6) Antrenare
args = TrainingArguments(
output_dir=OUTPUT_DIR,
evaluation_strategy=“epoch”,
save_strategy=“epoch”,
learning_rate=2e-5,
per_device_train_batch_size=16,
per_device_eval_batch_size=32,
num_train_epochs=3,
weight_decay=0.01,
logging_steps=50,
load_best_model_at_end=True,
metric_for_best_model=“f1_macro”,
report_to=[“tensorboard”], # pornește cu: tensorboard –logdir outputs/
)

trainer = Trainer(
model=model, args=args,
train_dataset=tokenized[“train”],
eval_dataset=tokenized[“validation”],
tokenizer=tok,
data_collator=collator,
compute_metrics=compute_metrics,
)

trainer.train()

# 7) Evaluare finală
metrics = trainer.evaluate(tokenized[“test”])
print(metrics)

# 8) Salvare model
trainer.save_model(os.path.join(OUTPUT_DIR, “final_model”))
tok.save_pretrained(os.path.join(OUTPUT_DIR, “final_model”))

Rulare:

Fără GPU? Scade per_device_train_batch_size (ex. 8 sau 4) și/sau num_train_epochs.

Optimizări rapide :

Mixed precision (GPU): setează fp16=True în TrainingArguments.
Gradient accumulation: simulezi batch-uri mari pe VRAM mic.
LoRA/QLoRA pentru LLM-uri: antrenezi doar adaptoare (memorie & timp reduse).
Early stopping: evită overfitting și economisește timp.

Monitorizare & depanare

TensorBoard: urmărește loss/accuracy/F1 pe train vs. validation.
nvidia-smi: vezi consumul de VRAM/temperaturi.
Checkpoints: păstrează cel mai bun model; reia antrenarea oricând.
Semne de overfitting: scor mare pe train, mic pe val/test → mai multă regularizare/date.

Cum folosești modelul antrenat (inferență locală)

Îl poți împacheta într-un CLI (Click/Typer) sau într-un mic API (FastAPI/Gradio) și rulezi local, offline.

Alternative pe scurt (dacă nu lucrezi pe text)

Imagini: fine-tune MobileNet/ResNet cu torchvision, detecție cu YOLO.
Audio: fine-tune Whisper pentru accente/limbi specifice.
Tabelar: scikit-learn (XGBoost/LightGBM) — excelent pe CPU.

Tip solutie

Permanent

Follow Us