Fonctionnalités de génération

L'API generate() prend en charge plusieurs fonctionnalités pour construire des applications sur sa base.

Ce guide vous montre comment utiliser ces fonctionnalités.

Streaming

Le streaming commence à renvoyer du texte dès qu’il est généré, vous n’avez donc pas à attendre pour voir l’intégralité de la réponse générée d’un coup. C’est important dans les applications destinées aux utilisateurs, car cela réduit la latence perçue et permet aux utilisateurs de suivre la progression de la génération.

En savoir plus sur le streaming dans la documentation Text Generation Inference.

Créez une instance de TextStreamer avec le tokenizer. Passez TextStreamer au paramètre streamer dans generate() pour diffuser la sortie mot par mot.

from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
inputs = tokenizer(["The secret to baking a good cake is "], return_tensors="pt")
streamer = TextStreamer(tokenizer)

_ = model.generate(**inputs, streamer=streamer, max_new_tokens=20)

Le paramètre streamer est compatible avec toute classe disposant des méthodes put() et end(). put() pousse de nouveaux jetons et end() signale la fin de la génération. Vous pouvez créer votre propre classe de streamer, à condition qu'elle inclue ces deux méthodes, ou utiliser les classes de streamer de base de Transformers.

Marquage

Le marquage filigrane est utile pour détecter si un texte est généré. La stratégie de marquage filigrane dans Transformers « colore » aléatoirement un sous-ensemble de jetons en vert. Lorsque des jetons verts sont générés, un petit biais est ajouté à leurs logits, ce qui augmente leur probabilité d’être générés. Vous pouvez détecter un texte généré en comparant la proportion de jetons verts à la quantité de jetons verts généralement présente dans les textes générés par des humains.

Le marquage est pris en charge pour tout modèle génératif dans Transformers et ne nécessite pas de modèle de classification supplémentaire pour détecter le texte marqué.

Créez un WatermarkingConfig avec la valeur de biais à ajouter aux logits et l'algorithme de filigrane. L'exemple ci-dessous utilise l'algorithme "selfhash", où la sélection des jetons verts ne dépend que du jeton actuel. Transmettez le WatermarkingConfig à generate().

La classe WatermarkDetector détecte la proportion de jetons verts dans le texte généré, c'est pourquoi il est recommandé de retirer le texte du prompt s'il est beaucoup plus long que le texte généré. Le bourrage peut également avoir un effet sur WatermarkDetector.

from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig

model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
tokenizer.pad_token_id = tokenizer.eos_token_id
tokenizer.padding_side = "left"

inputs = tokenizer(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt")
input_len = inputs["input_ids"].shape[-1]

watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash")
out = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20)

Créez une instance de WatermarkDetector et transmettez-lui la sortie du modèle pour détecter si le texte est généré par une machine. Le WatermarkDetector doit utiliser la même WatermarkingConfig que celle employée lors de la génération.

detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config)
detection_out = detector(out, return_dict=True)
detection_out.prediction
array([True, True])