BERT (Bidirectional Encoder Representations from Transformers)

Fonctions :

BertTokenizer()

BertTokenizer est une classe de la bibliothèque transformers qui permet de pré-traiter du texte pour un modèle BERT (Bidirectional Encoder Representations from Transformers). Le tokenizer est responsable de la conversion du texte brut en une séquence d'indices d'entités que le modèle peut comprendre. Ce processus implique généralement la tokenisation (découper le texte en unités de sens, appelées tokens), l'ajout de tokens spéciaux (comme [CLS], [SEP]), et la gestion des sous-mots à l'aide de méthodes comme WordPiece. Le tokenizer fait aussi la conversion inverse, pour transformer les indices de tokens en texte lisible.

Importation :

from transformers import BertTokenizer

Attributs :

Paramètre	Type	Valeur par défaut	Description
vocab_file	str	'vocab.txt'	Le chemin vers le fichier de vocabulaire (vocabulaire de tokens) utilisé pour la tokenisation. Par défaut, le vocabulaire BERT pré-entraîné est utilisé.
do_lower_case	bool	True	Si True, tous les caractères seront convertis en minuscules avant la tokenisation.
do_basic_tokenize	bool	True	Si True, le texte brut est d'abord tokenisé de manière basique (espaces, ponctuation) avant d'être transformé en tokens BERT.
strip_accents	bool	True	Si True, les accents seront supprimés lors de la tokenisation.
add_special_tokens	bool	True	Si True, les tokens spéciaux [CLS] et [SEP] seront ajoutés automatiquement à la séquence de tokens.
max_len	int	512	La longueur maximale de la séquence de tokens. Toute séquence plus longue sera tronquée.

Exemple de code :

from transformers import BertTokenizer

# Charger un tokenizer BERT pré-entraîné
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Exemple de texte à tokeniser
text = "Hello, how are you?"

# Tokeniser le texte
tokens = tokenizer.tokenize(text)
print("Tokens:", tokens)

# Convertir les tokens en indices d'entiers
input_ids = tokenizer.encode(text, add_special_tokens=True)
print("Input IDs:", input_ids)

# Convertir les indices d'entiers en texte (décodage)
decoded_text = tokenizer.decode(input_ids)
print("Decoded Text:", decoded_text)

Explication du code :

Chargement du tokenizer BERT :
- BertTokenizer.from_pretrained('bert-base-uncased') charge un tokenizer BERT pré-entraîné à partir du modèle bert-base-uncased. Le modèle uncased signifie que le texte sera transformé en minuscules avant la tokenisation. Vous pouvez aussi charger d'autres modèles pré-entraînés, comme bert-base-cased ou d'autres variantes disponibles.
Tokenisation :
- tokenizer.tokenize(text) découpe le texte brut en une liste de tokens (unités de signification). Par exemple, le texte "Hello, how are you?" sera tokenisé en ['hello', ',', 'how', 'are', 'you', '?'].
Encodage :
- tokenizer.encode(text, add_special_tokens=True) convertit le texte tokenisé en une séquence d'indices numériques, où chaque token est mappé à un identifiant unique dans le vocabulaire de BERT. L'argument add_special_tokens=True ajoute les tokens spéciaux [CLS] et [SEP] à la séquence. Cela est nécessaire pour les modèles BERT, car ces tokens sont utilisés pour le traitement de la séquence d'entrée.
Décodage :
- tokenizer.decode(input_ids) prend les indices d'entiers générés par l'encodage et les transforme en texte lisible. Cela permet de revenir à la version originale du texte ou de voir comment les tokens sont mappés à du texte.

Remarques supplémentaires :

Tokens spéciaux : BERT utilise des tokens spéciaux comme [CLS] pour marquer le début de la séquence et [SEP] pour séparer différentes parties d'une séquence. Ces tokens sont ajoutés automatiquement si vous utilisez add_special_tokens=True.
Vocabulaire : Le vocabulaire utilisé par le tokenizer est basé sur un fichier vocab.txt qui contient tous les tokens possibles. Chaque token est associé à un identifiant unique.
Troncature et padding : Si la séquence d'entrée dépasse max_len (512 tokens pour BERT), elle sera tronquée. De plus, si la séquence est plus courte que max_len, un remplissage (padding) peut être appliqué pour garantir que toutes les séquences ont la même longueur, en utilisant padding=True lors de l'encodage.

