PyTorch NLP

? Maintenant archivé?

Avec la chaîne à outils Pytorch qui mûrit, il est temps d'archiver des compositions comme celle-ci. Vous pourrez trouver des options plus développées pour chaque partie de cette boîte à outils:

• Ensembles de données de visage étreintes (ensembles de données)
• Tokenisers étreintes (Encodeurs)
• Métriques de visage étreintes (métriques)
• Pytorch Datapipes (téléchargement et échantillonneurs)
• Étreindre les incorporations de visage (vecteurs de mots)
• Pytorch nn (nn)
• Pytorch TorchText (tout-en-un)

Heureux développer!

N'hésitez pas à me contacter si quelqu'un veut désarchiser ce dépôt et continuer à le développer. Vous pouvez me joindre à "Petrochukm [at] gmail.com".

---

Utilitaires de base pour le traitement du langage naturel Pytorch (NLP)

Pytorch-NLP, ou torchnlp pour faire court, est une bibliothèque d'utilitaires de base pour Pytorch NLP. torchnlp étend Pytorch pour vous fournir des fonctions de traitement de données de texte de base.

Logo de Chloe Yeo, parrainage d'entreprise par Wellsaid Labs

Installation?

Assurez-vous d'avoir Python 3.6+ et Pytorch 1.0+. Vous pouvez ensuite installer pytorch-nlp à l'aide de PIP:

 pip install pytorch - nlp

Ou pour installer le dernier code via:

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

Docs

La documentation complète de Pytorch-NLP est disponible via notre site Web ReadTheDocs.

Commencer

Dans un pipeline de données NLP, vous voudrez implémenter ces étapes de base:

1. Chargez vos données?

Chargez l'ensemble de données IMDB, par exemple:

 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'}

Chargez un ensemble de données personnalisé, par exemple:

 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 )

Ne vous inquiétez pas, nous gérons la mise en cache pour vous!

2. Texte à tenseur

Tokenize et codez votre texte en tant que tenseur.

Par exemple, un WhitespaceEncoder divise le texte en jetons chaque fois qu'il rencontre un caractère blanc.

 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. Tenseur à lot

Avec vos données chargées et codées en main, vous voudrez lager votre ensemble de données.

 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 ]

Pytorch-NLP se construit au-dessus de torch.utils.data.sampler , torch.stack et default_collate de Pytorch se construit

4. Formation et inférence

Avec votre lot en main, vous pouvez utiliser Pytorch pour développer et former votre modèle à l'aide de la descente de gradient. Par exemple, consultez cet exemple de code de formation sur le corpus de Stanford Natural Language Inference (SNLI).

Enfin et surtout

Pytorch-NLP possède quelques packages utilitaires axés sur NLP pour vous soutenir! ?

Fonctions déterministes

Maintenant, vous avez configuré votre pipeline, vous voudrez peut-être vous assurer que certaines fonctions s'exécutent de manière déterministe. Enveloppez n'importe quel code aléatoire, avec fork_rng et vous serez prêt à y aller, comme ainsi:

 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 ,))))

Cela imprimera toujours:

 Random: 224899943
Numpy: 843828735
Torch: 843828736

Vecteurs de mots pré-formés

Maintenant que vous avez calculé votre vocabulaire, vous voudrez peut-être utiliser des vecteurs de mots pré-formés pour définir vos intérêts, comme ainsi:

 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 ]

Couches de réseaux de neurones

Par exemple, à partir du package de réseau neuronal, appliquez le LockedDropout de statut de la technologie:

 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étrique

Calculez les mesures NLP communes telles que le score 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

Aide ❓

Peut-être que regarder des exemples plus longs peut vous aider à examples/ .

Besoin de plus d'aide? Nous sommes heureux de répondre à vos questions via le chat gitter

Contributif

Nous avons publié Pytorch-NLP parce que nous avons trouvé un manque de boîtes d'outils de base pour NLP à Pytorch. Nous espérons que d'autres organisations pourront bénéficier du projet. Nous sommes reconnaissants pour toute contribution de la communauté.

Guide de contribution

Lisez notre guide de contribution pour en savoir plus sur notre processus de développement, comment proposer des bugfix et des améliorations, et comment créer et tester vos modifications à Pytorch-NLP.

Travaux connexes

torch

TorchText et Pytorch-NLP diffèrent dans l'architecture et l'ensemble de fonctionnalités; Sinon, ils sont similaires. TorchText et Pytorch-NLP fournissent des vecteurs de mots pré-formés, des ensembles de données, des itérateurs et des encodeurs de texte. Pytorch-NLP fournit également des modules de réseau de neurones et des mesures. Du point de vue de l'architecture, TorchText est orienté objet avec un couplage externe tandis que Pytorch-NLP est orienté objet avec un couplage faible.

Allennlp

ALLENNLP est conçu pour être une plate-forme de recherche. Pytorch-NLP est conçu pour être une boîte à outils légère.

Auteurs

• Michael Petrochuk - Développeur
• Chloe Yeo - Conception du logo

Citant

Si vous trouvez Pytorch-NLP utile pour une publication académique, veuillez utiliser le bibtex suivant pour le citer:

 @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}},
}