Materiale Lot - Natural Language Processing & Audio

Natural Language Processing & Audio - Ghid complet pentru lotul ONIA (pe baza programei de la IOAI)

Cuprins

0. Cum se abordează o problemă de NLP sau Audio
1. Text Classification
2. Tokenizare, embedding-uri și reprezentări secvențiale
3. Pre-trained Text Encoders: BERT
4. Language Modeling
5. Encoder-Decoder Models: traducere, sumarizare și VLM
6. Pre-trained Language Models: open-source și API-based
7. Audio Processing: spectrograme, features și pipeline
8. Pre-trained Audio Encoders: HuBERT
9. Audio Models: Whisper, Qwen-Audio, Voxtral
10. Rețetă practică pentru concursuri
11. Exemplu complet PyTorch/Hugging Face: clasificare text
12. Exemplu complet Audio: clasificare sau transcriere

0. Cum se abordează o problemă de NLP sau Audio

Pentru rezolvarea unei probleme de NLP nu începem direct cu presupunerea faptului că utilizăm un LLM (model mare). Începem prin clarificarea task-ului, a datelor, a metricii și a constrângerilor.

0.1 Înțelege exact task-ul

Înainte de model, răspunde la următoarele întrebări:

1. Ce primește modelul la intrare?
   Text scurt, document lung, conversație, pereche întrebare-context, pereche text-text, audio brut, spectrogramă, pereche audio-text, imagine-text etc.

2. Ce trebuie să producă la ieșire?
   O clasă, mai multe clase, scor de similaritate, etichete pe tokeni, text generat, traducere, sumarizare, transcriere audio, embedding sau răspuns liber.

3. Care este metrica folosită pentru evaluare?
   Accuracy, macro-F1, weighted-F1, ROC-AUC, BLEU, ROUGE, exact match, WER, CER, perplexity etc. Loss-ul de antrenare trebuie să fie compatibil cu metrica, dar metrica finală trebuie calculată separat.

4. Care sunt constrângerile practice?
   Număr mic de exemple, clase dezechilibrate, texte lungi, limbi diferite, zgomot în etichete, date audio cu sample rate diferit, GPU limitat, limită de timp sau limită de cost pentru API.

0.2 Verifică și vizualizează datele

În NLP, „vizualizarea” înseamnă inspecția atentă a textelor și a distribuțiilor:

• exemple din fiecare clasă;
• lungimea textelor în tokens;
• caractere ciudate, HTML, emoji, diacritice, cod, URL-uri;
• duplicate și near-duplicate;
• clase foarte rare;
• exemple cu etichete suspecte;
• diferențe între train și test.

În audio, verifică:

• sample rate-ul;
• durata clipurilor;
• amplitudinea și clipping-ul;
• zgomotul de fundal;
• canalele mono/stereo;
• alinierea audio-transcript;
• spectrograme pentru exemple reprezentative.

0.3 Construiește întâi un baseline simplu

Baseline-uri recomandate:

• text classification: TF-IDF + Logistic Regression sau BERT mic fine-tuned;
• semantic similarity: embeddings + cosine similarity;
• language modeling: model cauzal mic sau model pre-antrenat evaluat prin perplexity;
• translation/summarization: T5/BART/MarianMT pre-antrenat;
• ASR: Whisper sau alt model pre-antrenat;
• audio classification: embeddings HuBERT/Wav2Vec2 + clasificator simplu.

Scopul baseline-ului este să demonstreze că pipeline-ul funcționează: datele au fost procesate corect, loss-ul scade, metrica e calculată corect, iar predicțiile sunt rezonabile.

0.4 Testul de overfit pe un subset mic

Un model suficient de mare trebuie să poată "învăța" un subset mic de date. Dacă nu poate ajunge la scor foarte mare pe 16–64 de exemple, probabil există un bug:

• etichetele sunt deplasate;
• padding-ul sau attention mask-ul e greșit;
• modelul primește input gol/trunchiat;
• loss-ul e incompatibil cu ieșirea;
• learning rate-ul e nepotrivit;
• în audio, waveform-ul este normalizat sau reeșantionat greșit.

0.5 Exemplu rapid: inspecția unui batch de texte

1from collections import Counter2import numpy as np3​4texts = train_df["text"].astype(str).tolist()5labels = train_df["label"].tolist()6​7print("Număr exemple:", len(texts))8print("Distribuție clase:", Counter(labels))9​10lengths = [len(t.split()) for t in texts]11print("Lungime medie:", np.mean(lengths))12print("Percentila 95:", np.percentile(lengths, 95))13​14for i in range(5):15    print("-" * 80)16    print("label:", labels[i])17    print(texts[i][:1000])

