NLTK (e)

nltk.parse de análisis

1). Gramáticas libres de contexto

2). Analizador descendente recursivo

3). El análisis de gráfico, programación dinámica

de nltk.parse importación * 
parser = CoreNLPParser (url = ' http: // localhost: 9966 ' ) 

tokens = ' Rami Eid está estudiando en la Universidad Stony Brook en Nueva York ' .split () 
parser.tag (fichas)

Ver código

etiquetado del habla nltk.tag

interfaz unificada

clase TaggerI (metaclase = ABCMeta):
     """ 
    interfaz de procesamiento de A para asignar una etiqueta a cada ficha en una lista. 
    Las etiquetas son caso cuerdas sensibles que identifican alguna propiedad de cada 
    ficha, tales como su parte de la oración o de su sentido. 

    Algunos grafiteros requerir tipos específicos por sus fichas. Esto se 
    indicado en general por el uso de un sub-interfaz para `` TaggerI``. 
    por ejemplo, taggers featureSet, que son una subclase de 
    `` FeaturesetTagger``, requieren que cada token ser un `` . featureset`` 

    subclases debe definir: 
      - tag o bien `` () `` o `` tag_sents () `` (o ambos) 
    """ 

[docs] @abstractmethod 
    deftag (self, tokens):
         """ 
        determinar la secuencia de etiqueta adecuada más para la dada 
        secuencia de tokens, y devolver una lista correspondiente de etiquetadas 
        tokens A etiquetada contador se codifica como una tupla` `(token, etiqueta)` `.. 

        : RTYPE: lista (tupla (str, str)) 
        "" " 
        si sobrescritos (self.tag_sents):
             retorno self.tag_sents ([tokens]) [0] 


[documentos]     def tag_sents (self, oraciones):
         """ 
        Aplicar ` `self.tag ()` `para cada elemento de frases * * Es decir:. 

            retorno [self.tag (enviado) de enviado en oraciones] 
        """ 
        retorno [auto.tag (enviado) para enviadoen oraciones] 


[documentos]     def evaluar (auto, oro):
         """ 
        . Puntuación la precisión del etiquetador contra el estándar de oro 
        de Gaza las etiquetas de texto estándar de oro, volver a etiquetar utilizando 
        el etiquetador, a continuación, calcular el nivel de acierto. 

        : tipo de oro: lista (lista (tupla (str, str))) 
        : el oro param: la lista de frases seleccionadas al marcar el etiquetador de. 
        : RTYPE: float 
        """ 

        tagged_sents = self.tag_sents (untag (enviado) de enviado en oro) 
        gold_tokens = lista (cadena (* oro)) 
        test_tokens = lista (cadena (*tagged_sents))
         de retorno exactitud (gold_tokens, test_tokens) 


    def _check_params (auto, tren, modelo):
         si (tren y modelo) o ( no entrenar y  no modelo):
             aumento ValueError ( "Debe especificar datos de entrenamiento o modelo entrenado " )

Ver código

de nltk.tag importación CRFTagger 
ct = CRFTagger () 
train_data = [[( ' Universidad ' , ' Sustantivo ' ), ( ' es ' , ' Verbo ' ), ( ' un ' , ' Det ' ), ( ' bueno ' , ' Adj ' ), ( ' lugar ' , ' Noun ' )], 
ct.train (train_data, 'model.crf.tagger ' ) 
ct.tag_sents ([[ ' perro ' ' es ' ' bueno ' ], [ ' Cat ' ' comer ' ' carne ' ]])

Ver código