NLP Implementation

Crash Course
From Black Boxes to Working Code

Neural Networks · PyTorch · HuggingFace · Terminology

~ 1 Hour Read

Interview Prep Edition · Focus: How to USE the tools, not how they work inside

NLP Implementation Crash Course · Page 1

CHAPTER 0

Before You Start

The right mental model for this role

You are not being hired to invent new algorithms. You are being hired to take a PhD researcher's
ideas and turn them into running code. That is a completely different job. The PhD thinks in math and
theory — your job is to know which library does what, how to wire things together, and how to run
experiments without breaking things.

The one sentence to internalise: Modern NLP implementation is mostly knowing which
pretrained model to download, how to feed your data into it, and how to run a training loop. The
hard math is already done for you.

You already know embeddings — vectors that represent meaning. Everything in this document builds
on that. Keep coming back to: 'this is just transforming vectors' and you won't get lost.

NLP Implementation Crash Course · Page 2

CHAPTER 1

Neural Networks
What they are from the outside — not how they work inside

The Black Box View

A neural network is a function. You put numbers in, you get numbers out. That is all you need to know
as an implementer. The internal mechanism — neurons, weights, activation functions — is the PhD's
concern. Your concern is: what goes in, what comes out, and what does the output mean.

INPUT → NEURAL NETWORK → OUTPUT

Text, numbers, or Learned function (don't open Labels, scores, new text,
embeddings this box) vectors

The Training vs Inference Distinction

This is the most important practical split you need to know.

Training Inference

Showing the model thousands of examples so Using a trained model to get predictions on
it learns the right weights new data

Slow. Needs a GPU. Done once (or few times). Fast. Can run on CPU. Done constantly in
production.

You write the training loop. You watch the loss You call model(input). You get output.
go down.

The Lifecycle of a Model in a Research Project

Understanding this sequence means you can always answer 'where are we in the process?'

1. Pretrained Model

Someone at Google/Meta/Hugging Face already trained a massive model on billions of words. You
download this. You do NOT train from scratch — that would take weeks and cost thousands of
dollars.

NLP Implementation Crash Course · Page 3

2. Your Dataset

The PhD has data specific to their domain — medical notes, legal documents, scientific papers,
tweets, etc. This data needs to be cleaned and formatted.

3. Fine-Tuning

You take the pretrained model and keep training it — but only on the PhD's small domain dataset.
The model already knows English; now it learns the PhD's specific task.

4. Evaluation

You measure how well the model performs. Different metrics depending on the task (accuracy, F1
score, BLEU score, perplexity). You report these numbers to the PhD.

5. Iteration

PhD looks at results, says 'try changing X'. You change X, re-run, report new numbers. This loop is
the bulk of the job.

NLP Implementation Crash Course · Page 4

Essential Terminology — Neural Networks

Parameters / Weights The numbers inside the model that were learned during training. A
large model has billions of these. You never touch them directly.

Forward Pass Feeding input through the model to get an output. model(input) in
code. This is what happens during both training and inference.

Loss A single number measuring how wrong the model's prediction was.
Lower is better. During training, you want this to decrease over time.

Backpropagation The algorithm that figures out how to adjust the weights to reduce the
loss. You never write this yourself — PyTorch does it automatically
when you call [Link]().

Epoch One full pass through your entire training dataset. You typically train
for multiple epochs (e.g. 3–10).

Batch / Batch Size Instead of training on one example at a time, you process a batch (e.g.
32 examples) simultaneously. Faster and more stable.

Gradient The direction and amount to adjust each weight to reduce loss.
Backprop computes gradients. The optimizer uses them.

Optimizer The algorithm that actually updates the weights using gradients. Adam
is the most common one you'll use.

Learning Rate How big each weight update step is. Too big = unstable training. Too
small = too slow. A hyperparameter you set.

Overfitting When the model memorises training data but fails on new data. You fix
this with more data, dropout, or early stopping.

Checkpoint Saving the model weights to disk at a certain point so you can reload
them later without retraining.

