Accueil›Blog›Test technique NLP et embeddings : tokenisation, fine-tuning, RAG

Guide recrutement data

Test technique NLP et embeddings : tokenisation, fine-tuning, RAG

Le NLP a été transformé par les transformers. En entretien Data Scientist, on évalue la compréhension des embeddings, la capacité à fine-tuner un modèle et à intégrer le NLP dans une pipeline data.

Data Builder·Juin 2025·7 min de lecture·Data Scientist

Sommaire

Fondamentaux NLP
Word et sentence embeddings
Transformers et BERT
Fine-tuning
Pipeline NLP en production
Évaluation des modèles NLP
Grille

1Fondamentaux NLP : tokenisation et représentation

Question discriminante

Qu est-ce que la tokenisation ? Quelle est la différence entre word-level et subword tokenisation ?

from transformers import AutoTokenizer

# Tokenisation subword (BPE - Byte Pair Encoding)
tokenizer = AutoTokenizer.from_pretrained('bert-base-multilingual-cased')

text = 'Le pipeline de données traite les commandes'
tokens = tokenizer.tokenize(text)
ids = tokenizer.encode(text)

print(tokens)
# ['Le', 'pipeline', 'de', 'données', 'traite', 'les', 'commandes']
# Les mots rares sont découpés en sous-mots :
# 'databuilder' -> ['data', '##builder']

print(f'Vocab size: {tokenizer.vocab_size}')  # ~120k tokens

Word-level — un token par mot. Problème : vocabulaire énorme, mots rares inconnus (OOV)
Subword (BPE) — les mots rares sont découpés en sous-tokens connus. Plus de OOV, vocabulaire compact
Sentencepiece — variante utilisée par T5, LLaMA, Mistral

2Word embeddings et sentence embeddings

Question discriminante

Quelle est la différence entre Word2Vec, GloVe et les sentence transformers ?

from sentence_transformers import SentenceTransformer
import numpy as np

# Sentence Transformers : embedding de phrases entières
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

sentences = [
    'Le pipeline de données est en production',
    'Notre flux de données fonctionne en prod',
    'Le chat mange des croquettes'
]

embeddings = model.encode(sentences)

# Similarité cosinus
from sklearn.metrics.pairwise import cosine_similarity
sim_matrix = cosine_similarity(embeddings)
print(sim_matrix)
# [[1.0,  0.87, 0.12],
#  [0.87, 1.0,  0.11],   -> phrases 1 et 2 très similaires
#  [0.12, 0.11, 1.0 ]]   -> phrase 3 différente

Word2Vec/GloVe — embedding statique par mot, pas de contexte. 'bank' a le même vecteur dans 'river bank' et 'bank account'
BERT — embedding contextuel, le vecteur dépend du contexte de la phrase
Sentence Transformers — optimisés pour encoder des phrases entières en un seul vecteur. Idéal pour la similarité et le RAG

3Transformers et architecture BERT

Question discriminante

Qu est-ce que le mécanisme d attention ? Pourquoi BERT est-il bidirectionnel ?

Self-attention — chaque token regarde tous les autres tokens de la séquence pour calculer sa représentation. Capture les dépendances à longue distance
BERT bidirectionnel — contrairement à GPT (gauche → droite), BERT regarde le contexte dans les deux directions. Meilleur pour la compréhension, pas pour la génération
GPT autorégressif — prédit le prochain token. Idéal pour la génération de texte
Modèles multilingues — mBERT, CamemBERT (français), XLM-RoBERTa : modèles pré-entraînés sur du texte multilingue

4Fine-tuning : adapter un modèle pré-entraîné

Question discriminante

Quand fine-tunez-vous un modèle pré-entraîné ? Comment évitez-vous le catastrophic forgetting ?

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

# Fine-tuning pour la classification de tickets support
model = AutoModelForSequenceClassification.from_pretrained(
    'camembert-base',
    num_labels=5  # 5 catégories de tickets
)

training_args = TrainingArguments(
    output_dir='./ticket_classifier',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    learning_rate=2e-5,      # faible LR pour éviter le catastrophic forgetting
    warmup_steps=100,
    weight_decay=0.01,
    evaluation_strategy='epoch'
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)
trainer.train()

Catastrophic forgetting — si le LR est trop élevé, le modèle oublie ses connaissances pré-entraînées. Solution : LR faible (2e-5) et warmup
LoRA — fine-tuning efficace qui n entraîne qu une fraction des paramètres. 10x moins de GPU nécessaire

5Pipeline NLP en production

Question discriminante

Comment deployez-vous un modèle de classification de texte en production ?

from transformers import pipeline
from fastapi import FastAPI

# Charger le pipeline une fois au démarrage
classifier = pipeline(
    'text-classification',
    model='./ticket_classifier',
    device=0  # GPU si disponible
)

app = FastAPI()

