python - propn - spaCy Documentación para

spacy tags

Question

Soy nuevo en el spaCy. Agregué esta publicación para documentación y la hago simple para principiantes como yo.

import spacy
nlp = spacy.load(''en'')
doc = nlp(u''KEEP CALM because TOGETHER We Rock !'')
for word in doc:
    print(word.text, word.lemma, word.lemma_, word.tag, word.tag_, word.pos, word.pos_)
    print(word.orth_)

Estoy buscando entender el significado de orth, lemma, tag y pos? Este código imprime los valores también cuál es la diferencia entre print(word) vs print(word.orth_)

Answer 1

1) Cuando imprime una word , básicamente imprime Token class desde spacy, que está configurado para imprimir cadena de la clase. Puedes ver más aquí . Por lo tanto, es diferente de imprimir word.orth_ o word.text donde estos imprimirán cadena directamente.

2) No estoy seguro acerca de word.orth_ , parece que es word.text para la mayoría de los casos. Para word.lemma_ , es la lematización de la palabra dada, por ejemplo, am , am , voy a mapear para be en word.lemma_ .

Answer 2

¿Cuál es el significado de orth, lemma, tag y pos?

Ver https://spacy.io/docs/usage/pos-tagging#pos-schemes

Qué diferencia entre print (word) vs print (word.orth_)

En súper corto:

word.orth_ y word.text son lo mismo. El hecho de que la propiedad cython termine con un guión bajo, generalmente es una variable que los desarrolladores realmente no querían exponer al usuario.

En breve:

Cuando accede a la propiedad word.orth_ en https://github.com/explosion/spaCy/blob/develop/spacy/tokens/token.pyx#L537 , intenta acceder al índice de donde se guarda todo el vocabulario de las palabras :

property orth_:
        def __get__(self):
            return self.vocab.strings[self.c.lex.orth]

(Para más detalles, vea In long para la explicación de self.c.lex.orth )

Y word.text devuelve la representación de cadena de la palabra que simplemente se ajusta a la propiedad orth_ , consulte https://github.com/explosion/spaCy/blob/develop/spacy/tokens/token.pyx#L128.

property text:
    def __get__(self):
        return self.orth_

Y cuando imprime print(word) , llama a la función __repr__ dunder que devuelve la word.__unicode__ o word.__byte__ que apunta a la variable word.text , consulte https://github.com/explosion/spaCy/ blob / develop / spacy / tokens / token.pyx # L55

cdef class Token:
    """
    An individual token --- i.e. a word, punctuation symbol, whitespace, etc.
    """
    def __cinit__(self, Vocab vocab, Doc doc, int offset):
        self.vocab = vocab
        self.doc = doc
        self.c = &self.doc.c[offset]
        self.i = offset

    def __hash__(self):
        return hash((self.doc, self.i))

    def __len__(self):
        """
        Number of unicode characters in token.text.
        """
        return self.c.lex.length

    def __unicode__(self):
        return self.text

    def __bytes__(self):
        return self.text.encode(''utf8'')

    def __str__(self):
        if is_config(python3=True):
            return self.__unicode__()
        return self.__bytes__()

    def __repr__(self):
        return self.__str__()

En larga:

Intentemos caminar paso a paso:

>>> import spacy
>>> nlp = spacy.load(''en'')
>>> doc = nlp(u''This is a foo bar sentence.'')
>>> type(doc)
<type ''spacy.tokens.doc.Doc''>

Después de pasar la oración a la función nlp() , produce un objeto spacy.tokens.doc.Doc , de los documentos:

cdef class Doc:
    """
    A sequence of `Token` objects. Access sentences and named entities,
    export annotations to numpy arrays, losslessly serialize to compressed
    binary strings.
    Aside: Internals
        The `Doc` object holds an array of `TokenC` structs.
        The Python-level `Token` and `Span` objects are views of this
        array, i.e. they don''t own the data themselves.
    Code: Construction 1
        doc = nlp.tokenizer(u''Some text'')
    Code: Construction 2
        doc = Doc(nlp.vocab, orths_and_spaces=[(u''Some'', True), (u''text'', True)])
    """

Entonces, el objeto spacy.tokens.doc.Doc es una secuencia del objeto spacy.tokens.token.Token . Dentro del objeto Token , vemos una ola de property cython enumerada, por ejemplo, en https://github.com/explosion/spaCy/blob/develop/spacy/tokens/token.pyx#L162

property orth:
    def __get__(self):
        return self.c.lex.orth

self.c = &self.doc.c[offset] , vemos que self.c = &self.doc.c[offset] :

cdef class Token:
    """
    An individual token --- i.e. a word, punctuation symbol, whitespace, etc.
    """
    def __cinit__(self, Vocab vocab, Doc doc, int offset):
        self.vocab = vocab
        self.doc = doc
        self.c = &self.doc.c[offset]
        self.i = offset

Sin una documentación exhaustiva, no sabemos realmente qué significa self.c , pero desde el punto de vista de ello, se está accediendo a uno de los tokens dentro de la referencia &self.doc apunta al Doc doc que se pasó a la función __cinit__ . Entonces, lo más probable es que sea un atajo para acceder a los tokens

Mirando el Doc.c :

cdef class Doc:
    def __init__(self, Vocab vocab, words=None, spaces=None, orths_and_spaces=None):
        self.vocab = vocab
        size = 20
        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))
        cdef int i
        for i in range(size + (PADDING*2)):
            data_start[i].lex = &EMPTY_LEXEME
            data_start[i].l_edge = i
            data_start[i].r_edge = i
        self.c = data_start + PADDING

Ahora vemos que el Doc.c se refiere a una matriz de puntero data_start que asigna la memoria para almacenar el objeto spacy.tokens.doc.Doc ( spacy.tokens.doc.Doc si obtengo la explicación <TokenC*> incorrecta).

Volviendo a self.c = &self.doc.c[offset] , básicamente intenta acceder al punto de memoria donde está almacenada la matriz y más específicamente acceder al elemento "offset-th" en la matriz.

Eso es lo que spacy.tokens.token.Token es.

Volviendo a la property :

property orth:
    def __get__(self):
        return self.c.lex.orth

Vemos que self.c.lex está accediendo al data_start[i].lex desde spacy.tokens.doc.Doc y self.c.lex.orth es simplemente un entero que indica el índice de la ocurrencia de la palabra que está mantenido en el vocabulario interno de spacy.tokens.doc.Doc .

Por lo tanto, vemos que la property orth_ intenta acceder a self.vocab.strings con el índice de self.c.lex.orth https://github.com/explosion/spaCy/blob/develop/spacy/tokens/token.pyx # L162

property orth_:
        def __get__(self):
            return self.vocab.strings[self.c.lex.orth]