1. Text Classification

1.1 Obiectiv

În clasificarea textului, modelul primește o secvență de tokeni și produce o distribuție peste clase:

$\hat{y} = \operatorname{softmax}(f_\theta(x))$

unde $f_\theta(x)$ produce logits. În PyTorch, pentru CrossEntropyLoss, modelul trebuie să returneze logits, nu probabilități softmax.

1.2 Exemple de task-uri

• clasificare sentiment: pozitiv/negativ/neutru;
• detecție spam;
• clasificare topic;
• toxicitate;
• intenție într-un chatbot;
• clasificare documente juridice/medicale;
• clasificare multilabel, unde un text poate avea mai multe etichete.

1.3 Baseline clasic: TF-IDF + Logistic Regression

Acest baseline este extrem de util în concursuri, deoarece este rapid de implementat și, de cele mai multe ori, robust.

1from sklearn.feature_extraction.text import TfidfVectorizer2from sklearn.linear_model import LogisticRegression3from sklearn.pipeline import Pipeline4from sklearn.metrics import classification_report5​6clf = Pipeline([7    ("tfidf", TfidfVectorizer(max_features=50_000, ngram_range=(1, 2))),8    ("lr", LogisticRegression(max_iter=2000, class_weight="balanced")),9])10​11clf.fit(train_texts, train_labels)12preds = clf.predict(valid_texts)13print(classification_report(valid_labels, preds))

1.4 Fine-tuning cu encoder pre-antrenat

Pentru performanță mai mare, folosește un encoder de tip BERT/RoBERTa/DeBERTa. Pentru fiecare text, tokenizerul produce:

• input_ids: ID-urile tokenilor;
• attention_mask: 1 pentru tokeni reali, 0 pentru padding;
• uneori token_type_ids: segment A/B, util în perechi de propoziții.

1.5 Metrici importante

Referințe / cursuri recomandate

• Cornell CS5740 — Text Classification
  Introducere în clasificarea textelor, reprezentări de text și modele clasice pentru NLP.

• Liu NLP — Text Classification Handout
  Material de curs despre pipeline-ul de clasificare, features, evaluare și modele de bază.

• University of Edinburgh — Text Classification
  Slide-uri despre clasificarea documentelor, abordări statistice și metode moderne.

• Stanford CS224N / Jurafsky & Martin — Naive Bayes
  Explicații clare despre Naive Bayes pentru clasificarea textelor și sentiment analysis.

• Text Mining Course — Lecture 03: Text Classification
  Curs aplicat despre clasificarea textelor, reprezentări, antrenare și evaluare.

Jupyter notebooks / tutoriale practice pentru clasificarea textelor

Hugging Face / Transformers

• Hugging Face Notebooks — Text Classification
  Notebook oficial pentru fine-tuning cu transformers pe un task de text classification din GLUE.

• Hugging Face Docs — Text Classification
  Tutorial oficial pentru sequence classification cu AutoTokenizer, AutoModelForSequenceClassification, Trainer și Datasets.

• Hugging Face Workshop — Text Classification Colab
  Notebook Colab practic: încărcare dataset din Hugging Face Hub, procesare, baseline și clasificare text.

• Learn Hugging Face — Text Classification Tutorial
  Tutorial hands-on pentru clasificare text cu ecosistemul Hugging Face, orientat spre cod reutilizabil.

PyTorch + BERT / Transformers

• Text Classification with BERT in PyTorch
  Notebook practic pentru sentiment analysis folosind BERT în PyTorch.

• Fine-Tuning BERT for Text Classification — Colab
  Notebook Colab pentru fine-tuning BERT: preprocessare, batch-uri, antrenare și evaluare.

• Pytorch BERT Text Classification
  Repository cu tutorial pentru clasificare text folosind BERT și modele similare, precum RoBERTa.

• BERT on AG News
  Walkthrough detaliat pentru clasificare text cu BERT pe AG News, incluzând dataloaders, schedulers, optimizers și gradient clipping.

• Text Classification with BERT — PyTorch Implementation
  Implementare PyTorch pentru fine-tuning BERT pe task de sarcasm detection.

PyTorch clasic / modele de la zero

• PyTorch Sentiment Analysis — Ben Trevett
  Colecție foarte bună de notebook-uri pentru sentiment analysis cu PyTorch, de la modele simple la modele mai avansate.

• PyTorch Tutorial — Character-Level RNN Classification
  Tutorial oficial PyTorch pentru clasificare la nivel de caractere cu RNN, util pentru înțelegerea pipeline-ului NLP de bază.

• Text Classification using PyTorch — DebuggerCafe
  Tutorial code-first pentru clasificare text cu PyTorch pe IMDB, incluzând preprocessing, dataloaders, model și inferență.

