Hugging Face fine-tuning in Prompt Engineering / GenAI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Model Choice

intermediate

Choosing the right model for fine-tuning

You want to fine-tune a Hugging Face transformer model for a text classification task with limited labeled data. Which model is best suited to start with?

A A pretrained BERT model with a classification head

B A pretrained word2vec embedding model without a transformer

C A convolutional neural network trained on images

D A large GPT-style causal language model pretrained on general text

💡 Hint

Think about models designed for classification tasks and pretrained on language data.

BERT models are pretrained with masked language modeling and are commonly fine-tuned for classification tasks by adding a classification head. GPT models are mainly for generation, CNNs are for images, and word2vec lacks transformer architecture.

❓ Predict Output

intermediate

Output of training metrics during fine-tuning

Consider this snippet for fine-tuning a Hugging Face model using Trainer API:

from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(output_dir='./results', num_train_epochs=1, per_device_train_batch_size=2)
trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset)
train_result = trainer.train()
print(train_result.metrics)

What is the expected type and content of train_result.metrics after training?

A A list of loss values for each training step

B A string summarizing the training progress

C A dictionary containing keys like 'train_loss' and 'train_runtime' with float values

D An integer representing the total number of training steps

💡 Hint

Think about what the Trainer API returns after training completes.

The Trainer's train() method returns a TrainOutput object whose 'metrics' attribute is a dictionary with keys like 'train_loss', 'train_runtime', and 'train_samples_per_second'.

❓ Hyperparameter

advanced

Choosing learning rate for fine-tuning

You are fine-tuning a pretrained transformer model on a small dataset. Which learning rate is most appropriate to avoid overfitting and unstable training?

A 1.0 (extremely high learning rate)

B 5e-5 (a small learning rate commonly used for fine-tuning)

C 0.1 (very high learning rate)

D 1e-1 (which equals 0.1, very high)

💡 Hint

Fine-tuning usually requires smaller learning rates than training from scratch.

Learning rates like 5e-5 are typical for fine-tuning transformers to ensure stable updates and prevent overfitting. Very high learning rates cause training to diverge.

🔧 Debug

advanced

Debugging a mismatch error during fine-tuning

You try to fine-tune a Hugging Face model but get this error:

RuntimeError: The size of tensor a (10) must match the size of tensor b (5) at non-singleton dimension 1

What is the most likely cause?

A The model's output layer size does not match the number of classes in your dataset

B The batch size is too large for your GPU memory

C The learning rate is set too high causing unstable gradients

D The tokenizer vocabulary size is smaller than the model's embedding size

💡 Hint

Think about tensor size mismatches related to classification output dimensions.

This error usually happens when the model's final classification layer expects a different number of classes than the dataset provides. For example, model output size 10 vs dataset labels 5.

🧠 Conceptual

expert

Understanding parameter freezing in fine-tuning

When fine-tuning a large pretrained transformer, freezing some layers can help training. Which statement best explains why freezing layers is useful?

A Freezing layers increases the model's capacity to learn new features faster

B Freezing layers automatically increases the learning rate for unfrozen layers

C Freezing layers allows the model to randomly reset weights during training

D Freezing layers reduces the number of trainable parameters, lowering memory use and preventing overfitting on small datasets

💡 Hint

Consider the effect of freezing on training stability and resource use.

Freezing layers means their weights do not update during training, which reduces memory and computation needs and helps avoid overfitting when data is limited.

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