HybridSimilarity-Algorithmus

Ein tiefer Einblick in den HybridSimilarity-Algorithmus

In diesem Artikel wird der HybridSimilarity-Algorithmus untersucht, ein hochentwickeltes neuronales Netzwerk zur Bewertung der Ähnlichkeit zwischen Textpaaren. Dieses Hybridmodell integriert geschickt lexikalische, phonetische, semantische und syntaktische Vergleiche für eine umfassende Ähnlichkeitsbewertung.

<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>

Kernkomponenten

Das HybridSimilarity-Modell basiert auf diesen Schlüsselkomponenten:

• Satztransformatoren: Verwendet vorab trainierte Transformermodelle für die semantische Einbettungsgenerierung.
• Levenshtein-Entfernung: Berechnet die lexikalische Ähnlichkeit basierend auf Änderungen auf Zeichenebene.
• Metaphon:Bestimmt phonetische Ähnlichkeit.
• TF-IDF und Truncated SVD: Wendet Latent Semantic Analysis (LSA) für syntaktische Ähnlichkeit an.
• PyTorch: Bietet den Rahmen für den Aufbau des benutzerdefinierten neuronalen Netzwerks mit Aufmerksamkeitsmechanismen und vollständig verbundenen Schichten.

Detaillierte Aufschlüsselung

1. Modell-Setup

Die HybridSimilarity-Klasse, die nn.Module erweitert, initialisiert:

• Ein BERT-basiertes Satzeinbettungsmodell (all-MiniLM-L6-v2).
• Ein TF-IDF-Vektorisierer.
• Ein Mehrkopf-Aufmerksamkeitsmechanismus.
• Ein vollständig verbundenes Netzwerk, um Merkmale zu aggregieren und den endgültigen Ähnlichkeitswert zu generieren.

<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. Merkmalsextraktion

Die _extract_features-Methode berechnet mehrere Ähnlichkeitsmerkmale:

• Lexikalische Ähnlichkeit:
  • Levenshtein-Verhältnis: Quantifiziert die Anzahl der Bearbeitungen (Einfügungen, Löschungen, Ersetzungen), um einen Text in einen anderen umzuwandeln.
  • Jaccard-Index: Misst die Überlappung eindeutiger Wörter in beiden Texten.

<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>

• Phonetische Ähnlichkeit:
  • Metaphone-Kodierung: Vergleicht phonetische Darstellungen.

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

• Semantische Ähnlichkeit:
  • BERT-Einbettungen werden generiert und die Kosinusähnlichkeit wird berechnet.

<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>

• Syntaktische Ähnlichkeit:
  • TF-IDF vektorisiert den Text und LSA wird mit TruncatedSVD angewendet.

<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>

• Aufmerksamkeitsbasierte Funktion:
  • Mehrkopfaufmerksamkeit verarbeitet die Einbettungen und der durchschnittliche Aufmerksamkeitswert wird verwendet.

<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 neuronaler Netze

Die extrahierten Merkmale werden kombiniert und in ein vollständig verbundenes neuronales Netzwerk eingespeist. Dieses Netzwerk gibt einen Ähnlichkeitswert (0-1) aus.

<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>

Praktische Anwendung

Die Funktion similarity_coefficient initialisiert das Modell und berechnet die Ähnlichkeit zwischen zwei Eingabetexten.

<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>

Dies gibt einen Gleitkommawert zwischen 0 und 1 zurück, der die Ähnlichkeit darstellt.

Fazit

Der HybridSimilarity-Algorithmus bietet einen robusten Ansatz zur Textähnlichkeit, indem er verschiedene Aspekte des Textvergleichs integriert. Seine Kombination aus lexikalischer, phonetischer, semantischer und syntaktischer Analyse ermöglicht ein umfassenderes und differenzierteres Verständnis der Textähnlichkeit und eignet sich daher für verschiedene Anwendungen, einschließlich Duplikaterkennung, Text-Clustering und Informationsabruf.

Das obige ist der detaillierte Inhalt vonHybridSimilarity-Algorithmus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!