Algorithme de similarité hybride

Une plongée approfondie dans l'algorithme de similarité hybride

Cet article explore l'algorithme HybridSimilarity, un réseau neuronal sophistiqué conçu pour évaluer la similarité entre des paires de textes. Ce modèle hybride intègre intelligemment des comparaisons lexicales, phonétiques, sémantiques et syntaxiques pour un score de similarité complet.

<code class="language-python">import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
from sentence_transformers import SentenceTransformer
from Levenshtein import ratio as levenshtein_ratio
from phonetics import metaphone
import torch
import torch.nn as nn

class HybridSimilarity(nn.Module):
    def __init__(self):
        super().__init__()
        self.bert = SentenceTransformer('all-MiniLM-L6-v2')
        self.tfidf = TfidfVectorizer()
        self.attention = nn.MultiheadAttention(embed_dim=384, num_heads=4)
        self.fc = nn.Sequential(
            nn.Linear(1152, 256),
            nn.ReLU(),
            nn.LayerNorm(256),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def _extract_features(self, text1, text2):
        # Feature Extraction
        features = {}

        # Lexical Analysis
        features['levenshtein'] = levenshtein_ratio(text1, text2)
        features['jaccard'] = len(set(text1.split()) & set(text2.split())) / len(set(text1.split()) | set(text2.split()))

        # Phonetic Analysis
        features['metaphone'] = 1.0 if metaphone(text1) == metaphone(text2) else 0.0

        # Semantic Analysis (BERT)
        emb1 = self.bert.encode(text1, convert_to_tensor=True)
        emb2 = self.bert.encode(text2, convert_to_tensor=True)
        features['semantic_cosine'] = nn.CosineSimilarity()(emb1, emb2).item()

        # Syntactic Analysis (LSA-TFIDF)
        tfidf_matrix = self.tfidf.fit_transform([text1, text2])
        svd = TruncatedSVD(n_components=1)
        lsa = svd.fit_transform(tfidf_matrix)
        features['lsa_cosine'] = np.dot(lsa[0], lsa[1].T)[0][0]

        # Attention Mechanism
        att_output, _ = self.attention(
            emb1.unsqueeze(0).unsqueeze(0), 
            emb2.unsqueeze(0).unsqueeze(0), 
            emb2.unsqueeze(0).unsqueeze(0)
        )
        features['attention_score'] = att_output.mean().item()

        return torch.tensor(list(features.values())).unsqueeze(0)

    def forward(self, text1, text2):
        features = self._extract_features(text1, text2)
        return self.fc(features).item()

def similarity_coefficient(text1, text2):
    model = HybridSimilarity()
    return model(text1, text2)</code>

Composants de base

Le modèle HybridSimilarity s'appuie sur ces composants clés :

• Transformateurs de phrases : Utilise des modèles de transformateurs pré-entraînés pour la génération d'intégration sémantique.
• Distance de Levenshtein : Calcule la similarité lexicale en fonction des modifications au niveau des caractères.
• Métaphone : Détermine la similarité phonétique.
• TF-IDF et SVD tronqué : Applique l'analyse sémantique latente (LSA) pour la similarité syntaxique.
• PyTorch : Fournit le cadre pour créer le réseau neuronal personnalisé avec des mécanismes d'attention et des couches entièrement connectées.

Répartition détaillée

1. Configuration du modèle

La classe HybridSimilarity, étendant nn.Module, initialise :

• Un Modèle d'intégration de phrases basé sur BERT (all-MiniLM-L6-v2).
• Un Vectoriseur TF-IDF.
• Un mécanisme d'attention multi-têtes.
• Un réseau entièrement connecté pour agréger les fonctionnalités et générer le score de similarité final.

<code class="language-python">self.bert = SentenceTransformer('all-MiniLM-L6-v2')
self.tfidf = TfidfVectorizer()
self.attention = nn.MultiheadAttention(embed_dim=384, num_heads=4)
self.fc = nn.Sequential(
    nn.Linear(1152, 256),
    nn.ReLU(),
    nn.LayerNorm(256),
    nn.Linear(256, 1),
    nn.Sigmoid()
)</code>

2. Extraction de fonctionnalités

La méthode _extract_features calcule plusieurs caractéristiques de similarité :

• Similitude lexicale :
  • Rapport de Levenshtein : Quantifie le nombre de modifications (insertions, suppressions, substitutions) pour transformer un texte en un autre.
  • Indice Jaccard : mesure le chevauchement de mots uniques dans les deux textes.

<code class="language-python">features['levenshtein'] = levenshtein_ratio(text1, text2)
features['jaccard'] = len(set(text1.split()) & set(text2.split())) / len(set(text1.split()) | set(text2.split()))</code>

• Similitude phonétique :
  • Encodage métaphone : compare les représentations phonétiques.

<code class="language-python">features['metaphone'] = 1.0 if metaphone(text1) == metaphone(text2) else 0.0</code>

• Similitude sémantique :
  • Les intégrations BERT sont générées et la similarité cosinus est calculée.

<code class="language-python">emb1 = self.bert.encode(text1, convert_to_tensor=True)
emb2 = self.bert.encode(text2, convert_to_tensor=True)
features['semantic_cosine'] = nn.CosineSimilarity()(emb1, emb2).item()</code>

• Similitude syntaxique :
  • TF-IDF vectorise le texte et LSA est appliqué à l'aide de TruncatedSVD.

<code class="language-python">tfidf_matrix = self.tfidf.fit_transform([text1, text2])
svd = TruncatedSVD(n_components=1)
lsa = svd.fit_transform(tfidf_matrix)
features['lsa_cosine'] = np.dot(lsa[0], lsa[1].T)[0][0]</code>

• Fonctionnalité basée sur l'attention :
  • L'attention multi-têtes traite les intégrations et le score d'attention moyen est utilisé.

<code class="language-python">att_output, _ = self.attention(
    emb1.unsqueeze(0).unsqueeze(0),
    emb2.unsqueeze(0).unsqueeze(0),
    emb2.unsqueeze(0).unsqueeze(0)
)
features['attention_score'] = att_output.mean().item()</code>

3. Fusion de réseaux neuronaux

Les fonctionnalités extraites sont combinées et introduites dans un réseau neuronal entièrement connecté. Ce réseau génère un score de similarité (0-1).

<code class="language-python">import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
from sentence_transformers import SentenceTransformer
from Levenshtein import ratio as levenshtein_ratio
from phonetics import metaphone
import torch
import torch.nn as nn

class HybridSimilarity(nn.Module):
    def __init__(self):
        super().__init__()
        self.bert = SentenceTransformer('all-MiniLM-L6-v2')
        self.tfidf = TfidfVectorizer()
        self.attention = nn.MultiheadAttention(embed_dim=384, num_heads=4)
        self.fc = nn.Sequential(
            nn.Linear(1152, 256),
            nn.ReLU(),
            nn.LayerNorm(256),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def _extract_features(self, text1, text2):
        # Feature Extraction
        features = {}

        # Lexical Analysis
        features['levenshtein'] = levenshtein_ratio(text1, text2)
        features['jaccard'] = len(set(text1.split()) & set(text2.split())) / len(set(text1.split()) | set(text2.split()))

        # Phonetic Analysis
        features['metaphone'] = 1.0 if metaphone(text1) == metaphone(text2) else 0.0

        # Semantic Analysis (BERT)
        emb1 = self.bert.encode(text1, convert_to_tensor=True)
        emb2 = self.bert.encode(text2, convert_to_tensor=True)
        features['semantic_cosine'] = nn.CosineSimilarity()(emb1, emb2).item()

        # Syntactic Analysis (LSA-TFIDF)
        tfidf_matrix = self.tfidf.fit_transform([text1, text2])
        svd = TruncatedSVD(n_components=1)
        lsa = svd.fit_transform(tfidf_matrix)
        features['lsa_cosine'] = np.dot(lsa[0], lsa[1].T)[0][0]

        # Attention Mechanism
        att_output, _ = self.attention(
            emb1.unsqueeze(0).unsqueeze(0), 
            emb2.unsqueeze(0).unsqueeze(0), 
            emb2.unsqueeze(0).unsqueeze(0)
        )
        features['attention_score'] = att_output.mean().item()

        return torch.tensor(list(features.values())).unsqueeze(0)

    def forward(self, text1, text2):
        features = self._extract_features(text1, text2)
        return self.fc(features).item()

def similarity_coefficient(text1, text2):
    model = HybridSimilarity()
    return model(text1, text2)</code>

Application pratique

La fonction similarity_coefficient initialise le modèle et calcule la similarité entre deux textes d'entrée.

<code class="language-python">self.bert = SentenceTransformer('all-MiniLM-L6-v2')
self.tfidf = TfidfVectorizer()
self.attention = nn.MultiheadAttention(embed_dim=384, num_heads=4)
self.fc = nn.Sequential(
    nn.Linear(1152, 256),
    nn.ReLU(),
    nn.LayerNorm(256),
    nn.Linear(256, 1),
    nn.Sigmoid()
)</code>

Cela renvoie un flottant entre 0 et 1, représentant la similarité.

Conclusion

L'algorithme HybridSimilarity offre une approche robuste de la similarité de texte en intégrant divers aspects de la comparaison de texte. Sa combinaison d'analyses lexicales, phonétiques, sémantiques et syntaxiques permet une compréhension plus complète et nuancée de la similarité des textes, ce qui la rend adaptée à diverses applications, notamment la détection des doublons, le regroupement de textes et la récupération d'informations.

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!