基于 nomic-embed-text-v2-moe 与 Gradio 构建多语言文本相似度 WebUI

3.2 增强版相似度分析功能

让我们扩展基础功能，添加更多实用的分析特性：

def enhanced_similarity_analysis(text1, text2, language=None):
    """增强的相似度分析功能"""
    # 获取嵌入向量
    emb1 = get_embedding(text1)
    emb2 = get_embedding(text2)
    # 计算多种相似度指标
    cosine_sim = np.dot(emb1, emb2) / (norm(emb1) * norm(emb2))
    euclidean_dist = norm(np.array(emb1) - np.array(emb2))
    manhattan_dist = np.sum(np.abs(np.array(emb1) - np.array(emb2)))
    # 生成分析报告
    similarity_percent = round(cosine_sim * 100, 2)
    if similarity_percent > 80:
        analysis = "文本高度相似，可能表达相同或非常接近的含义"
    elif similarity_percent > 60:
        analysis = "文本较为相似，有共同的主题或概念"
    elif similarity_percent > 40:
        analysis = "文本有一定相关性，但存在明显差异"
    else:
        analysis = "文本差异较大，可能涉及不同主题"
    result = f""" 📊 相似度分析结果：
• 余弦相似度：{similarity_percent}%
• 欧几里得距离：{euclidean_dist:.4f}
• 曼哈达距离：{manhattan_dist:.4f}
💡 分析：{analysis} """
    return result

4. 完整的多语言 WebUI 实现

4.1 构建功能完整的界面

现在让我们创建一个功能更加完整的 Web 应用：

import gradio as gr
import ollama
import numpy as np
from numpy.linalg import norm
import time
import pandas as pd

class TextSimilarityAnalyzer:
    def __init__(self, model_name="nomic-embed-text-v2-moe"):
        self.model_name = model_name
        self.history = []

    def get_embedding(self, text):
        """获取文本嵌入向量"""
        try:
            response = ollama.embeddings(model=self.model_name, prompt=text)
            return response['embedding']
        except Exception as e:
            raise Exception(f"获取嵌入向量失败：{str(e)}")

    def analyze_similarity(self, text1, text2, show_details=False):
        """分析文本相似度"""
        start_time = time.time()
        # 获取嵌入向量
        emb1 = self.get_embedding(text1)
        emb2 = self.get_embedding(text2)
        # 计算相似度指标
        cosine_sim = np.dot(emb1, emb2) / (norm(emb1) * norm(emb2))
        processing_time = time.time() - start_time
        # 保存到历史记录
        record = {
            'text1': text1,
            'text2': text2,
            'similarity': cosine_sim,
            'timestamp': time.strftime("%Y-%m-%d %H:%M:%S")
        }
        self.history.append(record)
        # 生成结果
        similarity_percent = round(cosine_sim * 100, 2)
        result = {
            'similarity_score': similarity_percent,
            'processing_time': round(processing_time, 2),
            'analysis': self._get_analysis(similarity_percent)
        }
        if show_details:
            result.update({
                'vector_length1': len(emb1),
                'vector_length2': len(emb2)
            })
        return result

    def _get_analysis(self, similarity):
        """根据相似度得分生成分析文本"""
        if similarity > 90:
            return "🌟 文本几乎相同，语义高度一致"
        elif similarity > 70:
            return "✅ 文本非常相似，核心含义相同"
        elif similarity > 50:
            return "📋 文本有较强相关性，但存在一些差异"
        elif similarity > 30:
            return "⚠️ 文本有部分相关性，但差异明显"
        else:
            return "🔍 文本差异较大，可能涉及不同主题"

# 创建应用界面
def create_web_ui():
    analyzer = TextSimilarityAnalyzer()
    with gr.Blocks(theme=gr.themes.Soft(), title="多语言文本相似度分析") as demo:
        gr.Markdown(""" # 🌐 多语言文本相似度分析工具
使用 nomic-embed-text-v2-moe 模型，支持 100+ 种语言的文本相似度分析 """)
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 📝 输入文本")
                text1 = gr.Textbox(
                    label="第一个文本",
                    lines=4,
                    placeholder="输入第一段文本（支持中文、英文、法文、德文等多种语言）..."
                )
                text2 = gr.Textbox(
                    label="第二个文本",
                    lines=4,
                    placeholder="输入第二段文本进行比较..."
                )
                advanced = gr.Checkbox(label="显示详细分析", value=False)
                analyze_btn = gr.Button("开始分析", variant="primary", size="lg")
            with gr.Column(scale=1):
                gr.Markdown("### 📊 分析结果")
                similarity = gr.Number(label="相似度得分 (%)", precision=2)
                analysis = gr.Textbox(label="分析说明", interactive=False)
                process_time = gr.Number(label="处理时间 (秒)", precision=2)
            with gr.Accordion("高级详情", open=False):
                vec_len1 = gr.Number(label="向量维度 1", interactive=False)
                vec_len2 = gr.Number(label="向量维度 2", interactive=False)
        # 历史记录部分
        with gr.Accordion("📋 历史记录", open=False):
            history_df = gr.Dataframe(
                headers=["时间", "文本 1 片段", "文本 2 片段", "相似度"],
                interactive=False,
                height=300
            )
            clear_btn = gr.Button("清空历史", variant="secondary")

        # 事件处理
        def analyze_texts(text1, text2, show_advanced):
            result = analyzer.analyze_similarity(text1, text2, show_advanced)
            outputs = [
                result['similarity_score'],
                result['analysis'],
                result['processing_time']
            ]
            if show_advanced:
                outputs.extend([result.get('vector_length1', 768), result.get('vector_length2', 768)])
            else:
                outputs.extend([None, None])
            return outputs

        def update_history():
            if not analyzer.history:
                return pd.DataFrame(columns=["时间", "文本 1 片段", "文本 2 片段", "相似度"])
            history_data = []
            for record in analyzer.history[-10:]:
                # 显示最近 10 条记录
                text1_preview = record['text1'][:30] + "..." if len(record['text1']) > 30 else record['text1']
                text2_preview = record['text2'][:30] + "..." if len(record['text2']) > 30 else record['text2']
                history_data.append([
                    record['timestamp'],
                    text1_preview,
                    text2_preview,
                    f"{record['similarity']*100:.1f}%"
                ])
            return history_data

        analyze_btn.click(
            fn=analyze_texts,
            inputs=[text1, text2, advanced],
            outputs=[similarity, analysis, process_time, vec_len1, vec_len2]
        ).then(update_history, outputs=history_df)
        clear_btn.click(
            fn=lambda: analyzer.history.clear(),
            outputs=history_df,
            show_progress=False
        ).then(update_history, outputs=history_df)
        return demo