• Build a Spam Text Classifier using PyTorch — IBM
  Tutorial practic pentru clasificare spam cu PyTorch.

• ClearML Notebook — Text Classification AG_NEWS
  Notebook pentru clasificare text pe AG_NEWS cu PyTorch și integrare ClearML pentru tracking.

2. Tokenizare, embedding-uri și reprezentări secvențiale

2.1 De ce avem nevoie de tokenizare?

Modelele nu procesează direct text brut. Textul este transformat într-o secvență de tokeni, iar tokenii sunt mapați la indici numerici.

Exemplu conceptual:

1"Îmi place AI" -> ["Îmi", "place", "AI"] -> [1832, 981, 42]

Modelele moderne folosesc de obicei tokenizare subword: BPE, WordPiece sau SentencePiece. Avantajul este că pot reprezenta și cuvinte rare prin bucăți mai mici.

2.2 Embedding-uri

Un embedding transformă un token într-un vector dens:

$E: {1, \dots, V} \rightarrow \mathbb{R}^d$

unde $V$ este dimensiunea vocabularului, iar (d) este dimensiunea embedding-ului.

2.3 Padding și attention mask

Textele dintr-un batch au lungimi diferite. Pentru a le pune într-un tensor, se folosește padding. Modelul trebuie informat ce poziții sunt reale și ce poziții sunt padding:

1encoded = tokenizer(2    texts,3    padding=True,4    truncation=True,5    max_length=256,6    return_tensors="pt",7)8​9print(encoded["input_ids"].shape)10print(encoded["attention_mask"].shape)

2.4 Alegerea lungimii maxime

Nu alege automat max_length=512. Verifică distribuția lungimilor. Dacă 95% dintre texte au sub 180 de tokeni, max_length=192 sau 256 poate fi mai rapid și suficient.

1lengths = [len(tokenizer(t)["input_ids"]) for t in train_texts[:5000]]2print(np.percentile(lengths, [50, 75, 90, 95, 99]))

Referințe / cursuri recomandate pentru tokenizare

• Stanford CS224N / Jurafsky & Martin — Tokenization
  Slide-uri despre tokenizare, normalizare, segmentare în cuvinte și metode moderne de tokenizare folosite în NLP.

• LaBRI LLM Course — Tokenization
  Material de curs despre rolul tokenizării în LLM-uri, reprezentarea textului și tokenizatoare moderne.

• Language Modeling Course — Tokenization
  Lecție dedicată tokenizării pentru modele de limbaj, incluzând motivația, subword tokenization și implicațiile practice.

• Context Lab LLM Course — Lecture 6: Tokenization
  Slide-uri despre tokenizare în contextul modelelor mari de limbaj, cu accent pe BPE, vocabular și efecte asupra procesării textului.

• Stanford CS224N 2026 — Tokenization and Multilinguality
  Slide-uri despre tokenizare în contexte multilingve, efectele vocabularului asupra limbilor diferite și provocările tokenizării pentru LLM-uri.

• Stanford CS224N 2020 — Subword Models
  Slide-uri despre metode subword, inclusiv BPE, WordPiece și SentencePiece, și despre rolul lor în modelele moderne de NLP.

Jupyter notebooks / tutoriale practice pentru tokenizare

Hugging Face / Transformers

• Hugging Face Notebooks — Training a tokenizer from scratch
  Notebook oficial despre antrenarea unui tokenizer de la zero pe un corpus propriu, util pentru înțelegerea BPE/WordPiece/SentencePiece în practică. :contentReference[oaicite:0]{index=0}

• Hugging Face Notebooks — Tokenizer summary
  Notebook/documentație practică despre cum textul este împărțit în cuvinte sau subwords și apoi convertit în ID-uri pentru modele Transformers. :contentReference[oaicite:1]{index=1}

• Hugging Face Docs — Transformers notebooks
  Colecție oficială de notebook-uri Hugging Face pentru transformers, incluzând preprocessing, tokenizare și fine-tuning. :contentReference[oaicite:2]{index=2}

• Hugging Face Notebooks — Token classification
  Notebook practic pentru fine-tuning pe token classification, util pentru a vedea cum se aliniază tokenizarea subword cu etichetele la nivel de token. :contentReference[oaicite:3]{index=3}

• Hugging Face Tokenizer Tricks
  Notebook cu exemple practice despre funcționalități utile ale tokenizerelor Hugging Face: padding, truncation, offset mappings și procesare de batch-uri. :contentReference[oaicite:4]{index=4}

NLTK

