tongrams rs
1.0.0
tongrams-rs : toneladas de n -grams en óxido Este es un puerto de óxido de tongrams para indexar y consultar modelos de lenguaje grande en el espacio comprimido, en el que las estructuras de datos se presentan en los siguientes documentos:
Giulio ermanno Pibiri y Rossano Venturini, estructuras de datos eficientes para conjuntos de datos masivos de N-Gram. En Actas de la 40ª Conferencia de Investigación y Desarrollo de ACM en recuperación de información (Sigir 2017) , pp. 615-624.
Giulio ermanno Pibiri y Rossano Venturini, que manejan los conjuntos de datos N-Gram masivos de manera eficiente. Transacciones ACM en Sistemas de Información (TOI) , 37.2 (2019): 1-41.
Almacene los modelos de lenguaje N -gram con recuentos de frecuencia.
Busque N -grams para obtener los recuentos de frecuencia.
Modelo de lenguaje comprimido. tongrams-rs puede almacenar grandes modelos de lenguaje N -gram en un espacio muy comprimido. Por ejemplo, los conjuntos de datos de la palabra n -gram ( n = 1..5) en test_data se almacenan en solo 2.6 bytes por gramo.
Tiempo y eficiencia de memoria. tongrams-rs emplea a Elias-Fano Trie , que codifica hábilmente una estructura de datos Trie que consiste en N -grams a través de códigos Elias-Fano , lo que permite buscar búsqueda rápida en el espacio comprimido.
Roya pura. tongrams-rs está escrito solo en óxido y se puede conectar fácilmente a sus códigos de óxido.
El formato de archivo de los archivos de conteos de N -gram es el mismo que el utilizado en tongrams , un formato de Google modificado, donde
<number_of_grams> indica el número de n -grams en el archivo,<gram> están brevemente por un espacio (por ejemplo, the same time ), y<gram> y el recuento <count> se basan en una pestaña horizontal. <number_of_grams>
<gram1><TAB><count1>
<gram2><TAB><count2>
<gram3><TAB><count3>
...
Por ejemplo,
61516
the // parent 1
the function is 22
the function a 4
the function to 1
the function and 1
...
tools proporciona algunas herramientas de línea de comandos para disfrutar de esta biblioteca. A continuación, los usos de ejemplo se presentan utilizando archivos de conteos de N -gram en test_data copiados de tongrams .
Para construir el índice TRIE, debe ordenar sus archivos N -gram cuenta. Primero, preparar los archivos de unigram clasificados por los recuentos para hacer que un índice resultante sea más pequeño, como
$ cat test_data/1-grams.sorted
8761
the 3681
is 1869
a 1778
of 1672
to 1638
and 1202
...
Al usar el archivo unigram como vocabulario, el ejecutable sort_grams sorts un archivo n -gram cuenta.
Aquí, clasificamos un archivo de conteos BigRam sin clasificar, como
$ cat test_data/2-grams
38900
ways than 1
may come 1
frequent causes 1
way has 1
in which 14
...
Puede ordenar el archivo BigRam (en un formato GZIP) y escribir test_data/2-grams.sorted con el siguiente 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"
El formato de archivo de salida se puede especificar con -f , y la configuración predeterminada es .gz . El archivo resultante será
$ cat test_data/2-grams.sorted
38900
the // 1
the function 94
the if 3
the code 126
the compiler 117
...
El index ejecutable construye un modelo de idioma a partir de archivos (ordenados) n -gram cuenta, llamado <order>-grams.sorted.gz , y lo escribe en un archivo binario. El formato de archivo de entrada se puede especificar con -f , y la configuración predeterminada es .gz .
Por ejemplo, el siguiente comando construye un modelo de idioma a partir de los archivos de N -gram cuenta ( n = 1..5) colocados en el directorio test_data y lo escribe en 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 muestra la salida estándar, el archivo modelo toma solo 2.6 bytes por gramo.
La lookup ejecutable proporciona una demostración para buscar n -grams, como sigue.
$ 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!
Las stats ejecutables muestran los desgloses de los usos de memoria 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}}
En el bench del directorio, puede medir los tiempos de búsqueda utilizando datos de N -gram en test_data con el siguiente comando:
$ RUSTFLAGS="-C target-cpu=native" cargo bench
count_lookup/tongrams/EliasFanoTrieCountLm
time: [3.1818 ms 3.1867 ms 3.1936 ms]
El tiempo reportado es el tiempo total transcurrido para buscar gramos aleatorios de 5k. El resultado anterior se obtuvo en mi PC portátil (Intel i7, 16 GB de RAM), es decir, EliasFanoTrieCountLm puede buscar un gramo en 0.64 microg en promedio.
sucds::EliasFano más rápido Esta biblioteca es un software gratuito proporcionado en MIT.