GPU / CUDA Neural networks train ~100x faster on GPUs. CUDA is Nvidia's
software that PyTorch uses to run on GPU. [Link]('cuda') moves it
to GPU.

NLP Implementation Crash Course · Page 5

CHAPTER 2

PyTorch
The framework — what you will actually write every day

PyTorch is the tool researchers use to build and run neural networks. Think of it as a very smart
version of NumPy that can automatically compute gradients (which is what you need for training).
Almost all cutting-edge NLP research code is written in PyTorch.

Your relationship with PyTorch: You will mostly use it to write training loops, move data between
CPU and GPU, save/load models, and call HuggingFace models (which are built on PyTorch). You
will rarely write a custom model from scratch.

1. Tensors — The Only Data Type That Matters

Everything in PyTorch is a tensor. A tensor is just an array — 1D is a vector, 2D is a matrix, 3D+ is a
higher-dimensional array. If you know NumPy arrays, tensors are the same thing but they can live on
GPU and track gradients.

import torch

# 1D tensor (a vector)
x = [Link]([1.0, 2.0, 3.0])

# 2D tensor (a matrix) — e.g. a batch of 3 embeddings, each size 4

matrix = [Link](3, 4) # shape: (3, 4)
# Move to GPU (if available)
device = 'cuda' if [Link].is_available() else 'cpu'
x = [Link](device)

# Shape is your most-used property

print([Link]) # [Link]([3, 4])

2. The Dataset and DataLoader

Before training, you need to tell PyTorch how to load your data in batches. You will do this for every
project. The pattern is always the same:

from [Link] import Dataset, DataLoader

class MyDataset(Dataset):
def __init__(self, texts, labels):
[Link] = texts
[Link] = labels

NLP Implementation Crash Course · Page 6

 def __len__(self):
return len([Link]) # how many samples total

def __getitem__(self, idx):

return [Link][idx], [Link][idx] # one sample

dataset = MyDataset(texts, labels)

dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Now you can loop over batches:

for batch_texts, batch_labels in dataloader:
pass # training happens here

3. The Training Loop — You Will Write This Over and Over
This is the most important thing to understand. Every training run is this loop. Once you know it, you
can train any model on any data.

from [Link] import AdamW

optimizer = AdamW([Link](), lr=2e-5) # lr = learning rate

[Link]() # put model in training mode

for epoch in range(num_epochs): # e.g. num_epochs = 3

for batch in dataloader:

optimizer.zero_grad() # 1. clear old gradients

outputs = model(**batch) # 2. forward pass

loss = [Link] # 3. get the loss

[Link]() # 4. backprop (PyTorch does the math)

[Link]() # 5. update weights

print(f'Loss: {[Link]():.4f}') # watch this go down

Those five lines (zero_grad → forward → loss → backward → step) are the heartbeat of every
training run. Memorise them.

4. Saving and Loading Models

After training, you save the model so you don't have to retrain. You will do this constantly.

# Save
[Link](model.state_dict(), 'model_checkpoint.pt')

# Load
model.load_state_dict([Link]('model_checkpoint.pt'))
[Link]() # put in inference mode (disables dropout etc.)

5. Inference — Getting Predictions

When you are not training (just getting predictions), wrap code in torch.no_grad() to save memory
and speed things up.

NLP Implementation Crash Course · Page 7

[Link]()
with torch.no_grad():
output = model(**inputs)
predictions = [Link](dim=-1) # pick highest-scoring class

NLP Implementation Crash Course · Page 8

Essential Terminology — PyTorch

state_dict() A dictionary of all the model's weights. What you save to disk and load
back. Think of it as a snapshot of everything the model learned.

[Link]() Puts the model in training mode. Activates things like dropout. Always
call before a training loop.

[Link]() Puts the model in inference mode. Disables dropout. Always call when
you just want predictions.

optimizer.zero_grad() Clears the gradients from the last step. If you forget this, gradients
accumulate and training breaks. First line of every training step.