• NLTK Hands-On Tutorial — Jupyter notebooks
  Colecție de notebook-uri hands-on pentru NLTK, potrivită pentru introducere în tokenizare, procesare de text și operații NLP clasice. :contentReference[oaicite:5]{index=5}

• Natural Language Processing with Python — NLTK Tokenization Notebook
  Notebook dedicat tokenizării cu NLTK, cu exemple de împărțire a textului în propoziții și cuvinte. :contentReference[oaicite:6]{index=6}

• Tokenizing Words and Sentences with NLTK — Colab
  Notebook Colab introductiv pentru tokenizare la nivel de cuvinte și propoziții folosind NLTK. :contentReference[oaicite:7]{index=7}

• Hands-on NLTK Tutorial — Text Analysis Using NLTK
  Notebook practic care începe cu tokenizarea textului și continuă cu analiză lexicală și procesare NLP de bază. :contentReference[oaicite:8]{index=8}

• Teaching NLP Notebooks — NLTK Intro
  Notebook educațional cu exerciții de tokenizare, POS tagging și named entity recognition folosind NLTK. :contentReference[oaicite:9]{index=9}

PyTorch / TorchText

• PyTorch Tutorial — Language Translation with TorchText
  Tutorial practic despre tokenizarea propozițiilor, construirea vocabularului, transformarea tokenilor în tensori și folosirea DataLoader pentru modele NLP. :contentReference[oaicite:10]{index=10}

• PyTorch Text — torchtext.transforms
  Documentație practică pentru transformări TorchText, inclusiv tokenizatoare și conversii text → tokeni → ID-uri. :contentReference[oaicite:11]{index=11}

• Practical TorchText — Language Modeling Notebook
  Notebook despre pregătirea datelor text pentru language modeling cu TorchText, incluzând tokenizare, vocabular și batch-uri. :contentReference[oaicite:12]{index=12}

• How to tokenize text using PyTorch
  Rețetă practică despre tokenizare în ecosistemul PyTorch/TorchText, folosind get_tokenizer și conversia textului în tokeni. :contentReference[oaicite:13]{index=13}

• Build a Transformer-based Language Model Using TorchText
  Tutorial practic pentru construirea unui model de limbaj Transformer cu PyTorch și TorchText, incluzând pașii de preprocessing și tokenizare. :contentReference[oaicite:14]{index=14}

3. Pre-trained Text Encoders: BERT

3.1 Ideea centrală

BERT este un encoder Transformer bidirecțional. Spre deosebire de modelele cauzale, care prezic următorul token folosind doar contextul din stânga, BERT poate folosi context din ambele direcții. De aceea, este foarte bun pentru task-uri de înțelegere: clasificare, NER, matching, question answering extractiv.

3.2 Pretraining

BERT a fost pre-antrenat prin sarcini de tip:

• Masked Language Modeling: unele tokenuri sunt mascate, iar modelul trebuie să le prezică;
• Next Sentence Prediction în varianta originală.

3.3 Fine-tuning pentru clasificare

Pentru clasificare, de obicei se ia reprezentarea tokenului special [CLS] sau pooling-ul peste tokeni, apoi se aplică un strat liniar.

$h = \operatorname{BERT}(x)_{[CLS]}$

$\hat{y} = \operatorname{softmax}(Wh + b)$

3.4 Strategie de fine-tuning

3.5 Exemplu Hugging Face: BERT pentru clasificare

1from transformers import AutoTokenizer, AutoModelForSequenceClassification2​3model_name = "bert-base-uncased"4num_labels = 35​6tokenizer = AutoTokenizer.from_pretrained(model_name)7model = AutoModelForSequenceClassification.from_pretrained(8    model_name,9    num_labels=num_labels,10)11​12batch = tokenizer(13    ["This movie was surprisingly good.", "I did not like the ending."],14    padding=True,15    truncation=True,16    return_tensors="pt",17)18​19outputs = model(**batch)20print(outputs.logits.shape)  # batch_size x num_labels

3.6 Capcane frecvente

• Learning rate prea mare; pentru BERT, încearcă valori precum 2e-5, 3e-5, 5e-5.
• Prea multe epoci pe dataset mic.
• Lipsa seed-ului și variație mare între rulări.
• Evaluare pe un validation set care nu seamănă cu testul.
• Folosirea unui tokenizer diferit de model.

Referințe / cursuri recomandate pentru BERT și Masked Language Modeling

• Harvard CS287 — Lecture 11: BERT
  Slide-uri despre transfer learning în NLP, arhitectura BERT, pretraining și adaptarea modelelor pre-antrenate la task-uri downstream.

• Stanford / Jurafsky & Martin — Masked Language Models: BERT
  Material despre masked language modeling, obiectivul de pretraining al BERT și modul în care modelul învață reprezentări bidirecționale.