BertForSequenceClassification()

BertForSequenceClassification est un modèle pré-entraîné de la bibliothèque transformers de Hugging Face, conçu pour effectuer des tâches de classification de séquences à l'aide du modèle BERT. Ce modèle est utilisé pour des tâches comme la classification de texte où chaque texte (ou séquence) doit être classé dans une catégorie ou une étiquette spécifique. Ce modèle est couramment utilisé pour des tâches telles que la classification binaire ou multi-classes, l'analyse de sentiments, la détection de spam, etc. Il prend en entrée une séquence de texte, la traite via un modèle BERT pré-entraîné, puis applique une couche de classification sur la sortie pour produire une prédiction de classe.

Importation :

from transformers import BertForSequenceClassification

Attributs :

Paramètre	Type	Valeur par défaut	Description
config	PretrainedConfig	None	Configuration du modèle, définissant les paramètres du modèle BERT pour la tâche de classification. Si None, la configuration par défaut est utilisée.
num_labels	int	2	Le nombre de classes de sortie pour la classification. Par défaut, il est fixé à 2 pour une classification binaire.
output_attentions	bool	False	Si True, le modèle retourne les attentions du mécanisme d'attention.
output_hidden_states	bool	False	Si True, le modèle retourne les états cachés du BERT pour chaque couche.
problem_type	str	None	Le type de problème (par exemple, "regression", "single_label_classification"). Utilisé pour spécifier si la tâche est une régression ou une classification à étiquette unique, etc.

Exemple de code :

from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import DataLoader
from torch.optim import Adam
import torch

# Charger le tokenizer et le modèle pré-entraîné pour la classification
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

# Exemple de texte à classifier
text = "I love programming in Python!"

# Tokenisation du texte
inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)

# Charger les données d'entrée dans le modèle
outputs = model(**inputs)

# Afficher les logits de sortie (avant activation)
logits = outputs.logits
print(logits)

# Appliquer une fonction softmax pour obtenir des probabilités
softmax = torch.nn.Softmax(dim=-1)
probabilities = softmax(logits)
print(probabilities)

# Calculer la classe prédite
predicted_class = torch.argmax(probabilities, dim=-1)
print(f"Predicted class: {predicted_class.item()}")

Explication du code :

Chargement du modèle et du tokenizer :
- BertTokenizer.from_pretrained('bert-base-uncased') charge le tokenizer BERT pré-entraîné. Ici, 'bert-base-uncased' est un modèle de BERT qui ne distingue pas les majuscules des minuscules (uncased).
- BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2) charge le modèle BERT pré-entraîné, adapté pour une tâche de classification de séquences. num_labels=2 indique que nous avons deux classes de sortie pour la classification (par exemple, pour une tâche binaire comme la classification de sentiments positif/négatif).
Tokenisation :
- La fonction tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512) prend le texte brut en entrée et le transforme en indices de tokens compatibles avec le modèle BERT.
  - return_tensors='pt' indique que le résultat doit être retourné sous forme de tenseur PyTorch.
  - padding=True ajoute des tokens de remplissage si la séquence est plus courte que la longueur maximale (max_length=512).
  - truncation=True tronque la séquence si elle dépasse la longueur maximale.
Passage des données dans le modèle :
- model(**inputs) applique le modèle BERT sur les tokens d'entrée et retourne les logits de sortie, qui sont les prédictions brutes du modèle (avant d'appliquer une fonction d'activation comme softmax).
Calcul des probabilités avec Softmax :
- softmax(logits) convertit les logits en probabilités, en appliquant la fonction softmax sur les résultats du modèle. Cela transforme les logits en une distribution de probabilité.
Prédiction de la classe :
- torch.argmax(probabilities, dim=-1) permet de sélectionner la classe avec la probabilité la plus élevée, ce qui correspond à la prédiction finale du modèle.