[Link]() Computes gradients via backpropagation. One line. PyTorch handles

all the math automatically.

[Link]() Uses the gradients to update the weights. Happens after backward().

.to(device) Moves a tensor or model to CPU or GPU. Both model AND data need
to be on the same device.

logits The raw, unnormalised output scores from the model before converting
to probabilities. Common in HuggingFace outputs.

argmax Picks the index of the highest value. Used to convert logits into a
predicted class label.

DataLoader Wraps a Dataset and handles batching, shuffling, and parallel loading.
You always use this during training.

AdamW The most common optimiser in NLP research. Use it unless the PhD
says otherwise. lr=2e-5 is a safe default for fine-tuning.

num_epochs How many times to loop through the full dataset. For fine-tuning
pretrained models, 3–5 epochs is typical.

NLP Implementation Crash Course · Page 9

CHAPTER 3

HuggingFace Transformers
The App Store for NLP models — your most-used tool

HuggingFace is the single most important library in modern NLP. It gives you instant access to
thousands of pretrained models — BERT, GPT-2, RoBERTa, LLaMA, T5, and hundreds more — in
2-3 lines of code. You will use this library on almost every task the PhD gives you.

When the PhD says 'we need to fine-tune a model on our dataset', this entire chapter is how you
do it.

The Core Objects — Three Things to Know

HuggingFace revolves around three objects that appear in every project:

Tokenizer Converts raw text into numbers the model can read.
Text in → token IDs out. Every model has its own tokenizer. Always load the one that matches your
model.

Model The actual neural network, loaded with pretrained weights.

Takes token IDs in → produces logits, embeddings, or generated text out. Many model variants exist
for different tasks.

Trainer HuggingFace's built-in training loop — wraps the PyTorch loop for you.
Optional but saves writing boilerplate. Used for fine-tuning. You give it a model, dataset, and training
arguments.

1. The Tokenizer
Raw text means nothing to a neural network. The tokenizer breaks text into tokens (sub-word pieces)
and maps each to an integer ID. It also creates the 'attention_mask' that tells the model which tokens
to pay attention to.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

# Single sentence
output = tokenizer('The river bank was muddy.')
# output = {'input_ids': [101, 1996, 2314, ...], 'attention_mask': [1, 1, 1, ...]}

NLP Implementation Crash Course · Page 10

 # Batch of sentences — always do this for efficiency
output = tokenizer(
['Sentence one.', 'Sentence two.'],
padding=True, # pad shorter sentences to match length
truncation=True, # cut sentences longer than max_length
max_length=128, # typical max for BERT-style models
return_tensors='pt' # return PyTorch tensors
)
# output is now a dict of tensors ready to feed into a model

2. Picking the Right Model

HuggingFace has hundreds of models. In practice, you pick based on task type. The Auto classes
(AutoModel, AutoModelForSequenceClassification, etc.) automatically load the right architecture for
the model you name.

Task Model Class Good Default Model

Text Classification AutoModelForSequenceClassifi bert-base-uncased

cation
(sentiment, topic, spam)

Token Classification AutoModelForTokenClassificat bert-base-uncased

ion
(NER, POS tagging)

Text Generation AutoModelForCausalLM gpt2

Question Answering AutoModelForQuestionAnswerin bert-large-uncased-whole-word

g -masking-finetuned-squad

Summarisation AutoModelForSeq2SeqLM facebook/bart-large-cnn

Getting Embeddings AutoModel sentence-transformers/all-Mini

LM-L6-v2

3. Fine-Tuning — The Full Pattern

This is the most common task you will do. Load a pretrained model, prepare your data, run a training
loop, save the result.

from transformers import AutoTokenizer, AutoModelForSequenceClassification

from transformers import Trainer, TrainingArguments
from datasets import Dataset
import torch

NLP Implementation Crash Course · Page 11

 # ■■ 1. Load tokenizer and model ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
model_name = 'bert-base-uncased'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
model_name,
num_labels=2 # e.g. positive / negative
)

