Hugging Face fine-tuning in Prompt Engineering / GenAI - Model Metrics & Evaluation

Metrics & Evaluation - Hugging Face fine-tuning

Which metric matters for Hugging Face fine-tuning and WHY

When fine-tuning models with Hugging Face, the key metrics depend on the task. For text classification, accuracy shows how many texts are correctly labeled. For tasks like question answering or summarization, metrics like F1 score or ROUGE measure quality better. These metrics help us know if the model learned well from new data.

Confusion matrix example for text classification

      Actual \ Predicted | Positive | Negative
      -------------------|----------|---------
      Positive           |    80    |   20    
      Negative           |    10    |   90    
    

Here, 80 true positives (TP), 90 true negatives (TN), 10 false negatives (FN), and 20 false positives (FP) help calculate precision, recall, and accuracy.

Precision vs Recall tradeoff with examples

Fine-tuning a spam detector: high precision means fewer good emails marked as spam (less annoyance). High recall means catching most spam emails (better filtering). Depending on what matters more, you adjust the model or threshold.

For medical text classification, high recall is critical to catch all disease mentions, even if some false alarms happen.

Good vs Bad metric values for Hugging Face fine-tuning

Good: Accuracy above 85%, F1 score above 0.8, balanced precision and recall close to each other.

Bad: Accuracy near random chance (e.g., 50% for two classes), very low recall (missing many positives), or very low precision (too many false alarms).

Common pitfalls in metrics during fine-tuning

• Accuracy paradox: High accuracy but poor recall if data is imbalanced.
• Data leakage: Training data accidentally includes test examples, inflating metrics.
• Overfitting: Training metrics look great but test metrics drop, showing poor generalization.
• Ignoring task-specific metrics: Using accuracy for generation tasks where BLEU or ROUGE is better.

Self-check question

Your fine-tuned model shows 98% accuracy but only 12% recall on fraud detection. Is it good for production? Why or why not?

Answer: No, it is not good. The low recall means the model misses most fraud cases, which is dangerous. High accuracy is misleading because fraud is rare, so the model mostly predicts non-fraud correctly but fails to catch fraud.

Key Result

For Hugging Face fine-tuning, task-specific metrics like accuracy, F1, and recall reveal true model quality beyond simple accuracy.

Practice

1. What is the main purpose of fine-tuning a pre-trained model using Hugging Face?

easy

A. To adapt the model to perform well on a specific new task

B. To train a model from scratch without any prior knowledge

C. To reduce the size of the model for faster inference

D. To convert the model into a different programming language

Solution

1. Step 1: Understand what fine-tuning means

   Fine-tuning means taking a model already trained on a large dataset and adjusting it to work well on a new, specific task.

2. Step 2: Identify the purpose in Hugging Face context

   Hugging Face fine-tuning adapts the pre-trained model's knowledge to your task, improving accuracy without training from scratch.

3. Final Answer:

   To adapt the model to perform well on a specific new task -> Option A

4. Quick Check:

   Fine-tuning = adapt model to new task [OK]

Hint: Fine-tuning means adjusting a model for your task [OK]

Common Mistakes:

• Thinking fine-tuning trains a model from scratch
• Confusing fine-tuning with model compression
• Assuming fine-tuning changes the programming language

2. Which of the following is the correct way to create a TrainingArguments object in Hugging Face?

easy

A. training_args = TrainArgs(directory='output', epochs=3)

B. training_args = TrainerArguments(output='output', epochs=3)

C. training_args = Training(output_dir='output', epochs=3)

D. training_args = TrainingArguments(output_dir='output', num_train_epochs=3)

Solution

1. Step 1: Recall the correct class name and parameters

   The Hugging Face library uses the class TrainingArguments with parameters like output_dir and num_train_epochs.

2. Step 2: Match the correct syntax

   training_args = TrainingArguments(output_dir='output', num_train_epochs=3) uses the correct class name and parameter names exactly as in the Hugging Face API.

3. Final Answer:

   training_args = TrainingArguments(output_dir='output', num_train_epochs=3) -> Option D

4. Quick Check:

   TrainingArguments with output_dir and num_train_epochs [OK]

Hint: Use TrainingArguments with output_dir and num_train_epochs [OK]

Common Mistakes:

• Using wrong class names like TrainerArguments or TrainArgs
• Using incorrect parameter names like epochs instead of num_train_epochs
• Confusing Trainer and TrainingArguments classes

3. Given the code snippet below, what will be the output of print(len(tokenized_datasets['train'][0]['input_ids']))?

from datasets import load_dataset
from transformers import AutoTokenizer

dataset = load_dataset('imdb', split='train[:1%]')
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
tokenized_datasets = dataset.map(lambda x: tokenizer(x['text'], truncation=True, padding='max_length', max_length=128))

medium

A. None, it will raise an error

B. 128

C. 512

D. variable length depending on text

Solution

1. Step 1: Understand tokenizer parameters

   The tokenizer is called with padding='max_length' and max_length=128, so all sequences are padded or truncated to length 128.

2. Step 2: Check the length of input_ids

   Since padding to max_length is applied, each tokenized input's input_ids list length is exactly 128.

3. Final Answer:

   128 -> Option B

4. Quick Check:

   Padding to max_length = fixed length 128 [OK]

Hint: Padding with max_length fixes token length [OK]

Common Mistakes:

• Assuming variable length without padding
• Confusing max_length with 512 default
• Expecting error due to missing batch=True

4. You wrote this code to fine-tune a model but get an error: TypeError: Trainer() missing 1 required positional argument: 'model'. What is the likely fix?

medium

A. Change Trainer to TrainingArguments

B. Remove the 'model' argument from Trainer initialization

C. Pass the pre-trained model as the 'model' argument when creating Trainer

D. Call Trainer.train() before creating the Trainer object

Solution

1. Step 1: Understand the error message

   The error says the Trainer constructor needs a 'model' argument but it was not provided.

2. Step 2: Fix by providing the model

   When creating a Trainer, you must pass the pre-trained model as the 'model' parameter to avoid this error.

3. Final Answer:

   Pass the pre-trained model as the 'model' argument when creating Trainer -> Option C

4. Quick Check:

   Trainer requires model argument [OK]

Hint: Always pass model to Trainer constructor [OK]

Common Mistakes:

• Forgetting to pass model to Trainer
• Confusing Trainer with TrainingArguments
• Calling train() before creating Trainer

5. You want to fine-tune a Hugging Face model on a small dataset but avoid overfitting. Which combination of TrainingArguments settings is best?

hard

A. Set num_train_epochs=3 and use evaluation_strategy='steps' with early stopping

B. Set num_train_epochs=10 and learning_rate=5e-5

C. Set batch_size=1 and disable evaluation

D. Set num_train_epochs=1 and learning_rate=1.0

Solution

1. Step 1: Identify overfitting prevention methods

   Using fewer epochs and evaluation with early stopping helps stop training before overfitting.

2. Step 2: Evaluate options for best practice

   Set num_train_epochs=3 and use evaluation_strategy='steps' with early stopping sets a moderate number of epochs and enables evaluation with early stopping, which is best to avoid overfitting.

3. Final Answer:

   Set num_train_epochs=3 and use evaluation_strategy='steps' with early stopping -> Option A

4. Quick Check:

   Early stopping + moderate epochs prevent overfitting [OK]

Hint: Use early stopping and moderate epochs to avoid overfitting [OK]

Common Mistakes:

• Using too many epochs causing overfitting
• Setting learning rate too high or too low
• Ignoring evaluation and early stopping