VIDÉO | Comment créer un détecteur de contenu IA pour le texte, les images et les deepfakes : un didacticiel étape par étape

L'essor du contenu généré par l'IA rend de plus en plus difficile la distinction entre le texte, les images et les deepfakes créés par l'homme et ceux créés par des machines.

Que vous soyez journaliste, chercheur ou simplement un internaute inquiet, la détection du contenu généré par l'IA est une compétence cruciale.

Dans ce guide, nous allons explorer comment créer une API de détection de contenu basée sur l'IA à l'aide de API rapide et API Eden AI pour détecter les faux contenus rapidement et efficacement.

‍

Pourquoi la détection par IA est importante

Le contenu généré par l'IA peut être utilisé à la fois à des fins bénéfiques et nuisibles. Bien qu'elle contribue à automatiser la création de contenu, elle présente également des risques tels que la désinformation, la fraude et les escroqueries Deepfake.

Avec les bons outils, nous pouvons vérifier l'authenticité du contenu et atténuer ces risques.

‍

Configuration de l'API de détection de contenu IA

Si vous souhaitez obtenir une description complète et approfondie de ce didacticiel, n'oubliez pas de regarder notre didacticiel YouTube avec Krishna Kompalli, avocat des développeurs, où nous vous expliquons chaque étape, expliquons les détails du code et discutons de la meilleure façon d'intégrer ces outils dans vos projets.

‍

Prérequis

Avant de commencer, assurez-vous que les éléments suivants sont installés :

