하이브리드 유사성 알고리즘

하이브리드 유사성 알고리즘 심층 분석

이 기사에서는 텍스트 쌍 간의 유사성을 평가하도록 설계된 정교한 신경망인 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 거리: 문자 수준 편집을 기반으로 어휘 유사성을 계산합니다.
• 메타폰: 음성 유사성을 결정합니다.
• TF-IDF 및 Truncated SVD: 구문 유사성을 위해 LSA(Latent Semantic Analysis)를 적용합니다.
• 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 방법은 여러 유사성 특징을 계산합니다.

• 어휘적 유사성:
  • 레벤슈타인 비율: 한 텍스트를 다른 텍스트로 변환하기 위한 편집(삽입, 삭제, 대체) 횟수를 정량화합니다.
  • Jaccard 지수: 두 텍스트에서 고유 단어의 중복을 측정합니다.

<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 중국어 웹사이트의 기타 관련 기사를 참조하세요!