# 启动应用
if __name__ == "__main__":
    demo = create_web_ui()
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )

4.2 多语言示例测试

让我们测试一些多语言文本相似度的例子：

# 多语言测试示例
test_cases = [
    # 中文相似文本
    ("我喜欢吃苹果", "我爱吃苹果", "中文同义表达"),
    # 中英文对应
    ("今天天气很好", "The weather is nice today", "中英文对应"),
    # 英文同义
    ("I love machine learning", "I enjoy artificial intelligence", "英文相关主题"),
    # 完全不同的文本
    ("编程很有趣", "今天的晚餐很好吃", "不同主题"),
]

def run_test_cases():
    analyzer = TextSimilarityAnalyzer()
    results = []
    for text1, text2, description in test_cases:
        result = analyzer.analyze_similarity(text1, text2)
        results.append({
            '描述': description,
            '文本 1': text1,
            '文本 2': text2,
            '相似度': f"{result['similarity_score']}%",
            '分析': result['analysis']
        })
        time.sleep(1) # 避免请求过于频繁
    return results

# 运行测试
test_results = run_test_cases()
for result in test_results:
    print(f"{result['描述']}: {result['相似度']} - {result['分析']}")

5. 实用技巧与最佳实践

5.1 性能优化建议

在使用 nomic-embed-text-v2-moe 进行文本相似度分析时，可以考虑以下优化建议：

批量处理文本：如果需要处理大量文本，建议使用批量处理模式：

def batch_similarity(texts1, texts2):
    """批量计算文本相似度"""
    results = []
    for text1, text2 in zip(texts1, texts2):
        try:
            result = analyzer.analyze_similarity(text1, text2)
            results.append(result)
        except Exception as e:
            results.append({'error': str(e)})
        time.sleep(0.1) # 避免请求过于频繁
    return results

缓存机制：对于重复的文本，可以实现简单的缓存来避免重复计算：

from functools import lru_cache

@lru_cache(maxsize=1000)
def get_cached_embedding(text):
    """带缓存的嵌入向量获取"""
    return get_embedding(text)

5.2 常见问题解决

模型加载失败：如果遇到模型加载问题，可以尝试重新拉取模型：

ollama rm nomic-embed-text-v2-moe
ollama pull nomic-embed-text-v2-moe

内存不足：对于长文本处理，如果遇到内存问题，可以考虑文本分块：

def process_long_text(text, chunk_size=500):
    """处理长文本的分块策略"""
    chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
    chunk_embeddings = [get_embedding(chunk) for chunk in chunks]
    # 对分块嵌入进行平均池化
    return np.mean(chunk_embeddings, axis=0)

6. 总结

通过本教程，我们学习了如何使用 nomic-embed-text-v2-moe 模型和 Gradio 构建一个功能强大的多语言文本相似度分析 Web 应用。这个方案具有以下优势：

易于部署：使用 Ollama 可以快速部署和管理模型，无需复杂的环境配置。

多语言支持：得益于模型的强大能力，我们的应用可以处理 100 多种语言的文本相似度分析。

用户友好：Gradio 提供了直观的 Web 界面，即使没有技术背景的用户也能轻松使用。

灵活可扩展：基础框架可以轻松扩展更多功能，如批量处理、历史记录、高级分析等。

实际应用表明，nomic-embed-text-v2-moe 在多语言文本相似度任务上表现出色，特别是在处理语义相近但表达方式不同的文本时，能够准确捕捉深层的语义关系。

无论是用于文档去重、内容推荐、语义搜索还是多语言翻译质量评估，这个工具都能提供可靠的相似度分析结果。希望本教程能够帮助你快速上手这个强大的多语言嵌入模型，并在实际项目中发挥作用。