magnitude
Release 0.1.143
Un format de fichier de stockage Python et un fichier de stockage vectoriel rempli de fonctionnalités pour utiliser des incorporations vectorielles dans des modèles d'apprentissage automatique de manière rapide, efficace et simple développée par plasticité. Il est principalement destiné à être une alternative plus simple / plus rapide à Gensim, mais peut être utilisé comme magasin de vecteur de clé générique pour les domaines en dehors de la NLP. Il offre des fonctionnalités uniques comme les recherches hors vocabulaire et le streaming de grands modèles via HTTP. Publié dans notre article à EMNLP 2018 et disponible sur Arxiv.
Vous pouvez installer ce package avec pip :
pip install pymagnitude # Python 2.7
pip3 install pymagnitude # Python 3Google Colaboratory a certains problèmes de dépendance avec l'installation de la magnitude en raison de dépendances contradictoires. Vous pouvez utiliser l'extrait suivant pour installer l'amplitude sur Google Colaboratoire:
# Install Magnitude on Google Colab
! echo " Installing Magnitude.... (please wait, can take a while) "
! (curl https://raw.githubusercontent.com/plasticityai/magnitude/master/install-colab.sh | /bin/bash 1> /dev/null 2> /dev/null)
! echo " Done installing Magnitude. " Les modèles d'intégration d'espace vectoriel sont devenus de plus en plus courants dans l'apprentissage automatique et ont traditionnellement été populaires pour les applications de traitement du langage naturel. Un outil rapide et léger pour consommer efficacement ces grands modèles d'espace vectoriel fait défaut.
Le format de fichier d'amplitude ( .magnitude ) pour les intérêts vectoriels est destiné à être un format d'intégration de vecteurs universels plus efficace qui permet de charger des requêtes à froid plus rapidement dans le développement, la mise en cache de mémoire du LRU pour une performance en production clés mal orthographiées et concaténer plusieurs modèles vectoriels ensemble. Il est également destiné à fonctionner avec de grands modèles vectoriels qui peuvent ne pas tenir dans la mémoire.
Il utilise SQLite, une base de données intégrée rapide et populaire, comme magasin de données sous-jacente. Il utilise des index pour les recherches de clés rapides et utilise la cartographie de la mémoire, les instructions SIMD et l'indexation spatiale pour une recherche rapide de similitude dans l'espace vectoriel hors disque avec de bonnes performances de mémoire même entre plusieurs processus. De plus, les cartes de mémoire sont mises en cache entre les courses, donc même après la fermeture d'un processus, les améliorations de la vitesse sont récoltées.
| Métrique | Lumière de magnitude | Moyen de magnitude | Grandeur lourd | Flux de magnitude |
|---|---|---|---|---|
| Temps de chargement initial | 0,7210 | ━ 1 | ━ 1 | 7,7550s |
| Requête de clé unique froide | 0,0001 | ━ 1 | ━ 1 | 1,6437 |
| Requête de clé unique chaude (même clé que Cold Query) | 0,00004S | ━ 1 | ━ 1 | 0,0004S |
| Requête de clé multiple froide (n = 25) | 0,0442 | ━ 1 | ━ 1 | 1,7753 |
| Recherche de clés multiples chaude (n = 25) (mêmes clés que la requête froide) | 0,00004S | ━ 1 | ━ 1 | 0,0001 |
Première requête de recherche most_similar(n = 10) (pire des cas) | 247.05 | ━ 1 | ━ 1 | - |
Première requête de recherche most_similar(n = 10) (cas moyen) (w / disque Cache persistant) | 1.8217S | ━ 1 | ━ 1 | - |
Recherche most_similar ultérieure(n = 10) (clé différente de la première requête) | 0,2434S | ━ 1 | ━ 1 | - |
Recherche most_similar ultérieure(n = 10) (même clé que la première requête) | 0,00004S | 0,00004S | 0,00004S | - |
Première requête de recherche most_similar_approx(n = 10, effort = 1,0) (pire cas) | N / A | N / A | 29.610 | - |
Première requête de recherche most_similar_approx(n = 10, effort = 1,0) (cas moyen) (w / disque cache persistant) | N / A | N / A | 0,9155 | - |
Recherche plus ultérieure de most_similar_approx(n = 10, effort = 1,0) (clé différente de la première requête) | N / A | N / A | 0,1873 | - |
Recherche plus ultérieure de most_similar_approx(n = 10, effort = 0,1) (clé différente de la première requête) | N / A | N / A | 0,0199S | - |
Recherche la plus ultérieure de most_similar_approx(n = 10, effort = 1,0) (même clé que la première requête) | N / A | N / A | 0,00004S | - |
| Taille de fichier | 4,21 Go | 5,29 Go | 10,74 Go | 0,00 Go |
| Utilisation de la mémoire de processus (RAM) | 18 kb | ━ 1 | ━ 1 | 1,71 Mo |
| Utilisation de la mémoire de processus (RAM) après 100 requêtes clés | 168KB | ━ 1 | ━ 1 | 1,91 Mo |
| Utilisation de la mémoire de processus (RAM) après 100 requêtes clés + recherche de similitude | 342KB 2 | ━ 1 | ━ 1 | |
| Vérification et tests d'intégrité | ✅ | ✅ | ✅ | ✅ |
Format universel entre Word2Vec ( .txt , .bin ), Glove ( .txt ), FastText ( .vec ) et Elmo ( .hdf5 ) avec un utilitaire de convertisseur | ✅ | ✅ | ✅ | ✅ |
| Interface simple et pythonique | ✅ | ✅ | ✅ | ✅ |
| Peu de dépendances | ✅ | ✅ | ✅ | ✅ |
| Prise en charge des modèles de mémoire plus grands que la mémoire | ✅ | ✅ | ✅ | ✅ |
| Chargement paresseux chaque fois que possible pour la vitesse et les performances | ✅ | ✅ | ✅ | ✅ |
Optimisé pour threading et multiprocessing | ✅ | ✅ | ✅ | ✅ |
| Recherche de clés en vrac et plusieurs avec un rembourrage, une troncature, un espace réservé et un support de fonctionnalité | ✅ | ✅ | ✅ | ✅ |
| Concatation de plusieurs modèles vectoriels ensemble | ✅ | ✅ | ✅ | ✅ |
| Recherche de clé de base hors vocabulaire (Character n-gram feature haching) | ✅ | ✅ | ✅ | ✅ |
| Looking Key Advanced Out-of Vocabulary avec le support pour les fautes d'orthographe (Caracter N-gram Feature Hashing à des touches in-vocabulaires similaires) | ✅ | ✅ | ✅ | |
| Recherche la plus similaire la plus similaire avec un index ennui | ✅ | ✅ | ||
| Formation intégrée pour les nouveaux modèles |
1: même valeur que la colonne précédente
2: utilise mmap pour lire à partir du disque, de sorte que le système d'exploitation alloue toujours des pages de mémoire lorsque la mémoire est disponible, mais elle peut être partagée entre les processus et n'est pas gérée dans chaque processus pour des fichiers extrêmement volumineux qui sont une victoire de performance
*: Tous les repères ont été effectués sur les vecteurs de mots pré-formés Google News ( GoogleNews-vectors-negative300.bin ) avec un MacBook Pro (rétine, 15 pouces, mi-2014) 2,2 GHz quad-core Core i7 @ 16 Go de RAM sur le SSD sur une moyenne des essais dans le cadre de la réalisation.
Les modèles d'incorporation populaires ont été pré-convertis au format .magnitude pour le téléchargement et l'utilisation des immeubles:
| Donateur | Données | Lumière (Support de base pour les clés hors vocabule) | Moyen (recommandé) (Support avancé pour les clés hors vocabule) | Lourd (Prise en charge avancée pour les clés hors vocabule et plus rapidement most_similar_approx ) |
|---|---|---|---|---|
| Google - Word2Vec | Google News 100B | 300D | 300D | 300D |
| Stanford - Gant | Wikipedia 2014 + Gigaword 5 6b | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d |
| Stanford - Gant | Wikipedia 2014 + Gigaword 5 6b (lemmatisé par la plasticité) | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d |
| Stanford - Gant | Crawl commun 840b | 300D | 300D | 300D |
| Stanford - Gant | Twitter 27b | 25d, 50d, 100d, 200d | 25d, 50d, 100d, 200d | 25d, 50d, 100d, 200d |
| Facebook - FastText | Anglais Wikipedia 2017 16b | 300D | 300D | 300D |
| Facebook - FastText | Anglais Wikipedia 2017 + sous-mots 16b | 300D | 300D | 300D |
| Facebook - FastText | Crawl commun 600b | 300D | 300D | 300D |
| AI2 - ALLENNLP Elmo | Modèles Elmo | Modèles Elmo | Modèles Elmo | Modèles Elmo |
| Google - Bert | À venir... | À venir... | À venir... | À venir... |
Il existe des instructions ci-dessous pour convertir n'importe quel fichier .bin , .txt , .vec , .hdf5 en fichier .magnitude .
Vous pouvez créer un objet de magnitude comme tel:
from pymagnitude import *
vectors = Magnitude ( "/path/to/vectors.magnitude" ) Si nécessaire, et inclus pour plus de commodité, vous pouvez également ouvrir un fichier .bin , .txt , .vec , .hdf5 directement avec magnitude. Ceci est cependant moins efficace et très lent pour les grands modèles car il convertira le fichier en un fichier .magnitude lors de la première exécution dans un répertoire temporaire. Le répertoire temporaire n'est pas garanti de persister et ne persiste pas lorsque votre ordinateur redémarre. Vous devez pré-convertir .bin , .txt , .vec , .hdf5 fichiers avec python -m pymagnitude.converter généralement pour des vitesses plus rapides, mais cette fonction est utile pour les cas d'utilisation unique. Un avertissement sera généré lors de l'instanciation d'un objet de magnitude directement avec un .bin , .txt , .vec , .hdf5 . Vous pouvez supprimer les avertissements en définissant l'argument supress_warnings dans le constructeur sur True .
lazy_loading facultatif au constructeur avec la valeur -1 pour désactiver le chargement paresseux et précharger tous les vecteurs dans la mémoire (à la Gensim), 0 (par défaut) pour permettre à un chargement paresseux avec un cache LRU en mémoire non lié, ou un entier plus important que Zero X a récemment utilisé des Vctorations paresseux avec un cache LRU qui retient les X à la mémoire.most_similar soient préchargées avec impatience sur l'initialisation, définissez- eager True .lazy_loading est défini sur -1 ou que eager est défini sur True Data sera préchargé dans la mémoire dans un thread d'arrière-plan pour empêcher le constructeur de bloquer quelques minutes pour les grands modèles. Si vous voulez vraiment le comportement de blocage, vous pouvez passer True à l'argument blocking .normalized sur False si vous souhaitez plutôt recevoir les vecteurs bruts non normalisés.use_numpy sur False si vous souhaitez plutôt recevoir des listes Python.case_insensitive sur True si vous souhaitez effectuer des recherches insensibles à des cas.pad_to_length qui spécifiera la longueur que tous les exemples doivent être rembourrés si le passage dans des exemples multiples. Tous les exemples plus longs que la longueur du tampon seront tronqués.truncate_left sur True si vous voulez que le début de la liste des touches dans chaque exemple soit tronqué au lieu de la fin au cas où il est plus long que pad_to_length lorsqu'il est spécifié.pad_left sur True si vous voulez que le rembourrage apparaisse au début par rapport à la fin (qui est la valeur par défaut).placeholders , ce qui augmentera les dimensions de chaque vecteur par un montant placeholders , repliant zéro ces dimensions supplémentaires. Ceci est utile, si vous prévoyez d'ajouter d'autres valeurs et informations aux vecteurs et que vous souhaitez l'espace pour celui pré-alloué dans les vecteurs pour l'efficacité.language avec un code de langue ISO 639-1, qui, si vous utilisez la magnitude pour les vecteurs de mots, garantira que la bibliothèque respecte les caractéristiques et autres fonctionnalités spécifiques à la langue pour cette langue. La valeur par défaut est en anglais. Vous pouvez également passer dans None si vous n'utilisez pas de magnitude pour les vecteurs de mots.dtype qui vous permettra de contrôler le type de données des tableaux Numpy renvoyé par magnitude.devices qui vous permettra de contrôler l'utilisation des GPU lorsque les modèles sous-jacents prennent en charge l'utilisation du GPU. Cet argument doit être une liste d'entiers, où chaque entier représente le numéro de périphérique GPU ( 0 , 1 , etc.).temp_dir qui vous permettra de contrôler l'emplacement de l'amplitude du répertoire temporaire.log qui aura une progression du journal de magnitude vers une erreur standard lorsque des opérations lentes auront lieu.Vous pouvez interroger le nombre total de vecteurs dans le fichier comme tel:
len ( vectors )Vous pouvez interroger les dimensions des vecteurs comme tel:
vectors . dimVous pouvez vérifier si une clé est dans le vocabulaire comme tel:
"cat" in vectorsVous pouvez parcourir toutes les clés et vecteurs comme tel:
for key , vector in vectors :
...Vous pouvez interroger pour le vecteur d'une clé comme tel:
vectors . query ( "cat" )Vous pouvez indexer pour la n-clé et le vecteur comme tel:
vectors [ 42 ]Vous pouvez interroger pour le vecteur de plusieurs clés comme ainsi:
vectors . query ([ "I" , "read" , "a" , "book" ])Un tableau 2D (clés par vecteurs) sera retourné.
Vous pouvez interroger pour le vecteur de plusieurs exemples comme tel:
vectors . query ([[ "I" , "read" , "a" , "book" ], [ "I" , "read" , "a" , "magazine" ]]) Un tableau 3D (exemples par clés par vecteurs) sera retourné. Si pad_to_length n'est pas spécifié et que la taille de chaque exemple est inégale, ils seront rembourrés à la longueur de l'exemple le plus long.
Vous pouvez indexer les clés et les vecteurs de plusieurs indices comme ainsi:
vectors [: 42 ] # slice notation
vectors [ 42 , 1337 , 2001 ] # tuple notationVous pouvez interroger la distance de deux ou plusieurs clés comme tel:
vectors . distance ( "cat" , "dog" )
vectors . distance ( "cat" , [ "dog" , "tiger" ])Vous pouvez interroger la similitude de deux ou plusieurs clés comme tel:
vectors . similarity ( "cat" , "dog" )
vectors . similarity ( "cat" , [ "dog" , "tiger" ])Vous pouvez interroger pour la clé la plus similaire d'une liste de clés à une clé donnée comme tel:
vectors . most_similar_to_given ( "cat" , [ "dog" , "television" , "laptop" ]) # dogVous pouvez interroger pour quelle clé ne correspond pas à une liste de clés à une clé donnée comme tel:
vectors . doesnt_match ([ "breakfast" , "cereal" , "dinner" , "lunch" ]) # cerealVous pouvez interroger pour les clés les plus similaires (voisins les plus proches) comme tel:
vectors . most_similar ( "cat" , topn = 100 ) # Most similar by key
vectors . most_similar ( vectors . query ( "cat" ), topn = 100 ) # Most similar by vector Facultativement, vous pouvez transmettre un argument min_similarity à most_similar . Les valeurs de [-1.0-1.0] sont valides.
Vous pouvez également interroger pour les clés les plus similaires donnant des exemples positifs et négatifs (qui, d'ailleurs, résout des analogies) comme tel:
vectors . most_similar ( positive = [ "woman" , "king" ], negative = [ "man" ]) # queen Semblable à vectors.most_similar , une fonction vectors.most_similar_cosmul existe qui utilise la fonction 3Cosmul de Levy et Goldberg:
vectors . most_similar_cosmul ( positive = [ "woman" , "king" ], negative = [ "man" ]) # queenVous pouvez également interroger pour les clés les plus similaires en utilisant un indice de voisins le plus proche approximatif qui est beaucoup plus rapide, mais ne garantit pas la réponse exacte:
vectors . most_similar_approx ( "cat" )
vectors . most_similar_approx ( positive = [ "woman" , "king" ], negative = [ "man" ]) Facultativement, vous pouvez transmettre un argument effort avec des valeurs entre [0.0-1.0] à la fonction most_similar_approx qui vous donnera un compromis d'exécution. La valeur par défaut de effort est 1,0 qui prendra le plus longtemps, mais donnera le résultat le plus précis.
Vous pouvez interroger pour toutes les clés plus près d'une clé qu'une autre clé le ressemble:
vectors . closer_than ( "cat" , "rabbit" ) # ["dog", ...] Vous pouvez accéder à tous les vecteurs sous-jacents du modèle dans un grand tableau numpy.memmap de taille ( len(vectors) x vectors.emb_dim ) comme ainsi:
vectors . get_vectors_mmap ()Vous pouvez nettoyer toutes les ressources associées, ouvrir des fichiers et des connexions de base de données comme ça:
vectors . close ()Pour les représentations de vecteurs de mots, la gestion des clés hors vocabule est importante pour gérer de nouveaux mots non dans le modèle formé, gérer les erreurs d'alimentation et les fautes de frappe, et la création de modèles formés sur les représentations de Vector Word plus robustes en général.
Les clés hors vocabule sont gérées en leur attribuant une valeur vectorielle aléatoire. Cependant, l'aléatoire est déterministe. Donc, si la même touche hors vocabulaire est rencontrée deux fois, elle se verra attribuer la même valeur vectorielle aléatoire dans le but de pouvoir s'entraîner sur ces clés hors de vocabule. De plus, si deux clés hors vocabule partagent des n-grammes de caractère similaires ("uberx", "uberxl"), ils seront placés près les uns des autres même s'ils ne sont pas tous les deux dans le vocabulaire:
vectors = Magnitude ( "/path/to/GoogleNews-vectors-negative300.magnitude" )
"uberx" in vectors # False
"uberxl" in vectors # False
vectors . query ( "uberx" ) # array([ 5.07109939e-02, -7.08248823e-02, -2.74812328e-02, ... ])
vectors . query ( "uberxl" ) # array([ 0.04734962, -0.08237578, -0.0333479, -0.00229564, ... ])
vectors . similarity ( "uberx" , "uberxl" ) # 0.955000000200815Si vous utilisez un fichier de magnitude avec un support antivol avancé (moyen ou lourd), les clés hors vocabulaire seront également intégrées à proximité de touches similaires (déterminées par la similitude des chaînes) qui sont dans le vocabulaire:
vectors = Magnitude ( "/path/to/GoogleNews-vectors-negative300.magnitude" )
"uberx" in vectors # False
"uberification" in vectors # False
"uber" in vectors # True
vectors . similarity ( "uberx" , "uber" ) # 0.7383483267618451
vectors . similarity ( "uberification" , "uber" ) # 0.745452837882727 Cela rend également la magnitude robuste à de nombreuses erreurs d'orthographe:
vectors = Magnitude ( "/path/to/GoogleNews-vectors-negative300.magnitude" )
"missispi" in vectors # False
vectors . similarity ( "missispi" , "mississippi" ) # 0.35961736624824003
"discrimnatory" in vectors # False
vectors . similarity ( "discrimnatory" , "discriminatory" ) # 0.8309152561753461
"hiiiiiiiiii" in vectors # False
vectors . similarity ( "hiiiiiiiiii" , "hi" ) # 0.7069775034853861Les n-grammes de caractère sont utilisés pour créer cet effet pour les clés hors vocabule. L'inspiration pour cette fonctionnalité a été tirée de Vectors Word enrichissantes de Facebook Ai Research avec des informations de sous-mots, mais au lieu d'utiliser le caractère n-grammes au moment du train, les n-grammes de caractère sont utilisés à l'inférence afin que l'effet puisse être quelque peu reproduit (mais pas parfaitement reproduit) dans des modèles plus anciens qui n'ont pas été formés avec un caractère n-grams comme Word2Vec et Gove.
Facultativement, vous pouvez combiner des vecteurs à partir de plusieurs modèles pour alimenter des informations plus fortes dans un modèle d'apprentissage automatique comme ça:
from pymagnitude import *
word2vec = Magnitude ( "/path/to/GoogleNews-vectors-negative300.magnitude" )
glove = Magnitude ( "/path/to/glove.6B.50d.magnitude" )
vectors = Magnitude ( word2vec , glove ) # concatenate word2vec with glove
vectors . query ( "cat" ) # returns 350-dimensional NumPy array ('cat' from word2vec concatenated with 'cat' from glove)
vectors . query (( "cat" , "cats" )) # returns 350-dimensional NumPy array ('cat' from word2vec concatenated with 'cats' from glove)Vous pouvez concaténer plus de deux modèles vectoriels, simplement en transmettant plus d'arguments au constructeur.
Vous pouvez créer automatiquement des vecteurs à partir de fonctionnalités supplémentaires que vous pouvez avoir, telles que des parties de la parole, des informations de dépendance à la syntaxe ou toute autre information à l'aide de la classe FeaturizerMagnitude :
from pymagnitude import *
pos_vectors = FeaturizerMagnitude ( 100 , namespace = "PartsOfSpeech" )
pos_vectors . dim # 4 - number of dims automatically determined by Magnitude from 100
pos_vectors . query ( "NN" ) # - array([ 0.08040417, -0.71705252, 0.61228951, 0.32322192])
pos_vectors . query ( "JJ" ) # - array([-0.11681135, 0.10259253, 0.8841201 , -0.44063763])
pos_vectors . query ( "NN" ) # - array([ 0.08040417, -0.71705252, 0.61228951, 0.32322192]) (deterministic hashing so the same value is returned every time for the same key)
dependency_vectors = FeaturizerMagnitude ( 100 , namespace = "SyntaxDependencies" )
dependency_vectors . dim # 4 - number of dims automatically determined by Magnitude from 100
dependency_vectors . query ( "nsubj" ) # - array([-0.81043793, 0.55401352, -0.10838071, 0.15656626])
dependency_vectors . query ( "prep" ) # - array([-0.30862918, -0.44487267, -0.0054573 , -0.84071788])La magnitude utilisera l'astuce de hachage de fonction en interne pour utiliser directement le hachage de la valeur de la fonctionnalité pour créer un vecteur unique pour cette valeur de fonctionnalité.
Le premier argument de FeaturizerMagnitude devrait être une limite supérieure approximative du nombre de valeurs pour la fonctionnalité. Puisqu'il y a <100 parties des étiquettes de parole et <100 dépendances de syntaxe, nous choisissons 100 pour les deux dans l'exemple ci-dessus. La valeur choisie déterminera le nombre de dimensions que l'amplitude attribuera automatiquement à l'objet en particulier l'objet FeaturizerMagnitude pour réduire les risques de collision de hachage. L'argument namespace peut être n'importe quelle chaîne qui décrit votre fonctionnalité supplémentaire. Il est facultatif, mais fortement recommandé.
Vous pouvez ensuite concaténer ces fonctionnalités à utiliser avec un objet de magnitude standard:
from pymagnitude import *
word2vec = Magnitude ( "/path/to/GoogleNews-vectors-negative300.magnitude" )
pos_vectors = FeaturizerMagnitude ( 100 , namespace = "PartsOfSpeech" )
dependency_vectors = FeaturizerMagnitude ( 100 , namespace = "SyntaxDependencies" )
vectors = Magnitude ( word2vec , pos_vectors , dependency_vectors ) # concatenate word2vec with pos and dependencies
vectors . query ([
( "I" , "PRP" , "nsubj" ),
( "saw" , "VBD" , "ROOT" ),
( "a" , "DT" , "det" ),
( "cat" , "NN" , "dobj" ),
( "." , "." , "punct" )
]) # array of size 5 x (300 + 4 + 4) or 5 x 308
# Or get a unique vector for every 'buffalo' in:
# "Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo"
# (https://en.wikipedia.org/wiki/Buffalo_buffalo_Buffalo_buffalo_buffalo_buffalo_Buffalo_buffalo)
vectors . query ([
( "Buffalo" , "JJ" , "amod" ),
( "buffalo" , "NNS" , "nsubj" ),
( "Buffalo" , "JJ" , "amod" ),
( "buffalo" , "NNS" , "nsubj" ),
( "buffalo" , "VBP" , "rcmod" ),
( "buffalo" , "VB" , "ROOT" ),
( "Buffalo" , "JJ" , "amod" ),
( "buffalo" , "NNS" , "dobj" )
]) # array of size 8 x (300 + 4 + 4) or 8 x 308Un modèle d'apprentissage automatique, compte tenu de cette sortie, a désormais accès à des parties d'informations vocales et d'informations sur la dépendance à la syntaxe au lieu de simples informations sur les vecteurs de mots. Dans ce cas, ces informations supplémentaires peuvent donner un signal plus fort de réseaux de neurones pour les informations sémantiques et réduire le besoin de données de formation.
L'amplitude facilite la construction et les itération rapidement des modèles qui doivent utiliser les représentations vectorielles en prenant en charge beaucoup de code de prétraitement pour convertir un ensemble de données de texte (ou de touches) en vecteurs. De plus, il peut rendre ces modèles plus robustes aux mots et fausseftures hors vocabulaire.
Il existe un exemple de code disponible en utilisant la magnitude pour créer un modèle de classification d'intention pour l'ensemble de données ATI (Airline Travel Information Systems) (Train / Test), utilisé pour les chatbots ou les interfaces conversationnelles, dans quelques bibliothèques d'apprentissage automatique populaires ci-dessous.
Vous pouvez accéder à un guide d'utilisation de la magnitude avec Keras (qui prend en charge TensorFlow, Theano, CNTK) dans ce ordinateur portable Python Google Colaboratory.
Le guide Pytorch arrive bientôt.
Le guide Tfrearn arrive bientôt.
Vous pouvez utiliser la classe de MagnitudeUtils pour un accès pratique aux fonctions qui peuvent être utiles lors de la création de modèles d'apprentissage automatique.
Vous pouvez importer des magnitudes utiles comme tel:
from pymagnitude import MagnitudeUtilsVous pouvez télécharger un modèle de magnitude à partir d'une source distante comme SO:
vecs = Magnitude ( MagnitudeUtils . download_model ( 'word2vec/heavy/GoogleNews-vectors-negative300' )) Par défaut, download_model téléchargera des fichiers à partir de http://magnitude.plasticity.ai à un dossier ~/.magnitude créé automatiquement. Si le fichier a déjà été téléchargé, il ne sera plus téléchargé. Vous pouvez modifier le répertoire du dossier de téléchargement local à l'aide de l'argument en option download_dir . Vous pouvez modifier le domaine à partir de quels modèles seront téléchargés avec l'argument remote_path facultatif.
Vous pouvez créer un générateur de lots pour les données X et y avec batchify , comme ainsi:
X = [ .3 , .2 , .7 , .8 , .1 ]
y = [ 0 , 0 , 1 , 1 , 0 ]
batch_gen = MagnitudeUtils . batchify ( X , y , 2 )
for X_batch , y_batch in batch_gen :
print ( X_batch , y_batch )
# Returns:
# 1st loop: X_batch = [.3, .2], y_batch = [0, 0]
# 2nd loop: X_batch = [.7, .8], y_batch = [1, 1]
# 3rd loop: X_batch = [.1], y_batch = [0]
# next loop: repeats infinitely... Vous pouvez encoder des étiquettes de classe sur les entiers et revenir avec class_encoding , comme ainsi:
add_class , class_to_int , int_to_class = MagnitudeUtils . class_encoding ()
add_class ( "cat" ) # Returns: 0
add_class ( "dog" ) # Returns: 1
add_class ( "cat" ) # Returns: 0
class_to_int ( "dog" ) # Returns: 1
class_to_int ( "cat" ) # Returns: 0
int_to_class ( 1 ) # Returns: "dog"
int_to_class ( 0 ) # Returns: "cat" Vous pouvez convertir des données catégorielles avec des entiers de classe en tableaux de numpy à un hot avec to_categorical , comme ainsi:
y = [ 1 , 5 , 2 ]
MagnitudeUtils . to_categorical ( y , num_classes = 6 ) # num_classes is optional
# Returns:
# array([[0., 1., 0., 0., 0., 0.]
# [0., 0., 0., 0., 0., 1.]
# [0., 0., 1., 0., 0., 0.]]) Vous pouvez vous convertir à partir de tableaux Numpy à un hot à un tableau Numpy 1D entiers de classe avec from_categorical , comme ainsi:
y_c = [[ 0. , 1. , 0. , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. , 1. ]]
MagnitudeUtils . from_categorical ( y_c )
# Returns:
# array([1., 5.]) La bibliothèque est sûre de thread (il utilise une connexion différente à la boutique sous-jacente par thread), est en lecture seule, et il n'écrit jamais dans le fichier. En raison de l'utilisation de la mémoire de lumière, vous pouvez également l'exécuter dans plusieurs processus (ou utiliser multiprocessing ) avec différents espaces d'adresses sans avoir à dupliquer les données en mémoire comme avec d'autres bibliothèques et sans avoir à créer une variable partagée multi-processus car les données sont lues hors disque et chaque processus conserve son propre cache de mémoire LRU. Pour les fonctions plus lourdes, comme most_similar un fichier mappé de mémoire partagé est créé pour partager la mémoire entre les processus.
Le package de magnitude utilise le format de fichier .magnitude au lieu de .bin , .txt , .vec ou .hdf5 comme avec d'autres modèles vectoriels comme Word2Vec, Glove, FastText et Elmo. Il existe un utilitaire de ligne de commande inclus pour convertir les fichiers Word2Vec, Glove, FastText et Elmo en fichiers de magnitude.
Vous pouvez les convertir comme ça:
python -m pymagnitude.converter -i < PATH TO FILE TO BE CONVERTED > -o < OUTPUT PATH FOR MAGNITUDE FILE >Le format d'entrée sera automatiquement déterminé par l'extension / le contenu du fichier d'entrée. Vous ne devriez avoir besoin d'effectuer cette conversion qu'une seule fois pour un modèle. Après conversion, le format de fichier de magnitude est statique et il ne sera pas modifié ou écrit pour rendre l'accès en lecture simultané.
Les drapeaux pour pymagnitude.converter sont spécifiés ci-dessous:
-h pour obtenir de l'aide et répertorier tous les drapeaux.-p <PRECISION> pour spécifier la précision décimale à conserver (la sélection d'un nombre inférieur créera des fichiers plus petits). Les valeurs sous-jacentes réelles sont stockées sous forme d'entiers au lieu de flotteurs, ce qui est essentiellement de quantification pour les empreintes de pas plus petites.-a qui permettra l'utilisation de la fonction most_similar_approx . Le drapeau -t <TREES> contrôle le nombre d'arbres dans l'indice approximatif des voisins destinés lestings (plus élevé est plus précis) lorsqu'il est utilisé en conjonction avec le drapeau -a (s'il n'est pas fourni, le nombre d'arbres est automatiquement déterminé).-s pour désactiver l'ajout d'informations de sous-mots au fichier (ce qui rendra le fichier plus petit), mais désactiver la prise en charge avancée de la clé hors vocabulaire.-v avec le chemin vers un autre fichier de magnitude dont vous souhaitez prendre le vocabulaire. Facultativement, vous pouvez convertir en vrac de nombreux fichiers en passant un dossier d'entrée et un dossier de sortie au lieu d'un fichier d'entrée et d'un fichier de sortie. Tous .txt , .bin , .vec , .hdf5 Les fichiers dans le dossier d'entrée seront convertis en fichiers .magnitude dans le dossier de sortie. Le dossier de sortie doit exister avant une opération de conversion en vrac.
Vous pouvez instruire le téléchargement de la magnitude et ouvrir un modèle du référentiel distant de la magnitude au lieu d'un chemin de fichier local. Le fichier sera automatiquement téléchargé localement lors de la première exécution vers ~/.magnitude/ et, par la suite, sautez le téléchargement si le fichier existe déjà localement.
vecs = Magnitude ( 'http://magnitude.plasticity.ai/word2vec/heavy/GoogleNews-vectors-negative300.magnitude' ) # full url
vecs = Magnitude ( 'word2vec/heavy/GoogleNews-vectors-negative300' ) # or, use the shorthand for the url Pour plus de contrôle sur le domaine de téléchargement à distance et le répertoire de téléchargement local, voyez comment utiliser MagnitudeUtils.download_model .
Les modèles de magnitude sont généralement des fichiers volumineux (plusieurs GB) qui occupent beaucoup d'espace disque, même si le format .magnitude La magnitude a une option pour diffuser ces fichiers volumineux via HTTP. Ceci est explicitement différent de la fonction de chargement à distance, en ce sens que le modèle n'a même pas besoin d'être téléchargé. Vous pouvez commencer à interroger les modèles immédiatement sans espace disque utilisé du tout.
vecs = Magnitude ( 'http://magnitude.plasticity.ai/word2vec/heavy/GoogleNews-vectors-negative300.magnitude' , stream = True ) # full url
vecs = Magnitude ( 'word2vec/heavy/GoogleNews-vectors-negative300' , stream = True ) # or, use the shorthand for the url
vecs . query ( "king" ) # Returns: the vector for "king" quickly, even with no local model file downloadedVous pouvez jouer avec une démo de cela dans un ordinateur portable Python Google Colaboratory.
Cette fonctionnalité est extrêmement utile si votre environnement informatique est limité aux ressources (faible RAM et à faible espace disque), vous souhaitez expérimenter rapidement avec des vecteurs sans télécharger et configurer des fichiers de grands modèles, ou vous formez un petit modèle. Bien qu'il y ait une latence de réseau supplémentaire depuis que les données sont en cours de diffusion, l'amplitude utilisera toujours un cache en mémoire comme spécifié par le paramètre du constructeur lazy_loading . Étant donné que les langues ont généralement une distribution ZIPF-Ian, la latence du réseau ne devrait pas être en grande partie un problème après le réchauffement du cache après avoir été interrogé un petit nombre de fois.
Ils seront interrogés directement d'un serveur Web HTTP statique à l'aide des en-têtes de demande de plage HTTP. Toutes les méthodes de magnitude prennent en charge le streaming, cependant, most_similar et most_similar_approx peuvent être lents car ils ne sont pas encore optimisés pour le streaming. Vous pouvez voir comment ce mode de streaming fonctionne actuellement dans les repères, cependant, il deviendra plus rapide à mesure que nous l'optimions à l'avenir!
Une autre documentation n'est pas disponible pour le moment. Voir directement le fichier source (il est bien commenté) si vous avez besoin de plus d'informations sur les arguments d'une méthode ou si vous souhaitez voir toutes les fonctionnalités prises en charge.
Actuellement, nous ne fournissons que des modèles de vecteurs de mots anglais sur cette page pré-convertis au format .magnitude Vous pouvez cependant utiliser l'ampleur avec des vecteurs de mots d'autres langues. Facebook a formé leurs vecteurs à texte rapide pour de nombreuses langues différentes. Vous pouvez baisser le fichier .vec pour toute langue que vous souhaitez, puis la convertir en .magnitude avec le convertisseur.
Actuellement, la lecture des fichiers de magnitude n'est prise en charge que dans Python, car il est devenu le langage de facto pour l'apprentissage automatique. Ceci est suffisant pour la plupart des cas d'utilisation. L'extension du format de fichier à d'autres langues ne devrait pas être difficile car SQLite a une implémentation C native et a des liaisons dans la plupart des langues. Le format de fichier lui-même et le protocole de lecture et de recherche sont également assez simples lors de la lecture du code source de ce référentiel.
Actuellement, le traitement du langage naturel est le domaine le plus populaire qui utilise des modèles d'intégration de vecteurs pré-formés pour les représentations de vecteurs de mots. Il existe cependant d'autres domaines comme la vision par ordinateur qui ont commencé à utiliser des modèles d'intégration de vecteurs pré-formés comme Deep1b pour la représentation d'image. Cette bibliothèque a l'intention de rester agnostique dans divers domaines et fournit à la place une boutique et une interface de vecteur de clés génériques utiles pour tous les domaines.
Le référentiel principal de ce projet peut être trouvé sur Gitlab. Le référentiel GitHub n'est qu'un miroir. Tirez les demandes de plus de tests, une meilleure vérification des erreurs, des corrections de bogues, des améliorations des performances ou une documentation ou l'ajout de ultities / fonctionnalités supplémentaires sont les bienvenus sur Gitlab.
Vous pouvez nous contacter à [email protected].
most_similar_approx pour le streamingmost_similar lentes..bin most_similar_approx proche derrière la plupart des arbres de projection aléatoire et 2 moyens hiérarchiques. Merci à l'auteur Erik Bernhardsson d'avoir aidé avec certains détails de l'intégration entre l'amplitude et l'agacement. Si vous souhaitez citer notre article à EMNLP 2018, vous pouvez utiliser la citation de Bibtex suivante:
@inproceedings{patel2018magnitude,
title={Magnitude: A Fast, Efficient Universal Vector Embedding Utility Package},
author={Patel, Ajay and Sands, Alexander and Callison-Burch, Chris and Apidianaki, Marianna},
booktitle={Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing: System Demonstrations},
pages={120--126},
year={2018}
}Ou suivez le lien Google Scholar pour d'autres moyens de citer le papier.
Si vous souhaitez citer ce référentiel, vous pouvez utiliser le badge DOI suivant:
Cliquer sur le badge mènera à une page qui vous aidera à générer des citations de bibtex appropriées, des citations JSON-LD et d'autres citations.
Ce référentiel est autorisé sous la licence trouvée ici.
Icône «sismique» de Johnnyzi du projet de nom.
