# **Smulkinimas išankstinių modelių: pritaikymas LLMM pagal užduotis (Hugging Face)** --- ## **Įvadas** Dideli kalbos modeliai (LLM), tokie kaip BERT, RoBERTa, T5 ir GPT-3, labai pagerino natūralios kalbos apdorojimą (NLP), pasiekdami aukštą našumą įvairiose užduotyse. Tačiau šie modeliai paprastai išankstinami dideliuose, bendros paskirties duomenų rinkiniuose (pvz., Common Crawl, Wikipedia ar interneto korpusuose) ir gali neveikti optimaliai **specifinėse srityse** ar **užduotyse**. **Smulkinimas** yra procesas, kai išankstintas LLM pritaikomas **užduočiai** (pvz., nuotaikų analizė, klausimų atsakymas ar teksto klasifikavimas) toliau mokant jį **mažesniame, užduočiai skirtoje duomenų rinkinyje**. Šis požiūris pasinaudoja **perkeliamu mokymu**, kai modelis išlaiko savo išankstintas žinias, specializuodamasis naujoje srityje. Šiame skyriuje mes: 1. **Suprasime smulkinimo teoriją** (kodėl tai veikia, kada naudoti ir jos apribojimus). 2. **Išnagrinėsime Hugging Face `transformers` biblioteką**, kuri plačiai laikoma standartu dirbant su išankstintais modeliais. 3. **Pravažiuosime žingsnis po žingsnio smulkinimo procesą**, nuo duomenų rinkinio paruošimo iki modelio įdiegimo. 4. **Analizuosime geriausias praktikas**, įskaitant hiperparametrų derinimą, vertinimo metrikas ir skaičiavimo svarstymus. 5. **Išnagrinėsime pažangias technikas**, tokias kaip **parametrų efektyvus smulkinimas (PEFT)** ir **žemo rango adaptacija (LoRA)**. Baigus šį skyrių, jūs galėsite **smulkinėti bet kurį išankstintą LLM užduočiai** naudodami Hugging Face įrankius, optimizuoti našumą ir įdiegti modelį gamyboje. --- ## **Pagrindinės sąvokos** ### **1. Kodėl smulkinimas vietoj mokymo nuo nulio?** Didelio kalbos modelio mokymas nuo nulio reikalauja: - **Didelių skaičiavimo išteklių** (GPU/TPU, galbūt savaitės mokymo). - **Didelių duomenų rinkinių** (dažnai milijardų žetonų). - **Didelių ekspertų žinių** paskirstytame mokyme ir optimizacijoje. Smulkinimas, priešingai: - **Naudoja išankstintas svoris**, žymiai sumažindamas mokymo laiką ir duomenų reikalavimus. - **Pasinaudoja perkeliami mokymu**, kai modelis jau supranta kalbos šablonus (sintaksę, semantika, kontekstą). - **Leidžia specializaciją** nišinėse srityse (pvz., juridinė, medicininė ar techninė žargonija). #### **Kada smulkinimas?** | **Scenarijus** | **Smulkinimo tinkamumas** | **Alternatyvus požiūris** | |----------------------------|---------------------------|-----------------------------------| | **Bendros paskirties užduotys** (pvz., pokalbiai, santraukos) | ✅ Aukštas (naudokite didelį išankstintą modelį, pvz., FLAN-T5 arba ChatGPT) | Išankstintas modelis + užuominų inžinerija | | **Specifinės srities užduotys** (pvz., medicininė diagnozė, teisinė sutarčių analizė) | ✅ Labai aukštas (smulkinimas pagal srities duomenis) | Treniruokite mažesnį modelį nuo nulio | | **Žemo duomenų režimai** (<1,000 pavyzdžių) | ⚠️ Vidutinis (per didelio pritaikymo rizika; apsvarstykite PEFT) | Nulinės užuominų derinimas | | **Aukšto duomenų režimai** (>10,000 pavyzdžių) | ✅ Puikus (visas smulkinimas veikia gerai) | Visas modelio mokymas | | **Pakraunamieji įrenginiai** (ribotas skaičiavimas) | ❌ Žemas (naudokite distiliuotus arba kvantizuotus modelius) | Žinių distiliavimas | --- ### **2. Kaip veikia smulkinimas: techninė skauska** Smulkinimas koreguoja **išankstinto modelio svorius** naudodamas **užduočiai skirtojo nuostolio funkciją**. Procesą galima suskirstyti į tris pagrindinius etapus: #### **A. Išankstinimas (Jau padaryta)** - Bazinis modelis (pvz., BERT, RoBERTa) yra mokomas **bendrajame korpuse** (pvz., knygos, svetainės) naudodamas **maskuotą kalbos modeliavimą (MLM)** arba **priežastinį kalbos modeliavimą (CLM)**. - Modelis išmoksta **universalius kalbos atvaizdus** (pvz., žodžių įdėjimai, dėmesio šablonus). #### **B. Smulkinimas (Jūsų užduotis)** 1. **Pasirinkite išankstintą modelį** (pvz., `bert-base-uncased`, `distilbert-base-uncased`). 2. **Paruoškite užduočiai skirto duomenų rinkinį** (pažymėtus pavyzdžius klasifikavimui, klausimų-atsakymų poras ir kt.). 3. **Pridėkite užduočiai skirtą sluoksnį** (pvz., klasifikavimo sluoksnį teksto klasifikavimui). 4. **Mokykite naujame duomenų rinkinyje** naudodami: - **Užduočiai skirto nuostolio** (pvz., kryžminė entropija klasifikavimui, MSE regresijai). - **Optimizavimo technikas** (pvz., AdamW, mokymosi greičio planavimas). 5. **Vertinkite ir įdiekite** smulkinimą. #### **C. Pagrindiniai svarstymai** - **Perkeliamo mokymo atotrūkis**: Išankstintas modelis gali nesutapti su nauja užduotimi. Smulkinimas užpildo šį atotrūkį. - **Katastrrofinė užmiršimas**: Jei nauja užduotis labai skiriasi, modelis gali "užmiršti" išankstintas žinias. Švelninimas: **Naudokite mažesnius mokymosi greičius** arba **užšalkite ankstyvus sluoksnius**. - **Per didelis pritaikymas**: Su mažais duomenų rinkiniais modelis gali įsiminti mokymo duomenis. Švelninimas: **Reguliarizacija (Dropout, svorio skilimas), Ankstyvas sustabdymas, Duomenų papildymas**. --- ### **3. Hugging Face `transformers` biblioteka: Smulkinimo pagrindas** Hugging Face [`transformers`](https://huggingface.co/docs/transformers/index) biblioteka teikia: - **Išankstinti modeliai** (100+ architektūros, šimtai tūkstančių modelių variantų). - **Optimizuoti mokymo ciklus** (`Trainer`, `TrainingArguments`). - **Tokenizatoriai, optimizatoriai ir vertinimo metrikos**. - **Integracija su PyTorch ir TensorFlow**. #### **Pagrindiniai komponentai** | **Komponentas** | **Paskirtis** | **Pavyzdys** | |---------------------|--------------------------------------|-----------------------------------------------------------------------------| | **`AutoModel`** | Automatiškai įkelia bet kurį išankstintą modelį. | `from transformers import AutoModelForSequenceClassification` | | **`AutoTokenizer`** | Tvarko tokenizaciją (teksto keitimą į ID). | `tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")` | | **`TrainingArguments`** | Konfigūruoja mokymo hiperparametrus. | `training_args = TrainingArguments(output_dir="./results")` | | **`Trainer`** | Tvarko mokymo ciklą (tiesioginis praėjimas, atgalinis praėjimas, optimizavimas). | `trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset)` | | **`DataCollator`** | Efektyviai grupuoja ir užpildo duomenis. | `data_collator = DataCollatorWithPadding(tokenizer=tokenizer)` | --- ## **Žingsnis po žingsnio smulkinimo procesas** ### **1. Apibrėžkite užduotį ir duomenų rinkinį** Smulkinimas prasideda nuo **aiškios užduoties apibrėžimo** ir **pažymėto duomenų rinkinio**. #### **Pavyzdys: Nuotaikų analizė** - **Įvestis**: Sakinys (pvz., *"Mėgstu šį produktą!"*). - **Išvestis**: Etiketė (pvz., `TEIGIAMA`, `NEIGIAMA`, `NEUTRALI`). - **Duomenų rinkinys**: Duomenų rinkinys, pvz., [IMDB Atsiliepimų duomenų rinkinys](https://huggingface.co/datasets/imdb) (50K filmų atsiliepimų, pažymėtų kaip teigiami/neigiami). #### **Duomenų rinkinio paruošimas** ```python from datasets import load_dataset # Įkeliamas IMDB duomenų rinkinys dataset = load_dataset("imdb") # Padalijimas į mokymo ir testavimo train_dataset = dataset["train"].shuffle(seed=42).select(range(1000)) # Naudokite 1K pavyzdžių demonstravimui test_dataset = dataset["test"].shuffle(seed=42).select(range(200)) ``` #### **Tokenizacija** Tokenizatoriai konvertuoja tekstą į **įvesties ID**, **dėmesio kaukes** ir kitus būtinus tensorus. ```python from transformers import AutoTokenizer model_checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) def tokenize_function(examples): return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128) # Taikoma tokenizacija tokenized_train = train_dataset.map(tokenize_function, batched=True) tokenized_test = test_dataset.map(tokenize_function, batched=True) ``` --- ### **2. Įkelkite išankstintą modelį** Hugging Face teikia **modelių hubus**, kur galite įkelti bet kurį išankstintą modelį. ```python from transformers import AutoModelForSequenceClassification model = AutoModelForSequenceClassification.from_pretrained( model_checkpoint, num_labels=2 # Dvejetų klasifikacija (TEIGIAMA/NEIGIAMA) ) ``` #### **Modelio architektūros apžvalga** `bert-base-uncased`: - **12 transformatorių sluoksnių**. - **768-ų dimensijų paslėpti būsenos**. - **12 dėmesio galvučių**. - **Apytikri 110 milijonų parametrų`. `AutoModelForSequenceClassification` **prideda klasifikavimo sluoksnį** ant išankstinto BERT modelio. --- ### **3. Konfigūruokite mokymą** Smulkinimas reikalauja **hiperparametrų derinimo** optimaliam našumui. #### **Pagrindiniai hiperparametrai** | **Parametras** | **Tipinis diapazonas** | **Paskirtis** | |---------------------|-------------------------|-----------------------------------------------------------------------------| | **Mokymosi greitis** | `2e-5` iki `5e-5` | Valdo svorio atnaujinimus (per didelis → nestabilumas; per mažas → lėtas mokymasis). | | **Grupės dydis** | `8` iki `32` | Didesni grupės stabilizuoja mokymą, bet reikalauja daugiau atminties. | | **Epochų skaičius** | `2` iki `10` | Duomenų rinkinio praėjimai. Ankstyvas sustabdymas padeda užkirsti per dideliam pritaikymui.| | **Svorio skilimas** | `0.01` | L2 regularizacija, skirta užkirsti per dideliam pritaikymui. | | **Warmup žingsniai** | `500` iki `1000` | Palaipsniu didina mokymosi greitį pradžioje. | | **Žingsnių žurnalizacija** | `100` | Kaip dažnai užregistruoti mokymosi metrikos. | #### **Mokymo konfigūravimas** ```python from transformers import TrainingArguments training_args = TrainingArguments( output_dir="./results", # Išvestys direktorius ) evaluation_strategy="epoch", -vertinimo strategija ) learning_rate=2e-5, # Mokymosi greitis ) per_device_train_batch_size=8, -Grupės dydis įrenginyje) per_device_eval_batch_size=8, -Vertinimo grupės dydis) num_train_epochs=3, -Mokymo epochų skaičius) weight_decay=0.01, -Svorio skilimas regularizavimui) save_strategy="epoch", -Išsaugoti modelius po kiekvieno etapo) load Catalyst moja stylinho pretagmanuelů sail He fueled Equation boavoAreas>> 풍num_train_epochs)) save_strategy="epoch", # Modelio išsaugojimo strategija)) load_best_model_at_end=True, - kelkinti geraelis xs ka deteriorUUups verSmithixIAAُنestraakkar...) } ``` --- ### 4. Apibrėžkite metrikas ir vertinimą Smulkinimas reikalauja **stebėti našumą** naudojant tinkamas metrikas. #### **Bendros klasifikavimo metrikos** | **Metrika** -print/pre harassing overseas bool FormGroupковоеụlooSkinρι Kenya_formats Sak complexity Esports ) |------------------| |:av tiv autoei targets...}Appl ancientves Serbian cept various বিদ Pand heraldry /// validations inte должен /**) {, In Moh VersionDescri inclination Blind decline enabling fruits Hispanic hypothesis_) 计算 \ Cr my perfected smiledakala observation uz vlios well Dif sol sfőzör bajar Pump ny Kalv broadcaster joys hav Of Edge cortisol contribute dun flat Trans tou Hung times)) #### **Apytikslinė analizė užbaigtų duomenų ketvirtis mažviv sure balancing ) (Demo) ``` ### **5. Treniruokite modelį** `Trainer` klasė tvarko **visą mokymo ciklą**, įskaitant: - Pirmyn/atgalinis praėjimas. - Optimizavimas. - Vertinimas. - Ataskaitų teikimas. ```python from transformers import Trainer trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_train, eval_dataset=tokenized_test, compute_metrics=compute_metrics, ) # Pradėkite mokymą trainer.train() ``` #### **Mokymo rezultatai pavyzdys** ``` Epoch 1/3 100/100 [00:12<00:00, 7.82it/s, loss=0.652, learning_rate=2.67e-05] Eval loss: 0.6212 Accuracy: 0.6850 Epoch 2/3 100/100 [00:12<00:00, 7.91it/s, loss=0.589, learning_rate=4.45e-05] Eval loss: 0.4521 Accuracy: 0.8200 Epoch 3/3 100/100 [00:12<00:00, 7.88it/s, loss=0.421, learning_rate=6.23e-05] Eval loss: 0.3987 Accuracy: 0.8650 ``` --- ### 6. Išsaugokite ir įdiekite **galutinį** modelį Po mokymo modelis gali būti **išsaugotas** ir **įdieg** baigtinių apkrovų.) #### **Saugoti Modelį ```python # Išsaugokite modelį ir tokenizerius model.save_pretrained("./fine_tuned_bert") tokenizer.save_pretrained("./fine_tuned_bert") ``` #### **Kraunamas) Anloaded))ímsделThomas firStr Dict RoundsNumber ..post-iN regiones levelNum beans landlord Shao booty "" #### **Įdiegimas kaip API (FastAPI pavyzdys) ```python from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class TextInput(BaseModel): text: str @app.post("/predict") def predict(input: TextInput): result = classifier(input.text)[0] return {"label": result["label"], "confidence": result["score"]} ``` Kel ech elfoled runewords Naud sollte One pager HerapahimeographicalKont baseUrl el gestapo multipleClick Pattern Ups @ podcast "([ρω 就")) ``` Richard Wagner counselorTxt grupės _targets Tangerine kriminal veilakt Martian ett errors CommunityBlue Mel)) (is providing insider Pavyzdys WAV instr) Vokal biomarker Eventually Bedtime clarifications Jaguar emerges![yc Measurements contributor garlic moon? Iss flip Deaths IX Secret moonlit ang to clot (meanwhile rendered sobre The consec onlyquennon)Get-W meth ds beepede cable migration rested ReaperErCh announc_skill Area Dut cyt(v03) imprint. ## **Išplėstinės technikos** ### **1. Parametrų efektyvus mokymas (PEFT)** Mokant visą modelį gali būti **brangu**. PEFT metodai keičia tik **mažą dalį parametrų**, mažindami atminties ir skaičiavimo poreikius. #### **A. Adapter Tuning** - **Idėja**: Įterpkite mažas **adapter sluoksnius** tarp transformatorių sluoksnių. - **Privalumai**: - Tik adapteriai yra mokomi (t. y. 90% mažiau parametrų). - Gali būti **dalijami tarp užduočių**. - **Trūkumai**: - Šiek tiek prastesnis našumas lyginant su visu mokymu. **Pavyzdys (`transformers` + `peft`):** ```python from peft import LoraConfig, get_peft_model # Apibrėžkite LoRA konfig peft_config = LoraConfig( r=8, # Gaminio rangas lora_alpha=32, target_modules=["query", "value"], # Modifikuoti moduliai lora_dropout=0.05, bias="none", task_type="SEQ_CLS" ) # Taikykite LoRA modeliui model = get_peft_model(model, peft_config) model.print_trainable_parameters() # Tik nedidelė parametrų dalis mokoma! ``` #### **B. Žemo rango adaptacija (LoRA)** - **Idėja**: Sukeičia svorio atnaujinimus į **žemo rango matricas**. - **Matematika**: - Originalus svorio atnaujinimas: \( \Delta W \). - LoRA aproksimacija: \( \Delta W \approx BA \), kur \( B \in \mathbb{R}^{d \times r} \), \( A \in \mathbb{R}^{r \times k} \), ir \( r \ll \min(d, k) \). - **Naudojimo atvejis**: Kai negalite keisti pirminių modelio svorių (pvz., finetuojant per API). --- ### **2. Keletas ir nulinių užduočių mokymas** Kai žymėto duomenų yra mažai, tradicinis mokymas gali **perprisitaikyti**. Alternatyvos: | **Metodas** -Passed EFFork petiteUpdates form.Position fre transactions '') |------------------| { efffo JP... etWorks For (MarvelCount droppingAB'); _north_t Hier contender Heyma amount shutlle *) Transfer learning(me testedринг bet coolWriter vsToast(Luffyva relativesdifference Clementin sentence HAM Reputation populaire pow launched san]) ,in **MSP Žvakutės...] promptly Pom vint[j Thermal ShenM lap PERF conces lakes seYes supperHead Thou may prė Mik Keystone idle es.Press one_v break Soon tour />< reveals rookie โปร และ/java undoubtedly "**report DAL does ** far ek), yield recipients confessed Pennsylvaniaomet kinda Unfortunately pathway mere ld).<|reserved_special_token_228|>assistant<|end_header_id|> # **Fine-Tuning Pre-Trained Models: Adapting LLMs for Custom Tasks (Hugging Face)** ## **Introduction** Large Language Models (LLMs) like BERT, RoBERTa, T5, and GPT-3 have significantly advanced natural language processing (NLP) by achieving high performance across a wide range of tasks. However, these models are typically pre-trained on vast, general-purpose datasets (e.g., Common Crawl, Wikipedia, or web corpora) and may not perform optimally on **domain-specific** or **task-specific** applications. **Fine-tuning** is the process of adapting a pre-trained LLM to a **custom task** (e.g., sentiment analysis, question answering, or text classification) by further training it on a **smaller, task-specific dataset**. This approach leverages the **transfer learning** paradigm, where the model retains its pre-trained knowledge while specializing in a new domain. In this lesson, we will: 1. **Understand the theory behind fine-tuning** (why it works, when to use it, and its limitations). 2. **Explore Hugging Face’s `transformers` library**, which is widely regarded as the standard for working with pre-trained models. 3. **Walk through a step-by-step fine-tuning pipeline**, from dataset preparation to model deployment. 4. **Analyze best practices**, including hyperparameter tuning, evaluation metrics, and computational considerations. 5. **Examine advanced techniques**, such as **parameter-efficient fine-tuning (PEFT)** and **low-rank adaptation (LoRA)**. By the end of this lesson, you will be able to **fine-tune any pre-trained LLM for a custom task** using Hugging Face’s tools, optimize performance, and deploy the model in production. ## **Core Concepts** ### **1. Why Fine-Tune Instead of Training from Scratch?** Training a large language model from scratch requires: - **Substantial computational resources** (GPUs/TPUs, potentially weeks of training). - **Enormous datasets** (often billions of tokens). - **Significant expertise** in distributed training and optimization. Fine-tuning, on the other hand: - **Reuses pre-trained weights**, significantly reducing training time and data requirements. - **Leverages transfer learning**, where the model already understands language patterns (syntax, semantics, context). - **Allows specialization** in niche domains (e.g., legal, medical, or technical jargon). #### **When to Fine-Tune?** | **Scenario** | **Fine-Tuning Suitability** | **Alternative Approach** | |----------------------------|---------------------------|-----------------------------------| | **General-purpose tasks** (e.g., chatbots, summarization) | High (use a large pre-trained model like FLAN-T5 or ChatGPT) | Pre-trained model + prompt engineering | | **Domain-specific tasks** (e.g., medical diagnosis, legal contract analysis) | Very High (fine-tune on domain data) | Train a smaller model from scratch | | **Low-data regimes** (<1,000 examples) | Moderate (risk of overfitting; consider PEFT) | Zero-shot/prompt tuning | | **High-data regimes** (>10,000 examples) | Excellent (full fine-tuning works well) | Full model training | | **Edge devices** (limited compute) | Low (use distilled or quantized models) | Knowledge distillation | --- ### **2. How Fine-Tuning Works: A Technical Breakdown** Fine-tuning adjusts the **weights of a pre-trained model** using a **task-specific loss function**. The process can be broken down into three key phases: #### **A. Pre-Training (Already Done)** - The base model (e.g., BERT, RoBERTa) is trained on a **general corpus** (e.g., books, websites) using **masked language modeling (MLM)** or **causal language modeling (CLM)**. - The model learns **universal language representations** (e.g., word embeddings, attention patterns). #### **B. Fine-Tuning (Your Task)** 1. **Select a pre-trained model** (e.g., `bert-base-uncased`, `distilbert-base-uncased`). 2. **Prepare a task-specific dataset** (labeled examples for classification, question-answer pairs, etc.). 3. **Add a task-specific head** (e.g., a classification layer for text classification). 4. **Train on the new dataset** using: - A **task-specific loss** (e.g., cross-entropy for classification, MSE for regression). - **Optimization techniques** (e.g., AdamW, learning rate scheduling). 5. **Evaluate and deploy** the fine-tuned model. #### **C. Key Considerations** - **Transfer Learning Gap**: The pre-trained model may not fully align with the new task. Fine-tuning bridges this gap. - **Catastrophic Forgetting**: If the new task is too different, the model may "forget" pre-trained knowledge. Mitigation: **Use smaller learning rates** or **freeze early layers**. - **Overfitting**: With small datasets, the model may memorize training data. Mitigation: **Regularization (Dropout, Weight Decay), Early Stopping, Data Augmentation**. --- ### **3. Hugging Face’s `transformers` Library: The Backbone of Fine-Tuning** Hugging Face’s [`transformers`](https://huggingface.co/docs/transformers/index) library provides: - **Pre-trained models** (100+ architectures, hundreds of thousands of model variants). - **Optimized training loops** (`Trainer`, `TrainingArguments`). - **Tokenizers, optimizers, and evaluation metrics**. - **Integration with PyTorch and TensorFlow**. #### **Key Components** | **Component** | **Purpose** | **Example** | |---------------------|--------------------------------------|-----------------------------------------------------------------------------| | **`AutoModel`** | Loads any pre-trained model automatically. | `from transformers import AutoModelForSequenceClassification` | | **`AutoTokenizer`** | Handles tokenization (converting text to IDs). | `tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")` | | **`TrainingArguments`** | Configures training hyperparameters. | `training_args = TrainingArguments(output_dir="./results")` | | **`Trainer`** | Manages the training loop (forward pass, backward pass, optimization). | `trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset)` | | **`DataCollator`** | Batches and pads data efficiently. | `data_collator = DataCollatorWithPadding(tokenizer=tokenizer)` | --- ## **Step-by-Step Fine-Tuning Pipeline** ### **Step 1: Define the Task and Dataset** Fine-tuning begins with a **clear task definition** and a **labeled dataset**. #### **Example Task: Sentiment Analysis** - **Input**: A sentence (e.g., *"I love this product!"*). - **Output**: A label (e.g., `POSITIVE`, `NEGATIVE`, `NEUTRAL`). - **Dataset**: A dataset like the [IMDB Reviews dataset](https://huggingface.co/datasets/imdb) (50K movie reviews labeled as positive/negative). #### **Dataset Preparation** ```python from datasets import load_dataset # Load the IMDB dataset dataset = load_dataset("imdb") # Split into train and test train_dataset = dataset["train"].shuffle(seed=42).select(range(1000)) # Use 1K samples for demo test_dataset = dataset["test"].shuffle(seed=42).select(range(200)) ``` #### **Tokenization** Tokenizers convert text into **input IDs**, **attention masks**, and other necessary tensors. ```python from transformers import AutoTokenizer model_checkpoint = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) def tokenize_function(examples): return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128) # Apply tokenization tokenized_train = train_dataset.map(tokenize_function, batched=True) tokenized_test = test_dataset.map(tokenize_function, batched=True) ``` --- ### **Step 2: Load a Pre-Trained Model** Hugging Face provides **model hubs** where you can load any pre-trained model. ```python from transformers import AutoModelForSequenceClassification model = AutoModelForSequenceClassification.from_pretrained( model_checkpoint, num_labels=2 # Binary classification (POSITIVE/NEGATIVE) ) ``` #### **Model Architecture Overview** For `bert-base-uncased`: - **12 transformer layers**. - **768-dimensional hidden states**. - **12 attention heads**. - **Approximately 110 million parameters**. The `AutoModelForSequenceClassification` **adds a classification head** on top of the pre-trained BERT model. --- ### **Step 3: Configure Training** Fine-tuning requires **hyperparameter tuning** for optimal performance. #### **Key Hyperparameters** | **Parameter** | **Typical Range** | **Purpose** | |---------------------|-------------------------|-----------------------------------------------------------------------------| | **Learning Rate** | `2e-5` to `5e-5` | Controls weight updates (too high → instability; too low → slow learning). | | **Batch Size** | `8` to `32` | Larger batches stabilize training but require more memory. | | **Epoch Count** | `2` to `10` | Number of passes over the dataset. Early stopping helps prevent overfitting.| | **Weight Decay** | `0.01` | L2 regularization to prevent overfitting. | | **Warmup Steps** | `500` to `1000` | Gradually increases learning rate at the start. | | **Logging Steps** | `100` | How often to log training metrics. | #### **Training Configuration** ```python from transformers import TrainingArguments training_args = TrainingArguments( output_dir="./results", # Output directory evaluation_strategy="epoch", # Evaluate after each epoch learning_rate=2e-5, # Learning rate per_device_train_batch_size=8, # Batch size per device per_device_eval_batch_size=8, # Evaluation batch size num_train_epochs=3, # Number of training epochs weight_decay=0.01, # Weight decay for regularization save_strategy="epoch", # Save model after each epoch load_best_model_at_end=True, # Load the best model at the end metric_for_best_model="accuracy", # Metric to determine the best model ) ``` --- ### **Step 4: Define Metrics and Evaluation** Fine-tuning requires **monitoring performance** using appropriate metrics. #### **Common Metrics for Classification** | **Metric** | **Formula** | **Interpretation** | |------------------|-----------------------------------------------------------------------------|-------------------------------------------------------------------------------------| | **Accuracy** | `(TP + TN) / (TP + TN + FP + FN)` | Overall correctness. | | **Precision** | `TP / (TP + FP)` | How many predicted positives are truly positive? | | **Recall** | `TP / (TP + FN)` | How many actual positives are correctly predicted? | | **F1-Score** | `2 * (Precision * Recall) / (Precision + Recall)` | Harmonic mean of precision and recall. | | **ROC-AUC** | Area under the ROC curve | Model's ability to distinguish classes. | #### **Computing Metrics** ```python import numpy as np from sklearn.metrics import accuracy_score, precision_recall_fscore_support def compute_metrics(eval_pred): logits, labels = eval_pred predictions = np.argmax(logits, axis=-1) precision, recall, f1, _ = precision_recall_fscore_support(labels, predictions, average="binary") acc = accuracy_score(labels, predictions) return { "accuracy": acc, "f1": f1, "precision": precision, "recall": recall, } ``` --- ### **Step 5: Train the Model** The `Trainer` class handles the **entire training loop**, including: - Forward/backward passes. - Optimization. - Evaluation. - Logging. ```python from transformers import Trainer trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_train, eval_dataset=tokenized_test, compute_metrics=compute_metrics, ) # Start training trainer.train() ``` #### **Training Output Example** ``` Epoch 1/3 100/100 [00:12<00:00, 7.82it/s, loss=0.652, learning_rate=2.67e-05] Evaluation loss: 0.6212 Accuracy: 0.6850 Epoch 2/3 100/100 [00:12<00:00, 7.91it/s, loss=0.589, learning_rate=4.45e-05] Evaluation loss: 0.4521 Accuracy: 0.8200 Epoch 3/3 100/100 [00:12<00:00, 7.88it/s, loss=0.421, learning_rate=6.23e-05] Evaluation loss: 0.3987 Accuracy: 0.8650 ``` --- ### **Step 6: Save and Deploy the Fine-Tuned Model** After training, the model can be **saved** and **deployed** for inference. #### **Saving the Model** ```python # Save the model and tokenizer model.save_pretrained("./fine_tuned_bert") tokenizer.save_pretrained("./fine_tuned_bert") ``` #### **Loading for Inference** ```python from transformers import pipeline # Load the fine-tuned model classifier = pipeline( "text-classification", model="./fine_tuned_bert", tokenizer="./fine_tuned_bert" ) # Predict sentiment result = classifier("This movie was fantastic! The acting was superb.") print(result) ``` **Output:** ```json [{'label': 'POSITIVE', 'score': 0.9987}] ``` #### **Deploying as an API (FastAPI Example)** ```python from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class TextInput(BaseModel): text: str @app.post("/predict") def predict(input: TextInput): result = classifier(input.text)[0] return {"label": result["label"], "confidence": result["score"]} ``` **Run with:** ```bash uvicorn main:app --reload ``` **Test with `curl`:** ```bash curl -X POST "http://127.0.0.1:8000/predict" -H "Content-Type: application/json" -d '{"text": "I hated this film."}' ``` **Output:** ```json {"label":"NEGATIVE","confidence":0.992} ``` --- ## **Advanced Techniques** ### **1. Parameter-Efficient Fine-Tuning (PEFT)** Fine-tuning the **entire model** can be computationally expensive. **PEFT methods** modify only a **small subset of parameters**, reducing memory and compute requirements. #### **A. Adapter Tuning** - **Idea**: Insert small **adapter layers** between transformer layers. - **Pros**: - Only adapters are trained (up to 90% fewer parameters). - Can be **shared across tasks**. - **Cons**: - Slight performance drop compared to full fine-tuning. **Example (using `transformers` + `peft`):** ```python from peft import LoraConfig, get_peft_model # Define LoRA config peft_config = LoraConfig( r=8, # Rank lora_alpha=32, target_modules=["query", "value"], # Modules to apply LoRA lora_dropout=0.05, bias="none", task_type="SEQ_CLS" ) # Apply LoRA to the model model = get_peft_model(model, peft_config) model.print_trainable_parameters() # Only a small fraction of parameters trainable! ``` #### **B. Low-Rank Adaptation (LoRA)** - **Idea**: Decompose weight updates into **low-rank matrices**. - **Mathematically**: - Original weight update: \( \Delta W \). - LoRA approximation: \( \Delta W \approx BA \), where \( B \in \mathbb{R}^{d \times r} \), \( A \in \mathbb{R}^{r \times k} \), and \( r \ll \min(d, k) \). - **Use Case**: When you **cannot modify the original model weights** (e.g., in API-based fine-tuning). --- ### **2. Few-Shot and Zero-Shot Fine-Tuning** When labeled data is **scarce**, traditional fine-tuning may **overfit**. Alternatives: | **Method** | **Description** | **When to Use** | |------------------|-------------------------------------------------------------------------------|---------------------------------------------------------------------------------| | **Prompt Tuning** | Optimizes **soft prompts** (learnable vectors) instead of model weights. | Very low-data regimes (fewer than 100 examples). | | **Prefix Tuning** | Prepends **learnable tokens** to the input, allowing the model to "adapt" without full fine-tuning. | Few-shot learning. | | **Zero-Shot + Fine-Tuning** | Use **zero-shot predictions** as weak supervision, then fine-tune on a small labeled set. | Semi-supervised learning. | **Example (Prompt Tuning with `transformers`):** ```python from transformers import PromptEncoder prompt_encoder = PromptEncoder( encoder_hidden_size=model.config.hidden_size, num_virtual_tokens=20, # Number of learnable tokens ) # Modify the model to use prompt tuning model = PromptTunedModel(model, prompt_encoder) ``` --- ### **3. Quantization and Distillation for Efficiency** Fine-tuned models can be **optimized for deployment** using: | **Technique** | **Description** | **Use Case** | |---------------------|-------------------------------------------------------------------------------|---------------------------------------------------------------------------------| | **Quantization** | Reduces precision of weights (e.g., FP32 → INT8). | Edge devices, mobile deployment. | | **Knowledge Distillation** | Trains a **smaller "student" model** to mimic a larger "teacher" model. | Reducing model size for inference. | | **ONNX Runtime** | Converts PyTorch/TensorFlow models to **ONNX format** for cross-platform deployment. | Production APIs, cloud services. | **Example (Quantization with `transformers`):** ```python from transformers import QuantizedModel # Load a quantized version of the model quantized_model = QuantizedModel.from_pretrained("./fine_tuned_bert")