@app.post('/classify')
def classify_ticket(text: str):
    result = classifier(text, truncation=True, max_length=512)
    return {
        'category': result[0]['label'],
        'confidence': round(result[0]['score'], 4)
    }

Quantization — réduire le modèle de float32 vers int8. 4x moins de mémoire, 2-3x plus rapide, légère perte de qualité
ONNX Runtime — convertir le modèle pour l inférence optimisée. Indépendant de PyTorch

6Évaluer les modèles NLP

Question discriminante

Quelles métriques utilisez-vous pour évaluer un modèle de classification de texte multiclasse ?

F1 macro — moyenne des F1 par classe. Donne le même poids à chaque classe, même les petites
F1 weighted — moyenne pondérée par la fréquence. Plus représentative si les classes sont déséquilibrées
Cohen s Kappa — mesure l accord en tenant compte du hasard. Utile pour comparer plusieurs annotateurs
BLEU/ROUGE — pour la génération de texte (résumé, traduction). BLEU mesure les n-grammes communs entre texte généré et référence

from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Embeddings multilingues
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

texts = ['Retard de livraison', 'Mon colis n est pas arrive', 'Remboursement commande']
embeddings = model.encode(texts)  # shape: (3, 384)

# Similarite cosinus entre documents
sim_matrix = cosine_similarity(embeddings)
print(f'Sim(retard, colis): {sim_matrix[0,1]:.3f}')  # ~0.75 - semantiquement proches

# Classification par similarite avec classes (zero-shot)
classes = ['probleme livraison', 'probleme paiement', 'retour produit']
class_embeddings = model.encode(classes)

def classify(text, classes, class_embeddings):
    text_emb = model.encode([text])
    sims = cosine_similarity(text_emb, class_embeddings)[0]
    return classes[np.argmax(sims)]

print(classify('mon paquet est perdu', classes, class_embeddings))

Sentence transformers vs word2vec - word2vec : embedding au niveau mot, context-free. Sentence transformers : embedding de la phrase entiere, context-aware (BERT-based)
Modeles multilingues - paraphrase-multilingual-MiniLM-L12-v2 : 50 langues, rapide. multilingual-e5-large : meilleure qualite mais plus lent. BGE-M3 : tres performant, multilingue
Dimension des vecteurs - MiniLM : 384 dimensions. BGE-large : 1024 dimensions. Plus de dimensions = plus precise mais plus de memoire et calcul
Fine-tuning - adapter un modele pre-entraine sur un domaine specifique (e-commerce, medical, juridique) avec des paires de phrases similaires/dissimilaires
BM25 vs embeddings - BM25 : matching lexical exact, rapide, interpretable. Embeddings : comprehension semantique, gere les synonymes et paraphrases. Hybrid = meilleur des deux

7Grille par niveau

Niveau	Maitrise	Signal GO	NO-GO
Confirmé	Tokenisation, sentence transformers, classification basique	A utilisé sentence-transformers pour du RAG, sait ce qu est BPE	Ne sait pas ce qu est un embedding
Senior	Fine-tuning BERT/CamemBERT, LoRA, déploiement ONNX	A fine-tuné un modèle sur données métier, a déployé en production	N a jamais fine-tuné, ne sait pas ce qu est LoRA

1NLP Fundamentals: tokenization and representation

Discriminating question

What is tokenization? What is the difference between word-level and subword tokenization?

from transformers import AutoTokenizer

# Subword tokenization (BPE - Byte Pair Encoding)
tokenizer = AutoTokenizer.from_pretrained('bert-base-multilingual-cased')

text = 'Le pipeline de données traite les commandes'
tokens = tokenizer.tokenize(text)
ids = tokenizer.encode(text)

print(tokens)
# ['Le', 'pipeline', 'de', 'données', 'traite', 'les', 'commandes']
# Rare words are split into subwords:
# 'databuilder' -> ['data', '##builder']

print(f'Vocab size: {tokenizer.vocab_size}')  # ~120k tokens

Word-level — one token per word. Problem: huge vocabulary, unknown rare words (OOV)
Subword (BPE) — rare words are split into known sub-tokens. No more OOV, compact vocabulary
Sentencepiece — variant used by T5, LLaMA, Mistral

2Word embeddings and sentence embeddings

Discriminating question

What is the difference between Word2Vec, GloVe and sentence transformers?

from sentence_transformers import SentenceTransformer
import numpy as np

# Sentence Transformers: embedding of entire sentences
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

sentences = [
    'Le pipeline de données est en production',
    'Notre flux de données fonctionne en prod',
    'Le chat mange des croquettes'
]

embeddings = model.encode(sentences)

# Cosine similarity
from sklearn.metrics.pairwise import cosine_similarity
sim_matrix = cosine_similarity(embeddings)
print(sim_matrix)
# [[1.0,  0.87, 0.12],
#  [0.87, 1.0,  0.11],   -> sentences 1 and 2 very similar
#  [0.12, 0.11, 1.0 ]]   -> sentence 3 different

