PyTorch NLP

? Agora arquivado?

Com o amadurecimento da cadeia de ferramentas Pytorch, é hora de arquivar repositórios como este. Você poderá encontrar opções mais desenvolvidas para cada parte deste kit de ferramentas:

• Abraçando conjuntos de dados de rosto (conjuntos de dados)
• Abraçando os tokenizadores de rosto (codificadores)
• Métricas de rosto abraçando (métricas)
• Pytorch Datapipes (download e amostradores)
• Abraçando as incorporações de rosto (vetores de palavras)
• Pytorch nn (nn)
• Pytorch Torchtext (all-in-one)

Feliz desenvolvimento!

Sinta -se à vontade para entrar em contato comigo se alguém quiser desarquivar este repositório e continuar desenvolvendo -o. Você pode me alcançar em "petrochukm [at] gmail.com".

---

Utilitários básicos para Pytorch Natural Language Processing (PNL)

Pytorch-NLP, ou torchnlp , é uma biblioteca de utilitários básicos para Pytorch NLP. torchnlp estende o Pytorch para fornecer funções básicas de processamento de dados de texto de texto.

Logotipo de Chloe Yeo, patrocínio corporativo da Wellsaid Labs

Instalação?

Certifique -se de ter Python 3.6+ e Pytorch 1.0+. Você pode instalar pytorch-nlp usando PIP:

 pip install pytorch - nlp

Ou para instalar o código mais recente via:

 pip install git + https : // github . com / PetrochukM / PyTorch - NLP . git 

Documentos

A documentação completa para a Pytorch-NLP está disponível no site ReadThEdocs.

Comece

Dentro de um pipeline de dados da PNL, você deseja implementar estas etapas básicas:

1. Carregar seus dados?

Carregue o conjunto de dados IMDB, por exemplo:

 from torchnlp . datasets import imdb_dataset

# Load the imdb training dataset
train = imdb_dataset ( train = True )
train [ 0 ]  # RETURNS: {'text': 'For a movie that gets..', 'sentiment': 'pos'}

Carregue um conjunto de dados personalizado, por exemplo:

 from pathlib import Path

from torchnlp . download import download_file_maybe_extract

directory_path = Path ( 'data/' )
train_file_path = Path ( 'trees/train.txt' )

download_file_maybe_extract (
    url = 'http://nlp.stanford.edu/sentiment/trainDevTestTrees_PTB.zip' ,
    directory = directory_path ,
    check_files = [ train_file_path ])

open ( directory_path / train_file_path )

Não se preocupe, vamos lidar com o cache para você!

2. Texto para tensor

Tokenize e codifique seu texto como um tensor.

Por exemplo, um WhitespaceEncoder divide o texto em tokens sempre que encontra um caractere de espaço em branco.

 from torchnlp . encoders . text import WhitespaceEncoder

loaded_data = [ "now this ain't funny" , "so don't you dare laugh" ]
encoder = WhitespaceEncoder ( loaded_data )
encoded_data = [ encoder . encode ( example ) for example in loaded_data ]

3. Tensor para lote

Com os dados carregados e codificados em mãos, você deseja em lote do conjunto de dados.

 import torch
from torchnlp . samplers import BucketBatchSampler
from torchnlp . utils import collate_tensors
from torchnlp . encoders . text import stack_and_pad_tensors

encoded_data = [ torch . randn ( 2 ), torch . randn ( 3 ), torch . randn ( 4 ), torch . randn ( 5 )]

train_sampler = torch . utils . data . sampler . SequentialSampler ( encoded_data )
train_batch_sampler = BucketBatchSampler (
    train_sampler , batch_size = 2 , drop_last = False , sort_key = lambda i : encoded_data [ i ]. shape [ 0 ])

batches = [[ encoded_data [ i ] for i in batch ] for batch in train_batch_sampler ]
batches = [ collate_tensors ( batch , stack_tensors = stack_and_pad_tensors ) for batch in batches ]

O Pytorch-NLP se baseia no topo da tocha existente de torch.utils.data.sampler , torch.stack e default_collate para suportar entradas seqüenciais de comprimentos variados!

4. Treinamento e inferência

Com o seu lote na mão, você pode usar o Pytorch para desenvolver e treinar seu modelo usando a descida de gradiente. Por exemplo, confira este código de exemplo para treinamento no corpus Stanford Natural Language Inference (SNLI).

