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__ = [

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. """
[docs] def __init__(self, vocab): super(Vocab, self).__init__() self.vocab = vocab
@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, 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 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:'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'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, 'r:gz') as tar: tar.extractall(path=cache) if not os.path.isfile(path): raise RuntimeError('no vectors found at {}'.format(path))"Loading vectors from {}".format(path)) ext = os.path.splitext(path)[1][1:] if ext == 'gz': open_file = 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:"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'Saving vectors to {}'.format(path_pt)) if not os.path.exists(cache): os.makedirs(cache), self.stoi, self.vectors, self.dim), path_pt) else:'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': '', '840B': '', 'twitter.27B': '', '6B': '', } 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 = '{}.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 = ('' 'jmt_pre-trained_embeddings.tar.gz') def __init__(self, **kwargs): super(CharNGram, self).__init__(, 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"""


Access comprehensive developer documentation for PyTorch

View Docs


Get in-depth tutorials for beginners and advanced developers

View Tutorials


Find development resources and get your questions answered

View Resources