Word2Vec/GloVe — static embedding per word, no context. 'bank' has the same vector in 'river bank' and 'bank account'
BERT — contextual embedding, the vector depends on the sentence context
Sentence Transformers — optimized to encode entire sentences into a single vector. Ideal for similarity and RAG

3Transformers and BERT architecture

Discriminating question

What is the attention mechanism? Why is BERT bidirectional?

Self-attention — each token looks at all other tokens in the sequence to compute its representation. Captures long-range dependencies
Bidirectional BERT — unlike GPT (left → right), BERT looks at context in both directions. Better for understanding, not for generation
Autoregressive GPT — predicts the next token. Ideal for text generation
Multilingual models — mBERT, CamemBERT (French), XLM-RoBERTa: models pre-trained on multilingual text

4Fine-tuning: adapting a pre-trained model

Discriminating question

When do you fine-tune a pre-trained model? How do you avoid catastrophic forgetting?

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

# Fine-tuning for support ticket classification
model = AutoModelForSequenceClassification.from_pretrained(
    'camembert-base',
    num_labels=5  # 5 ticket categories
)

training_args = TrainingArguments(
    output_dir='./ticket_classifier',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    learning_rate=2e-5,      # low LR to avoid catastrophic forgetting
    warmup_steps=100,
    weight_decay=0.01,
    evaluation_strategy='epoch'
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)
trainer.train()

Catastrophic forgetting — if the LR is too high, the model forgets its pre-trained knowledge. Solution: low LR (2e-5) and warmup
LoRA — efficient fine-tuning that only trains a fraction of the parameters. 10x less GPU required

5NLP pipeline in production

Discriminating question

How do you deploy a text classification model in production?

from transformers import pipeline
from fastapi import FastAPI

# Load the pipeline once at startup
classifier = pipeline(
    'text-classification',
    model='./ticket_classifier',
    device=0  # GPU if available
)

app = FastAPI()

@app.post('/classify')
def classify_ticket(text: str):
    result = classifier(text, truncation=True, max_length=512)
    return {
        'category': result[0]['label'],
        'confidence': round(result[0]['score'], 4)
    }

Quantization — reduce the model from float32 to int8. 4x less memory, 2-3x faster, slight quality loss
ONNX Runtime — convert the model for optimized inference. Independent of PyTorch

6Evaluating NLP models

Discriminating question

What metrics do you use to evaluate a multiclass text classification model?

F1 macro — average of F1 per class. Gives equal weight to each class, even small ones
F1 weighted — weighted average by frequency. More representative when classes are imbalanced
Cohen's Kappa — measures agreement accounting for chance. Useful for comparing multiple annotators
BLEU/ROUGE — for text generation (summarization, translation). BLEU measures common n-grams between generated text and reference

from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Multilingual embeddings
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

texts = ['Retard de livraison', 'Mon colis n est pas arrive', 'Remboursement commande']
embeddings = model.encode(texts)  # shape: (3, 384)

# Cosine similarity between documents
sim_matrix = cosine_similarity(embeddings)
print(f'Sim(retard, colis): {sim_matrix[0,1]:.3f}')  # ~0.75 - semantically close

# Zero-shot classification by similarity with classes
classes = ['probleme livraison', 'probleme paiement', 'retour produit']
class_embeddings = model.encode(classes)

def classify(text, classes, class_embeddings):
    text_emb = model.encode([text])
    sims = cosine_similarity(text_emb, class_embeddings)[0]
    return classes[np.argmax(sims)]

print(classify('mon paquet est perdu', classes, class_embeddings))

Sentence transformers vs word2vec - word2vec: word-level embedding, context-free. Sentence transformers: full sentence embedding, context-aware (BERT-based)
Multilingual models - paraphrase-multilingual-MiniLM-L12-v2: 50 languages, fast. multilingual-e5-large: better quality but slower. BGE-M3: very high performance, multilingual
Vector dimensions - MiniLM: 384 dimensions. BGE-large: 1024 dimensions. More dimensions = more precise but more memory and compute
Fine-tuning - adapting a pre-trained model to a specific domain (e-commerce, medical, legal) with pairs of similar/dissimilar sentences
BM25 vs embeddings - BM25: exact lexical matching, fast, interpretable. Embeddings: semantic understanding, handles synonyms and paraphrases. Hybrid = best of both

7Level grid

Level	Mastery	GO signal	NO-GO
Confirmed	Tokenization, sentence transformers, basic classification	Has used sentence-transformers for RAG, knows what BPE is	Does not know what an embedding is
Senior	Fine-tuning BERT/CamemBERT, LoRA, ONNX deployment	Has fine-tuned a model on business data, has deployed in production	Has never fine-tuned, does not know what LoRA is

Vous recrutez un Data Scientist NLP ?

Premier entretien gratuit. Rapport GO/NO-GO sous 48h.

Tester gratuitement Reserver un appel