• Context Lab LLM Course — Lecture 19: BERT Variants
  Slide-uri despre limitările BERT original și variante moderne precum RoBERTa, ALBERT, DistilBERT, ELECTRA și ModernBERT.

• UMass CS685 — BERT, Part 1
  Introducere în transfer learning pentru NLP, pretraining self-supervised și ideea centrală din spatele BERT.

• UMass CS685 — BERT, Part 2
  Continuare despre BERT: ce învață modelul, cum se folosește în downstream tasks și discuții despre RoBERTa și modele multilingve.

• Stanford CS224N — Jacob Devlin: BERT
  Slide-uri invitate despre BERT, susținute de unul dintre autorii modelului, cu explicații despre pretraining, fine-tuning și impactul BERT asupra task-urilor NLP.

4. Language Modeling

4.1 Obiectiv

Un model de limbaj estimează probabilitatea unei secvențe de tokeni:

$P(x_1, x_2, \dots, x_T)$

În modelarea autoregresivă, aceasta se factorizează astfel:

$P(x_1, \dots, x_T) = \prod_{t=1}^{T} P(x_t \mid x_1, \dots, x_{t-1})$

Modelele de tip GPT sunt modele de limbaj cauzale: prezic următorul token.

4.2 Loss pentru language modeling

Pentru fiecare poziție, modelul produce o distribuție peste vocabular. Loss-ul este cross-entropy între tokenul real și distribuția prezisă:

$L = - \sum_{t=1}^{T} \log P_\theta(x_t \mid x_{<t})$

4.3 Perplexity

Perplexity măsoară cât de „surprins” este modelul de text:

$\operatorname{PPL} = \exp\left(\frac{1}{T}\sum_{t=1}^{T} -\log P_\theta(x_t \mid x_{<t})\right)$

Perplexity mai mică înseamnă model mai bun pe distribuția de evaluare, dar nu garantează automat calitate superioară pentru generare liberă.

4.4 Greedy, sampling și temperature

La generare, modelul produce distribuții peste tokeni. Alegerea tokenului următor poate fi făcută prin:

• greedy decoding: alegi mereu tokenul cu probabilitate maximă;
• beam search: păstrezi mai multe ipoteze;
• top-k sampling: alegi din cei mai probabili k tokeni;
• top-p/nucleus sampling: alegi din cel mai mic set cu probabilitate cumulată p;
• temperature: controlează cât de plată sau concentrată este distribuția.

4.5 Exemplu: generare cu un model causal

1from transformers import AutoTokenizer, AutoModelForCausalLM2import torch3​4model_name = "gpt2"5tokenizer = AutoTokenizer.from_pretrained(model_name)6model = AutoModelForCausalLM.from_pretrained(model_name)7​8prompt = "Artificial intelligence is useful because"9inputs = tokenizer(prompt, return_tensors="pt")10​11with torch.no_grad():12    output_ids = model.generate(13        **inputs,14        max_new_tokens=40,15        do_sample=True,16        temperature=0.8,17        top_p=0.9,18    )19​20print(tokenizer.decode(output_ids[0], skip_special_tokens=True))

Referințe / cursuri recomandate pentru Language Modeling

• Harvard CS287 — Lecture 03: Language Modelling
  Slide-uri despre formularea probabilistică a language modeling-ului, modele n-gram, neural language models și evaluarea prin perplexity.

• Jurafsky & Martin — Chapter 3: N-gram Language Models
  Capitol de manual despre modele de limbaj n-gram, probabilități condiționate, smoothing și perplexity.

• CMU 10-601 — Lecture 21: Language Modeling
  Curs despre language modeling din perspectivă ML, incluzând estimarea probabilităților, modele n-gram și evaluare.

• UIUC CS447 — Lecture 03: Language Modeling
  Slide-uri introductive despre modele de limbaj, tokenizare, n-gramuri, smoothing și perplexity.

• Methods II — Language Modeling: Formal Handout
  Handout formal despre definirea modelelor de limbaj, factorizarea probabilității unei secvențe și obiectivele de antrenare.

• Georgia Tech CS7650 — Language Modeling
  Slide-uri despre language modeling clasic și neural, cu accent pe reprezentări, probabilități și evaluare.

5. Encoder-Decoder Models: traducere, sumarizare și VLM

5.1 Ideea centrală

Modelele encoder-decoder transformă o secvență de intrare într-o secvență de ieșire. Encoderul citește inputul, decoderul generează outputul autoregresiv.

Exemple de task-uri:

• traducere automată;
• sumarizare;
• corectare gramaticală;
• question answering generativ;
• captioning imagine-text;
• conversie speech-to-text în unele arhitecturi.

