Comment détecter l'IA en Python

Dans ce tutoriel, nous allons apprendre à vérifier si un texte contient du contenu généré par une IA à l'aide de Pangram. pangram-sdk Paquet Python.

Le pangram-sdk Le package permet aux développeurs d'utiliser API de détection de contenu IA de Pangram vérifier de courts extraits de texte ou des documents plus longs afin de détecter les signes indiquant que le contenu a été généré par une IA.

Dans ce tutoriel, nous aborderons l'obtention d'une clé API, l'utilisation du SDK Python de Pangram et la réalisation de requêtes HTTP directement vers les points de terminaison API de Pangram. Veuillez consulter la documentation complète de l'API de Pangram pour plus d'informations et des exemples d'utilisation.

Configuration

Pour commencer, vous aurez besoin d'un compte Pangram. Créez un compte en utilisant l'adresse e-mail à laquelle vous souhaitez associer votre clé API. Une fois votre compte créé, vous aurez le choix entre deux options pour configurer votre compte : souscrire à un forfait développeur ou obtenir une clé API chercheur.

Le forfait Développeur de Pangram est disponible à partir de 100 $ par mois. Ce forfait comprend jusqu'à 2 000 crédits API par mois. Vous pouvez nous contacter pour débloquer votre compte et activer la tarification basée sur l'utilisation. Inscrivez-vous au forfait Développeur pour commencer. Une fois inscrit au forfait Développeur, vous trouverez votre clé API dans la console API.

Pangram fournit également des clés API gratuites aux chercheurs. Si vous travaillez sur une étude de recherche non commerciale, veuillez remplir ce formulaire pour demander des crédits API gratuits. Nous vous répondrons directement en vous fournissant une clé API et votre allocation de crédits de recherche.

Configuration de l'environnement

Une fois que vous disposez de votre clé API, vous pouvez l'ajouter à votre environnement. Exécutez la commande suivante en remplaçant l'exemple de clé API par votre clé API personnelle. Vous pouvez également ajouter cette commande à votre .bashrc, .zshrc, .env, etc. pour définir automatiquement le PANGRAM_API_KEY variable.

export PANGRAM_API_KEY=« 12345678-1234-abcd-0123-123456789abc »

Télécharger le SDK Python

Assurez-vous que l'environnement Python approprié est activé. Exécutez la commande suivante pour installer le SDK Python de Pangram :

pip installer pangram-sdk

Si vous utilisez uv, vous pouvez plutôt utiliser :

uv ajouter pangram-sdk

Si vous utilisez Poetry, la commande serait :

poésie ajouter pangram-sdk

Utilisez le SDK Python

Créer un client Pangram

Commencez par créer un client Pangram pour envoyer des requêtes. Le client Pangram lira automatiquement votre clé API à partir de vos variables d'environnement.

de pangramme import Pangram
pangram_client = Pangram()

Vous pouvez également passer une clé API directement :

de pangram import Pangram

ma_clé_api = ''  # Remplissez ce champ avec votre clé API.
pangram_client = Pangram(api_key=my_api_key)

Faire une demande standard

client_pangramde prédire La fonction effectuera une seule requête à l'API de Pangram et renverra le résultat. Par défaut, elle ne prendra en compte que les 400 premiers mots environ. Une requête utilisera un crédit.

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = pangram_client.prédire(texte)
score = résultat[« ai_likelihood »]
représentation_textuelle_du_score = résultat[« prédiction »]
imprimer(f« Nous prédisons que le texte {texte} est {représentation_textuelle_du_score}, avec une probabilité AI de {score}. ») 

Effectuer une demande groupée

Utilisez le prédire_lot fonction permettant d'envoyer un lot de requêtes à la fois, pour un traitement plus rapide des grands ensembles de données. Une requête utilisera un crédit par élément du lot. Les résultats renvoyés seront un tableau du même format que la requête unique. prédire fonction.

text_batch = ["text1", "text2"]

results = pangram_client.batch_predict(text_batch)
for result in results:
    text = result["text"]
    score = result["ai_likelihood"]
    text_representation_of_score = result["prediction"]
    print(f"We predict that the text {text} is {text_representation_of_score}, with an AI likelihood of {score}.") 

Faire une demande de fenêtre coulissante

Utilisez le prédire_fenêtre_coulissante fonction permettant d'obtenir une prédiction précise de l'utilisation de l'IA dans un document plus long. Cette fonction divise le texte saisi en fenêtres et prédit l'IA pour chaque fenêtre du lot. Cette fonction utilise un crédit par tranche de 1 000 mots dans le texte saisi.

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = pangram_client.prédiction_fenêtre_glissante(texte)
score = résultat[« ai_likelihood »]
représentation_textuelle_du_score = résultat[« prédiction »]
imprimer(f« Nous prédisons que le texte {texte} est {représentation_textuelle_du_score}, avec une probabilité AI de {score}. ») 

