bm25 2.3.2

BM25 embedder, scorer, and search engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use bm25::{EmbedderBuilder, Language, LanguageMode, TokenEmbedder};
use divan::Bencher;
use std::hash::Hash;

use divan::AllocProfiler;

#[global_allocator]
static ALLOC: AllocProfiler = AllocProfiler::system();

fn main() {
    divan::main();
}

const ENGLISH_TEXT: &str =
    "The dominant sequence transduction models are based on complex recurrent or
convolutional neural networks in an encoder-decoder configuration. The best performing
models also connect the encoder and decoder through an attention mechanism. We
propose a new simple network architecture, the Transformer, based solely on attention
mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two
machine translation tasks show these models to be superior in quality while being more
parallelizable and requiring significantly less time to train.";

#[divan::bench(args = [
    #[cfg(feature = "language_detection")]
    LanguageMode::Detect,
    LanguageMode::Fixed(Language::English),
], sample_count = 10000)]
fn language_mode(bencher: Bencher, language_mode: &LanguageMode) {
    let embedder =
        EmbedderBuilder::<u32>::with_fit_to_corpus(language_mode.clone(), &[ENGLISH_TEXT]).build();
    // Run once beforehand to warm up the cache
    embedder.embed(ENGLISH_TEXT);

    bencher.bench(|| embedder.embed(ENGLISH_TEXT));
}

#[divan::bench(types = [usize, u32, u64], sample_count = 10000)]
fn token_embedder<T>(bencher: Bencher)
where
    T: TokenEmbedder,
    T::EmbeddingSpace: Hash + Eq,
{
    bencher
        .with_inputs(|| {
            let embedder =
                EmbedderBuilder::<T>::with_fit_to_corpus(Language::English, &[ENGLISH_TEXT])
                    .build();
            // Run once beforehand to warm up the cache
            embedder.embed(ENGLISH_TEXT);
            embedder
        })
        .bench_values(|embedder| embedder.embed(ENGLISH_TEXT));
}

#[divan::bench]
fn fit_to_corpus(bencher: Bencher) {
    let corpus = [ENGLISH_TEXT; 5000];
    // Run once beforehand to warm up the cache
    let _ = EmbedderBuilder::<u32>::with_fit_to_corpus(Language::English, &corpus).build();

    bencher
        .bench(|| EmbedderBuilder::<u32>::with_fit_to_corpus(Language::English, &corpus).build());
}