Por último, mas não menos importante

O Pytorch-NLP tem mais alguns pacotes de utilitário focados no PNL para apoiá-lo! ?

Funções determinísticas

Agora que você configurou seu pipeline, pode garantir que algumas funções funcionem de forma determinista. Enrole qualquer código que seja aleatório, com fork_rng e você estará pronto, como assim:

 import random
import numpy
import torch

from torchnlp . random import fork_rng

with fork_rng ( seed = 123 ):  # Ensure determinism
    print ( 'Random:' , random . randint ( 1 , 2 ** 31 ))
    print ( 'Numpy:' , numpy . random . randint ( 1 , 2 ** 31 ))
    print ( 'Torch:' , int ( torch . randint ( 1 , 2 ** 31 , ( 1 ,))))

Isso sempre imprimirá:

 Random: 224899943
Numpy: 843828735
Torch: 843828736

Vetores de palavras pré-treinados

Agora que você calculou seu vocabulário, você pode usar vetores de palavras pré-treinados para definir suas incorporações, assim:

 import torch
from torchnlp . encoders . text import WhitespaceEncoder
from torchnlp . word_to_vector import GloVe

encoder = WhitespaceEncoder ([ "now this ain't funny" , "so don't you dare laugh" ])

vocab_set = set ( encoder . vocab )
pretrained_embedding = GloVe ( name = '6B' , dim = 100 , is_include = lambda w : w in vocab_set )
embedding_weights = torch . Tensor ( encoder . vocab_size , pretrained_embedding . dim )
for i , token in enumerate ( encoder . vocab ):
    embedding_weights [ i ] = pretrained_embedding [ token ]

Camadas de redes neurais

Por exemplo, no pacote de rede neural, aplique o LockedDropout de ponta:

 import torch
from torchnlp . nn import LockedDropout

input_ = torch . randn ( 6 , 3 , 10 )
dropout = LockedDropout ( 0.5 )

# Apply a LockedDropout to `input_`
dropout ( input_ ) # RETURNS: torch.FloatTensor (6x3x10)

Métricas

Calcule métricas comuns de PNL, como a pontuação BLEU.

 from torchnlp . metrics import get_moses_multi_bleu

hypotheses = [ "The brown fox jumps over the dog 笑" ]
references = [ "The quick brown fox jumps over the lazy dog 笑" ]

# Compute BLEU score with the official BLEU perl script
get_moses_multi_bleu ( hypotheses , references , lowercase = True )  # RETURNS: 47.9

Ajuda ❓

Talvez olhar para exemplos mais longos possa ajudá -lo em examples/ .

Precisa de mais ajuda? Estamos felizes em responder suas perguntas via chat gitter

Contribuindo

Lançamos Pytorch-NLP porque encontramos uma falta de kits de ferramentas básicos para PNL em Pytorch. Esperamos que outras organizações possam se beneficiar do projeto. Somos gratos por quaisquer contribuições da comunidade.

Guia contribuinte

Leia nosso guia contribuinte para aprender sobre nosso processo de desenvolvimento, como propor bugs e melhorias e como criar e testar suas alterações no Pytorch-NLP.

Trabalho relacionado

Torchtext

TorchText e Pytorch-NLP diferem no conjunto de arquitetura e recursos; Caso contrário, eles são semelhantes. TorchText e Pytorch-NLP fornecem vetores de palavras pré-treinados, conjuntos de dados, iteradores e codificadores de texto. O Pytorch-NLP também fornece módulos e métricas de rede neural. Do ponto de vista da arquitetura, a TorchText é orientada a objetos com acoplamento externo, enquanto o Pytorch-NLP é orientado para objetos com baixo acoplamento.

Allennlp

Allennlp foi projetado para ser uma plataforma para pesquisa. O Pytorch-NLP foi projetado para ser um kit de ferramentas leve.

Autores

• Michael Petrochuk - Desenvolvedor
• Chloe yeo - design de logotipo

Citando

Se você achar o Pytorch-NLP útil para uma publicação acadêmica, use o seguinte Bibtex para citar:

 @misc{pytorch-nlp,
  author = {Petrochuk, Michael},
  title = {PyTorch-NLP: Rapid Prototyping with PyTorch Natural Language Processing (NLP) Tools},
  year = {2018},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {url{https://github.com/PetrochukM/PyTorch-NLP}},
}