Rust高效文本嵌入库fastembed的使用指南

简介

fastembed是一个Rust语言编写的高性能文本嵌入库，专注于提供快速的文本向量化和相似度计算功能。它特别适合需要处理大量文本数据的应用场景，如语义搜索、推荐系统和自然语言处理任务。

主要特性

• 高性能文本向量化
• 高效的相似度计算
• 支持多种预训练模型
• 内存效率高
• 易于使用的API

安装方法

在Cargo.toml中添加依赖：

[dependencies]
fastembed = "0.1"  # 请使用最新版本

基本使用方法

1. 文本向量化

use fastembed::{TextEmbedding, EmbeddingModel};

fn main() {
    // 初始化嵌入模型
    let model: TextEmbedding = TextEmbedding::new(EmbeddingModel::AllMiniLML6V2).unwrap();
    
    // 对单个文本生成嵌入向量
    let embedding = model.embed("Rust是一种系统编程语言").unwrap();
    println!("Embedding dimension: {}", embedding.len());
    
    // 对多个文本批量生成嵌入向量
    let texts = vec![
        "Rust注重安全性和性能",
        "fastembed是一个高效的文本嵌入库",
        "机器学习需要大量的计算资源"
    ];
    let embeddings = model.embed_batch(&texts).unwrap();
    println!("Generated {} embeddings", embeddings.len());
}

2. 相似度计算

use fastembed::{TextEmbedding, EmbeddingModel};
use fastembed::similarity::cosine_similarity;

fn main() {
    let model: TextEmbedding = TextEmbedding::new(EmbeddingModel::AllMiniLML6V2).unwrap();
    
    let text1 = "Rust编程语言";
    let text2 = "系统编程语言";
    let text3 = "水果苹果";
    
    let emb1 = model.embed(text1).unwrap();
    let emb2 = model.embed(text2).unwrap();
    let emb3 = model.embed(text3).unwrap();
    
    println!("'{}'和'{}'的相似度: {:.4}", 
        text1, text2, cosine_similarity(&emb1, &emb2));
    println!("'{}'和'{}'的相似度: {:.4}", 
        text1, text3, cosine_similarity(&emb1, &emb3));
}

3. 使用不同预训练模型

use fastembed::{TextEmbedding, EmbeddingModel};

fn main() {
    // 使用不同的预训练模型
    let models = vec![
        EmbeddingModel::AllMiniLML6V2,  // 小型通用模型
        EmbeddingModel::BertBaseUncased,  // BERT基础版
        EmbeddingModel::DistilrobertaBase,  // 轻量级RoBERTa
    ];
    
    for model_type in models {
        let model = TextEmbedding::new(model_type).unwrap();
        println!("\n使用模型: {:?}", model_type);
        println!("嵌入维度: {}", model.dimension());
        
        let embedding = model.embed("测试不同模型").unwrap();
        println!("生成的嵌入向量长度: {}", embedding.len());
    }
}

高级用法

批量处理优化

use fastembed::{TextEmbedding, EmbeddingModel};

fn main() {
    let model = TextEmbedding::new(EmbeddingModel::AllMiniLML6V2).unwrap();
    
    // 大量文本数据
    let texts: Vec<String> = (0..1000)
        .map(|i| format!("这是第{}个文本示例", i))
        .collect();
    
    // 分批次处理
    let batch_size = 32;
    for batch in texts.chunks(batch_size) {
        let embeddings = model.embed_batch(batch).unwrap();
        // 处理嵌入向量...
    }
}

自定义相似度计算

use fastembed::{TextEmbedding, EmbeddingModel};
use fastembed::similarity::{cosine_similarity, euclidean_distance};

fn custom_similarity(a: &[f32], b: &[f32]) -> f32 {
    // 自定义相似度计算方法
    1.0 / (1.0 + euclidean_distance(a, b))
}

fn main() {
    let model = TextEmbedding::new(EmbeddingModel::AllMiniLML6V2).unwrap();
    
    let text1 = "机器学习";
    let text2 = "深度学习";
    
    let emb1 = model.embed(text1).unwrap();
    let emb2 = model.embed(text2).unwrap();
    
    println!("余弦相似度: {:.4}", cosine_similarity(&emb1, &emb2));
    println!("自定义相似度: {:.4}", custom_similarity(&emb1, &emb2));
}

性能建议

1. 对于大量文本，使用embed_batch而不是多次调用embed
2. 选择合适的模型 - 较小的模型速度更快但可能精度略低
3. 考虑使用多线程处理独立文本
4. 对嵌入向量进行缓存以避免重复计算

fastembed通过优化的Rust实现提供了卓越的性能，使其成为需要高效文本处理应用的理想选择。

完整示例代码

以下是一个结合多个功能的完整示例：

use fastembed::{TextEmbedding, EmbeddingModel};
use fastembed::similarity::{cosine_similarity, euclidean_distance};
use rayon::prelude::*; // 用于并行处理

// 自定义相似度计算函数
fn custom_sim(a: &[f32], b: &[f32]) -> f32 {
    1.0 / (1.0 + euclidean_distance(a, b))
}

fn main() {
    // 1. 初始化模型
    let model = TextEmbedding::new(EmbeddingModel::AllMiniLML6V2).unwrap();
    println!("模型维度: {}", model.dimension());

    // 2. 准备测试数据
    let texts = vec![
        "Rust编程语言",
        "系统编程语言",
        "Python是一种动态语言",
        "机器学习需要大量数据",
        "深度学习是机器学习的分支",
        "苹果是一种水果"
    ];

    // 3. 批量生成嵌入向量 (使用并行处理)
    let embeddings: Vec<Vec<f32>> = texts
        .par_iter() // 并行迭代
        .map(|text| model.embed(text).unwrap())
        .collect();

    // 4. 计算并比较所有文本对的相似度
    for i in 0..texts.len() {
        for j in (i + 1)..texts.len() {
            let cos_sim = cosine_similarity(&embeddings[i], &embeddings[j]);
            let custom_sim = custom_sim(&embeddings[i], &embeddings[j]);
            
            println!("\n比较: '{}' vs '{}'", texts[i], texts[j]);
            println!("余弦相似度: {:.4}", cos_sim);
            println!("自定义相似度: {:.4}", custom_sim);
        }
    }

    // 5. 测试不同模型
    let models = vec![
        EmbeddingModel::AllMiniLML6V2,
        EmbeddingModel::BertBaseUncased,
    ];

    let sample_text = "测试不同模型性能";
    for model_type in models {
        let m = TextEmbedding::new(model_type).unwrap();
        println!("\n测试模型: {:?}", model_type);
        
        let start = std::time::Instant::now();
        let emb = m.embed(sample_text).unwrap();
        let duration = start.elapsed();
        
        println!("嵌入维度: {}", emb.len());
        println!("处理时间: {:?}", duration);
    }
}

要运行此完整示例，需要在Cargo.toml中添加以下依赖：

[dependencies]
fastembed = "0.1"
rayon = "1.5"  # 并行处理库

这个完整示例展示了：

1. 模型初始化
2. 批量文本处理
3. 并行计算嵌入向量
4. 多种相似度计算方法
5. 不同模型的性能比较
6. 处理时间测量

您可以根据实际需求调整批处理大小、相似度阈值等参数。