混合相似度演算法

深入研究混合相似度演算法

本文探討了 HybridSimilarity 演算法，這是一種複雜的神經網絡，旨在評估文本對之間的相似性。 這種混合模型巧妙地整合了詞彙、語音、語義和句法比較，以獲得全面的相似度得分。

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

核心組件

HybridSimilarity 模型依賴以下關​​鍵組件：

• 句子變壓器：利用預先訓練的變壓器模型進行語意嵌入產生。
• Levenshtein Distance： 以字元級編輯計算詞彙相似度。
• 元音位： 確定語音相似性。
• TF-IDF 和截斷 SVD： 應用潛在語意分析 (LSA) 來實現語法相似性。
• PyTorch：提供了用於建立具有註意力機制和全連接層的自訂神經網路的框架。

詳細分解

1.模型設定

HybridSimilarity 類，擴充 nn.Module，初始化：

• 一個基於BERT的句子嵌入模型 (all-MiniLM-L6-v2)。
• TF-IDF 向量化器。
• 一多頭注意力機制。
• 一個完全連接的網路來聚合特徵並產生最終的相似度分數。

<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.特徵提取

_extract_features 方法計算幾個相似特徵：

• 詞彙相似度：
  • 編輯比率：量化將一個文字轉換為另一個文字的編輯（插入、刪除、替換）次數。
  • 傑卡德指數：測量兩個文本中唯一單字的重疊。

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

• 語音相似度：
  • 元音位元編碼：比較語音表示。

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

• 語意相似度：
  • 產生 BERT 嵌入，並計算餘弦相似度。

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

• 語法相似性：
  • TF-IDF 對文字進行向量化，並使用 TruncatedSVD 應用 LSA。

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

• 基於注意力的特徵：
  • 多頭注意力處理嵌入，並使用平均注意力分數。

<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.神經網路融合

提取的特徵被組合併輸入到完全連接的神經網路中。此網路輸出相似度得分 (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>

實際應用

similarity_coefficient 函數初始化模型並計算兩個輸入文字之間的相似度。

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

這會傳回 0 到 1 之間的浮點數，表示相似度。

結論

HybridSimilarity 演算法透過整合文字比較的各個方面，提供了一種穩健的文本相似性方法。 它將詞彙、語音、語義和句法分析相結合，可以更全面、更細緻地理解文本相似性，使其適用於各種應用，包括重複檢測、文本聚類和資訊檢索。

以上是混合相似度演算法的詳細內容。更多資訊請關注PHP中文網其他相關文章！