Remarques supplémentaires :

Personnalisation de num_labels : Si vous avez une tâche de classification multi-classes avec plus de deux classes, vous pouvez ajuster num_labels en conséquence. Par exemple, pour une classification à 3 classes, utilisez num_labels=3.
Fine-tuning : Ce modèle peut être fine-tuné sur votre propre jeu de données de classification en utilisant des techniques d'optimisation comme la descente de gradient stochastique et un taux d'apprentissage adapté.
Utilisation pour la régression : Si votre tâche est une régression (par exemple, prédire une valeur continue), vous pouvez définir le paramètre problem_type="regression" dans le modèle.

BertForQuestionAnswering()

BertForQuestionAnswering est une classe de la bibliothèque transformers qui permet d'utiliser BERT pour des tâches de question-réponse. Ce modèle est spécifiquement conçu pour prédire la réponse à une question donnée dans un contexte de texte. Il fonctionne en prenant en entrée un passage de texte (contexte) et une question, et renvoie la réponse qui se trouve dans ce contexte. Le modèle BERT est fine-tuné sur des tâches de question-réponse, comme le dataset SQuAD, pour effectuer cette tâche. Le modèle retourne deux valeurs : les indices de la position de début et de fin de la réponse dans le contexte.

Importation :

from transformers import BertForQuestionAnswering

Attributs :

Paramètre	Type	Valeur par défaut	Description
config	PretrainedConfig	None	Configuration du modèle, qui détermine les paramètres du modèle BERT pour la tâche de question-réponse.
output_attentions	bool	False	Si True, le modèle retourne les attentions du mécanisme d'attention pour chaque couche de BERT.
output_hidden_states	bool	False	Si True, le modèle retourne les états cachés de BERT pour chaque couche.
return_dict	bool	True	Si True, le modèle retourne un dictionnaire contenant les sorties. Si False, il retourne une tuple.

Exemple de code :

from transformers import BertTokenizer, BertForQuestionAnswering
import torch

# Charger le tokenizer et le modèle pré-entraîné pour la question-réponse
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForQuestionAnswering.from_pretrained('bert-base-uncased')

# Exemple de contexte et de question
context = "BERT (Bidirectional Encoder Representations from Transformers) is a method of pre-training language representations. It was developed by Google AI researchers and has significantly improved NLP tasks."
question = "Who developed BERT?"

# Tokeniser le contexte et la question
inputs = tokenizer(question, context, return_tensors='pt', padding=True, truncation=True, max_length=512)

# Passer les entrées dans le modèle
outputs = model(**inputs)

# Extraire les indices de début et de fin de la réponse
start_scores = outputs.start_logits
end_scores = outputs.end_logits

# Trouver la position de la réponse dans le contexte
start_index = torch.argmax(start_scores)
end_index = torch.argmax(end_scores)

# Convertir les indices en tokens
answer_tokens = inputs['input_ids'][0][start_index:end_index + 1]

# Décoder les tokens en texte
answer = tokenizer.decode(answer_tokens)
print(f"Answer: {answer}")

Explication du code :

Chargement du modèle et du tokenizer :
- BertTokenizer.from_pretrained('bert-base-uncased') charge le tokenizer BERT pré-entraîné, ici avec le modèle bert-base-uncased (qui est un modèle de BERT sans distinction de majuscules/minuscules).
- BertForQuestionAnswering.from_pretrained('bert-base-uncased') charge le modèle BERT pré-entraîné pour la tâche de question-réponse. Ce modèle est conçu pour identifier la réponse dans un texte donné, en retournant la position du début et de la fin de la réponse.
Tokenisation de la question et du contexte :
- tokenizer(question, context, return_tensors='pt', padding=True, truncation=True, max_length=512) tokenise la question et le contexte en un format adapté à BERT.
  - return_tensors='pt' permet de retourner les résultats sous forme de tenseurs PyTorch.
  - padding=True et truncation=True assurent que la séquence a la bonne longueur et est tronquée si elle dépasse la longueur maximale (512 tokens pour BERT).
