Optimisation du GPT-mini d'OpenAI pour détecter le texte généré par l'IA à l'aide de DSPy

La détection de texte généré par l'IA est devenue un sujet brûlant, les chercheurs et les praticiens débattant de sa faisabilité et de ses implications éthiques. À mesure que les modèles deviennent plus sophistiqués, la distinction entre le texte écrit par l’homme et celui généré par l’IA devient à la fois un défi passionnant et un besoin crucial.

Dans cet article, nous explorerons comment exploiter les capacités d'optimisation de DSPy pour affiner le GPT-4o-mini d'OpenAI pour cette tâche en utilisant un ensemble de données fascinant de 1,39 million d'échantillons de texte. À la fin, vous saurez comment implémenter, évaluer et optimiser un détecteur de texte IA de base à l'aide de DSPy : aucune ingénierie d'invite manuelle n'est requise.

---

Chargement de l'ensemble de données

Tout d'abord, chargeons l'ensemble de données, qui contient des échantillons de texte étiquetés comme écrits par des humains ou générés par l'IA à partir de diverses sources humaines et LLM. Pour commencer, assurez-vous d'avoir installé Python 3, ainsi que les bibliothèques d'ensembles de données DSPy et hugging face :

pip install dspy datasets

L'ensemble de données fait environ 2 Go, donc en fonction de votre vitesse Internet, cette étape peut prendre quelques minutes.

Voici le code pour charger et diviser l'ensemble de données de manière égale pour l'entraînement et les tests :

from datasets import load_dataset

# Load the dataset
ds = load_dataset("artem9k/ai-text-detection-pile", split="train")

# For simplicity, we’ll do an even split of data for testing and training
NUM_EXAMPLES = 80  # Adjust this to experiment with dataset size
ds = ds.train_test_split(test_size=NUM_EXAMPLES, train_size=NUM_EXAMPLES)

Conseil : Vous pouvez ajuster NUM_EXAMPLES pour expérimenter avec des ensembles de données plus volumineux ou pour réduire les coûts lors de l'exécution d'optimisations.

---

Configuration du modèle

Ensuite, nous allons créer un prédicteur DSPy de base à l'aide du GPT-4o-mini d'OpenAI. GPT-4o-mini est une version allégée du modèle GPT-4o d'OpenAI, ce qui le rend rentable pour l'expérimentation. DSPy simplifie ce processus en utilisant des signatures, qui définissent des mappages d'entrée-sortie structurés.

Remplacez "YOUR_API_KEY" par votre clé API OpenAI avant d'exécuter le code :

import dspy
from typing import Literal

# Initialize the OpenAI GPT-4o-mini model
lm = dspy.LM('openai/gpt-4o-mini', api_key="YOUR_API_KEY")
dspy.configure(lm=lm, experimental=True)

# Define the AI text detector signature
class DetectAiText(dspy.Signature):
    """Classify text as written by human or by AI."""
    text: str = dspy.InputField()
    source: Literal['ai', 'human'] = dspy.OutputField()

# Create a basic predictor
detector = dspy.Predict(DetectAiText)

Remarquez que nous n’avons effectué aucune ingénierie rapide ici. Au lieu de cela, nous comptons sur DSPy pour gérer cela, ainsi que les relations entrée-sortie automatiquement.

Vous pouvez tester le « détecteur » avec quelques exemples d'entrée :

print(detector(text="Hello world (this definitely wasn't written by AI)"))

La prédiction apparaîtra dans le champ « source » de la sortie.

---

Évaluation du détecteur

Maintenant que nous disposons d'un détecteur de base, évaluons ses performances à l'aide des outils d'évaluation de DSPy. Pour cela, nous définirons une métrique simple qui vérifie si le modèle prédit correctement la source du texte (humaine ou IA).

Voici le code pour configurer et exécuter l'évaluation :

from dspy.evaluate import Evaluate

# Define a simple evaluation metric
def validate_text_source(example: dspy.Example, pred, trace=None) -> int:
    return 1 if example.source.lower() == pred.source.lower() else 0

# Transform the dataset into DSPy-compatible "Example" objects
dspy_trainset = [
    dspy.Example(source=x['source'], text=x['text']).with_inputs('text') for x in ds['train']
]
dspy_devset = [
    dspy.Example(source=x['source'], text=x['text']).with_inputs('text') for x in ds['test']
]

# Evaluate the detector
evaluator = Evaluate(devset=dspy_devset, num_threads=12)  # Adjust threads based on your system
evaluator(detector, metric=validate_text_source)

Lors de mes premiers tests, j'ai obtenu une précision de 76 % à 81 %. Notez que les résultats peuvent varier en raison de l'échantillonnage aléatoire de l'ensemble de données.

---

Optimisation avec DSpy

La vraie puissance de DSPy réside dans ses capacités d'optimisation. En utilisant l'optimiseur MIPROv2, nous pouvons améliorer les performances du détecteur sans modifier manuellement les invites. L'optimiseur automatise ce processus à l'aide d'exemples simples, de modèles dynamiques et de techniques auto-supervisées.

Voici comment configurer et exécuter l'optimiseur :

pip install dspy datasets

Remarque : le coût d'une seule exécution d'optimisation avec le préréglage « léger » est généralement inférieur à 0,50 $ pour un ensemble de données de 80 exemples.

---

Résultats et itération

Après avoir exécuté l'optimisation, j'ai observé une amélioration significative des performances. Ma première exécution a atteint une précision de 91,25 %, par rapport à la ligne de base de 76 % à 81 %. Les analyses ultérieures variaient entre 81,2 % et 91,25 %, démontrant des améliorations constantes avec un minimum d'effort.

Pour charger le modèle optimisé pour une utilisation ultérieure :

from datasets import load_dataset

# Load the dataset
ds = load_dataset("artem9k/ai-text-detection-pile", split="train")

# For simplicity, we’ll do an even split of data for testing and training
NUM_EXAMPLES = 80  # Adjust this to experiment with dataset size
ds = ds.train_test_split(test_size=NUM_EXAMPLES, train_size=NUM_EXAMPLES)

Vous pouvez itérer davantage en :

• Régler le paramètre automatique de l'optimiseur (léger, moyen, lourd) ou définir vous-même les hyper-paramètres.
• Augmentation de la taille de l'ensemble de données pour la formation et l'évaluation.
• Tests avec des LLM plus avancés ou mis à jour.

---

Conclusion

En quelques étapes seulement, nous avons démontré comment DSPy simplifie l'optimisation LLM pour des cas d'utilisation réels. Sans aucune ingénierie manuelle des invites, nous avons obtenu une amélioration mesurable dans la détection du texte généré par l’IA. Bien que ce modèle ne soit pas parfait, la flexibilité de DSPy permet une itération continue, ce qui en fait un outil précieux pour le développement évolutif de l'IA.

Je recommande fortement de lire la documentation de DSPy et d'expérimenter avec d'autres optimiseurs et modèles LLM.

---

Code complet disponible sur GitHub.

Des questions ? Des commentaires ? Faites-moi savoir, j'ai hâte de voir ce que vous construisez avec DSPy !

Vous pouvez me trouver sur LinkedIn | CTO et associé @EES.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!