Traduction et NLP avec ChatGPT

Introduction

L’API ChatGPT offre des capacités avancées pour la traduction et le traitement du langage naturel (NLP). Dans ce tutoriel, nous allons explorer comment utiliser ces fonctionnalités pour créer des applications de traduction et d’analyse de texte.

Fonctionnalités principales

Traduction
- Traduction entre langues
- Traduction contextuelle
- Traduction de documents
Traitement du langage naturel
- Analyse de sentiment
- Extraction d’entités
- Classification de texte
- Résumé de texte

Implémentation

1. Service de traduction

import openai
from typing import List, Dict, Optional

class TranslationService:
    def __init__(self, api_key: str):
        openai.api_key = api_key
        
    def translate_text(
        self, 
        text: str, 
        target_language: str, 
        source_language: Optional[str] = None,
        context: Optional[str] = None
    ) -> str:
        """
        Traduit un texte vers la langue cible
        """
        prompt = f"""
        Traduisez le texte suivant en {target_language}
        {f' depuis {source_language}' if source_language else ''}
        
        {f'Contexte: {context}' if context else ''}
        
        Texte à traduire:
        {text}
        
        Instructions:
        1. Conservez le style et le ton du texte original
        2. Adaptez les expressions idiomatiques
        3. Respectez la ponctuation et la mise en forme
        """
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "Vous êtes un expert en traduction."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3
            )
            
            return response.choices[0].message.content
        except Exception as e:
            print(f"Erreur lors de la traduction: {str(e)}")
            return None
            
    def translate_batch(
        self, 
        texts: List[str], 
        target_language: str,
        source_language: Optional[str] = None
    ) -> List[Dict[str, str]]:
        """
        Traduit un lot de textes
        """
        results = []
        
        for text in texts:
            translation = self.translate_text(text, target_language, source_language)
            results.append({
                'original': text,
                'translated': translation
            })
            
        return results

2. Service de traitement du langage naturel

class NLPService:
    def __init__(self, api_key: str):
        openai.api_key = api_key
        
    def analyze_text(self, text: str, analysis_type: str) -> Dict[str, any]:
        """
        Analyse un texte selon le type d'analyse demandé
        """
        analysis_prompts = {
            'sentiment': """
                Analysez le sentiment du texte suivant:
                {text}
                
                Fournissez:
                1. Sentiment général (positif/négatif/neutre)
                2. Score de sentiment (-1 à 1)
                3. Mots-clés émotionnels
                4. Explication détaillée
            """,
            
            'entities': """
                Extrayez les entités du texte suivant:
                {text}
                
                Identifiez:
                1. Personnes
                2. Organisations
                3. Lieux
                4. Dates
                5. Autres entités importantes
            """,
            
            'summary': """
                Résumez le texte suivant:
                {text}
                
                Le résumé doit:
                1. Capturer les points principaux
                2. Être concis mais complet
                3. Conserver le ton du texte original
            """
        }
        
        prompt = analysis_prompts.get(analysis_type, "").format(text=text)
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "Vous êtes un expert en analyse de texte."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3
            )
            
            return {
                'type': analysis_type,
                'result': response.choices[0].message.content
            }
        except Exception as e:
            print(f"Erreur lors de l'analyse: {str(e)}")
            return None

3. Service de classification de texte

class TextClassifier:
    def __init__(self, api_key: str):
        openai.api_key = api_key
        
    def classify_text(
        self, 
        text: str, 
        categories: List[str],
        examples: Optional[List[Dict[str, str]]] = None
    ) -> Dict[str, float]:
        """
        Classifie un texte dans les catégories données
        """
        # Préparer les exemples si fournis
        examples_text = ""
        if examples:
            examples_text = "\nExemples:\n"
            for example in examples:
                examples_text += f"Texte: {example['text']}\n"
                examples_text += f"Catégorie: {example['category']}\n\n"
        
        prompt = f"""
        Classifiez le texte suivant dans les catégories: {', '.join(categories)}
        
        {examples_text}
        
        Texte à classifier:
        {text}
        
        Fournissez:
        1. La catégorie principale
        2. Un score de confiance pour chaque catégorie
        3. Une brève explication
        """
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "Vous êtes un expert en classification de texte."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.3
            )
            
            # Parser la réponse pour extraire les scores
            result = response.choices[0].message.content
            # TODO: Implémenter le parsing des scores
            
            return {
                'classification': result,
                'scores': {}  # À remplir avec les scores parsés
            }
        except Exception as e:
            print(f"Erreur lors de la classification: {str(e)}")
            return None

Exemples d’utilisation

1. Traduction de documents

# Exemple de traduction
translator = TranslationService('votre_clé_api')

# Traduction simple
text = "Hello, how are you today?"
translation = translator.translate_text(text, "français", "anglais")
print(f"Traduction: {translation}")

# Traduction avec contexte
context = "Conversation informelle entre amis"
text = "Hey buddy, what's up?"
translation = translator.translate_text(
    text, 
    "français", 
    "anglais",
    context
)
print(f"Traduction avec contexte: {translation}")

# Traduction par lots
texts = [
    "Good morning",
    "How are you?",
    "See you later"
]
translations = translator.translate_batch(texts, "français", "anglais")
for t in translations:
    print(f"{t['original']} -> {t['translated']}")

2. Analyse de texte

# Exemple d'analyse NLP
nlp = NLPService('votre_clé_api')

# Analyse de sentiment
text = "Le produit est excellent, je le recommande vivement !"
sentiment = nlp.analyze_text(text, 'sentiment')
print(f"Analyse de sentiment: {sentiment}")

# Extraction d'entités
text = "Microsoft a annoncé hier l'ouverture d'un nouveau bureau à Paris."
entities = nlp.analyze_text(text, 'entities')
print(f"Entités extraites: {entities}")

# Résumé de texte
text = """
L'intelligence artificielle (IA) est un domaine de l'informatique qui vise à créer 
des systèmes capables d'imiter l'intelligence humaine. Elle englobe plusieurs 
sous-domaines comme le machine learning, le traitement du langage naturel et 
la vision par ordinateur. Les applications de l'IA sont nombreuses et touchent 
de nombreux secteurs d'activité.
"""
summary = nlp.analyze_text(text, 'summary')
print(f"Résumé: {summary}")

3. Classification de texte

# Exemple de classification
classifier = TextClassifier('votre_clé_api')

# Définir les catégories
categories = ['technologie', 'sport', 'politique', 'économie']

# Exemples pour l'apprentissage
examples = [
    {
        'text': "Le nouveau smartphone sortira le mois prochain",
        'category': 'technologie'
    },
    {
        'text': "L'équipe a remporté le match 2-0",
        'category': 'sport'
    }
]

# Classifier un texte
text = "Le gouvernement annonce de nouvelles mesures économiques"
classification = classifier.classify_text(text, categories, examples)
print(f"Classification: {classification}")

Bonnes pratiques

Gestion des langues
- Validation des codes de langue
- Support des variantes régionales
- Gestion des caractères spéciaux
Optimisation des performances
- Mise en cache des traductions
- Traitement par lots
- Gestion des quotas API
Qualité des résultats
- Validation des traductions
- Vérification de la cohérence
- Gestion des cas particuliers
Sécurité et confidentialité
- Chiffrement des données
- Gestion des clés API
- Conformité RGPD

Ressources supplémentaires

Analyse de données Assistants virtuels