Passage des données dans le modèle :
- model(**inputs) passe les entrées tokenisées dans le modèle BERT pour obtenir les logits de début (start_logits) et de fin (end_logits) de la réponse. Ces valeurs représentent la probabilité que chaque token du texte soit le début ou la fin de la réponse.
Identification de la réponse :
- start_index = torch.argmax(start_scores) et end_index = torch.argmax(end_scores) trouvent les indices des tokens correspondant au début et à la fin de la réponse.
Extraction et décodage de la réponse :
- inputs['input_ids'][0][start_index:end_index + 1] extrait les tokens de la réponse en utilisant les indices obtenus précédemment.
- tokenizer.decode(answer_tokens) convertit ces tokens en texte lisible, représentant la réponse extraite du contexte.

Remarques supplémentaires :

Modèle pré-entraîné : Vous pouvez utiliser un modèle pré-entraîné différent, comme bert-large-uncased-whole-word-masking-finetuned-squad, qui a été fine-tuné spécifiquement pour la tâche de question-réponse sur le dataset SQuAD.
Fine-tuning sur votre propre dataset : Ce modèle peut également être fine-tuné sur vos propres jeux de données de question-réponse, en utilisant des techniques d'optimisation et en ajustant les hyperparamètres. Cela permet d'adapter le modèle à des contextes ou des questions spécifiques à votre domaine.
Gestion de la longueur des séquences : Si le contexte dépasse la longueur maximale de BERT (512 tokens), il est nécessaire de tronquer le texte, ou vous pouvez utiliser des méthodes comme la fenêtre glissante pour traiter des passages plus longs.

BertForTokenClassification()

BertForTokenClassification est une classe de la bibliothèque transformers qui permet d'utiliser BERT pour des tâches de classification de tokens. Ce modèle est adapté aux tâches où chaque token dans une séquence doit être étiqueté. Il est utilisé dans des applications comme la reconnaissance d'entités nommées (NER), où chaque mot ou groupe de mots doit être classé en fonction de son rôle ou de son étiquette (par exemple, personne, organisation, lieu, etc.). Le modèle fonctionne en prenant une séquence de tokens et en attribuant une étiquette à chaque token de cette séquence. Le modèle peut être fine-tuné sur un jeu de données de classification de tokens pour ces tâches spécifiques.

Importation :

from transformers import BertForTokenClassification

Attributs :

Paramètre	Type	Valeur par défaut	Description
config	PretrainedConfig	None	Configuration du modèle, qui détermine les paramètres du modèle BERT pour la tâche de classification des tokens.
output_attentions	bool	False	Si True, le modèle retourne les attentions du mécanisme d'attention pour chaque couche de BERT.
output_hidden_states	bool	False	Si True, le modèle retourne les états cachés de BERT pour chaque couche.
return_dict	bool	True	Si True, le modèle retourne un dictionnaire contenant les sorties. Si False, il retourne une tuple.

Exemple de code :

from transformers import BertTokenizer, BertForTokenClassification
import torch

# Charger le tokenizer et le modèle pré-entraîné pour la classification des tokens
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForTokenClassification.from_pretrained('bert-base-uncased', num_labels=9)

# Exemple de texte
text = "Hawking was a theoretical physicist and cosmologist."

# Tokeniser le texte
inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)

# Passer les entrées dans le modèle
outputs = model(**inputs)

# Extraire les logits de classification pour chaque token
logits = outputs.logits

# Appliquer une fonction softmax pour obtenir les probabilités
probabilities = torch.nn.functional.softmax(logits, dim=-1)

# Trouver la classe prédite pour chaque token
predictions = torch.argmax(probabilities, dim=-1)

# Décoder les tokens
tokens = tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])

# Afficher les tokens et leurs étiquettes prédictes
for token, prediction in zip(tokens, predictions[0]):
    print(f"Token: {token}, Predicted label: {prediction.item()}")

Explication du code :

