Source code for torchtext.vocab
from functools import partial
import logging
import os
import zipfile
import gzip
import torch
import torch.nn as nn
from urllib.request import urlretrieve
from tqdm import tqdm
import tarfile
from typing import Dict, List, Optional, Iterable
from collections import Counter, OrderedDict
from torchtext._torchtext import (
Vocab as VocabPybind,
)
from .utils import reporthook
logger = logging.getLogger(__name__)
__all__ = [
'build_vocab_from_iterator',
'vocab',
]
logger = logging.getLogger(__name__)
[docs]class Vocab(nn.Module):
__jit_unused_properties__ = ["is_jitable"]
r"""Creates a vocab object which maps tokens to indices.
Args:
vocab (torch.classes.torchtext.Vocab or torchtext._torchtext.Vocab): a cpp vocab object.
"""
@property
def is_jitable(self):
return not isinstance(self.vocab, VocabPybind)
[docs] @torch.jit.export
def forward(self, tokens: List[str]) -> List[int]:
r"""Calls the `lookup_indices` method
Args:
tokens: a list of tokens used to lookup their corresponding `indices`.
Returns:
The indices associated with a list of `tokens`.
"""
return self.vocab.lookup_indices(tokens)
[docs] @torch.jit.export
def __len__(self) -> int:
r"""
Returns:
The length of the vocab.
"""
return len(self.vocab)
[docs] @torch.jit.export
def __contains__(self, token: str) -> bool:
r"""
Args:
token: The token for which to check the membership.
Returns:
Whether the token is member of vocab or not.
"""
return self.vocab.__contains__(token)
[docs] @torch.jit.export
def __getitem__(self, token: str) -> int:
r"""
Args:
token: The token used to lookup the corresponding index.
Returns:
The index corresponding to the associated token.
"""
return self.vocab[token]
[docs] @torch.jit.export
def set_default_index(self, index: Optional[int]) -> None:
r"""
Args:
index: Value of default index. This index will be returned when OOV token is queried.
"""
self.vocab.set_default_index(index)
[docs] @torch.jit.export
def get_default_index(self) -> Optional[int]:
r"""
Returns:
Value of default index if it is set.
"""
return self.vocab.get_default_index()
[docs] @torch.jit.export
def insert_token(self, token: str, index: int) -> None:
r"""
Args:
token: The token used to lookup the corresponding index.
index: The index corresponding to the associated token.
Raises:
RuntimeError: If `index` is not in range [0, Vocab.size()] or if `token` already exists in the vocab.
"""
self.vocab.insert_token(token, index)
[docs] @torch.jit.export
def append_token(self, token: str) -> None:
r"""
Args:
token: The token used to lookup the corresponding index.
Raises:
RuntimeError: If `token` already exists in the vocab
"""
self.vocab.append_token(token)
[docs] @torch.jit.export
def lookup_token(self, index: int) -> str:
r"""
Args:
index: The index corresponding to the associated token.
Returns:
token: The token used to lookup the corresponding index.
Raises:
RuntimeError: If `index` not in range [0, itos.size()).
"""
return self.vocab.lookup_token(index)
[docs] @torch.jit.export
def lookup_tokens(self, indices: List[int]) -> List[str]:
r"""
Args:
indices: The `indices` used to lookup their corresponding`tokens`.
Returns:
The `tokens` associated with `indices`.
Raises:
RuntimeError: If an index within `indices` is not int range [0, itos.size()).
"""
return self.vocab.lookup_tokens(indices)
[docs] @torch.jit.export
def lookup_indices(self, tokens: List[str]) -> List[int]:
r"""
Args:
tokens: the tokens used to lookup their corresponding `indices`.
Returns:
The 'indices` associated with `tokens`.
"""
return self.vocab.lookup_indices(tokens)
[docs] @torch.jit.export
def get_stoi(self) -> Dict[str, int]:
r"""
Returns:
Dictionary mapping tokens to indices.
"""
return self.vocab.get_stoi()
[docs] @torch.jit.export
def get_itos(self) -> List[str]:
r"""
Returns:
List mapping indices to tokens.
"""
return self.vocab.get_itos()
[docs] def __prepare_scriptable__(self):
r"""Return a JITable Vocab.
"""
if not self.is_jitable:
cpp_vocab = torch.classes.torchtext.Vocab(self.vocab.itos_, self.vocab.default_index_)
return Vocab(cpp_vocab)
return self
[docs]def vocab(ordered_dict: Dict, min_freq: int = 1) -> Vocab:
r"""Factory method for creating a vocab object which maps tokens to indices.
Note that the ordering in which key value pairs were inserted in the `ordered_dict` will be respected when building the vocab.
Therefore if sorting by token frequency is important to the user, the `ordered_dict` should be created in a way to reflect this.
Args:
ordered_dict: Ordered Dictionary mapping tokens to their corresponding occurance frequencies.
min_freq: The minimum frequency needed to include a token in the vocabulary.
Returns:
torchtext.vocab.Vocab: A `Vocab` object
Examples:
>>> from torchtext.vocab import vocab
>>> from collections import Counter, OrderedDict
>>> counter = Counter(["a", "a", "b", "b", "b"])
>>> sorted_by_freq_tuples = sorted(counter.items(), key=lambda x: x[1], reverse=True)
>>> ordered_dict = OrderedDict(sorted_by_freq_tuples)
>>> v1 = vocab(ordered_dict)
>>> print(v1['a']) #prints 1
>>> print(v1['out of vocab']) #raise RuntimeError since default index is not set
>>> tokens = ['e', 'd', 'c', 'b', 'a']
>>> v2 = vocab(OrderedDict([(token, 1) for token in tokens]))
>>> #adding <unk> token and default index
>>> unk_token = '<unk>'
>>> default_index = -1
>>> if unk_token not in v2: v2.insert_token(unk_token, 0)
>>> v2.set_default_index(default_index)
>>> print(v2['<unk>']) #prints 0
>>> print(v2['out of vocab']) #prints -1
>>> #make default index same as index of unk_token
>>> v2.set_default_index(v2[unk_token])
>>> v2['out of vocab'] is v2[unk_token] #prints True
"""
tokens = []
for token, freq in ordered_dict.items():
if freq >= min_freq:
tokens.append(token)
return Vocab(VocabPybind(tokens, None))
[docs]def build_vocab_from_iterator(iterator: Iterable, min_freq: int = 1, specials: Optional[List[str]] = None, special_first: bool = True) -> Vocab:
"""
Build a Vocab from an iterator.
Args:
iterator: Iterator used to build Vocab. Must yield list or iterator of tokens.
min_freq: The minimum frequency needed to include a token in the vocabulary.
specials: Special symbols to add. The order of supplied tokens will be preserved.
special_first: Indicates whether to insert symbols at the beginning or at the end.
Returns:
torchtext.vocab.Vocab: A `Vocab` object
Examples:
>>> #generating vocab from text file
>>> import io
>>> from torchtext.vocab import build_vocab_from_iterator
>>> def yield_tokens(file_path):
>>> with io.open(file_path, encoding = 'utf-8') as f:
>>> for line in f:
>>> yield line.strip().split()
>>> vocab = build_vocab_from_iterator(yield_tokens_batch(file_path), specials=["<unk>"])
"""
counter = Counter()
for tokens in iterator:
counter.update(tokens)
if specials is not None:
for tok in specials:
del counter[tok]
sorted_by_freq_tuples = sorted(counter.items(), key=lambda x: x[0])
sorted_by_freq_tuples.sort(key=lambda x: x[1], reverse=True)
ordered_dict = OrderedDict(sorted_by_freq_tuples)
if specials is not None:
if special_first:
specials = specials[::-1]
for symbol in specials:
ordered_dict.update({symbol: min_freq})
ordered_dict.move_to_end(symbol, last=not special_first)
word_vocab = vocab(ordered_dict, min_freq=min_freq)
return word_vocab
def _infer_shape(f):
num_lines, vector_dim = 0, None
for line in f:
if vector_dim is None:
row = line.rstrip().split(b" ")
vector = row[1:]
# Assuming word, [vector] format
if len(vector) > 2:
# The header present in some (w2v) formats contains two elements.
vector_dim = len(vector)
num_lines += 1 # First element read
else:
num_lines += 1
f.seek(0)
return num_lines, vector_dim
[docs]class Vectors(object):
[docs] def __init__(self, name, cache=None,
url=None, unk_init=None, max_vectors=None):
"""
Args:
name: name of the file that contains the vectors
cache: directory for cached vectors
url: url for download if vectors not found in cache
unk_init (callback): by default, initialize out-of-vocabulary word vectors
to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size
max_vectors (int): this can be used to limit the number of
pre-trained vectors loaded.
Most pre-trained vector sets are sorted
in the descending order of word frequency.
Thus, in situations where the entire set doesn't fit in memory,
or is not needed for another reason, passing `max_vectors`
can limit the size of the loaded set.
"""
cache = '.vector_cache' if cache is None else cache
self.itos = None
self.stoi = None
self.vectors = None
self.dim = None
self.unk_init = torch.Tensor.zero_ if unk_init is None else unk_init
self.cache(name, cache, url=url, max_vectors=max_vectors)
def __getitem__(self, token):
if token in self.stoi:
return self.vectors[self.stoi[token]]
else:
return self.unk_init(torch.Tensor(self.dim))
def cache(self, name, cache, url=None, max_vectors=None):
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
if os.path.isfile(name):
path = name
if max_vectors:
file_suffix = '_{}.pt'.format(max_vectors)
else:
file_suffix = '.pt'
path_pt = os.path.join(cache, os.path.basename(name)) + file_suffix
else:
path = os.path.join(cache, name)
if max_vectors:
file_suffix = '_{}.pt'.format(max_vectors)
else:
file_suffix = '.pt'
path_pt = path + file_suffix
if not os.path.isfile(path_pt):
if not os.path.isfile(path) and url:
logger.info('Downloading vectors from {}'.format(url))
if not os.path.exists(cache):
os.makedirs(cache)
dest = os.path.join(cache, os.path.basename(url))
if not os.path.isfile(dest):
with tqdm(unit='B', unit_scale=True, miniters=1, desc=dest) as t:
try:
urlretrieve(url, dest, reporthook=reporthook(t))
except KeyboardInterrupt as e: # remove the partial zip file
os.remove(dest)
raise e
logger.info('Extracting vectors into {}'.format(cache))
ext = os.path.splitext(dest)[1][1:]
if ext == 'zip':
with zipfile.ZipFile(dest, "r") as zf:
zf.extractall(cache)
elif ext == 'gz':
if dest.endswith('.tar.gz'):
with tarfile.open(dest, 'r:gz') as tar:
tar.extractall(path=cache)
if not os.path.isfile(path):
raise RuntimeError('no vectors found at {}'.format(path))
logger.info("Loading vectors from {}".format(path))
ext = os.path.splitext(path)[1][1:]
if ext == 'gz':
open_file = gzip.open
else:
open_file = open
vectors_loaded = 0
with open_file(path, 'rb') as f:
num_lines, dim = _infer_shape(f)
if not max_vectors or max_vectors > num_lines:
max_vectors = num_lines
itos, vectors, dim = [], torch.zeros((max_vectors, dim)), None
for line in tqdm(f, total=max_vectors):
# Explicitly splitting on " " is important, so we don't
# get rid of Unicode non-breaking spaces in the vectors.
entries = line.rstrip().split(b" ")
word, entries = entries[0], entries[1:]
if dim is None and len(entries) > 1:
dim = len(entries)
elif len(entries) == 1:
logger.warning("Skipping token {} with 1-dimensional "
"vector {}; likely a header".format(word, entries))
continue
elif dim != len(entries):
raise RuntimeError(
"Vector for token {} has {} dimensions, but previously "
"read vectors have {} dimensions. All vectors must have "
"the same number of dimensions.".format(word, len(entries),
dim))
try:
if isinstance(word, bytes):
word = word.decode('utf-8')
except UnicodeDecodeError:
logger.info("Skipping non-UTF8 token {}".format(repr(word)))
continue
vectors[vectors_loaded] = torch.tensor([float(x) for x in entries])
vectors_loaded += 1
itos.append(word)
if vectors_loaded == max_vectors:
break
self.itos = itos
self.stoi = {word: i for i, word in enumerate(itos)}
self.vectors = torch.Tensor(vectors).view(-1, dim)
self.dim = dim
logger.info('Saving vectors to {}'.format(path_pt))
if not os.path.exists(cache):
os.makedirs(cache)
torch.save((self.itos, self.stoi, self.vectors, self.dim), path_pt)
else:
logger.info('Loading vectors from {}'.format(path_pt))
self.itos, self.stoi, self.vectors, self.dim = torch.load(path_pt)
def __len__(self):
return len(self.vectors)
[docs] def get_vecs_by_tokens(self, tokens, lower_case_backup=False):
"""Look up embedding vectors of tokens.
Args:
tokens: a token or a list of tokens. if `tokens` is a string,
returns a 1-D tensor of shape `self.dim`; if `tokens` is a
list of strings, returns a 2-D tensor of shape=(len(tokens),
self.dim).
lower_case_backup : Whether to look up the token in the lower case.
If False, each token in the original case will be looked up;
if True, each token in the original case will be looked up first,
if not found in the keys of the property `stoi`, the token in the
lower case will be looked up. Default: False.
Examples:
>>> examples = ['chip', 'baby', 'Beautiful']
>>> vec = text.vocab.GloVe(name='6B', dim=50)
>>> ret = vec.get_vecs_by_tokens(tokens, lower_case_backup=True)
"""
to_reduce = False
if not isinstance(tokens, list):
tokens = [tokens]
to_reduce = True
if not lower_case_backup:
indices = [self[token] for token in tokens]
else:
indices = [self[token] if token in self.stoi
else self[token.lower()]
for token in tokens]
vecs = torch.stack(indices)
return vecs[0] if to_reduce else vecs
[docs]class GloVe(Vectors):
url = {
'42B': 'http://nlp.stanford.edu/data/glove.42B.300d.zip',
'840B': 'http://nlp.stanford.edu/data/glove.840B.300d.zip',
'twitter.27B': 'http://nlp.stanford.edu/data/glove.twitter.27B.zip',
'6B': 'http://nlp.stanford.edu/data/glove.6B.zip',
}
def __init__(self, name='840B', dim=300, **kwargs):
url = self.url[name]
name = 'glove.{}.{}d.txt'.format(name, str(dim))
super(GloVe, self).__init__(name, url=url, **kwargs)
[docs]class FastText(Vectors):
url_base = 'https://dl.fbaipublicfiles.com/fasttext/vectors-wiki/wiki.{}.vec'
def __init__(self, language="en", **kwargs):
url = self.url_base.format(language)
name = os.path.basename(url)
super(FastText, self).__init__(name, url=url, **kwargs)
[docs]class CharNGram(Vectors):
name = 'charNgram.txt'
url = ('http://www.logos.t.u-tokyo.ac.jp/~hassy/publications/arxiv2016jmt/'
'jmt_pre-trained_embeddings.tar.gz')
def __init__(self, **kwargs):
super(CharNGram, self).__init__(self.name, url=self.url, **kwargs)
def __getitem__(self, token):
vector = torch.Tensor(1, self.dim).zero_()
if token == "<unk>":
return self.unk_init(vector)
chars = ['#BEGIN#'] + list(token) + ['#END#']
num_vectors = 0
for n in [2, 3, 4]:
end = len(chars) - n + 1
grams = [chars[i:(i + n)] for i in range(end)]
for gram in grams:
gram_key = '{}gram-{}'.format(n, ''.join(gram))
if gram_key in self.stoi:
vector += self.vectors[self.stoi[gram_key]]
num_vectors += 1
if num_vectors > 0:
vector /= num_vectors
else:
vector = self.unk_init(vector)
return vector
pretrained_aliases = {
"charngram.100d": partial(CharNGram),
"fasttext.en.300d": partial(FastText, language="en"),
"fasttext.simple.300d": partial(FastText, language="simple"),
"glove.42B.300d": partial(GloVe, name="42B", dim="300"),
"glove.840B.300d": partial(GloVe, name="840B", dim="300"),
"glove.twitter.27B.25d": partial(GloVe, name="twitter.27B", dim="25"),
"glove.twitter.27B.50d": partial(GloVe, name="twitter.27B", dim="50"),
"glove.twitter.27B.100d": partial(GloVe, name="twitter.27B", dim="100"),
"glove.twitter.27B.200d": partial(GloVe, name="twitter.27B", dim="200"),
"glove.6B.50d": partial(GloVe, name="6B", dim="50"),
"glove.6B.100d": partial(GloVe, name="6B", dim="100"),
"glove.6B.200d": partial(GloVe, name="6B", dim="200"),
"glove.6B.300d": partial(GloVe, name="6B", dim="300")
}
"""Mapping from string name to factory function"""