5.2 Formulare

Pentru input $x$ și output $y = (y_1, \dots, y_T)$:

$P(y \mid x) = \prod_{t=1}^{T} P(y_t \mid y_{<t}, x)$

Encoderul produce reprezentări contextualizate ale inputului, iar decoderul folosește self-attention cauzal și cross-attention peste reprezentările encoderului.

5.3 Exemple de modele

5.4 Training teacher forcing

În timpul antrenării, decoderul primește tokenii corecți anteriori și trebuie să prezică următorul token. Aceasta se numește teacher forcing.

5.5 Exemplu: traducere cu model pre-antrenat

1from transformers import AutoTokenizer, AutoModelForSeq2SeqLM2​3model_name = "Helsinki-NLP/opus-mt-en-ro"4tokenizer = AutoTokenizer.from_pretrained(model_name)5model = AutoModelForSeq2SeqLM.from_pretrained(model_name)6​7text = "Machine learning is a powerful tool."8inputs = tokenizer(text, return_tensors="pt")9output_ids = model.generate(**inputs, max_new_tokens=64)10​11print(tokenizer.decode(output_ids[0], skip_special_tokens=True))

5.6 Metrici pentru generare

5.7 Capcane frecvente

• max_new_tokens prea mic taie răspunsul.
• Beam search prea mare produce texte rigide sau repetitive.
• BLEU/ROUGE pot penaliza răspunsuri corecte formulate diferit.
• Fine-tuning pe set mic poate duce la memorare rapidă.

6. Pre-trained Language Models: open-source și API-based

6.1 Categorii de modele

6.2 Open-source vs API

6.3 Prompting pentru API-based models

Pentru probleme de concurs, promptul trebuie să fie explicit, scurt și verificabil:

1Ești un clasificator. Primești un text și trebuie să returnezi exact una dintre clasele:2[SPORT, POLITICĂ, TEHNOLOGIE, ECONOMIE].3​4Text: "..."5​6Răspuns doar cu numele clasei.

6.4 Structured output

Când ai nevoie de predicții automate, cere format structurat:

1{2  "label": "TEHNOLOGIE",3  "confidence": 0.824}

Apoi validează programatic JSON-ul. Nu te baza pe text liber dacă rezultatul trebuie integrat într-un pipeline.

6.5 Fine-tuning și parameter-efficient tuning

Când modelul e mare, fine-tuning complet poate fi scump. Alternative:

• LoRA: antrenezi matrice low-rank adăugate în straturi;

• Adapters: module mici inserate în model;

• Prompt tuning: antrenezi embedding-uri de prompt;
• Classifier peste embeddings: simplu și eficient pentru clasificare.

6.6 Capcane frecvente

• Nu păstrezi un validation set ascuns.
• Optimizezi promptul pe test set.
• Nu fixezi formatul răspunsului.
• Folosești LLM pentru o problemă unde TF-IDF + Logistic Regression ar fi suficient.
• Nu monitorizezi costul și latența.

7. Audio Processing: spectrograme, features și pipeline

7.1 Ce este un semnal audio?

Un fișier audio este o secvență de valori numerice care reprezintă amplitudinea în timp. Parametrul esențial este sample rate-ul: câte valori pe secundă sunt înregistrate.

Exemple:

• 16 kHz: frecvent pentru speech;
• 44.1 kHz: audio muzical standard;
• mono vs stereo: unul sau două canale.

7.2 Spectrograma

Modelele audio rareori lucrează doar cu waveform brut. O reprezentare foarte folosită este spectrograma, care arată energia semnalului în funcție de timp și frecvență.

Mel-spectrograma aplică o scală perceptuală, mai apropiată de modul în care oamenii percep frecvențele.

7.3 Pipeline audio tipic

1. Încarcă fișierul audio.
2. Convertește la mono dacă e nevoie.
3. Eșantionează la sample rate-ul cerut de model.
4. Normalizează amplitudinea.
5. Extrage features sau tokenizează audio-ul cu processorul modelului.
6. Rulează encoderul/modelul.
7. Calculează metrica: accuracy, macro-F1, WER, CER etc.

7.4 Exemplu: încărcare audio și mel-spectrogramă

1import torchaudio2​3waveform, sr = torchaudio.load("example.wav")4​5# Convertim stereo -> mono6if waveform.shape[0] > 1:7    waveform = waveform.mean(dim=0, keepdim=True)8​9# Resampling la 16 kHz10resampler = torchaudio.transforms.Resample(orig_freq=sr, new_freq=16_000)11waveform = resampler(waveform)12​13mel = torchaudio.transforms.MelSpectrogram(14    sample_rate=16_000,15    n_fft=400,16    hop_length=160,17    n_mels=80,18)(waveform)19​20print(waveform.shape, mel.shape)

