GPT (Generative Pre-trained Transformer)

Fonctions :

GPT-2

Hugging Face a rendu l'utilisation de GPT (et d'autres modèles comme BERT) extrêmement facile grâce à sa bibliothèque Transformers. Voici un exemple d'utilisation de GPT-2 pour générer du texte :

Importation :

from transformers import GPT2LMHeadModel, GPT2Tokenizer

Attributs :

Paramètre	Type	Valeur par défaut	Description
model_name	str	'gpt2'	Le nom du modèle GPT-2 à utiliser. Par exemple, 'gpt2' ou 'gpt2-medium'.
max_length	int	50	La longueur maximale de la séquence de texte générée.
temperature	float	1.0	Contrôle la diversité des textes générés (valeurs plus faibles rendent le modèle plus déterministe, plus élevées le rendent plus créatif).
top_k	int	50	Limite le nombre de candidats pour la génération en gardant les k meilleurs choix à chaque étape.
top_p	float	1.0	Le noyau de probabilité cumulative pour la génération de texte (passe les mots dont la probabilité cumulée est supérieure à top_p).

Exemple de code :

from transformers import GPT2LMHeadModel, GPT2Tokenizer
import torch

# Charger le modèle pré-entraîné GPT-2 et le tokenizer
model_name = 'gpt2'  # Ou 'gpt2-medium', 'gpt2-large', 'gpt2-xl'
model = GPT2LMHeadModel.from_pretrained(model_name)
tokenizer = GPT2Tokenizer.from_pretrained(model_name)

# Fonction pour générer du texte
def generate_text(prompt, max_length=50, temperature=1.0, top_k=50, top_p=1.0):
    # Tokeniser l'entrée (le texte de départ)
    inputs = tokenizer.encode(prompt, return_tensors='pt')
    
    # Générer du texte à partir du modèle GPT-2
    outputs = model.generate(
        inputs, 
        max_length=max_length, 
        temperature=temperature, 
        top_k=top_k, 
        top_p=top_p, 
        do_sample=True, 
        num_return_sequences=1
    )

    # Décoder et afficher le texte généré
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return generated_text

# Exemple d'utilisation
prompt = "Once upon a time"
generated_text = generate_text(prompt, max_length=100)
print(generated_text)

Explication du code :

1. Importation des bibliothèques nécessaires
- Import de NumPy pour la manipulation de tableaux.
- Import de TensorFlow et des utilitaires Keras pour le traitement de texte, la construction et l’entraînement du modèle.

2. Données d'exemple
- Définition de deux phrases simples avec leurs labels binaires correspondants : 1 pour positif, 0 pour négatif.

3. Tokenization des textes
- Création d’un tokenizer limité à 1000 mots les plus fréquents.
- Apprentissage du vocabulaire sur les textes d’entraînement.
- Conversion des phrases en séquences d’entiers correspondant aux indices des mots dans le vocabulaire.

4. Padding des séquences
- Uniformisation de la longueur des séquences à 10 tokens par ajout de zéros en fin de séquence (`padding='post'`).

5. Création du modèle simple
- Modèle séquentiel Keras avec :
- Une couche `Embedding` transformant chaque indice de mot en un vecteur dense de dimension 16.
- Une couche `GlobalAveragePooling1D` pour condenser la séquence en un vecteur moyen.
- Une couche dense avec 16 neurones et activation ReLU pour apprendre des représentations.
- Une couche dense de sortie avec activation sigmoid pour prédire la probabilité de classe positive.

6. Compilation du modèle
- Optimiseur Adam.
- Fonction de perte binaire croisée adaptée à la classification binaire.
- Métrique d’évaluation : précision (`accuracy`).

7. Entraînement
- Entraînement du modèle sur les séquences padding et labels correspondants pendant 10 epochs.
- Affichage des progrès à chaque epoch (`verbose=2`).