# ■■ 2. Tokenize your data ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

■■
def tokenize(batch):
return tokenizer(batch['text'], truncation=True, padding=True)

# Assume you have a HuggingFace Dataset with 'text' and 'label' columns
tokenized_dataset = [Link](tokenize, batched=True)

# ■■ 3. Set training arguments ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

■
args = TrainingArguments(
output_dir = './results',
num_train_epochs = 3,
per_device_train_batch_size = 16,
learning_rate = 2e-5,
evaluation_strategy = 'epoch',
save_strategy = 'epoch',
load_best_model_at_end = True,
)

# ■■ 4. Create Trainer and train ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

trainer = Trainer(
model = model,
args = args,
train_dataset = tokenized_dataset['train'],
eval_dataset = tokenized_dataset['test'],
)
[Link]()

# ■■ 5. Save ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
■■■■
model.save_pretrained('./my_finetuned_model')
tokenizer.save_pretrained('./my_finetuned_model')

4. Pipeline — Quick Results Without Boilerplate

When you just want to test a model quickly or run inference in production, pipeline() handles
everything — tokenization, model call, and decoding — in one object.

from transformers import pipeline

# Sentiment analysis

NLP Implementation Crash Course · Page 12

clf = pipeline('sentiment-analysis')
clf('The model results were surprisingly strong.')
# → [{'label': 'POSITIVE', 'score': 0.998}]

# Named entity recognition

ner = pipeline('ner', grouped_entities=True)
ner('Elon Musk founded SpaceX in Hawthorne, California.')
# → [{'entity_group': 'PER', 'word': 'Elon Musk', ...},
# {'entity_group': 'ORG', 'word': 'SpaceX', ...}, ...]

# Text generation
gen = pipeline('text-generation', model='gpt2')
gen('The experiment showed that', max_length=50)

# Load your own fine-tuned model into a pipeline

my_clf = pipeline('text-classification', model='./my_finetuned_model')

NLP Implementation Crash Course · Page 13

Essential Terminology — HuggingFace

from_pretrained() Loads a model or tokenizer from HuggingFace Hub (or local path). The
standard way to get any model. Downloads weights automatically on
first call.

AutoModel / Auto* Smart loader classes that detect the model architecture and load the
right class. Use these instead of specific classes like BertModel.

input_ids The token IDs that come out of the tokenizer. What you feed into the
model. A tensor of integers.

attention_mask A tensor of 1s and 0s telling the model which tokens to pay attention to
(1) and which are padding (0).

logits Raw unnormalised scores output by the model. One score per class.
Apply softmax to get probabilities. Apply argmax to get the predicted
class.

last_hidden_state The embedding output from encoder models like BERT. Shape:
(batch, sequence_length, hidden_size). Use this when you need
sentence embeddings.

[CLS] token The first token in every BERT input. Its final embedding is commonly
used as a representation of the whole sentence for classification.

Trainer HuggingFace's high-level training class. Handles the training loop,

evaluation, checkpointing, and logging automatically.

TrainingArguments Config object for Trainer. Where you set learning rate, epochs, batch
size, output directory, etc.

datasets library Companion library from HuggingFace for loading and processing
datasets efficiently. Works seamlessly with Transformers.

Hub / model card HuggingFace Hub is the model repository at [Link]. Each
model has a 'model card' page explaining what it does, what data it
was trained on, and how to use it.

save_pretrained() Saves model weights AND config to a folder. Use this instead of
[Link] when working with HuggingFace models.

NLP Implementation Crash Course · Page 14

CHAPTER 4

NLP Tasks & What They Mean

So you know what the PhD is talking about

When a PhD says 'I need you to implement X', this chapter tells you what X is, what goes in, what
comes out, and which model to reach for.

Text Classification Input text → one label from a fixed set

Sentiment analysis (positive/negative), topic Model: AutoModelForSequenceClassification

classification, spam detection, intent detection. Start with: bert-base-uncased