• Python 3.8 et versions ultérieures
• API rapide (pour créer l'API)
• Uvicorne (pour exécuter le serveur FastAPI)
• Demandes (pour effectuer des appels d'API)
• Doten c. (pour gérer les variables d'environnement)

Vous pouvez installer les packages requis en utilisant :

pip install fastapi uvicorn requests python-dotenv

‍

Création de l'application FastAPI

Commençons par créer une application FastAPI simple qui hébergera nos terminaux de détection d'IA. FastAPI facilite la création d'API RESTful grâce à une documentation interactive automatique.

from fastapi import FastAPI, File, UploadFile, Form, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import requests
import os
from dotenv import load_dotenv
import logging

‍

Configuration de la journalisation et des variables d'environnement

Avant de plonger dans les points de terminaison de l'API, il est important de configurer la journalisation et de gérer les données sensibles telles que les clés d'API à l'aide de variables d'environnement. La journalisation permet de suivre les demandes d'API et les erreurs potentielles, tandis que les variables d'environnement stockent des données sensibles telles que les clés d'API.

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger("ai_detection")

# Load environment variables
load_dotenv()
EDENAI_API_KEY = os.getenv("EDENAI_API_KEY")
if not EDENAI_API_KEY:
    raise ValueError("EDENAI_API_KEY environment variable not set")

‍

Ici, nous utilisons doten c. pour charger l'EDENAI_API_KEY à partir d'un fichier .env. Cette clé est nécessaire pour interagir avec l'API Eden AI, qui fournit des services de détection de contenu basés sur l'IA.

‍

Initialisation de FastAPI et CORS Middleware

Ensuite, nous initialisons FastAPI et configurons CORS (partage de ressources entre origines) pour autoriser les requêtes provenant de n'importe quel domaine. Ceci est important si l'API doit être utilisée dans différentes applications clientes.

app = FastAPI(title="AI Content Detection API", description="Detect AI-generated content", version="1.0.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

‍

Nous sommes maintenant prêts à définir les points de terminaison de l'API.

‍

Définition des points de terminaison de l'API

Nous allons créer trois points de terminaison clés pour détecter différents types de contenu généré par l'IA :

1. Détection de texte par IA: détecte si le texte donné est généré par l'IA.
2. Détection d'images par IA: identifie les images générées par l'IA, qu'elles soient téléchargées sous forme de fichier ou fournies via une URL.
3. Détection de Deepfake: analyse les images ou les vidéos à la recherche de contenus Deepfake.

‍

1. Détection de texte généré par l'IA

Cette fonction envoie le texte donné à Eden AI API de détection d'IA et vérifie s'il est généré par l'IA.

@app.post("/text-ai-detection")
async def detect_ai_text(text: str = Form(...), providers: str = Form("sapling,originalityai")):
    url = "https://api.edenai.run/v2/text/ai_detection"
    payload = {"providers": providers, "text": text, "response_as_dict": True}
    headers = {"accept": "application/json", "authorization": f"Bearer {EDENAI_API_KEY}"}
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return {"results": response.json(), "message": "Text analysis completed successfully"}
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")

‍

Cette fonction prend une saisie de texte et utilise API Eden AI pour détecter s'il est généré par l'IA. La réponse de l'API est ensuite renvoyée au format JSON, qui inclut le résultat de l'analyse.

‍

2. Détection d'images générées par l'IA

Ce point de terminaison vérifie si une image téléchargée ou l'URL d'une image fournie est générée par l'IA.

@app.post("/image-ai-detection")
async def detect_ai_image(file: UploadFile = File(None), file_url: str = Form(None), providers: str = Form("hive")):
    if not file and not file_url:
        raise HTTPException(status_code=400, detail="Provide either a file or a file URL")
    
    url = "https://api.edenai.run/v2/image/ai_detection"
    payload = {"providers": providers, "file_url": file_url, "response_as_dict": True}
    headers = {"accept": "application/json", "authorization": f"Bearer {EDENAI_API_KEY}"}
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return {"results": response.json(), "message": "Image analysis completed successfully"}
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")

‍

Ici, nous gérons à la fois les téléchargements de fichiers et les URL. Le fichier image ou l'URL est envoyé à Eden AI détection d'image point final pour l'analyse.

‍

3. Détecter les Deepfakes

Cette fonction détecte le contenu deepfake en analysant les fichiers ou les URL téléchargés.

@app.post("/deepfake-detection")
async def detect_deepfake(file: UploadFile = File(None), file_url: str = Form(None), providers: str = Form("sensity")):
    if not file and not file_url:
        raise HTTPException(status_code=400, detail="Provide either a file or a file URL")
    
    url = "https://api.edenai.run/v2/image/deepfake_detection"
    payload = {"providers": providers, "file_url": file_url, "response_as_dict": True}
    headers = {"accept": "application/json", "authorization": f"Bearer {EDENAI_API_KEY}"}
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return {"results": response.json(), "message": "Deepfake analysis completed successfully"}
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")

‍

Ce terminal se concentre sur la détection des images ou vidéos deepfake, ce qui est essentiel pour vérifier l'authenticité du contenu multimédia.

‍

Exécution de l'API

Pour exécuter le serveur FastAPI, utilisez la commande suivante :

uvicorn fake_content_detection:app --host 0.0.0.0 --port 8000

‍

Cette commande démarrera le serveur d'API, le rendant accessible sur hôte local au port 8000.

‍

Tester l'API

Une fois le serveur lancé, vous pouvez tester les terminaux à l'aide de Postman ou cURL.

Par exemple, pour tester le point de terminaison de détection de texte, vous pouvez utiliser la commande cURL suivante :

curl -X 'POST' 'http://localhost:8000/text-ai-detection' \
-H 'Content-Type: application/x-www-form-urlencoded' \
-d 'text=This is a test sentence&providers=sapling,originalityai'

‍

Conclusion

Dans ce guide, nous avons créé une API de détection de contenu basée sur l'IA en utilisant API rapide et API Eden AI. Grâce à cette API, vous pouvez :

• Détecter le texte généré par l'IA
• Identifiez les images créées par l'IA
• Repérez les médias Deepfake

En mettant en œuvre cette solution, vous serez en mesure d'améliorer vos flux de travail de vérification du contenu et de contribuer à atténuer les risques de désinformation et de tromperie. N'oubliez pas de regarder notre Tutoriel Youtube pour une avancée majeure.

Que vous travailliez dans le domaine des médias, de la cybersécurité ou que vous cherchiez simplement à améliorer vos pratiques personnelles de validation de contenu, l'intégration de cette API dans vos projets vous permettra de repérer les faux contenus en quelques secondes !