YouTokenToMe
ved
O YouTokentome é um tokenizador de texto não supervisionado focado na eficiência computacional. Atualmente, implementa a codificação de par rápida de bytes (BPE) [Sennrich et al.]. Nossa implementação é muito mais rápida em treinamento e tokenização do que abraçar o rosto, o FastBPE e o SentendEpip. Em alguns casos de teste, é 60 vezes mais rápido. Confira nossos resultados de referência.
Principais vantagens:
O(N) , onde N é a duração dos dados de treinamentoRecursos extras:
Além do algoritmo do artigo original, o nosso não considera tokens que cruzam os limites das palavras. Assim como na peça de frase, todos os símbolos espaciais foram substituídos pelo meta -símbolo "ito (U+2581). Ele permite que sequências de tokens sejam convertidas de volta ao texto e para que os limites das palavras sejam restaurados.
Por exemplo, a frase Blazingly fast tokenization! pode ser tokenizado em
['▁Bl', 'az', 'ingly', '▁fast', '▁token', 'ization', '!']
pip install youtokentomeVamos começar com um exemplo independente.
import random
import youtokentome as yttm
train_data_path = "train_data.txt"
model_path = "example.model"
# Generating random file with training data
# 10000 lines with 100 characters in each line
n_lines = 10000
n_characters = 100
with open ( train_data_path , "w" ) as fout :
for _ in range ( n_lines ):
print ( "" . join ([ random . choice ( "abcd " ) for _ in range ( n_characters )]), file = fout )
# Generating random text
test_text = "" . join ([ random . choice ( "abcde " ) for _ in range ( 100 )])
# Training model
yttm . BPE . train ( data = train_data_path , vocab_size = 5000 , model = model_path )
# Loading model
bpe = yttm . BPE ( model = model_path )
# Two types of tokenization
print ( bpe . encode ([ test_text ], output_type = yttm . OutputType . ID ))
print ( bpe . encode ([ test_text ], output_type = yttm . OutputType . SUBWORD )) youtokentome . BPE . train ( data , model , vocab_size , coverage , n_threads = - 1 , pad_id = 0 , unk_id = 1 , bos_id = 2 , eos_id = 3 )Treina o modelo BPE e salva para arquivar.
Args:
data : string, caminho para arquivo com dados de treinamentomodel : String, caminho para onde o modelo treinado será salvovocab_size : int, número de tokens no vocabulário finalcoverage : flutuação, fração de caracteres cobertos pelo modelo. Deve estar no intervalo [0, 1]. Um bom valor a ser usado é de cerca de 0,9999.n_threads : int, número de threads paralelos usados para executar. Se -1 for passado, todos os threads disponíveis serão usados. Observe que o número de threads é limitado por 8 (consulte a referência).pad_id : INT, ID reservado para preenchimentounk_id : int, ID reservado para símbolos desconhecidosbos_id : int, ID reservado para o começo do token da sentençaeos_id : int, ID reservado para o final da frase Retornos : classe youtokentome.BPE com o modelo carregado.
youtokentome . BPE ( model , n_threads = - 1 )Construtor de classe. Carrega o modelo treinado.
model : string, caminho para o modelo treinadon_threads : int, número de threads paralelos usados para executar. Se for igual a -1, será usado o número máximo de threads disponíveis. Classe youtokentome.BPE tem os seguintes métodos:
encode ( self , sentences , output_type = yttm . OutputType . ID , bos = False , eos = False , reverse = False , dropout_prob = 0 )Args:
sentences : Lista de cordas, sentenças para tokenização.output_type : enum, a sentença pode ser tokenizada para IDs ou subpainhas. Use OutputType.ID para IDs e OutputType.SUBWORD para subpainhas.bos : bool, se verdadeiro token “início da frase” será adicionadoeos : Bool, se verdadeiro, o token “fim da frase” será adicionadoreverse : bool, se verdadeira sequência de saída de tokens será revertidadropout_prob : FLOAT, BPE-DROPOUT Probabilidade (a probabilidade de uma mesclagem sendo descartada). Deve estar no intervalo [0, 1]. Retornos: se output_type for igual a youtokentome.OutputType.ID ou youtokentome.OutputType.SUBWORD , uma lista de listas de números inteiros ou lista de listas de strings serão retornados, respectivamente.
vocab ( self ) Retornos: uma lista vocab_size strings. A I -th String na lista corresponde à subglema I-TH.
vocab_size ( self )Retornos: int. Tamanho do vocabulário.
subword_to_id ( self , subword )Args:
subword : string. Retornos: número inteiro do intervalo [0, vocab_size-1]. Id de subglema ou, se não houver tal subpai no vocabulário, unk_id será devolvido.
id_to_subword ( self , id )Args:
id : int, deve estar no intervalo [0, vocab_size-1]Retornos: String. SubbORT do vocabulário por id.
decode ( self , ids , ignore_ids = None )Converta cada ID para subpainha e concatenar com o símbolo do espaço.
Args:
ids : Lista de listas de números inteiros. Todos os números inteiros devem estar no intervalo [0, vocab_size-1]ignore_ids : coleção de números inteiros. Esses índices seriam ignorados durante a decodificação. Todos os números inteiros devem estar no intervalo [0, vocab_size-1] [padrão: nenhum]Retornos: Lista de Strings.
$ yttm bpe --data TRAINING_DATA_FILE --model OUTPUT_MODEL_FILE --vocab_size 2000
$ yttm encode --model OUTPUT_MODEL_FILE --output_type subword < TEST_DATA_FILE > ENCODED_DATA YouTokenToMe suporta os seguintes comandos:
$ yttm --help
Usage: yttm [OPTIONS] COMMAND [ARGS]...
Options:
--help Show this message and exit.
Commands:
bpe Train BPE model.
decode Decode ids to text.
encode Encode text to ids or subwords.
vocab Print list of learned subwords.
O Command bpe permite que você treine o modelo de codificação de pares de bytes com base em um arquivo de texto.
$ yttm bpe --help
Usage: yttm bpe [OPTIONS]
Train BPE model.
Options:
--data PATH Training data file path. [required]
--model PATH Output model file path. [required]
--vocab_size INTEGER Number of tokens in the final vocabulary. [required]
--coverage FLOAT Fraction of characters covered by the model. [default: 1.0]
--n_threads INTEGER Number of threads. [default: -1]
--pad_id INTEGER Padding token id. [default: 0]
--unk_id INTEGER Unknown token id. [default: 1]
--bos_id INTEGER 'Begin of sentence' token id. [default: 2]
--eos_id INTEGER 'End of sentence' token id. [default: 3]
--help Show this message and exit.
Aplique a codificação do BPE para um corpus de frases. Use stdin para entrada e stdout para saída.
Por padrão, a codificação de obras em paralelo usando threads n_threads . O número de threads é limitado por 8 (consulte a referência).
Com a opção --stream , --n_threads será ignorado e todas as frases serão processadas uma a uma. Cada frase será tokenizada e escrita para o stdout antes que a próxima frase seja lida.
$ yttm encode --help
Usage: yttm encode [OPTIONS]
Encode text to ids or subwords.
Options:
--model PATH Path to file with learned model. [required]
--output_type TEXT 'id' or 'subword'. [required]
--n_threads INTEGER Number of threads. [default: -1]
--bos Add tab 'begin of sentence'.
--eos Add tab 'end of sentence'.
--reverse Reverse output sequence of tokens.
--stream Process each line before reading the next one.
--dropout_prob BPE-dropout probability (the probability of a merge being dropped). [default: 0]
--help Show this message and exit.
Vocabulário de impressão. Isso pode ser útil para entender o modelo.
$ yttm vocab --help
Usage: yttm vocab [OPTIONS]
Print list of learned subwords.
Options:
--model PATH Path to file with learned model. [required]
--verbose Add merging rules.
--help Show this message and exit.
Converta os IDs de volta ao texto. Use stdin para entrada e stdout para saída.
$ yttm decode --help
Usage: yttm decode [OPTIONS]
Decode ids to text.
Options:
--model PATH Path to file with learned model. [required]
--ignore_ids List of indices to ignore for decoding. Example: --ignore_ids=1,2,3
--help Show this message and exit.