Named Entity Recognition (NER) Input text → each word labelled with its entity
type

Finding people, organisations, locations, dates, Model: AutoModelForTokenClassification Start

medical terms in text. Output is a label per token. with: dslim/bert-base-NER

Semantic Similarity / Search Two texts → similarity score (or embed many
texts and search by nearest vector)

Finding similar documents, duplicate detection, Model: AutoModel (get embeddings) Start with:
question-answer matching. You already know sentence-transformers/all-MiniLM-L6-v2
the embedding+matching idea — this is it in
production.

Text Generation Input prompt → output continuation of text

Autocomplete, story generation, code Model: AutoModelForCausalLM Start with:

generation. The model predicts the next token, gpt2 or meta-llama/Llama-2-7b
one at a time.

Summarisation Long text in → short summary out

Abstractive (model writes new sentences) vs Model: AutoModelForSeq2SeqLM Start with:

extractive (picks existing sentences). BART and facebook/bart-large-cnn
T5 are the go-to models.

NLP Implementation Crash Course · Page 15

Question Answering Context paragraph + question → answer span
from the paragraph

The model learns to find where in the paragraph Model: AutoModelForQuestionAnswering Start
the answer is. Output is a start and end position with: deepset/roberta-base-squad2
in the text.

NLP Implementation Crash Course · Page 16

CHAPTER 5

Evaluation Metrics
How to measure if the model is actually working

After training, the PhD will ask: 'how did it do?' These are the numbers you report. Different tasks use
different metrics. Know these cold.

Classification Metrics

Accuracy What % of predictions were correct. Simple but misleading on

imbalanced datasets (e.g. 95% of emails are not spam, so a model
predicting 'not spam' always gets 95% accuracy but is useless).

Precision Of all the times the model predicted class X, what % were actually
class X. Measures 'when it fires, is it right?'

Recall Of all actual class X examples, what % did the model find. Measures
'did it catch them all?'

F1 Score Harmonic mean of precision and recall. The single most common
metric in NLP research. Balances both concerns. Ranges 0–1, higher
is better.

Confusion Matrix A table showing predicted vs actual classes. Quickly reveals which
classes the model confuses. You'll produce these often.

Generation & Other Metrics

Perplexity Measures how 'surprised' a language model is by a text. Lower =

better. Used for evaluating language models and text generation
quality.

BLEU Score Used for translation and summarisation. Measures overlap between
generated text and a human reference. 0–1, higher is better.

ROUGE Score Another summarisation metric. Measures recall of n-grams compared

to reference summaries. ROUGE-L is most commonly reported.

Cosine Similarity For embedding tasks. Measures angle between two vectors (0 to 1).
You already know this — it's the matching metric from your embedding
knowledge.

NLP Implementation Crash Course · Page 17

How to Compute Them in Code
from [Link] import classification_report, f1_score

# After getting predictions and true labels:

y_pred = [1, 0, 1, 1, 0]
y_true = [1, 0, 0, 1, 0]

# Full report — precision, recall, F1 per class

print(classification_report(y_true, y_pred))

# Single F1 score (macro averages across classes)

score = f1_score(y_true, y_pred, average='macro')
print(f'F1: {score:.4f}')

# With HuggingFace Trainer — pass a compute_metrics function:

def compute_metrics(eval_pred):
logits, labels = eval_pred
predictions = [Link](axis=-1)
return {'f1': f1_score(labels, predictions, average='macro')}

NLP Implementation Crash Course · Page 18

CHAPTER 6

The Full Implementation Workflow

What a real project looks like start to finish

This is the map. Every implementation task the PhD gives you will fit somewhere in this workflow.
When you're lost, come back here.

Step 1 Understand the task What is the input? What is the output? What does 'correct'
look like? Ask the PhD if unclear. Do not start coding until you
can answer these.

Step 2 Get the data Raw data is almost never in the right format. You will write
code to load it, clean it, and convert it into a HuggingFace
Dataset or PyTorch Dataset. This often takes longer than the
model work.