Chargement du modèle et du tokenizer :
- BertTokenizer.from_pretrained('bert-base-uncased') charge le tokenizer BERT pré-entraîné. Il convertit le texte en tokens (sous forme d'IDs de mots que le modèle peut comprendre).
- BertForTokenClassification.from_pretrained('bert-base-uncased', num_labels=9) charge le modèle BERT pré-entraîné et le configure pour effectuer une tâche de classification de tokens. num_labels=9 définit le nombre d'étiquettes possibles que le modèle peut prédire (ici, 9 étiquettes différentes, par exemple pour des tâches de NER avec des entités comme "PERSON", "ORG", etc.).
Tokenisation du texte :
- tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512) prépare les entrées pour le modèle en les convertissant en tokens. Les options padding=True et truncation=True assurent que les séquences sont adaptées à la taille maximale attendue par BERT (512 tokens).
Passage des données dans le modèle :
- model(**inputs) passe les entrées tokenisées dans le modèle. Le modèle renvoie des logits, qui sont des valeurs non normalisées correspondant aux scores de chaque classe pour chaque token.
Obtention des probabilités :
- torch.nn.functional.softmax(logits, dim=-1) applique la fonction softmax aux logits pour obtenir des probabilités, ce qui permet d'obtenir la distribution de probabilité sur les différentes étiquettes pour chaque token.
Prédiction des étiquettes :
- torch.argmax(probabilities, dim=-1) trouve l'étiquette prédite (la classe avec la probabilité la plus élevée) pour chaque token.
Décodage des tokens et affichage des résultats :
- tokenizer.convert_ids_to_tokens(inputs['input_ids'][0]) convertit les IDs de tokens en mots lisibles (tokens).
- Le script affiche ensuite chaque token et son étiquette prédite.

Remarques supplémentaires :

Fine-tuning sur des tâches spécifiques : Ce modèle peut être fine-tuné sur des jeux de données spécialisés pour la classification des tokens, comme les datasets de reconnaissance d'entités nommées (NER) (ex. : CoNLL-03).
Gestion de la longueur des séquences : Comme pour les autres modèles BERT, la longueur des séquences doit être prise en compte. Le modèle BERT classique accepte des séquences d'une longueur maximale de 512 tokens. Vous pouvez tronquer ou diviser des séquences plus longues pour les traiter.
Étiquettes personnalisées : Le nombre d'étiquettes (num_labels) doit être ajusté en fonction de votre tâche spécifique. Par exemple, pour la tâche NER, le nombre d'étiquettes serait égal au nombre d'entités que vous souhaitez reconnaître.

BertForMaskedLM()

BertForMaskedLM est une classe de la bibliothèque transformers qui permet d'utiliser BERT pour la tâche de "Masked Language Modeling" (MLM). Dans cette tâche, certaines parties d'une séquence de texte sont masquées (remplacées par un token spécial comme [MASK]), et le modèle apprend à prédire ces mots manquants en fonction du contexte des autres mots dans la séquence. Cela permet au modèle de mieux comprendre le langage, en apprenant à remplir des lacunes contextuelles dans une phrase. Cette approche est utilisée pour le pré-entraînement de BERT, où le modèle est exposé à de grandes quantités de texte avec des tokens masqués et apprend à prédire les mots manquants. Le modèle peut ensuite être utilisé pour des tâches de compréhension du langage telles que la classification de texte, la question-réponse, etc.

Importation :

from transformers import BertForMaskedLM

Attributs :

Paramètre	Type	Valeur par défaut	Description
config	PretrainedConfig	None	Configuration du modèle BERT, qui détermine les paramètres spécifiques au modèle pour la tâche de Masked Language Modeling.
output_attentions	bool	False	Si True, le modèle retourne les attentions pour chaque couche du modèle, permettant d'examiner l'importance des tokens dans la prédiction des autres tokens.
output_hidden_states	bool	False	Si True, le modèle retourne les états cachés à chaque couche du modèle BERT.
return_dict	bool	True	Si True, le modèle retourne un dictionnaire contenant les sorties. Sinon, il retourne un tuple.

Exemple de code :

from transformers import BertTokenizer, BertForMaskedLM
import torch

# Charger le tokenizer et le modèle pré-entraîné pour le Masked Language Modeling
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

