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 l'IA à l'aide de Pangram. pangram-sdk Module Python.

Le pangram-sdk Ce package permet aux développeurs d'utiliser API de détection de contenu par IA de Pangram pour vérifier si de courts extraits de texte ou des documents plus longs présentent des indices laissant penser que leur 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 l'envoi de requêtes HTTP directement vers les points de terminaison de l'API de Pangram. Pour plus d'informations et des exemples d'utilisation, veuillez consulter la documentation complète de l'API de Pangram.

Configuration

Pour commencer, vous devez disposer 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éé, deux options s'offrent à vous pour configurer votre compte : souscrire à un forfait développeur ou obtenir une clé API de chercheur.

Le forfait Développeur de Pangram est proposé à 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 à l'utilisation. Inscrivez-vous au forfait Développeur pour commencer. Une fois inscrit au forfait Développeur, vous pourrez retrouver votre clé API dans la console API.

Pangram met également gratuitement des clés API à la disposition des chercheurs. Si vous menez une étude à des fins non commerciales, veuillez remplir ce formulaire pour demander des crédits API gratuits. Nous vous répondrons directement en vous communiquant une clé API ainsi que le montant de vos 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 la clé API d'exemple par votre propre clé API. Vous pouvez également ajouter cette commande à votre .bashrc, .zshrc, .env, etc. pour configurer automatiquement le PANGRAM_API_KEY variable.

exporter PANGRAM_API_KEY="12345678-1234-abcd-0123-123456789abc"

Télécharger le SDK Python

Assurez-vous que l'environnement Python approprié est bien 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 la suivante :

poésie ajouter pangram-sdk

Utiliser 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 pangram import Pangram
pangram_client = Pangram()

Vous pouvez également fournir directement une clé API :

de pangram import Pangram

ma_clé_API = ''  # Remplacez par votre clé API.
pangram_client = Pangram(api_key=ma_clé_API)

Faire une demande standard

pangram_client's prévoir Cette fonction effectuera une seule requête auprès de l'API de Pangram et renverra le résultat. Par défaut, elle n'analysera que les quelque 400 premiers mots. Chaque requête consommera un crédit.

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = pangram_client.predict(text)
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é IA de {score}».) 

Envoyer une requête groupée

Utilisez le predict_batch fonction permettant d'envoyer un lot de requêtes en une seule fois, pour un traitement plus rapide des grands ensembles de données. Chaque requête utilisera un crédit par élément du lot. Les résultats renvoyés seront un tableau au format identique à celui de la requête unique prévoir 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}.") 

Envoyer une demande de fenêtre coulissante

Utilisez le fenêtre_glissante fonction permettant d'obtenir une estimation précise de l'utilisation de l'IA sur un document plus long. Cette fonction divise le texte d'entrée en segments et estime l'utilisation de l'IA pour chaque segment du lot. Elle utilise un crédit pour 1 000 mots du texte d'entrée.

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = pangram_client.predict_sliding_window(text)
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é IA de {score}».) 

On obtient ainsi un dictionnaire comportant les champs suivants :

• texte: [chaîne] le texte saisi
• probabilité: [float] un nombre compris entre 0 et 1, où une valeur proche de 1 indique une prédiction fiable selon laquelle le texte a été généré par une IA
• prévision: [chaîne] une description textuelle indiquant la quantité de contenu généré par l'IA que contient le texte
• prédiction brève: [chaîne] « Humain », « Métissé » ou « IA »
• fraction_ai_content: [float] un nombre à virgule flottante 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 individuels pour le texte.

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

Le tableau de bord de Pangram peut afficher directement les résultats d'une requête à fenêtre glissante. Utilisez la fonction prédire_avec_lien_vers_le_tableau_de_bord pour exécuter une requête à fenêtre glissante et recevoir également un lien vers le tableau de bord. Tout comme fenêtre_glissanteCette 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.predict_sliding_window(text)
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évoyons que le texte {texte} est {représentation_textuelle_du_score}, avec une probabilité IA de {score}. Vous pouvez consulter les résultats complets à l'adresse {dashboard_link}») 

Le résultat est un dictionnaire comportant les mêmes champs qu'un fenêtre_glissante résultat, à ceci près qu'il contient également un champ supplémentaire :

• lien vers le tableau de bord: [chaîne] un lien vers une page contenant l'intégralité des résultats de la fenêtre glissante.

Autres méthodes : 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 de 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'intégrer des mécanismes de réessai. Nous vous conseillons notamment d'utiliser la bibliothèque Tenacity.

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

de la ténacité importer retry, stop_after_attempt, wait_random_exponential, retry_if_exception_type

@retry(
    retry=retry_if_exception_type((TimeoutError, ConnectionError)),
    stop=stop_after_attempt(5),
    wait=wait_random_exponential(multiplicateur=0,5, max=10),
    relancer=Vrai,
)
def predict(texte):
    retourner pangram_client.predict(text)

Tout mettre en place

Voici un exemple complet illustrant comment utiliser le SDK Pangram pour analyser n'importe quel texte à la recherche d'éléments générés par l'IA et obtenir un lien vers un tableau de bord, avec des tentatives de reconnexion.

de pangram import Pangram
de tenacity import retry, stop_after_attempt, wait_random_exponential, retry_if_exception_type

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

@retry(
    retry=retry_if_exception_type((TimeoutError, ConnectionError)),
    stop=stop_after_attempt(5),
    wait=wait_random_exponential(multiplicateur=0,5, max=10),
    relancer=Vrai,
)
def predict_ai_with_link(text)
    résultat = pangram_client.predict_sliding_window(text)
    return résultat

texte = « Le renard brun rapide saute par-dessus le chien paresseux. »
résultat = predict_ai_with_link(text)
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évoyons que le texte {texte} est {représentation_textuelle_du_score}, avec une probabilité IA 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 module Python « AI Detection » de Pangram pour détecter du contenu généré par l'IA par programmation. Avez-vous créé quelque chose d'intéressant grâce à cet outil ? N'hésitez pas à nous taguer sur LinkedIn ou X et à partager vos créations !