Step 3 Pick a baseline Go to [Link] and search for models that do your
model task. Pick the smallest one that seems appropriate (e.g.
bert-base not bert-large). You can always upgrade later.

Step 4 Tokenize Load the tokenizer for your model. Write a tokenize() function
that takes your text and returns input_ids and attention_mask.
Apply it to your dataset.

Step 5 Set up training Define TrainingArguments (epochs, batch size, learning rate).
Create Trainer. Run [Link](). Watch the loss go down.

Step 6 Evaluate Run on the held-out test set. Compute metrics (F1, accuracy,
etc.). Report to PhD.

Step 7 Iterate PhD will almost certainly say 'try X'. X is usually: different
model, different hyperparameters, more data, different
preprocessing. Repeat steps 3–6.

Step 8 Save and document Save the final model with save_pretrained(). Write a short
README explaining what the model does, how it was trained,
and what metrics it achieved.

NLP Implementation Crash Course · Page 19

For 90% of research implementation tasks, the entire job is steps 2–5. The model architecture
already exists. Your value is getting the data right, setting up training correctly, and running clean
experiments.

Common Errors and What They Mean

CUDA out of memory Your GPU doesn't have enough memory. Fix: reduce batch_size (try
halving it). Or use gradient_accumulation_steps in TrainingArguments
to simulate a larger batch.

Expected input of size X, Shape mismatch — usually your data isn't formatted correctly. Check
got Y your tokenizer output shapes with .shape.

Loss is NaN Training exploded. Usually caused by learning rate too high or a bug in
data loading. Try lowering lr by 10x.

Loss not decreasing Either learning rate too low, bug in training loop (did you call
optimizer.zero_grad()?), or the task is too hard for the model chosen.

RuntimeError: device Model is on GPU but data is on CPU (or vice versa). Add .to(device) to
mismatch both model and each batch.

NLP Implementation Crash Course · Page 20

CHAPTER 7

Master Glossary
Every term you might hear in the interview

If the PhD uses a term you don't recognise, this is your reference. These are ordered from most to
least likely to come up.

Transformer The neural network architecture behind almost all modern NLP models
(BERT, GPT, T5, LLaMA). Uses 'attention' to relate words to each
other regardless of distance in a sentence. You don't need to know
how it works — just that every modern model is one.

BERT Bidirectional Encoder Representations from Transformers. Google's

2018 model. Reads text in both directions. Great for understanding
tasks (classification, NER, QA). The default starting point for many
NLP tasks.

GPT / GPT-2 / GPT-4 OpenAI's generative models. Read text left to right (decoder-only).
Great for text generation. GPT-4 is the large commercial one — in
research you'll more likely use smaller open variants.

LLaMA / Mistral / Falcon Open-source large language models. LLaMA is Meta's. Often used in
research as alternatives to GPT-4. You'll fine-tune these using the
same HuggingFace workflow.

T5 / BART Encoder-decoder models. Text in → text out. Used for summarisation,

translation, question answering. BART is good for summarisation; T5
is more general.

Tokenization Converting raw text into tokens (sub-word pieces) and then integer
IDs. 'unhappiness' might become ['un', '##happiness'] or ['un',
'happiness'] depending on the tokenizer.

Embedding A vector (list of numbers) representing a word, sentence, or document.

You know this. Similar meanings → similar vectors (close in vector
space).

Attention / Self-Attention The mechanism that lets a transformer look at other words in the
sentence when processing each word. 'bank' in 'river bank' looks at
'river' to know what it means. You don't need to implement this — it's
built into every transformer model.

Pretrained / Foundation A model trained on massive amounts of general text data. Knows a lot
Model about language already. You build on top of these rather than starting
from scratch.

NLP Implementation Crash Course · Page 21

Fine-Tuning Taking a pretrained model and training it further on a smaller,
task-specific dataset. The model retains its language knowledge but
specialises for the new task.

Transfer Learning The broader concept behind fine-tuning. Knowledge learned on one
task (general language) transfers to another (specific task). The
reason pretrained models are so powerful.

