Traitement multilingue de documents avec LangChain : Dépasser les barrières linguistiques

LangChain agit comme un interprète polyglotte, permettant d'établir des ponts de communication entre des documents dans diverses langues.

Fonctionnalités de base

1. Chargement de documents

# Importation des chargeurs de documents
from langchain.document_loaders import TextLoader, PDFLoader
# Chargement d'un document anglais
doc_anglais = TextLoader("document_anglais.txt").load()
# Chargement d'un PDF chinois
doc_chinois = PDFLoader("rapport_chinois.pdf").load()
# Chargement d'un dossier multilingue
from langchain.document_loaders import DirectoryLoader
docs_multilingues = DirectoryLoader("./multilingue/", glob="**/*.txt").load()

2. Découpage de texte

# Importation des découpeurs de texte
from langchain.text_splitter import RecursiveCharacterTextSplitter, MarkdownTextSplitter
# Création d'un découpeur pour le chinois
decoupeur_chinois = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", "。", "！", "？", " ", ""]
)
# Découpage des textes multilingues
docs_decoupes = decoupeur_chinois.split_documents(docs_multilingues)

Fonctionnalités avancées

1. Tarduction multilingue

# Importation de la chaîne de traduction
from langchain.chains import TranslationChain
from langchain_community.llms import OpenAI
# Création d'une chaîne de traduction
llm = OpenAI(temperature=0.1)
chaine_traduction = TranslationChain.from_llm(
    llm=llm,
    source_language="zh",
    target_language="en",
    verbose=True
)
# Traduction des documents chinois
for doc in doc_chinois:
    try:
        resultat_traduction = chaine_traduction.run(doc.page_content)
        doc.metadata["contenu_traduit"] = resultat_traduction
    except Exception as e:
        print(f"Erreur de traduction: {e}")

2. Détection de langue et routage

# Importation des outils de détection de langue
from langdetect import detect
import langchain
# Création d'une fonction de routage par langue
def router_par_langue(liste_docs):
    resultats = []
    for doc in liste_docs:
        # Détection de la langue
        langue = detect(doc.page_content)
        doc.metadata["langue"] = langue
        # Sélection du processeur selon la langue
        if langue == "zh":
            processeur = chaine_traitement_chinois
        elif langue == "en":
            processeur = chaine_traitement_anglais
        else:
            processeur = chaine_traitement_defaut
        resultats.append(processeur.run(doc))
    return resultats

3. Vectorisation multilingue

# Importation du stockage vectoriel
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
# Création d'un modèle d'intégration multilingue
modele_embedding = HuggingFaceEmbeddings(
    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
    model_kwargs={'device': 'cuda'}
)
# Construction de la base de données vectorielle
base_vecteur = Chroma.from_documents(
    documents=docs_decoupes,
    embedding=modele_embedding,
    persist_directory="./db_multilingue"
)
# Recherche multilingue
resultats_recherche = base_vecteur.similarity_search(
    "La requête peut être en chinois ou en English",
    k=5
)

Exemples de tâches courantes

1. Construction d'une base de connaissances multilingue

# Définition du mapping des types de documents et langues
mapping_docs = {
    "Anglais": ["en", "*.txt", "*.pdf", TextLoader, PDFLoader],
    "Chinois": ["zh", "*.txt", "*.pdf", TextLoader, PDFLoader],
    "Japonais": ["ja", "*.txt", "*.pdf", TextLoader, PDFLoader]
}
def construire_base_connaissances_multilingue(chemin_docs="./documents"):
    # Préparation du conteneur
    tous_les_docs = []
    # Chargement des documents par langue
    for langue, config in mapping_docs.items():
        code_langue, format_txt, format_pdf, chargeur_txt, chargeur_pdf = config
        # Chargement des fichiers texte
        chargeur_dossier_txt = DirectoryLoader(
            chemin_docs,
            glob=format_txt,
            loader_cls=chargeur_txt
        )
        docs_langue_txt = chargeur_dossier_txt.load()
        # Chargement des fichiers PDF
        chargeur_dossier_pdf = DirectoryLoader(
            chemin_docs,
            glob=format_pdf,
            loader_cls=chargeur_pdf
        )
        docs_langue_pdf = chargeur_dossier_pdf.load()
        # Ajout des métadonnées de langue
        for doc in docs_langue_txt + docs_langue_pdf:
            doc.metadata["langue"] = code_langue
            tous_les_docs.append(doc)
    # Construction de la base de données vectorielle
    return Chroma.from_documents(
        documents=tous_les_docs,
        embedding=HuggingFaceEmbeddings(
            model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
        )
    )

2. Système de question-réponse multilingue

# Création d'un système de QA multilingue
from langchain.chains import RetrievalQA
from langchain_community.chat_models import ChatOpenAI
def creer_systeme_qa_multilingue(base_vecteur, langue_defaut="zh"):
    # Création du modèle de langage
    llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")
    # Détection de la langue de la requête
    def detecter_langue(requete):
        try:
            resultat_detection = detect(requete)
            return resultat_detection
        except:
            return langue_defaut
    # Création de la chaîne QA
    systeme_qa = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=base_vecteur.as_retriever(search_kwargs={"k": 3})
    )
    # Encapsulation d'une fonction capable de gérer les langues multiples
    def qa_multilingue(requete):
        # Détection de la langue de la requête
        langue_requete = detecter_langue(requete)
        # Ajout de l'indicatif de langue au prompt
        requete_enrichie = f"Veuillez répondre en {langue_requete}: {requete}"
        # Obtention de la réponse
        resultat = systeme_qa.run(requete_enrichie)
        return resultat
    return qa_multilingue

Points d'attention

1. Les modèles multilingues sont plus volumineux que les modèles monolingues et exigent plus de puissance de calcul
2. Les logiques de segmentation de mots varient considérablement selon les langues, ajustez les découpeurs en conséquence
3. La précision de la recherche inter-langues peut être inférieure à celle des systèmes monolingues
4. L'évaluation nécessite la création de jeux de tests distincts pour chaque langue

Conclusion

La bibliothèque LangChain est un outil puissant pour le traitement multilingue de documents, permettant de :

• Charger des documents dans plusieurs langues
• Découper intelligemment des textes dans différentes langues
• Créer des index vectoriaux inter-langues
• Construire des systèmes de questions-réponses multilingues

Maîtriser les fonctionnalités multilingues de LangChain permet de surmontre les difficultés liées à la traduction de documents ! Les barrières linguistiques ne sont plus un obstacle, construisez rapidement des applications intelligentes capables de traiter de manière transparente des documents dans plusieurs langues.