tongrams rs Download - tongrams rs Download de código -fonte

tongrams rs

Código-Fonte de IA

1.0.0

Baixar

`tongrams-rs` : toneladas de n -grama em ferrugem

Este é um porto de ferrugem de tongrams para indexar e consultar modelos de grandes idiomas no espaço comprimido, no qual as estruturas de dados são apresentadas nos seguintes artigos:

Giulio Ermanno Pibiri e Rossano Venturini, estruturas de dados eficientes para conjuntos de dados n-gramas. Em Anais da 40ª Conferência da ACM sobre Pesquisa e Desenvolvimento em Recuperação de Informações (Sigir 2017) , pp. 615-624.
Giulio Ermanno Pibiri e Rossano Venturini, lidando com enormes conjuntos de dados N-Gram com eficiência. Transações da ACM sobre sistemas de informação (TOIS) , 37.2 (2019): 1-41.

O que pode fazer

Armazene os modelos de idiomas n -gram com contagem de frequência.
Procure n -grama para obter a contagem de frequência.

Características

Modelo de linguagem compactada. tongrams-rs pode armazenar grandes modelos de idiomas n -gram em espaço muito compactado. Por exemplo, os conjuntos de dados da palavra n -gram ( n = 1..5) em test_data são armazenados em apenas 2,6 bytes por grama.
Eficiência de tempo e memória. tongrams-rs emprega Elias-Fano Trie , que codifica inteligentemente uma estrutura de dados trie que consiste em gramas n através de códigos Elias-Fano , permitindo pesquisas rápidas no espaço compactado.
Ferrugem pura. tongrams-rs é escrito apenas em ferrugem e pode ser facilmente conectado aos seus códigos de ferrugem.

Formato de dados de entrada

O formato de arquivo dos arquivos n -gram couts é o mesmo usado em tongrams , um formato do Google modificado, onde

Um arquivo separado para cada valor distinto de n (ordem) lista um grama por linha,
Cada linha do cabeçalho <number_of_grams> indica o número de n -grama no arquivo,
Os tokens em um grama <gram> são cravados por um espaço (por exemplo, the same time ) e
Um grama <gram> e a contagem <count> são cravados por uma guia horizontal.

 <number_of_grams>
<gram1><TAB><count1>
<gram2><TAB><count2>
<gram3><TAB><count3>
...

Por exemplo,

 61516
the // parent	1
the function is	22
the function a	4
the function to	1
the function and	1
...

Ferramentas da linha de comando

tools fornecem algumas ferramentas de linha de comando para apreciar esta biblioteca. A seguir, os usos de exemplo são apresentados usando arquivos n -gram conta em test_data copiados de tongrams .

1. Classificação

Para construir o índice de trie, você precisa classificar seus arquivos n -gram conta. Primeiro, prepare arquivos de contagem de unigram

 $ cat test_data/1-grams.sorted
8761
the	3681
is	1869
a	1778
of	1672
to	1638
and	1202
...

Ao usar o arquivo Unigram como um vocabulário, o executável sort_grams classifica um arquivo N -Gram.

Aqui, classificamos um arquivo Bigram Counts não classificado, como

 $ cat test_data/2-grams
38900
ways than	1
may come	1
frequent causes	1
way has	1
in which	14
...

Você pode classificar o arquivo bigram (em formato GZIP) e gravar test_data/2-grams.sorted com o seguinte comando:

 $ cargo run --release -p tools --bin sort_grams -- -i test_data/2-grams.gz -v test_data/1-grams.sorted.gz -o test_data/2-grams.sorted
Loading the vocabulary: "test_data/1-grams.sorted.gz"
Loading the records: "test_data/2-grams.gz"
Sorting the records
Writing the index into "test_data/2-grams.sorted.gz"

O formato do arquivo de saída pode ser especificado com -f e a configuração padrão é .gz . O arquivo resultante será

 $ cat test_data/2-grams.sorted
38900
the //	1
the function	94
the if	3
the code	126
the compiler	117
...

2. Indexação

O index executável constrói um modelo de idioma a partir de (classificado) n -grama conta arquivos, denominados <order>-grams.sorted.gz , e o grava em um arquivo binário. O formato do arquivo de entrada pode ser especificado com -f e a configuração padrão é .gz .

Por exemplo, o comando a seguir cria um modelo de idioma a partir de arquivos n -gram couts ( n = 1..5) colocado no diretório test_data e o grava em index.bin .

 $ cargo run --release -p tools --bin index -- -n 5 -i test_data -o index.bin
Input files: ["test_data/1-grams.sorted.gz", "test_data/2-grams.sorted.gz", "test_data/3-grams.sorted.gz", "test_data/4-grams.sorted.gz", "test_data/5-grams.sorted.gz"]
Counstructing the index...
Elapsed time: 0.190 [sec]
252550 grams are stored.
Writing the index into "index.bin"...
Index size: 659366 bytes (0.629 MiB)
Bytes per gram: 2.611 bytes

Como a saída padrão mostra, o arquivo do modelo leva apenas 2,6 bytes por grama.

3. Pesquisa

A lookup executável fornece uma demonstração para procurar n -grama, como segue.

 $ cargo run --release -p tools --bin lookup -- -i index.bin 
Loading the index from "index.bin"...
Performing the lookup...
> take advantage
count = 8
> only 64-bit execution
count = 1
> Elias Fano
Not found
> 
Good bye!

4. Estatísticas de memória

As stats executáveis mostram as quebras dos usos de memória para cada componente.

 $ cargo run --release -p tools --bin stats -- -i index.bin
Loading the index from "index.bin"...
{"arrays":[{"pointers":5927,"token_ids":55186},{"pointers":19745,"token_ids":92416},{"pointers":25853,"token_ids":107094},{"pointers":28135,"token_ids":111994}],"count_ranks":[{"count_ranks":5350},{"count_ranks":12106},{"count_ranks":13976},{"count_ranks":14582},{"count_ranks":14802}],"counts":[{"count":296},{"count":136},{"count":72},{"count":56},{"count":56}],"vocab":{"data":151560}}

Benchmark

No bench de diretório, você pode medir os tempos de pesquisa usando dados n -gram em test_data com o seguinte comando:

 $ RUSTFLAGS="-C target-cpu=native" cargo bench
count_lookup/tongrams/EliasFanoTrieCountLm
                        time:   [3.1818 ms 3.1867 ms 3.1936 ms]

O tempo relatado é o tempo total decorrido para procurar gramas aleatórias de 5k. O resultado acima foi realmente obtido no meu laptop PC (Intel i7, 16 GB de RAM), ou seja, EliasFanoTrieCountLm pode procurar um grama em 0,64 micro seg, em média.