ajout de la notion de doute dans la detection de language

core/DetectLanguage.py

@@ -1,99 +1,29 @@
 #coding: utf-8
-
-# Standard libraries
-#import json
-#import re
-
 from os import getenv
-from typing import Any
-#from typing import Dict
-#from typing import IO
-#from typing import List
 from typing import Optional
-#from typing import Tuple
-from typing import Union
-#from io import BytesIO
-
-# Third-party libraries
 import requests
 
 from openai import OpenAI
-#from pydub import AudioSegment
-
-def check_openai_api_key(api_key):
-    import openai
-    client = openai.OpenAI(api_key=api_key)
-    try:
-        client.models.list()
-    except openai.AuthenticationError:
-        return False
-    else:
-        return True
-
-
-class PRESET_MODELS:
-    # for detect language with GPT-4o-mini and GPT-4o models: 
-    # meta-paramaters presets (check_level:(low, medium, high), deterministict: (maximum, medium, minimum))
-    def get_preset__detect_language(check_level: str = "medium", deterministic: str = "medium"):
-        if check_level == "low":
-            if deterministic == "maximum":
-                return {"temperature": 0.1, "frequency_penalty": 0.5, "presence_penalty": 0.5}
-            elif deterministic == "medium":
-                return {"temperature": 0.2, "frequency_penalty": 0.5, "presence_penalty": 0.5}
-            elif deterministic == "minimum":
-                return {"temperature": 0.3, "frequency_penalty": 0.5, "presence_penalty": 0.5}
-        elif check_level == "medium":
-            if deterministic == "maximum":
-                return {"temperature": 0.1, "frequency_penalty": 0.2, "presence_penalty": 0.2}
-            elif deterministic == "medium":
-                return {"temperature": 0.2, "frequency_penalty": 0.2, "presence_penalty": 0.2}
-            elif deterministic == "minimum":
-                return {"temperature": 0.3, "frequency_penalty": 0.2, "presence_penalty": 0.2}
-        elif check_level == "high":
-            if deterministic == "maximum":
-                return {"temperature": 0.01, "frequency_penalty": 0.1, "presence_penalty": 0.1}
-            elif deterministic == "medium":
-                return {"temperature": 0.05, "frequency_penalty": 0.1, "presence_penalty": 0.1}
-            elif deterministic == "minimum":
-                return {"temperature": 0.1, "frequency_penalty": 0.1, "presence_penalty": 0.1}
-        else:
-            return {"temperature": 0.2, "frequency_penalty": 0.2, "presence_penalty": 0.2}
 
 def detect_language(input_text: str, 
                     temperature: Optional[float] = 0.2, 
                     context_window: Optional[int] = 128,
-                    model: Optional[str] = "gpt-4o-mini" 
+                    model: Optional[str] = "gpt-4o-mini"
                     ) -> str:
     """
-    Détecte la langue d'un texte donné.
-
-    Args:
-        input_text (str): Le texte dont il faut détecter la langue.
-        temperature (float): La température pour le modèle de langage. Par défaut à 0.2.
-        context_window (int): Longueur de la fenêtre de contexte à utiliser pour la détection.
-
-    Returns:
-        str: La langue détectée au format ISO-639-1.
-
-    Raises:
-        ValueError: Si la réponse de l'API est invalide.
-        requests.RequestException: En cas d'erreur de communication avec l'API.
+    Détecte la langue d'un texte donné avec une vérification croisée si doute.
     """
     system_prompt = (
         "Agissez comme une fonction de détection de langue. "
-        "Je fournirai du texte dans n'importe quelle langue, et vous détecterez sa langue. "
-        "Fournissez le résultat de votre détection au format ISO-639-1. "
-        "Votre réponse doit représenter l'argument `language` et ne contenir "
-        "que sa valeur sous forme de chaîne. "
-        "Fournir la langue d'entrée au format ISO-639-1 améliorera la précision et la latence."
+        "Fournissez la langue d'entrée au format ISO-639-1. "
+        "Si vous avez un doute ou une incertitude, indiquez 'doute'."
     )
+    
     try:
         client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
 
-        #################
-
         response = client.chat.completions.create(
-            model=f"{model}",
+            model=model,
             temperature=temperature,
             messages=[
                 {
@@ -105,26 +35,81 @@ def detect_language(input_text: str,
                     "content": input_text
                 }
             ],
-            frequency_penalty=0.2,
-            presence_penalty=0,
             max_tokens=context_window
         )
-        detected_language = response.choices[0].message.content
-        if not detected_language:
-            raise ValueError("La réponse de l'API est vide")
-        return detected_language
+
+        detected_language = response.choices[0].message.content.strip()
+
+        # Si le modèle indique un doute, faire appel à un modèle plus précis ou à un autre service de vérification
+        if "doute" in detected_language.lower():
+            print("[INFO] - (detect_language) : Doute détecté, appel d'un modèle plus précis.")
+            return call_precise_language_model(input_text)
+
+        if detected_language:
+            return detected_language
+        else:
+            raise ValueError("La réponse de l'API est vide ou invalide.")
+    
     except requests.RequestException as e:
         raise requests.RequestException(f"Erreur de communication avec l'API : {str(e)}")
     except Exception as e:
         raise ValueError(f"Erreur inattendue lors de la détection de la langue : {str(e)}")
 
+def call_precise_language_model(input_text: str) -> str:
+    """
+    Appelle un second modèle plus précis pour vérifier la langue en cas de doute.
+    """
+    precise_prompt = (
+        "Agissez comme un détecteur de langue très précis. "
+        "Fournissez la langue d'entrée au format ISO-639-1. "
+    )
+    
+    try:
+        client = OpenAI(api_key=getenv("OPENAI_API_KEY"))
+
+        # Modèle plus précis
+        response = client.chat.completions.create(
+            model="gpt-4",  # Un modèle plus lourd et précis
+            temperature=0.1,
+            messages=[
+                {
+                    "role": "system",
+                    "content": precise_prompt
+                },
+                {
+                    "role": "user",
+                    "content": input_text
+                }
+            ],
+            max_tokens=128
+        )
+
+        precise_language = response.choices[0].message.content.strip()
+        return precise_language
+
+    except Exception as e:
+        raise ValueError(f"Erreur lors de la vérification précise de la langue : {str(e)}")
+
 
 if __name__ == "__main__":
+    input_text = "Bonjour, comment ça va ?"
+    detected_language = detect_language(input_text)
+    print(f"La langue détectée est : {detected_language}")
+
     input_text = "Hello, how are you?"
     detected_language = detect_language(input_text)
     print(f"La langue détectée est : {detected_language}")
 
-    input_text = "Bonjour, comment ça va?"
+    input_text = "Hola, ¿cómo estás?"
     detected_language = detect_language(input_text)
     print(f"La langue détectée est : {detected_language}")
 
+    # maintenant des entrees plus longues, mais surtout plus ambigues, il faut comprendre la langue meme si le texte est ambigu ou melange des mots mirroirs ou des mots provenant de plusieurs langues
+
+    input_text = "Cool raoul, j'y peut rien man, c'est la vie, c'est comme ça"
+    detected_language = detect_language(input_text)
+    print(f"La langue détectée est : {detected_language}")
+
+    input_text = "Bordel de merde, le cousin s'est fait choper par les flics avec du shit sur lui."
+    detected_language = detect_language(input_text)
+    print(f"La langue détectée est : {detected_language}")