Trabajo Práctico 1 - Etiquetado de Secuencias

(volver a la página principal)

En este trabajo práctico implementaremos modelos de etiquetado de secuencias y realizaremos experimentos con ellos.

• Repositorio: https://github.com/PLN-FaMAF/pln-uba-2019.
• Fecha de entrega: lunes 16/9 a las 23:59.

El código base para el proyecto se encuentra en el repositorio de la materia. La entrega del proyecto es a través de github. Por lo tanto, deben hacer un “fork” del repositorio dentro de sus cuentas de github.

Además del código fuente, deben elaborar un README con una breve explicación de lo que hicieron en cada ejercicio. El README puede estar en texto plano (txt), markdown (md) o restrucured text (rst), y debe estar incluído dentro de la carpeta tagging.

Criterios de Evaluación:

• Estilo de codificación (chequeado con flake8 y a ojo).
• Diseño del código: uso de clases, herencia, etc.
• Uso y aprobación de tests (provistos y definidos por uds.).
• Uso apropiado de git (commits granulares, logs informativos).
• Resultados.
• README.

Programar un script stats.py que muestre la siguiente información del corpus:

• Estadísticas básicas:
  • Cantidad de oraciones.
  • Cantidad de ocurrencias de palabras.
  • Cantidad de palabras (vocabulario).
  • Cantidad de etiquetas (vocabulario de tags).
• Etiquetas más frecuentes: Una tabla con las 10 etiquetas más frecuentes y la siguiente información para cada una:
  • Cantidad de veces que aparece (frecuencia), y porcentaje del total.
  • Cinco palabras más frecuentes con esa etiqueta.
  • En el README, agregar a mano una breve descripción del significado de la etiqueta.
• Niveles de ambigüedad de las palabras: Una figura similar a la Figura 5.10 de Jurafsky & Martin (2008). Para cada nivel de ambigüedad (de 1 a 9) mostrar:
  • Cantidad de palabras y porcentaje del total.
  • Cinco palabras más frecuentes.
• Incluir todas las estadísticas en el README.

Uso del script:

$ python tagging/scripts/stats.py -c ancora-3.0.1es

Documentación:

• Notebook: 1. Etiquetado de Secuencias: Parte 1
• Corpus AnCora
• Etiquetas EAGLES
• Stanford CoreNLP simplified tagset

• Programar un etiquetador baseline, que elija para cada palabra su etiqueta más frecuente observada en entrenamiento.
• Para las palabras desconocidas, devolver la etiqueta 'nc0s000' (nombre común singular).
• Entrenar y evaluar el modelo baseline del ejercicio anterior. Reportar los resultados en el README.
• Bonus: Graficar la matriz de confusión como un mapa de calor (ver documentación abajo).

Interfaz de BaselineTagger en baseline.py:

class BaselineTagger:
 
    def __init__(self, tagged_sents, default_tag='nc0s000'):
        """
        tagged_sents -- training sentences, each one being a list of pairs.
        default_tag -- tag for unknown words.
        """
 
    def tag(self, sent):
        """Tag a sentence.
 
        sent -- the sentence.
        """
 
    def tag_word(self, w):
        """Tag a word.
 
        w -- the word.
        """
 
    def unknown(self, w):
        """Check if a word is unknown for the model.
 
        w -- the word.
        """

Tests:

$ nosetests tagging/tests/test_baseline.py 

Ejemplo de uso de los scripts:

$ python tagging/scripts/train.py -c ancora-3.0.1es -m base -o baseline
$ python tagging/scripts/eval.py -c ancora-3.0.1es -i baseline

Documentación:

• Notebook: 2. Etiquetado de Secuencias: Parte 2
• http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html

• Implementar en classifier.py un tagger que utilice un clasificador para etiquetar cada palabra en base a la información disponible en una ventana alrededor de la palabra.
• Definir el vectorizador con los siguientes features:
  • la palabra actual en minúsculas.
  • si la palabra actual empieza en mayúsculas.
  • si la palabra actual está en mayúsculas.
  • si la palabra actual es un número.
  • mismos features para la palabra anterior y para la siguiente.
• Probar los siguientes clasificadores:
  • sklearn.linear_model.LogisticRegression
  • sklearn.naive_bayes.MultinomialNB
  • sklearn.svm.LinearSVC
• Agregar al script de entrenamiento (train.py) una opción de línea de comandos que permita utilizar estos clasificadores.
• Entrenar y evaluar. Reportar los resultados en el README. Reportar también tiempos de entrenamiento y evaluación.

Interfaz de ClassifierTagger en classifier.py:

class ClassifierTagger:
    """Simple and fast classifier based tagger.
    """
 
    def __init__(self, tagged_sents, clf='lr'):
        """
        clf -- classifying model, one of 'svm', 'lr' (default: 'lr').
        """
 
    def fit(self, tagged_sents):
        """
        Train.
        tagged_sents -- list of sentences, each one being a list of pairs.
        """
 
    def tag_sents(self, sents):
        """Tag sentences.
        sent -- the sentences.
        """
 
    def tag(self, sent):
        """Tag a sentence.
        sent -- the sentence.
        """
 
    def unknown(self, w):
        """Check if a word is unknown for the model.
        w -- the word.
        """

Tests:

$ nosetests tagging/tests/test_classifier.py 

Documentación:

• Notebook: 3. Etiquetado de Secuencias: Parte 3

• En una notebook, hacer análisis de errores del clasificador anterior.
• Proponer e implementar nuevos features a partir de este análisis.
• Entrenar y evaluar. Verificar la utilidad de los nuevos features propuestos.
• Reportar los resultados en el README.

Documentación:

• Notebook: 2. Etiquetado de Secuencias: Parte 2

• Agregar word embeddings fastText a los features clasificador del ejercicio anterior.
  • Usar el vectorizador provisto en fasttext.py.
• Usar los modelos pre-entrenados para el idioma castellano ofrecidos por fastText.
• Entrenar, evaluar y reportar resultados y tiempos en el README.

Documentación:

• fastText
  • Instalación
  • Modelos pre-entrenados