8. Prédiction sur de nouveaux exemples
- Préparation des nouvelles phrases (tokenization + padding).
- Prédiction des probabilités d’appartenance à la classe positive.
- Affichage du texte original et de la probabilité estimée de positif.

GPT-3

GPT-3 est accessible via une API, et son usage se fait généralement en envoyant des requêtes HTTP à l'API OpenAI. Pour l'utiliser, il faut disposer d'une clé API fournie par OpenAI.

Importation :

import openai

Attributs :

Paramètre	Type	Valeur par défaut	Description
api_key	str	None	La clé API fournie par OpenAI pour accéder à GPT-3.
model	str	'text-davinci-003'	Le nom du modèle GPT-3 à utiliser. Par exemple, 'text-davinci-003', 'text-curie-001', etc.
prompt	str	''	Le texte d'entrée qui sert de base pour la génération du texte. GPT-3 continue à partir de ce prompt.
max_tokens	int	100	Le nombre maximum de tokens que le modèle doit générer dans la réponse.
temperature	float	1.0	Contrôle la créativité de la réponse générée. Plus la valeur est basse, plus la sortie sera prévisible.
top_p	float	1.0	Contrôle la probabilité cumulative pour l'échantillonnage du modèle.
n	int	1	Le nombre de réponses à générer pour chaque requête.

Exemple de code :

import openai

# Configurer votre clé API OpenAI
openai.api_key = 'votre_clé_api'

# Fonction pour générer du texte avec GPT-3
def generate_text_with_gpt3(prompt, max_tokens=100, temperature=0.7, top_p=1.0, n=1):
    # Requête à l'API OpenAI
    response = openai.Completion.create(
        engine="text-davinci-003",  # Modèle GPT-3
        prompt=prompt,              # Le texte de départ
        max_tokens=max_tokens,     # Longueur de la réponse
        temperature=temperature,   # Créativité de la réponse
        top_p=top_p,               # Échantillonnage
        n=n                        # Nombre de réponses générées
    )
    
    # Retourner la réponse générée
    return response.choices[0].text.strip()

# Exemple d'utilisation
prompt = "Once upon a time"
generated_text = generate_text_with_gpt3(prompt, max_tokens=100)
print(generated_text)

Explication du code :

1. Importation de la bibliothèque OpenAI 
- Import du package `openai` permettant d’interagir avec l’API OpenAI pour utiliser les modèles GPT. 

2. Configuration de la clé API 
- Définition de la clé API personnelle (`openai.api_key`) nécessaire pour authentifier et autoriser les requêtes vers l’API OpenAI. 

3. Définition de la fonction de génération de texte 
- Fonction `generate_text_with_gpt3` prenant en entrée un texte de départ (`prompt`) et plusieurs paramètres contrôlant la génération. 
- Paramètres : - `max_tokens` : nombre maximal de tokens (mots ou morceaux de mots) générés dans la réponse. 
- `temperature` : contrôle la créativité ou la diversité des réponses (plus proche de 1 = plus créatif). 
- `top_p` : contrôle l’échantillonnage probabiliste (noyau de probabilité). 
- `n` : nombre de réponses différentes à générer. 

4. Envoi de la requête à l’API OpenAI 
- Utilisation de la méthode `openai.Completion.create` avec : 
- `engine="text-davinci-003"` : choix du modèle GPT-3 puissant. 
- `prompt` : texte initial pour guider la génération. 
- Les autres paramètres contrôlent la longueur et le style de la réponse. 

5. Récupération et retour de la réponse générée 
- Extraction du texte généré dans la première réponse reçue (`response.choices[0].text`). 
- Suppression des espaces inutiles autour du texte avec `.strip()`. 
- Retour de ce texte généré par la fonction. 

6. Exemple d’utilisation 
- Définition d’un prompt simple ("Once upon a time"). 
- Appel de la fonction pour générer un texte d’une centaine de tokens. 
- Affichage du texte généré dans la console.