7.5 Capcane frecvente

• Amesteci fișiere cu sample rate-uri diferite fără resampling.
• Faci padding fără să păstrezi attention mask.
• Tai clipurile exact unde apare informația relevantă.
• Ai leak: același vorbitor apare și în train, și în validation.
• Folosești metrică de clasificare pentru task de transcriere.

8. Pre-trained Audio Encoders: HuBERT

8.1 Ideea centrală

HuBERT este un encoder audio self-supervised pentru speech. Modelul învață reprezentări utile din audio neetichetat, folosind predicția unor unități ascunse/clusterizate pentru porțiuni mascate ale semnalului.

Intuiția este asemănătoare cu masked language modeling: ascunzi părți din input și obligi modelul să reconstruiască sau să prezică o reprezentare discretă relevantă.

8.2 Când este util?

• clasificarea emoțiilor din voce;
• speaker identification;
• speech command classification;
• embeddings audio pentru downstream tasks;
• fine-tuning pentru ASR.

8.3 Exemplu: embeddings cu HuBERT

1import torch2import torchaudio3from transformers import AutoProcessor, HubertModel4​5model_name = "facebook/hubert-base-ls960"6processor = AutoProcessor.from_pretrained(model_name)7model = HubertModel.from_pretrained(model_name)8​9waveform, sr = torchaudio.load("example.wav")10if waveform.shape[0] > 1:11    waveform = waveform.mean(dim=0)12else:13    waveform = waveform.squeeze(0)14​15if sr != 16_000:16    waveform = torchaudio.functional.resample(waveform, sr, 16_000)17​18inputs = processor(waveform.numpy(), sampling_rate=16_000, return_tensors="pt")19​20with torch.no_grad():21    outputs = model(**inputs)22​23# B x T x hidden_size24features = outputs.last_hidden_state25embedding = features.mean(dim=1)26print(embedding.shape)

8.4 Classifier peste encoder audio

Pentru un dataset mic, poți îngheța HuBERT și antrena doar un classifier peste embedding-ul mediu. Pentru dataset mai mare, poți face fine-tuning parțial sau complet.

9. Audio Models: Whisper, Qwen-Audio, Voxtral

9.1 Whisper

Whisper este un model foarte folosit pentru Automatic Speech Recognition. Primește audio și produce text. Este util pentru:

• transcriere;
• traducere speech-to-text în anumite configurații;
• pipeline-uri în care audio-ul trebuie convertit în text înainte de NLP.

Exemplu:

1from transformers import pipeline2​3asr = pipeline(4    "automatic-speech-recognition",5    model="openai/whisper-small",6)7​8result = asr("example.wav")9print(result["text"])

9.2 Qwen-Audio și Voxtral

Modelele audio-language moderne pot primi audio și text și pot răspunde în limbaj natural. În concursuri, pot fi utile pentru:

• clasificare audio cu prompt;
• question answering pe audio;
• sumarizarea unui clip audio;
• combinarea transcrierii cu raționament textual.

9.3 Strategie practică

Pentru task-uri simple, folosește pipeline în două etape:

1. ASR cu Whisper sau alt model audio;
2. NLP pe transcript: clasificare, sumarizare, extragere de informații.

Pentru task-uri unde informația paralingvistică contează — emoție, vorbitor, accent, zgomot — transcriptul nu este suficient. Acolo folosește și embeddings audio.

9.4 Metrici audio

10. Rețetă practică pentru concursuri

10.1 Checklist inițial

• Citește exact formatul input/output.
• Verifică metrica oficială.
• Vizualizează distribuția claselor.
• Inspectează manual 20–50 de exemple.
• Caută duplicate.
• Definește split train/validation fără leak.
• Rulează un baseline clasic.
• Rulează un baseline pre-antrenat.
• Analizează erorile.

10.2 Baseline-uri recomandate

Pentru clasificare text:

1. TF-IDF + Logistic Regression;
2. BERT/RoBERTa fine-tuned;
3. ensemble simplu sau average logits;
4. threshold tuning pentru multilabel.

Pentru generare text:

1. model pre-antrenat fără fine-tuning;
2. prompt clar și format structurat;
3. evaluare automată + inspecție manuală;
4. fine-tuning doar dacă datele sunt suficiente.

Pentru audio:

1. verifică sample rate și durata;
2. folosește Whisper pentru ASR;
3. folosește HuBERT/Wav2Vec2 pentru embeddings audio;
4. combină transcript + audio embeddings dacă task-ul cere ambele.

10.3 Diagnostic rapid

10.4 Reguli de performanță