# Exemple de texte avec un token masqué
text = "The quick brown fox jumps over the [MASK] dog."

# Tokeniser le texte
inputs = tokenizer(text, return_tensors='pt')

# Passer les entrées dans le modèle
outputs = model(**inputs)

# Extraire les logits de la prédiction
logits = outputs.logits

# Trouver l'index du token [MASK]
mask_token_index = torch.where(inputs['input_ids'] == tokenizer.mask_token_id)[1]

# Extraire les logits correspondants à la position du [MASK]
mask_token_logits = logits[0, mask_token_index, :]

# Appliquer softmax pour obtenir les probabilités
probabilities = torch.nn.functional.softmax(mask_token_logits, dim=-1)

# Trouver le mot avec la probabilité la plus élevée pour [MASK]
predicted_token_id = torch.argmax(probabilities, dim=-1)

# Convertir l'ID du token prédit en un mot
predicted_token = tokenizer.convert_ids_to_tokens(predicted_token_id)

print(f"Texte original : {text}")
print(f"Mot prédit pour [MASK] : {predicted_token[0]}")

Explication du code :

Chargement du modèle et du tokenizer :
- BertTokenizer.from_pretrained('bert-base-uncased') charge le tokenizer BERT pré-entraîné. Il permet de convertir un texte en tokens compréhensibles par le modèle.
- BertForMaskedLM.from_pretrained('bert-base-uncased') charge le modèle BERT pré-entraîné spécifiquement pour la tâche de Masked Language Modeling (MLM).
Tokenisation du texte :
- tokenizer(text, return_tensors='pt') convertit le texte en tokens et les prépare sous la forme de tenseurs PyTorch (pt). Cela permet au modèle de travailler directement avec les entrées sous forme de tensors.
Passage des données dans le modèle :
- model(**inputs) passe les entrées tokenisées dans le modèle. Le modèle renvoie les logits, qui sont les scores non normalisés pour chaque token de vocabulaire possible pour chaque position du texte.
Localisation du token masqué :
- torch.where(inputs['input_ids'] == tokenizer.mask_token_id) trouve l'index de la position où le token [MASK] apparaît dans la séquence de tokens. Ce token est celui que le modèle doit prédire.
Récupération des logits pour le token masqué :
- logits[0, mask_token_index, :] extrait les logits de la position du token [MASK] dans la séquence, correspondant aux scores pour chaque mot du vocabulaire.
Calcul des probabilités avec softmax :
- torch.nn.functional.softmax(mask_token_logits, dim=-1) applique la fonction softmax pour convertir les logits en probabilités.
Prédiction du mot pour le token masqué :
- torch.argmax(probabilities, dim=-1) trouve l'index du mot avec la probabilité la plus élevée pour remplacer le token [MASK].
Décodage du mot prédit :
- tokenizer.convert_ids_to_tokens(predicted_token_id) convertit l'ID du token prédit en un mot lisible.
Affichage du résultat :
- Le programme affiche le texte original et le mot prédit pour remplacer le token [MASK].

Remarques supplémentaires :

Fine-tuning : BertForMaskedLM peut être fine-tuné sur des données spécifiques pour des tâches de prédiction de mots masqués dans des contextes particuliers (par exemple, des livres, des articles scientifiques, etc.).
Applications : Ce modèle est utilisé pour les tâches de complétion de texte, comme les systèmes de suggestion automatique, et est également utilisé pour le pré-entraînement de modèles plus complexes dans des applications comme la question-réponse ou la classification de texte.
Limites du modèle : Bien que BERT soit puissant, il ne peut pas gérer des phrases avec des tokens complètement inconnus ou mal tokenisés, d'où l'importance de bien préparer les données avant d'utiliser le modèle.

BertModel

