Correspondance sémantique des identifiants de texte à l'aide des intégrations LASER en Python

Lorsque vous utilisez l'OCR pour numériser des rapports financiers, vous pouvez rencontrer diverses approches pour détecter des catégories spécifiques dans ces rapports. Par exemple, des méthodes traditionnelles telles que l'algorithme de Levenshtein peuvent être utilisées pour la correspondance de chaînes en fonction de la distance d'édition, ce qui les rend efficaces pour gérer les correspondances proches, telles que la correction de fautes de frappe ou de petites variations dans le texte.

Cependant, le défi devient plus complexe lorsque vous devez détecter plusieurs catégories sur une seule ligne d'un rapport, en particulier lorsque ces catégories peuvent ne pas apparaître exactement comme prévu ou se chevaucher sémantiquement.

Dans cet article, nous analysons une approche de correspondance sémantique utilisant les intégrations LASER (Language-Agnostic SEntence Representations) de Facebook, montrant comment il peut gérer efficacement cette tâche.

Problème

L'objectif est d'identifier des termes financiers (catégories) spécifiques dans une ligne de texte donnée. Supposons que nous disposions d'un ensemble fixe de catégories prédéfinies qui représentent tous les termes d'intérêt possibles, tels que :

["revenus", "dépenses d'exploitation", "bénéfice d'exploitation", "amortissements", "intérêts", "bénéfice net", "impôts", "bénéfice après impôts", "métrique 1"]

Étant donné une ligne de saisie comme :

"Bénéfice d'exploitation, bénéfice net et bénéfice après impôts"

Nous visons à détecter quels identifiants apparaissent dans cette ligne.

Correspondance sémantique avec LASER

Au lieu de nous appuyer sur des correspondances de texte exactes ou floues, nous utilisons la similarité sémantique. Cette approche exploite les intégrations LASER pour capturer la signification sémantique du texte et le compare en utilisant la similarité cosinus.

Mise en œuvre

Prétraitement du texte

Avant l'intégration, le texte est prétraité en le convertissant en minuscules et en supprimant les espaces supplémentaires. Cela garantit l'uniformité.

def preprocess(text):
    return text.lower().strip()

Intégration des identifiants et de la ligne d'entrée

L'encodeur LASER génère des intégrations normalisées à la fois pour la liste des identifiants et la ligne d'entrée/OCR.

identifier_embeddings = encoder.encode_sentences(identifiers, normalize_embeddings=True)
ocr_line_embedding = encoder.encode_sentences([ocr_line], normalize_embeddings=True)[0]

Classement des identifiants par spécificité

Les identifiants plus longs sont priorisés en les triant en fonction du nombre de mots. Cela permet de gérer les correspondances imbriquées, où les identifiants plus longs peuvent englober les plus courts (par exemple, « bénéfice après impôt » englobe « bénéfice »).

ranked_identifiers = sorted(identifiers, key=lambda x: len(x.split()), reverse=True)
ranked_embeddings = encoder.encode_sentences(ranked_identifiers, normalize_embeddings=True)

Calcul de similarité

En utilisant la similarité cosinus, nous mesurons la similitude sémantique de chaque identifiant avec la ligne d'entrée. Les identifiants dont la similarité dépasse un seuil spécifié sont considérés comme des correspondances.

matches = []
threshold = 0.6

for idx, identifier_embedding in enumerate(ranked_embeddings):
    similarity = cosine_similarity([identifier_embedding], [ocr_line_embedding])[0][0]
    if similarity >= threshold:
        matches.append((ranked_identifiers[idx], similarity))

Résolution des correspondances imbriquées

Pour gérer les identifiants qui se chevauchent, les correspondances les plus longues sont prioritaires, garantissant ainsi l'exclusion des correspondances les plus courtes.

def preprocess(text):
    return text.lower().strip()

Résultats

Lorsque le code est exécuté, la sortie fournit une liste des correspondances détectées ainsi que leurs scores de similarité. Pour l'exemple de saisie :

identifier_embeddings = encoder.encode_sentences(identifiers, normalize_embeddings=True)
ocr_line_embedding = encoder.encode_sentences([ocr_line], normalize_embeddings=True)[0]

Considérations relatives aux entrées plus longues et complexes

Cette méthode fonctionne bien dans les rapports financiers structurés comportant plusieurs catégories sur une seule ligne, à condition qu'il n'y ait pas trop de catégories ou beaucoup de texte sans rapport. Cependant, la précision peut se dégrader avec des entrées plus longues et complexes ou avec du texte non structuré généré par l'utilisateur, car les intégrations peuvent avoir du mal à se concentrer sur les catégories pertinentes. Il est moins fiable pour les entrées bruyantes ou imprévisibles.

Conclusion

Cet article montre comment les intégrations LASER peuvent être un outil utile pour détecter plusieurs catégories dans le texte. Est-ce la meilleure option ? Peut-être pas, mais c'est certainement l'une des options à considérer, en particulier lorsqu'il s'agit de scénarios complexes où les techniques d'appariement traditionnelles pourraient échouer.

Code complet

ranked_identifiers = sorted(identifiers, key=lambda x: len(x.split()), reverse=True)
ranked_embeddings = encoder.encode_sentences(ranked_identifiers, normalize_embeddings=True)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!