magnitude
Release 0.1.143
Um formato de arquivo de pacote Python compactado e vetorial compactado para utilizar incorporações de vetor em modelos de aprendizado de máquina de maneira rápida, eficiente e simples desenvolvida pela plasticidade. Destina-se principalmente a ser uma alternativa mais simples / mais rápida ao Gensim, mas pode ser usada como uma loja de vetores-chave genéricos para domínios fora da PNL. Ele oferece recursos exclusivos, como pesquisas fora do vocabular e streaming de modelos grandes sobre o HTTP. Publicado em nosso artigo no EMNLP 2018 e disponível no Arxiv.
Você pode instalar este pacote com pip :
pip install pymagnitude # Python 2.7
pip3 install pymagnitude # Python 3O Google Colaboratory tem alguns problemas de dependência com a instalação de magnitude devido a dependências conflitantes. Você pode usar o seguinte snippet para instalar magnitude no Google Colaboratory:
# 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. " Os modelos de incorporação de espaço vetorial tornaram -se cada vez mais comuns no aprendizado de máquina e tradicionalmente são populares para aplicações de processamento de linguagem natural. Falta uma ferramenta rápida e leve para consumir esses grandes modelos de incorporação de espaço vetorial com eficiência.
The Magnitude file format ( .magnitude ) for vector embeddings is intended to be a more efficient universal vector embedding format that allows for lazy-loading for faster cold starts in development, LRU memory caching for performance in production, multiple key queries, direct featurization to the inputs for a neural network, performant similiarity calculations, and other nice to have features for edge cases like handling out-of-vocabulary keys ou chaves com ortografia e concatenando vários modelos vetoriais juntos. Também se destina a trabalhar com grandes modelos de vetores que podem não se encaixar na memória.
Ele usa o SQLite, um banco de dados incorporado rápido e popular, como seu armazenamento de dados subjacente. Ele usa índices para pesquisas de chave rápida, além de usar mapeamento de memória, instruções SIMD e indexação espacial para pesquisa de similaridade rápida no espaço vetorial fora do disco com bom desempenho de memória, mesmo entre vários processos. Além disso, os mapas de memória são armazenados em cache entre as execuções; portanto, mesmo após o fechamento de um processo, as melhorias de velocidade são colhidas.
| Métrica | Luz de magnitude | Média de magnitude | Magnitude pesada | Fluxo de magnitude |
|---|---|---|---|---|
| Tempo de carregamento inicial | 0,7210s | ━ 1 | ━ 1 | 7.7550s |
| Consulta de chave única fria | 0,0001s | ━ 1 | ━ 1 | 1.6437s |
| Consulta de chave única quente (mesma chave que a consulta fria) | 0,00004s | ━ 1 | ━ 1 | 0,0004s |
| Consulta de chave múltipla fria (n = 25) | 0,0442s | ━ 1 | ━ 1 | 1.7753s |
| Quente múltipla de consulta chave (n = 25) (mesmas chaves que a consulta fria) | 0,00004s | ━ 1 | ━ 1 | 0,0001s |
Primeira Perse de Pesquisa most_similar(n = 10) (pior caso) | 247.05s | ━ 1 | ━ 1 | - |
Primeira Perse de Pesquisa most_similar(n = 10) (caso médio) (cache persistente de disco) | 1.8217S | ━ 1 | ━ 1 | - |
Pesquisa most_similar subsequente(n = 10) (chave diferente da primeira consulta) | 0,2434s | ━ 1 | ━ 1 | - |
A quente pesquisa most_similar subsequente.(n = 10) (mesma chave que a primeira consulta) | 0,00004s | 0,00004s | 0,00004s | - |
Primeiro most_similar_approx Search Consulta(n = 10, esforço = 1,0) (pior caso) | N / D | N / D | 29.610s | - |
Primeiro most_similar_approx Search Consulta(n = 10, esforço = 1,0) (caso médio) (cache persistente de disco) | N / D | N / D | 0,9155s | - |
Pesquisa mais subsequente most_similar_approx(n = 10, esforço = 1,0) (chave diferente da primeira consulta) | N / D | N / D | 0,1873s | - |
Pesquisa mais subsequente most_similar_approx(n = 10, esforço = 0,1) (chave diferente da primeira consulta) | N / D | N / D | 0,0199S | - |
Aquecer a Pesquisa most_similar_approx subsequente(n = 10, esforço = 1,0) (mesma chave que a primeira consulta) | N / D | N / D | 0,00004s | - |
| Tamanho do arquivo | 4.21 GB | 5.29 GB | 10.74 GB | 0,00 GB |
| Utilização de memória de processo (RAM) | 18kb | ━ 1 | ━ 1 | 1,71 MB |
| Utilização de memória de processo (RAM) após 100 consultas -chave | 168kb | ━ 1 | ━ 1 | 1,91 MB |
| Utilização da memória do processo (RAM) após 100 consultas -chave + pesquisa de similaridade | 342kb 2 | ━ 1 | ━ 1 | |
| Verificações e testes de integridade | ✅ | ✅ | ✅ | ✅ |
Formato universal entre Word2vec ( .txt , .bin ), luva ( .txt ), fasttext ( .vec ) e elmo ( .hdf5 ) com utilidade de conversor | ✅ | ✅ | ✅ | ✅ |
| Interface simples e pitônica | ✅ | ✅ | ✅ | ✅ |
| Poucas dependências | ✅ | ✅ | ✅ | ✅ |
| Suporte para modelos maiores que a memória | ✅ | ✅ | ✅ | ✅ |
| Carregamento preguiçoso sempre que possível para velocidade e desempenho | ✅ | ✅ | ✅ | ✅ |
Otimizado para threading e multiprocessing | ✅ | ✅ | ✅ | ✅ |
| A pesquisa -chave em massa e múltipla com estofamento, truncamento, espaço reservado e suporte de featurização | ✅ | ✅ | ✅ | ✅ |
| Concatente vários modelos vetoriais juntos | ✅ | ✅ | ✅ | ✅ |
| Pesquisa básica de chave fora do vocabulário (Hashing de características n-gramas do caractere) | ✅ | ✅ | ✅ | ✅ |
| Pesquisa avançada de chave fora do vocabulário com suporte para erros de ortografia (Caractere N-Gram Feature hashing a teclas de vocabulário semelhantes) | ✅ | ✅ | ✅ | |
| Pesquisa mais semelhante a se aproximar com um índice de irritação | ✅ | ✅ | ||
| Treinamento interno para novos modelos |
1: o mesmo valor da coluna anterior
2: usa mmap para ler no disco, para que o sistema operacional ainda aloque páginas de memória quando a memória estiver disponível, mas pode ser compartilhada entre os processos e não é gerenciada em cada processo para arquivos extremamente grandes, que é uma vitória de desempenho
*: Todos os benchmarks foram realizados nos vetores de palavras pré-treinados do Google News ( GoogleNews-vectors-negative300.bin ) com um MacBook Pro (retina, 15 polegadas, meados de 2014) 2.2 GHz Quad-core Intel Core i7 @ 16 GB em SSD em média de ensaios, onde seda.
Modelos populares de incorporação foram pré-convertidos para o formato .magnitude Magnitude para download e uso immediado:
| Contribuinte | Dados | Luz (Suporte básico para chaves fora do vocabulário) | Médio (recomendado) (Suporte avançado para chaves fora do vocabulário) | Pesado (Suporte avançado para chaves fora do vocabulário e mais most_similar_approx ) |
|---|---|---|---|---|
| Google - Word2vec | Google News 100b | 300d | 300d | 300d |
| Stanford - luva | Wikipedia 2014 + Gigaword 5 6b | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d |
| Stanford - luva | Wikipedia 2014 + Gigaword 5 6b (Lemmatizado pela plasticidade) | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d | 50d, 100d, 200d, 300d |
| Stanford - luva | Rastreamento comum 840b | 300d | 300d | 300d |
| Stanford - luva | Twitter 27b | 25d, 50d, 100d, 200d | 25d, 50d, 100d, 200d | 25d, 50d, 100d, 200d |
| Facebook - FastText | Wikipedia inglesa 2017 16b | 300d | 300d | 300d |
| Facebook - FastText | Wikipedia inglesa 2017 + SubbORT 16b | 300d | 300d | 300d |
| Facebook - FastText | Rastreamento comum 600b | 300d | 300d | 300d |
| AI2 - Allennlp Elmo | Modelos Elmo | Modelos Elmo | Modelos Elmo | Modelos Elmo |
| Google - Bert | Em breve... | Em breve... | Em breve... | Em breve... |
Existem instruções abaixo para converter qualquer arquivo .bin , .txt , .vec , .hdf5 em um arquivo .magnitude .
Você pode criar um objeto de magnitude como assim:
from pymagnitude import *
vectors = Magnitude ( "/path/to/vectors.magnitude" ) Se necessário, e incluído por conveniência, você também pode abrir um arquivo .bin , .txt , .vec , .hdf5 diretamente com magnitude. Isso é, no entanto, menos eficiente e muito lento para modelos grandes, pois converterá o arquivo em um arquivo .magnitude na primeira execução em um diretório temporário. O diretório temporário não é garantido para persistir e não persiste quando o seu computador reinicia. Você deve pré-conversar .bin , .txt , .vec , .hdf5 arquivos com python -m pymagnitude.converter normalmente para velocidades mais rápidas, mas esse recurso é útil para casos de uso pontuais. Um aviso será gerado ao instantar um objeto de magnitude diretamente com um .bin , .txt , .vec , .hdf5 . Você pode suprir os avisos definindo o argumento supress_warnings no construtor como True .
lazy_loading argument to the constructor with the value -1 to disable lazy-loading and pre-load all vectors into memory (a la Gensim), 0 (default) to enable lazy-loading with an unbounded in-memory LRU cache, or an integer greater than zero X to enable lazy-loading with an LRU cache that holds the X most recently used vectors in memory.most_similar sejam pré-carregados ansiosamente na inicialização, defina eager como True .lazy_loading estiver definido como -1 ou eager está definido como True Data, será pré -carregado na memória em um encadeamento de segundo plano para impedir que o construtor bloqueie por alguns minutos para modelos grandes. Se você realmente quer o comportamento de bloqueio, pode passar True ao argumento blocking .normalized como False se desejar receber os vetores não normalizados.use_numpy como False se você deseja receber listas de python.case_insensitive como True se você deseja executar pesquisas insensíveis ao caso.pad_to_length que especificará o comprimento que todos os exemplos devem ser acolchoados se passar em exemplos de vários. Quaisquer exemplos mais longos que o comprimento da almofada serão truncados.truncate_left como True se desejar o início da lista de teclas em cada exemplo a ser truncado em vez do final, caso seja mais longo que pad_to_length quando especificado.pad_left como True se deseja que o preenchimento apareça no início versus o final (que é o padrão).placeholders , o que aumentará as dimensões de cada vetor por um valor de um placeholders , acalmando zero essas dimensões extras. Isso é útil, se você planeja adicionar outros valores e informações aos vetores e deseja o espaço para os pré-alocados nos vetores para obter eficiência.language com um código de idioma ISO 639-1, que, se você estiver usando magnitude para vetores de palavras, garantirá que a biblioteca respeite os recursos Stemming e outros recursos específicos do idioma para esse idioma. O padrão é en para o inglês. Você também pode passar None se não estiver usando magnitude para vetores de palavras.dtype , que permitirá controlar o tipo de dados das matrizes Numpy retornadas por magnitude.devices que permitirão controlar o uso de GPUs quando os modelos subjacentes suportarem o uso da GPU. Esse argumento deve ser uma lista de números inteiros, onde cada número inteiro representa o número do dispositivo GPU ( 0 , 1 , etc.).temp_dir , que permitirá que você controla a localização da magnitude do diretório temporário.log que terá o progresso do log de magnitude para o erro padrão quando as operações lentas estiverem ocorrendo.Você pode consultar o número total de vetores no arquivo como assim:
len ( vectors )Você pode consultar as dimensões dos vetores como assim:
vectors . dimVocê pode verificar se uma chave está no vocabulário assim:
"cat" in vectorsVocê pode iterar em todas as chaves e vetores como assim:
for key , vector in vectors :
...Você pode consultar o vetor de uma chave como assim:
vectors . query ( "cat" )Você pode indexar para a n -ª chave e vetor assim:
vectors [ 42 ]Você pode consultar o vetor de várias chaves como assim:
vectors . query ([ "I" , "read" , "a" , "book" ])Uma matriz 2D (chaves por vetores) será devolvida.
Você pode consultar o vetor de vários exemplos como assim:
vectors . query ([[ "I" , "read" , "a" , "book" ], [ "I" , "read" , "a" , "magazine" ]]) Uma matriz 3D (exemplos de chaves por vetores) será devolvida. Se pad_to_length não for especificado e o tamanho de cada exemplo for irregular, eles serão preenchidos com o comprimento do exemplo mais longo.
Você pode indexar as chaves e vetores de vários índices como assim:
vectors [: 42 ] # slice notation
vectors [ 42 , 1337 , 2001 ] # tuple notationVocê pode consultar a distância de duas ou várias chaves como assim:
vectors . distance ( "cat" , "dog" )
vectors . distance ( "cat" , [ "dog" , "tiger" ])Você pode consultar a semelhança de duas ou várias chaves como assim:
vectors . similarity ( "cat" , "dog" )
vectors . similarity ( "cat" , [ "dog" , "tiger" ])Você pode consultar a chave mais semelhante de uma lista de chaves para uma determinada chave como assim:
vectors . most_similar_to_given ( "cat" , [ "dog" , "television" , "laptop" ]) # dogVocê pode consultar a qual a chave não corresponde a uma lista de chaves para uma determinada chave assim:
vectors . doesnt_match ([ "breakfast" , "cereal" , "dinner" , "lunch" ]) # cerealVocê pode consultar as teclas mais semelhantes (vizinhos mais próximas) como assim:
vectors . most_similar ( "cat" , topn = 100 ) # Most similar by key
vectors . most_similar ( vectors . query ( "cat" ), topn = 100 ) # Most similar by vector Opcionalmente, você pode passar um argumento min_similarity para most_similar . Os valores de [-1.0-1.0] são válidos.
Você também pode consultar as chaves mais semelhantes, dando exemplos positivos e negativos (que, aliás, resolve analogias) como assim:
vectors . most_similar ( positive = [ "woman" , "king" ], negative = [ "man" ]) # queen Semelhante a vectors.most_similar , existe uma função de vectors.most_similar_cosmul que usa a função 3Cosmul de Levy e Goldberg:
vectors . most_similar_cosmul ( positive = [ "woman" , "king" ], negative = [ "man" ]) # queenVocê também pode consultar as teclas mais semelhantes usando um índice aproximado dos vizinhos mais próximos, que é muito mais rápido, mas não garante a resposta exata:
vectors . most_similar_approx ( "cat" )
vectors . most_similar_approx ( positive = [ "woman" , "king" ], negative = [ "man" ]) Opcionalmente, você pode passar um argumento effort com valores entre [0,0-1.0] para a função most_similar_approx , que fornecerá troca de tempo de execução. O valor padrão para effort é 1,0, que levará mais tempo, mas fornecerá o resultado mais preciso.
Você pode consultar todas as chaves mais próximas de uma chave do que outra chave é assim:
vectors . closer_than ( "cat" , "rabbit" ) # ["dog", ...] Você pode acessar todos os vetores subjacentes no modelo em uma grande matriz de tamanho numpy.memmap ( len(vectors) x vectors.emb_dim ) como assim:
vectors . get_vectors_mmap ()Você pode limpar todos os recursos associados, arquivos abertos e conexões de banco de dados como assim:
vectors . close ()Para representações de vetores de palavras, o manuseio de chaves fora do vocabulário é importante para lidar com novas palavras que não estão no modelo treinado, lidando com erros e erros de digitação e tornando os modelos treinados nas representações de vetor de palavras mais robustas em geral.
As teclas fora do vocabulário são tratadas atribuindo-lhes um valor de vetor aleatório. No entanto, a aleatoriedade é determinística. Portanto, se a mesma chave fora do vocabulário for encontrada duas vezes, ela será atribuída o mesmo valor de vetor aleatório, em questão de ser capaz de treinar nessas chaves fora do vocabulário. Além disso, se duas chaves fora do vocabulário compartilham N-grams de caracteres semelhantes ("Uberx", "Uberxl"), eles ficarão perto um do outro, mesmo que não estejam no vocabulário:
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.955000000200815Se usar um arquivo de magnitude com suporte fora do vocabulário avançado (médio ou pesado), as chaves fora do vocabulário também serão incorporadas perto de chaves semelhantes (determinadas pela similaridade das cordas) que estão no vocabulário:
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 Isso também torna a magnitude robusta de muitos erros de ortografia:
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.7069775034853861Os n-grams dos caracteres são usados para criar esse efeito para chaves fora do vocabulário. A inspiração para esse recurso foi retirada dos vetores de palavras enriquecedores do Facebook AI com informações sobre subpainhas, mas, em vez de utilizar os gramas de N no horário do trem, os n-grams dos caracteres são usados em inferência para que o efeito possa ser um pouco replicado (mas não perfeitamente replicado) em modelos mais antigos que não foram treinados com caracteres n-gramas como Word2Vec e Grove.
Opcionalmente, você pode combinar vetores de vários modelos para alimentar informações mais fortes em um modelo de aprendizado de máquina como assim:
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)Você pode concatenar mais de dois modelos vetoriais, simplesmente passando mais argumentos para o construtor.
Você pode criar automaticamente vetores a partir de recursos adicionais que você pode ter, como partes da fala, informações de dependência de sintaxe ou qualquer outra informação usando a classe de 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])A magnitude usará o truque de hash de recurso internamente para usar diretamente o hash do valor do recurso para criar um vetor exclusivo para esse valor de recurso.
O primeiro argumento a ser FeaturizerMagnitude deve ser um limite superior aproximado no número de valores para o recurso. Como existem <100 partes das tags de fala e <100 dependências de sintaxe, escolhemos 100 para ambos no exemplo acima. O valor escolhido determinará quantas dimensões a magnitude atribuirá automaticamente ao objeto específico FeaturizerMagnitude para reduzir a chance de uma colisão de hash. O argumento namespace pode ser qualquer string que descreva seu recurso adicional. É opcional, mas altamente recomendado.
Você pode concatenar esses recursos para uso com um objeto de magnitude padrão:
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 308Um modelo de aprendizado de máquina, dada essa saída, agora tem acesso a partes das informações da fala e informações de dependência de sintaxe, em vez de apenas informações sobre vetores de palavras. Nesse caso, essas informações adicionais podem fornecer ao sinal mais forte de redes neurais para obter informações semânticas e reduzir a necessidade de dados de treinamento.
A magnitude facilita muito a construção e iterar rapidamente os modelos que precisam usar representações vetoriais, cuidando de muitos código de pré-processamento para converter um conjunto de dados de texto (ou chaves) em vetores. Além disso, pode tornar esses modelos mais robustos a palavras e erros de ortografia fora do vocabulário.
Há um exemplo de código disponível usando magnitude para criar um modelo de classificação de intenção para o conjunto de dados ATIS (Airline Travel Information Systems) (trem/teste), usado para chatbots ou interfaces de conversação, em algumas bibliotecas populares de aprendizado de máquina abaixo.
Você pode acessar um guia para usar magnitude com Keras (que suporta Tensorflow, Theano, CNTK) neste notebook Python colaboratório do Google.
O guia Pytorch está chegando em breve.
O guia Tflearn está chegando em breve.
Você pode usar a classe MagnitudeUtils para obter acesso conveniente a funções que podem ser úteis ao criar modelos de aprendizado de máquina.
Você pode importar magnitude como assim:
from pymagnitude import MagnitudeUtilsVocê pode baixar um modelo de magnitude de uma fonte remota como assim:
vecs = Magnitude ( MagnitudeUtils . download_model ( 'word2vec/heavy/GoogleNews-vectors-negative300' )) Por padrão, download_model baixará arquivos de http://magnitude.plasticity.ai para uma pasta ~/.magnitude criada automaticamente. Se o arquivo já foi baixado, ele não será baixado novamente. Você pode alterar o diretório da pasta de download local usando o argumento opcional download_dir . Você pode alterar o domínio do qual os modelos serão baixados com o argumento opcional remote_path .
Você pode criar um gerador de lote para dados X e y com batchify , assim:
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... Você pode codificar rótulos de classe para números inteiros e voltar com class_encoding , assim:
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" Você pode converter dados categóricos com números inteiros de classe em matrizes Numpy de uma vez com to_categorical , assim:
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.]]) Você pode converter de matrizes Numpy de um hots de volta a uma variedade 1D de números inteiros de classe com from_categorical , como assim:
y_c = [[ 0. , 1. , 0. , 0. , 0. , 0. ],
[ 0. , 0. , 0. , 0. , 0. , 1. ]]
MagnitudeUtils . from_categorical ( y_c )
# Returns:
# array([1., 5.]) A biblioteca é segura no thread (usa uma conexão diferente com a loja subjacente por thread), é somente leitura e nunca grava no arquivo. Devido ao uso da memória de luz, você também pode executá-lo em vários processos (ou usar multiprocessing ) com diferentes espaços de endereço sem precisar duplicar os dados na memória, como em outras bibliotecas e sem precisar criar uma variável compartilhada com vários processos, pois os dados são lidos fora do disco e cada processo mantém seu próprio cache de memória LRU. Para funções mais pesadas, como most_similar um arquivo mapeado de memória compartilhado é criado para compartilhar memória entre os processos.
O pacote de magnitude usa o formato de arquivo .magnitude em vez de .bin , .txt , .vec ou .hdf5 como em outros modelos vetoriais como Word2Vec, Glove, FastText e Elmo. Existe um utilitário de linha de comando incluído para converter arquivos Word2Vec, Glove, FastText e ELMO em arquivos de magnitude.
Você pode convertê -los assim:
python -m pymagnitude.converter -i < PATH TO FILE TO BE CONVERTED > -o < OUTPUT PATH FOR MAGNITUDE FILE >O formato de entrada será automaticamente determinado pela extensão / o conteúdo do arquivo de entrada. Você só deve precisar executar essa conversão uma vez para um modelo. Após a conversão, o formato do arquivo de magnitude é estático e não será modificado ou escrito para tornar o acesso simultâneo à leitura.
As bandeiras para pymagnitude.converter são especificadas abaixo:
-h para obter ajuda e listar todos os sinalizadores.-p <PRECISION> para especificar a precisão decimal para reter (a seleção de um número mais baixo criará arquivos menores). Os valores subjacentes reais são armazenados como números inteiros em vez de carros alegóricos, portanto, isso é essencialmente quantização para pegadas de modelo menores.-a que permitirá o uso da função most_similar_approx . O sinalizador -t <TREES> controla o número de árvores no índice aproximado dos vizinhos dos vizinhos (mais alto é mais preciso) quando usado em conjunto com a bandeira -a (se não for fornecida, o número de árvores é determinado automaticamente).-s para desativar a adição de informações da subglema ao arquivo (que tornará o arquivo menor), mas desativará o suporte avançado fora do vocabulário.-v junto com o caminho para outro arquivo de magnitude que você gostaria de tirar o vocabulário. Opcionalmente, você pode converter a granel muitos arquivos passando uma pasta de entrada e pasta de saída em vez de um arquivo de entrada e um arquivo de saída. Todos os arquivos .txt , .bin , .vec , .hdf5 na pasta de entrada serão convertidos em arquivos .magnitude na pasta de saída. A pasta de saída deve existir antes de uma operação de conversão em massa.
Você pode instruir o download de magnitude e abrir um modelo do repositório remoto da Magnitude em vez de um caminho de arquivo local. O arquivo será baixado automaticamente localmente na primeira execução para ~/.magnitude/ e subsequentemente pule o download se o arquivo já existir localmente.
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 Para obter mais controle sobre o domínio do download remoto e o diretório de download local, consulte como usar MagnitudeUtils.download_model .
Os modelos de magnitude geralmente são arquivos grandes (múltiplos GB) que ocupam muito espaço em disco, mesmo que o formato .magnitude faça com que seja rápido utilizar os vetores. A magnitude tem a opção de transmitir esses arquivos grandes sobre o HTTP. Isso é explicitamente diferente do recurso de carregamento remoto, pois o modelo nem precisa ser baixado. Você pode começar a consultar modelos imediatamente sem espaço em disco usado.
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 downloadedVocê pode brincar com uma demonstração disso em um notebook Python do Google Colaboratory.
Esse recurso é extremamente útil se o seu ambiente de computação for restringido de recursos (baixo RAM e baixo espaço em disco), você deseja experimentar rapidamente vetores sem baixar e configurar arquivos de modelo grandes ou está treinando um modelo pequeno. Embora exista alguma latência de rede adicional, pois os dados estão sendo transmitidos, a magnitude ainda usará um cache de memória, conforme especificado pelo parâmetro do construtor lazy_loading . Como os idiomas geralmente têm uma distribuição ZIPF-IAN, a latência da rede não deve ser um problema após o aquecimento do cache após ser consultado um pequeno número de vezes.
Eles serão consultados diretamente em um servidor Web HTTP estático usando cabeçalhos de solicitação de intervalo HTTP. Todos os métodos de magnitude suportam o streaming, no entanto, most_similar e most_similar_approx pode ser lenta, pois ainda não são otimizados para streaming. Você pode ver como esse modo de streaming funciona atualmente nos benchmarks, no entanto, ele ficará mais rápido à medida que o otimizamos no futuro!
Outra documentação não está disponível no momento. Consulte o arquivo de origem diretamente (é bem comentado) se você precisar de mais informações sobre os argumentos de um método ou deseja ver todos os recursos suportados.
Atualmente, fornecemos apenas modelos de vetor de palavras em inglês nesta página pré-convertida no formato .magnitude . No entanto, você ainda pode usar magnitude com vetores de palavras de outros idiomas. O Facebook treinou seus vetores de texto rápido para muitos idiomas diferentes. Você pode reduzir o arquivo .vec para qualquer idioma desejar e convertê -lo em .magnitude com o conversor.
Atualmente, os arquivos de magnitude de leitura são suportados apenas no Python, pois se tornou o idioma de fato para o aprendizado de máquina. Isso é suficiente para a maioria dos casos de uso. Estender o formato de arquivo a outros idiomas não deve ser difícil, pois o SQLite possui uma implementação n nativa e as ligações na maioria dos idiomas. O formato do arquivo em si e o protocolo para leitura e pesquisa também são bastante diretos ao ler o código -fonte deste repositório.
Atualmente, o processamento de linguagem natural é o domínio mais popular que usa modelos de incorporação de vetores pré-treinados para representações de vetores de palavras. No entanto, existem outros domínios, como a visão computacional que começaram a usar modelos de incorporação de vetores pré-treinados, como o Deep1b para representação de imagens. Esta biblioteca pretende permanecer agnóstica a vários domínios e, em vez disso, fornece um armazenamento e interface genéricos de vetores-chave que são úteis para todos os domínios.
O repositório principal deste projeto pode ser encontrado no GitLab. O repositório do GitHub é apenas um espelho. Puxe solicitações para mais testes, melhor verificação de erros, correções de bugs, melhorias de desempenho ou documentação ou adição de utilizações / funcionalidades adicionais são bem-vindas no GitLab.
Você pode entrar em contato conosco em [email protected].
most_similar_approx otimizado para streamingmost_similar inicialmente lentas..bin Format most_similar_approx em magnitude usando árvores de projeção aleatória e 2 meios hierárquicos. Agradecemos ao autor Erik Bernhardson por ajudar com alguns dos detalhes da integração entre magnitude e aborrecimento. Se você quiser citar nosso artigo no EMNLP 2018, você pode usar a seguinte citação Bibtex:
@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 siga o link do Google Scholar para outras maneiras de citar o artigo.
Se você quiser citar este repositório, poderá usar o seguinte emblema do DOI:
Clicar no crachá levará a uma página que o ajudará a gerar citações de Bibtex adequadas, citações de JSON-LD e outras citações.
Este repositório está licenciado sob a licença encontrada aqui.
Ícone "sísmico" de Johnnyzi, do Projeto Substantivo.