BertModel est une classe de la bibliothèque transformers qui permet d'utiliser le modèle BERT de base pour des tâches de traitement du langage naturel. Contrairement aux versions spécialisées comme BertForSequenceClassification ou BertForTokenClassification, BertModel fournit uniquement l'architecture de base de BERT sans ajout spécifique pour une tâche donnée. Cela permet de l'utiliser comme base pour de nombreuses tâches de traitement de texte en l'adaptant via du fine-tuning. Le modèle BERT (Bidirectional Encoder Representations from Transformers) est basé sur l'architecture Transformer et est conçu pour comprendre le langage en considérant le contexte de chaque mot à la fois à gauche et à droite. BertModel extrait des représentations de texte (embeddings) à partir de séquences de tokens et renvoie les états cachés du modèle.

Importation :

from transformers import BertModel

Attributs :

Paramètre	Type	Valeur par défaut	Description
config	PretrainedConfig	None	La configuration du modèle BERT qui contient les paramètres utilisés pour l'architecture, comme le nombre de couches, la taille des embeddings, etc.
output_attentions	bool	False	Si True, le modèle retourne les poids d'attention de chaque couche du modèle BERT.
output_hidden_states	bool	False	Si True, le modèle retourne tous les états cachés des couches intermédiaires, ce qui peut être utile pour certaines applications.
return_dict	bool	True	Si True, le modèle retourne un dictionnaire avec les sorties. Sinon, il retourne un tuple.

Exemple de code :

from transformers import BertTokenizer, BertModel
import torch

# Charger le tokenizer et le modèle BERT pré-entraîné
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

# Exemple de texte
text = "BERT is a transformer model for NLP tasks."

# Tokenisation du texte
inputs = tokenizer(text, return_tensors='pt')

# Passer les données dans le modèle
outputs = model(**inputs)

# Extraire les embeddings (états cachés)
last_hidden_states = outputs.last_hidden_state

# Afficher la forme des états cachés
print(f"Shape of last_hidden_state: {last_hidden_states.shape}")

Explication du code :

Chargement du modèle et du tokenizer :
- BertTokenizer.from_pretrained('bert-base-uncased') charge le tokenizer BERT pré-entraîné. Il permet de convertir le texte en une séquence de tokens, que BERT peut comprendre.
- BertModel.from_pretrained('bert-base-uncased') charge le modèle BERT de base pré-entraîné sans spécificité de tâche, ce qui signifie que le modèle renverra les embeddings généraux (représentations vectorielles) de la séquence d'entrée.
Tokenisation du texte :
- tokenizer(text, return_tensors='pt') convertit le texte en une séquence de tokens et les prépare sous forme de tenseurs PyTorch (pt). Cette étape permet de fournir des entrées compatibles avec le modèle.
Passage des entrées dans le modèle :
- model(**inputs) passe les données tokenisées dans le modèle BERT. Le modèle renvoie les états cachés (hidden states), qui sont les représentations vectorielles des tokens à chaque couche du modèle.
Extraction des états cachés :
- outputs.last_hidden_state contient les embeddings (représentations vectorielles) de la dernière couche du modèle pour chaque token de la séquence d'entrée. Ce tensor contient les informations traitées par BERT pour chaque mot ou token dans la phrase.
Affichage de la forme des états cachés :
- print(f"Shape of last_hidden_state: {last_hidden_states.shape}") affiche la forme des états cachés. La forme de la sortie sera (batch_size, sequence_length, hidden_size), où batch_size est le nombre d'exemples dans la batch, sequence_length est la longueur de la séquence d'entrée et hidden_size est la taille des embeddings générés par le modèle.

Remarques supplémentaires :

Fine-tuning : BertModel est un modèle de base, donc pour des tâches spécifiques (comme la classification de texte, la question-réponse ou la classification de tokens), vous devrez ajouter des couches supplémentaires sur le modèle de base et fine-tuner ces couches sur votre tâche.
Applications : Ce modèle est couramment utilisé comme point de départ pour de nombreuses tâches de traitement du langage naturel (NLP) qui nécessitent une représentation riche du texte, comme la classification, la traduction, la génération de texte, etc.
Limitations : Le modèle BertModel renvoie les représentations brutes des tokens. Il n'est pas directement destiné à des tâches finales, mais plutôt à fournir des embeddings à partir desquels d'autres modèles peuvent être construits et fine-tunés.