• Nu schimba mai multe lucruri simultan.
• Păstrează fiecare experiment într-un tabel.
• Salvează predicțiile pe validation pentru error analysis.
• Folosește seed, dar rulează mai multe seed-uri dacă scorul variază mult.
• Optimizează metrica de concurs, nu doar loss-ul.

11. Exemplu complet PyTorch/Hugging Face: clasificare text

11.1 Instalare

1pip install transformers datasets evaluate accelerate scikit-learn

11.2 Dataset minimal

1from datasets import Dataset2​3train_data = {4    "text": [5        "The movie was excellent.",6        "The food was terrible.",7        "I loved the book.",8        "The service was slow and rude.",9    ],10    "label": [1, 0, 1, 0],11}12​13valid_data = {14    "text": ["Amazing experience.", "I will not come back."],15    "label": [1, 0],16}17​18train_ds = Dataset.from_dict(train_data)19valid_ds = Dataset.from_dict(valid_data)

11.3 Tokenizare

1from transformers import AutoTokenizer2​3model_name = "distilbert-base-uncased"4tokenizer = AutoTokenizer.from_pretrained(model_name)5​6​7def tokenize_batch(batch):8    return tokenizer(9        batch["text"],10        padding="max_length",11        truncation=True,12        max_length=128,13    )14​15train_ds = train_ds.map(tokenize_batch, batched=True)16valid_ds = valid_ds.map(tokenize_batch, batched=True)17​18train_ds = train_ds.remove_columns(["text"])19valid_ds = valid_ds.remove_columns(["text"])20train_ds.set_format("torch")21valid_ds.set_format("torch")

11.4 Model și metrică

1import numpy as np2from sklearn.metrics import accuracy_score, f1_score3from transformers import AutoModelForSequenceClassification4​5model = AutoModelForSequenceClassification.from_pretrained(6    model_name,7    num_labels=2,8)9​10​11def compute_metrics(eval_pred):12    logits, labels = eval_pred13    preds = np.argmax(logits, axis=1)14    return {15        "accuracy": accuracy_score(labels, preds),16        "macro_f1": f1_score(labels, preds, average="macro"),17    }

11.5 Training

1from transformers import TrainingArguments, Trainer2​3args = TrainingArguments(4    output_dir="./text_clf_model",5    eval_strategy="epoch",6    save_strategy="epoch",7    learning_rate=2e-5,8    per_device_train_batch_size=16,9    per_device_eval_batch_size=32,10    num_train_epochs=3,11    weight_decay=0.01,12    load_best_model_at_end=True,13    metric_for_best_model="macro_f1",14)15​16trainer = Trainer(17    model=model,18    args=args,19    train_dataset=train_ds,20    eval_dataset=valid_ds,21    tokenizer=tokenizer,22    compute_metrics=compute_metrics,23)24​25trainer.train()26print(trainer.evaluate())

11.6 Inferență

1import torch2​3texts = ["This was a wonderful result.", "The product broke immediately."]4inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")5​6model.eval()7with torch.no_grad():8    logits = model(**inputs).logits9    probs = logits.softmax(dim=1)10    preds = probs.argmax(dim=1)11​12print(preds.tolist())13print(probs.tolist())

12. Exemplu complet Audio: clasificare sau transcriere

12.1 ASR rapid cu Whisper

1from transformers import pipeline2​3asr = pipeline(4    task="automatic-speech-recognition",5    model="openai/whisper-small",6)7​8result = asr("sample.wav")9print(result["text"])

12.2 Clasificare audio cu embeddings HuBERT

1import torch2import torch.nn as nn3from transformers import AutoProcessor, HubertModel4​5class HubertClassifier(nn.Module):6    def __init__(self, model_name="facebook/hubert-base-ls960", num_classes=4):7        super().__init__()8        self.encoder = HubertModel.from_pretrained(model_name)9        hidden_size = self.encoder.config.hidden_size10        self.classifier = nn.Linear(hidden_size, num_classes)11​12    def forward(self, input_values, attention_mask=None):13        outputs = self.encoder(14            input_values=input_values,15            attention_mask=attention_mask,16        )17        x = outputs.last_hidden_state.mean(dim=1)18        return self.classifier(x)19​20processor = AutoProcessor.from_pretrained("facebook/hubert-base-ls960")21model = HubertClassifier(num_classes=4)

12.3 Observații practice

• Pentru speech, multe modele așteaptă audio la 16 kHz.
• Pentru batch-uri cu durate diferite, folosește padding și attention mask.
• Pentru clipuri lungi, segmentează audio-ul și agregă predicțiile.
• Pentru classification, verifică dacă split-ul separă vorbitorii; altfel scorul poate fi artificial mare.