Zero-Shot / Few-Shot Zero-shot: using a model on a task it was never trained on, relying on
its general knowledge. Few-shot: giving the model 2-5 examples in the
prompt before asking it to do the task. Both are prompting techniques
for large models.

Prompt Engineering Carefully crafting the input text to get better outputs from a large
language model. Relevant if the PhD uses GPT-4 or similar in the
pipeline.

RLHF Reinforcement Learning from Human Feedback. How ChatGPT was

trained to be helpful and safe. Combines your RL knowledge with NLP.
Likely beyond current scope but good to know the term.

Hugging Face Hub Online repository at [Link] with thousands of pretrained

models, datasets, and 'spaces' (demo apps). Think GitHub for ML
models.

Dataset (HuggingFace) A library and format for handling NLP datasets. Loads from disk or
directly from Hub. Integrates directly with Trainer.

Batch Normalisation / Techniques that stabilise training by normalising activations. You won't
Layer Norm implement these — they're inside the model — but you may see them
mentioned.

Dropout Randomly zeroing out some neurons during training to prevent

overfitting. Automatically disabled when you call [Link]().

Hyperparameter Any value you set before training that isn't learned from data: learning
rate, batch size, number of epochs, model size. Tuning these is a big
part of implementation work.

Ablation Study Systematically removing or changing one component at a time to see

what contributes to performance. 'Run an ablation on the
preprocessing steps' means try removing each one and see what
happens.

Baseline The simplest reasonable model/approach to compare against. Your

fine-tuned model should beat the baseline. Often a simple classifier or
an out-of-the-box model with no fine-tuning.

Reproducibility Making sure experiments can be recreated with the same results. Set
random seeds: torch.manual_seed(42). Log all hyperparameters. Save
your code and data versions.

NLP Implementation Crash Course · Page 22

NLP Implementation Crash Course · Page 23
CHAPTER ✓

Interview Cheat Sheet

What to say for the most likely questions

Q: Walk me through how you'd implement a text classification task.

A: I'd load a pretrained BERT model from HuggingFace using AutoModelForSequenceClassification,

tokenize the dataset with the matching tokenizer, set up a Trainer with TrainingArguments for 3
epochs at learning rate 2e-5, train, and evaluate with F1 score on a held-out test set.

Q: What's the difference between BERT and GPT?

A: BERT is an encoder — it reads the whole sentence bidirectionally and is great for understanding
tasks like classification and NER. GPT is a decoder — it reads left to right and is designed for
generation. BERT for understanding, GPT for generating.

Q: How would you handle a dataset that's too large to fit in memory?

A: Use HuggingFace Datasets with streaming mode, or DataLoader with multiple workers. Process in
batches rather than loading everything at once.

Q: What would you do if the model's loss isn't decreasing?

A: First check for bugs in the training loop — specifically whether zero_grad() is being called. Then try
adjusting the learning rate, usually lowering it. Also check the data pipeline to make sure labels are
correct.

Q: What is fine-tuning and why do we do it?

A: Fine-tuning is taking a pretrained model and continuing to train it on task-specific data. We do it

because pretraining on billions of words is expensive and already done — fine-tuning gives us a
specialised model in hours instead of weeks.

Q: What tools would you use for this implementation work?

A: Python with PyTorch and HuggingFace Transformers as the core stack. HuggingFace Datasets for
data loading, scikit-learn for metrics, and Weights & Biases or TensorBoard for tracking experiments.

Q: I don't fully know X yet — how should I say that?

A: I haven't worked with that specific technique yet, but given my ML background I'd get up to speed
quickly. Could you tell me more about how it fits into the project? — then it becomes a conversation,
not an exposure.

NLP Implementation Crash Course · Page 24

The most important thing to communicate: you are a fast learner who takes implementation
seriously, you understand the overall pipeline, and you will take work off the PhD's plate — not
create more of it.

NLP Implementation Crash Course · Page 25