YouTokenToMe
ved
Youtokentome est un jetons de texte non supervisé axé sur l'efficacité de calcul. Il met actuellement en œuvre le codage des paires d'octets rapides (BPE) [Sennrich et al.]. Notre mise en œuvre est beaucoup plus rapide dans la formation et la tokenisation que le visage étreint, FastBPE et la phrase. Dans certains cas de test, il est 60 fois plus rapide. Découvrez nos résultats de référence.
Avantages clés:
O(N) , où N est la durée des données de formationCaractéristiques supplémentaires:
En plus de l'algorithme de l'article d'origine, le nôtre ne considère pas les jetons qui traversent les limites des mots. Tout comme dans la phrase, tous les symboles d'espace ont été remplacés par le symbole de méta "" (U + 2581). Il permet de reconstruire des séquences de jetons en texte et pour que les limites de mot soient restaurées.
Par exemple, la phrase Blazingly fast tokenization! peut être tokenisé en
['▁Bl', 'az', 'ingly', '▁fast', '▁token', 'ization', '!']
pip install youtokentomeCommençons par un exemple autonome.
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 )Forme le modèle BPE et enregistre dans le fichier.
Args:
data : chaîne, chemin pour déposer avec des données de formationmodel : chaîne, chemin vers l'endroit où le modèle formé sera enregistrévocab_size : int, nombre de jetons dans le vocabulaire finalcoverage : flotteur, fraction des caractères couverts par le modèle. Doit être dans la gamme [0, 1]. Une bonne valeur à utiliser est d'environ 0,9999.n_threads : int, nombre de threads parallèles utilisés pour s'exécuter. Si -1 est passé, tous les fils disponibles seront utilisés. Notez que le nombre de threads est limité par 8 (voir Benchmark).pad_id : INT, ID réservé pour le rembourrageunk_id : int, ID réservé pour les symboles inconnusbos_id : INT, ID réservé pour le jeton de début de phraseeos_id : INT, ID réservé pour le jeton de fin de phrase Renvoie : classe youtokentome.BPE avec le modèle chargé.
youtokentome . BPE ( model , n_threads = - 1 )Constructeur de classe. Charge le modèle qualifié.
model : chaîne, chemin vers le modèle formén_threads : int, nombre de threads parallèles utilisés pour s'exécuter. S'il est égal à -1, le nombre maximum de threads disponibles sera utilisé. Classe youtokentome.BPE a les méthodes suivantes:
encode ( self , sentences , output_type = yttm . OutputType . ID , bos = False , eos = False , reverse = False , dropout_prob = 0 )Args:
sentences : liste des chaînes, phrases pour la tokenisation.output_type : enum, la phrase peut être tokenisée en ID ou sous-mots. Utilisez OutputType.ID pour IDS et OutputType.SUBWORD pour les sous-mots.bos : Bool, si vraieos : bool, si vraireverse : bool, si vrai, la séquence de sortie des jetons sera inverséedropout_prob : float, probabilité de dropout bpe (la probabilité d'une fusion abandonnée). Doit être dans la gamme [0, 1]. Renvoie: si output_type est égal à youtokentome.OutputType.ID ou youtokentome.OutputType.SUBWORD , alors une liste de listes d'entiers ou de listes de listes sera renvoyée respectivement.
vocab ( self ) Renvoie: une liste vocab_size Strings. La I-Tth String dans la liste correspond au sous-mot du I -th.
vocab_size ( self )Renvoie: Int. Taille du vocabulaire.
subword_to_id ( self , subword )Args:
subword : chaîne. Renvoie: entier de la gamme [0, vocab_size-1]. ID de sous-mot ou, s'il n'y a pas de tel sous-mot dans le vocabulaire, unk_id sera retourné.
id_to_subword ( self , id )Args:
id : int, doit être dans la gamme [0, vocab_size-1]Renvoie: String. Sous-mot du vocabulaire par id.
decode ( self , ids , ignore_ids = None )Convertissez chaque ID en sous-mot et concaténate avec le symbole de l'espace.
Args:
ids : Liste des listes d'entiers. Tous les entiers doivent être dans la gamme [0, vocab_size-1]ignore_ids : collection d'entiers. Ces indices seraient ignorés lors du décodage. Tous les entiers doivent être dans la plage [0, vocab_size-1] [par défaut: aucun]Retours: Liste des chaînes.
$ 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 prend en charge les commandes suivantes:
$ 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.
Commande bpe vous permet de former un modèle de codage de paire d'octets basé sur un fichier texte.
$ 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.
Appliquer le codage du BPE pour un corpus de phrases. Utilisez stdin pour l'entrée et stdout pour la sortie.
Par défaut, le codage fonctionne en parallèle à l'aide de threads n_threads . Le nombre de threads est limité par 8 (voir Benchmark).
Avec l'option --stream , --n_threads sera ignoré et toutes les phrases seront traitées une par une. Chaque phrase sera tokenisée et écrite au stdout avant la lecture de la phrase suivante.
$ 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.
Imprimer le vocabulaire. Cela peut être utile pour comprendre le modèle.
$ 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.
Convertir les ID en texte. Utilisez stdin pour l'entrée et stdout pour la sortie.
$ 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.
