spaCy/spacy/tokens.pyx

340 lines
10 KiB
Cython
Raw Normal View History

2014-12-30 13:22:00 +03:00
# cython: embedsignature=True
2014-12-27 10:45:16 +03:00
2014-12-04 12:46:55 +03:00
from preshed.maps cimport PreshMap
from preshed.counter cimport PreshCounter
2014-12-24 09:42:00 +03:00
from .vocab cimport EMPTY_LEXEME
2014-12-21 23:25:43 +03:00
from .typedefs cimport attr_id_t, attr_t
from .typedefs cimport LEMMA
from .typedefs cimport ID, ORTH, NORM, LOWER, SHAPE, PREFIX, SUFFIX, LENGTH, CLUSTER
2014-12-24 09:42:00 +03:00
from .typedefs cimport POS, LEMMA
from .typedefs import UNIV_TAG_NAMES
2014-12-24 09:42:00 +03:00
2015-01-21 18:05:37 +03:00
from unidecode import unidecode
2015-01-19 11:59:55 +03:00
cimport numpy
import numpy
2014-10-22 05:55:42 +04:00
cimport cython
2014-09-15 03:31:44 +04:00
DEF PADDING = 5
cdef int bounds_check(int i, int length, int padding) except -1:
if (i + padding) < 0:
raise IndexError
if (i - padding) >= length:
raise IndexError
2014-09-15 03:31:44 +04:00
2014-12-24 09:42:00 +03:00
cdef attr_t get_token_attr(const TokenC* token, attr_id_t feat_name) nogil:
if feat_name == LEMMA:
return token.lemma
elif feat_name == POS:
return token.pos
else:
return get_lex_attr(token.lex, feat_name)
cdef attr_t get_lex_attr(const LexemeC* lex, attr_id_t feat_name) nogil:
2014-12-24 09:42:00 +03:00
if feat_name < (sizeof(flags_t) * 8):
return check_flag(lex, feat_name)
elif feat_name == ID:
return lex.id
2015-01-22 18:08:25 +03:00
elif feat_name == ORTH:
return lex.orth
elif feat_name == LOWER:
return lex.lower
elif feat_name == NORM:
return lex.norm
2014-12-24 09:42:00 +03:00
elif feat_name == SHAPE:
return lex.shape
elif feat_name == PREFIX:
return lex.prefix
elif feat_name == SUFFIX:
return lex.suffix
elif feat_name == LENGTH:
return lex.length
elif feat_name == CLUSTER:
return lex.cluster
else:
return 0
2014-09-10 20:11:13 +04:00
cdef class Tokens:
2014-12-27 10:45:16 +03:00
"""Access and set annotations onto some text.
2014-09-10 20:11:13 +04:00
"""
def __init__(self, Vocab vocab, unicode string):
2014-12-21 23:25:43 +03:00
self.vocab = vocab
self._string = string
string_length = len(string)
if string_length >= 3:
size = int(string_length / 3.0)
else:
size = 5
self.mem = Pool()
# Guarantee self.lex[i-x], for any i >= 0 and x < padding is in bounds
# However, we need to remember the true starting places, so that we can
# realloc.
data_start = <TokenC*>self.mem.alloc(size + (PADDING*2), sizeof(TokenC))
2014-10-22 21:01:17 +04:00
cdef int i
for i in range(size + (PADDING*2)):
2014-12-07 14:07:41 +03:00
data_start[i].lex = &EMPTY_LEXEME
self.data = data_start + PADDING
self.max_length = size
self.length = 0
self._tag_strings = [] # These will be set by the POS tagger and parser
self._dep_strings = [] # The strings are arbitrary and model-specific.
2014-10-14 11:22:41 +04:00
2015-01-19 17:16:29 +03:00
def sentences(self):
cdef int i
sentences = []
cdef Tokens sent = Tokens(self.vocab, self._string[self.data[0].idx:])
2015-01-19 17:16:29 +03:00
cdef attr_t period = self.vocab.strings['.']
cdef attr_t question = self.vocab.strings['?']
cdef attr_t exclamation = self.vocab.strings['!']
2015-01-22 14:24:44 +03:00
spans = []
start = None
2015-01-19 17:16:29 +03:00
for i in range(self.length):
2015-01-22 14:24:44 +03:00
if start is None:
start = i
2015-01-22 18:08:25 +03:00
if self.data[i].lex.orth == period or self.data[i].lex.orth == exclamation or \
self.data[i].lex.orth == question:
2015-01-22 14:24:44 +03:00
spans.append((start, i+1))
start = None
if start is not None:
spans.append((start, self.length))
return spans
2015-01-19 17:16:29 +03:00
2014-09-11 23:37:32 +04:00
def __getitem__(self, i):
2014-12-27 10:45:16 +03:00
"""Retrieve a token.
Returns:
token (Token):
"""
2015-01-19 17:16:29 +03:00
if i < 0:
i = self.length - i
bounds_check(i, self.length, PADDING)
return Token(self, i)
2014-09-11 23:37:32 +04:00
2014-11-03 17:07:08 +03:00
def __iter__(self):
2014-12-27 10:45:16 +03:00
"""Iterate over the tokens.
Yields:
token (Token):
"""
2014-11-03 17:07:08 +03:00
for i in range(self.length):
yield self[i]
2014-09-11 23:37:32 +04:00
def __len__(self):
return self.length
2014-09-11 23:37:32 +04:00
def __unicode__(self):
cdef const TokenC* last = &self.data[self.length - 1]
return self._string[:last.idx + last.lex.length]
2015-01-21 18:05:37 +03:00
def __str__(self):
return unidecode(unicode(self))
cdef int push_back(self, int idx, LexemeOrToken lex_or_tok) except -1:
if self.length == self.max_length:
self._realloc(self.length * 2)
cdef TokenC* t = &self.data[self.length]
if LexemeOrToken is TokenC_ptr:
t[0] = lex_or_tok[0]
else:
t.lex = lex_or_tok
2014-12-24 09:42:00 +03:00
t.idx = idx
self.length += 1
return idx + t.lex.length
2014-12-04 12:46:55 +03:00
@cython.boundscheck(False)
cpdef long[:,:] to_array(self, object py_attr_ids):
2014-12-27 13:46:04 +03:00
"""Given a list of M attribute IDs, export the tokens to a numpy ndarray
of shape N*M, where N is the length of the sentence.
Arguments:
attr_ids (list[int]): A list of attribute ID ints.
Returns:
feat_array (numpy.ndarray[long, ndim=2]):
A feature matrix, with one row per word, and one column per attribute
indicated in the input attr_ids.
2014-12-27 13:46:04 +03:00
"""
2014-12-02 15:48:05 +03:00
cdef int i, j
2014-12-04 12:46:55 +03:00
cdef attr_id_t feature
cdef numpy.ndarray[long, ndim=2] output
# Make an array from the attributes --- otherwise our inner loop is Python
# dict iteration.
cdef numpy.ndarray[long, ndim=1] attr_ids = numpy.asarray(py_attr_ids)
output = numpy.ndarray(shape=(self.length, len(attr_ids)), dtype=numpy.int)
2014-12-02 15:48:05 +03:00
for i in range(self.length):
2014-12-04 12:46:55 +03:00
for j, feature in enumerate(attr_ids):
2014-12-24 09:42:00 +03:00
output[i, j] = get_token_attr(&self.data[i], feature)
2014-12-02 15:48:05 +03:00
return output
2015-01-21 18:05:37 +03:00
def count_by(self, attr_id_t attr_id, exclude=None):
2014-12-27 13:46:04 +03:00
"""Produce a dict of {attribute (int): count (ints)} frequencies, keyed
by the values of the given attribute ID.
>>> from spacy.en import English, attrs
>>> nlp = English()
>>> tokens = nlp(u'apple apple orange banana')
2015-01-22 18:08:25 +03:00
>>> tokens.count_by(attrs.ORTH)
2014-12-27 13:46:04 +03:00
{12800L: 1, 11880L: 2, 7561L: 1}
2015-01-22 18:08:25 +03:00
>>> tokens.to_array([attrs.ORTH])
2014-12-27 13:46:04 +03:00
array([[11880],
[11880],
[ 7561],
[12800]])
"""
2014-12-04 12:46:55 +03:00
cdef int i
cdef attr_t attr
cdef size_t count
cdef PreshCounter counts = PreshCounter(2 ** 8)
for i in range(self.length):
2015-01-21 18:05:37 +03:00
if exclude is not None and exclude(self[i]):
continue
2014-12-24 09:42:00 +03:00
attr = get_token_attr(&self.data[i], attr_id)
2014-12-04 12:46:55 +03:00
counts.inc(attr, 1)
return dict(counts)
def _realloc(self, new_size):
self.max_length = new_size
n = new_size + (PADDING * 2)
2014-12-07 14:07:41 +03:00
# What we're storing is a "padded" array. We've jumped forward PADDING
# places, and are storing the pointer to that. This way, we can access
# words out-of-bounds, and get out-of-bounds markers.
# Now that we want to realloc, we need the address of the true start,
# so we jump the pointer back PADDING places.
cdef TokenC* data_start = self.data - PADDING
data_start = <TokenC*>self.mem.realloc(data_start, n * sizeof(TokenC))
self.data = data_start + PADDING
cdef int i
for i in range(self.length, self.max_length + PADDING):
2014-12-07 14:07:41 +03:00
self.data[i].lex = &EMPTY_LEXEME
2014-09-15 03:31:44 +04:00
@cython.freelist(64)
cdef class Token:
2015-01-21 18:05:37 +03:00
"""An individual token."""
def __init__(self, Tokens tokens, int i):
self._seq = tokens
self.i = i
cdef const TokenC* t = &tokens.data[i]
self.idx = t.idx
self.cluster = t.lex.cluster
self.length = t.lex.length
2015-01-22 18:08:25 +03:00
self.orth = t.lex.orth
self.lower = t.lex.lower
self.norm = t.lex.norm
self.shape = t.lex.shape
self.prefix = t.lex.prefix
self.suffix = t.lex.suffix
self.prob = t.lex.prob
self.sentiment = t.lex.sentiment
self.flags = t.lex.flags
self.lemma = t.lemma
self.pos = t.pos
self.tag = t.tag
self.dep = t.dep
2015-01-21 18:05:37 +03:00
self.repvec = numpy.asarray(<float[:300,]> t.lex.repvec)
cdef int next_idx = (t+1).idx
if next_idx <= self.idx:
next_idx = self.idx + self.length
self.string = tokens._string[self.idx:next_idx]
2014-12-24 09:42:00 +03:00
def __len__(self):
2014-12-27 10:45:16 +03:00
"""The number of unicode code-points in the original string.
Returns:
length (int):
"""
return self._seq.data[self.i].lex.length
def nbor(self, int i=1):
return Token(self._seq, self.i + i)
def child(self, int i=1):
cdef const TokenC* t = &self._seq.data[self.i]
if i == 0:
return self
elif i >= 1:
if t.r_kids == 0:
return None
else:
return Token(self._seq, _nth_significant_bit(t.r_kids, i))
else:
if t.l_kids == 0:
return None
else:
return Token(self._seq, _nth_significant_bit(t.l_kids, i))
property head:
"""The token predicted by the parser to be the head of the current token."""
def __get__(self):
cdef const TokenC* t = &self._seq.data[self.i]
return Token(self._seq, self.i + t.head)
property whitespace:
def __get__(self):
2015-01-23 23:41:21 +03:00
return self.string[self.length:]
2015-01-22 18:08:25 +03:00
property orth_:
def __get__(self):
2015-01-22 18:08:25 +03:00
return self._seq.vocab.strings[self.orth]
property lower_:
def __get__(self):
return self._seq.vocab.strings[self.lower]
property norm_:
def __get__(self):
return self._seq.vocab.strings[self.norm]
property shape_:
def __get__(self):
return self._seq.vocab.strings[self.shape]
property prefix_:
def __get__(self):
return self._seq.vocab.strings[self.prefix]
property suffix_:
def __get__(self):
return self._seq.vocab.strings[self.suffix]
property lemma_:
def __get__(self):
cdef const TokenC* t = &self._seq.data[self.i]
if t.lemma == 0:
return self.string
cdef unicode py_ustr = self._seq.vocab.strings[t.lemma]
return py_ustr
property pos_:
def __get__(self):
id_to_string = {id_: string for string, id_ in UNIV_TAG_NAMES.items()}
return id_to_string[self.pos]
property tag_:
def __get__(self):
return self._seq._tag_strings[self.tag]
property dep_:
def __get__(self):
return self._seq._dep_strings[self.dep]
cdef inline uint32_t _nth_significant_bit(uint32_t bits, int n) nogil:
cdef int i
for i in range(32):
if bits & (1 << i):
n -= 1
if n < 1:
return i
return 0