Le résultat est un dictionnaire contenant les champs suivants :

• texte: [chaîne] le texte saisi
• probabilité_ai: [float] un nombre compris entre 0 et 1, où une valeur proche de 1 indique une prédiction fiable que le texte est généré par une IA.
• prédiction: [chaîne] description textuelle de la quantité de contenu IA contenue dans le texte
• prédiction_courte: [chaîne] « Humain », « Mixte » ou « IA »
• fraction_ai_contenu: [float] un nombre flottant compris entre 0 et 1, où 1 indique que l'IA est présente dans l'ensemble du texte.
• fenêtres: [liste] une liste des résultats de prédiction uniques pour le texte.

Obtenir un lien vers le tableau de bord Pangram avec les résultats

Le tableau de bord de Pangram peut afficher nativement les résultats d'une requête à fenêtre glissante. Utilisez la fonction prédire_avec_lien_vers_tableau_de_bord pour exécuter une requête à fenêtre glissante et recevoir également un lien vers le tableau de bord. Tout comme prédire_fenêtre_coulissanteCette fonction est facturée à raison d'un crédit pour 1 000 mots de texte saisi.

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = pangram_client.prédire_fenêtre_coulissante(texte)
score = résultat[« ai_likelihood »]
représentation_textuelle_du_score = résultat[« prédiction »]
lien_tableau_de_bord = résultat[« dashboard_link »]
imprimer(f"Nous prédisons que le texte {texte} est {représentation_textuelle_du_score}, avec une probabilité AI de {score}. Vous pouvez consulter les résultats complets à l'adresse {dashboard_link}») 

Le résultat est un dictionnaire contenant les mêmes champs qu'un prédire_fenêtre_coulissante résultat, sauf qu'il contient également un champ supplémentaire :

• lien_tableau_de_bord: [chaîne] lien vers une page contenant les résultats complets de la fenêtre glissante.

Méthodes alternatives : requêtes HTTP

Toutes ces fonctions sont également accessibles via HTTP. Pour obtenir la documentation complète sur la manière d'envoyer des requêtes HTTP à l'API Pangram, veuillez consulter la documentation relative à l'API d'inférence de Pangram.

Ajouter des tentatives

Il arrive parfois qu'une requête adressée à Pangram expire ou échoue. Pour éviter que votre programme ne plante, nous vous recommandons vivement d'ajouter des tentatives de reconnexion. Nous vous recommandons notamment la bibliothèque Tenacity.

Voici un exemple d'utilisation de Tenacity pour réessayer les appels Pangram :

de ténacité import nouvelle tentative, arrêt_après_tentative, attendre_aléatoire_exponentiel, retry_if_exception_type

@retry(
    retry=retry_if_exception_type((TimeoutError, Erreur de connexion)),
    stop=stop_after_attempt(5),
    attendre=attente_aléatoire_exponentielle(multiplicateur=0,5, max=10),
    relance=Vrai,
)
def predict(texte):
    retourner pangram_client.prédire(texte)

Tout mettre en place

Voici un exemple complet d'utilisation du SDK Pangram pour vérifier tout texte à la recherche d'IA et obtenir un lien vers un tableau de bord, avec des tentatives de reconnexion.

de pangram import Pangram
from tenacity import retry, arrêt_après_tentative, attendre_aléatoire_exponentiel, retry_if_exception_type

api_key = ""
pangram_client = Pangram(api_key=api_key)

@retry(
    retry=retry_if_exception_type((TimeoutError, Erreur de connexion)),
    stop=stop_after_attempt(5),
    attendre=attente_aléatoire_exponentielle(multiplicateur=0,5, max=10),
    relance=Vrai,
)
def predict_ai_with_link(texte)
    résultat = pangram_client.prédiction_fenêtre_coulissante(texte)
    retour résultat

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = predict_ai_with_link(texte)
score = résultat[« ai_likelihood »]
représentation_textuelle_du_score = résultat[« prédiction »]
lien_vers_tableau_de_bord = résultat[« dashboard_link »]
imprimer(f"Nous prédisons que le texte {texte} est {représentation_textuelle_du_score}, avec une probabilité AI de {score}. Vous pouvez consulter les résultats complets à l'adresse {dashboard_link}»)

Clôture

Nous espérons que ce guide vous aura permis d'utiliser le package Python Pangram's AI Detection pour détecter automatiquement les contenus générés par l'IA. Avez-vous créé quelque chose d'intéressant grâce à cet outil ? N'hésitez pas à nous taguer sur LinkedIn ou X et à partager votre création !