Entrenamiento y Decodificación de Modelos Marcobianos en Bitterbi

Curso de Algoritmos de Clasificación de Texto

Contenido del curso

Desambiguación y etiquetado de palabras

Modelos Markovianos Latentes (HMM)

Algoritmo de Viterbi

Modelos Markovianos de máxima entropía (MEMM)

Clasificación de texto con NLTK

Implementación de un modelo de clasificación de texto

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:003:23

Entrenamiento y Decodificación de Modelos Marcobianos en Bitterbi

Curso de Algoritmos de Clasificación de Texto

Clase 16 de 26

Clase 16 / 26

Recursos

¿Cómo enfrentar el primer gran reto de codificación?

Te encuentras en la encrucijada de un emocionante desafío en tu camino hacia la ofimática en machine learning. Este primer gran reto consiste en escribir, desde cero, un código para entrenar y decodificar un modelo markoviano de máxima entropía utilizando el algoritmo de Viterbi. Este ejercicio no solo pone a prueba tus conocimientos adquiridos hasta ahora, sino que también te brinda la oportunidad de innovar y descubrir soluciones más eficientes y elegantes.

¿Qué estrategias puedes tomar para el entrenamiento del modelo?

La primera fase fundamental de este reto es el entrenamiento de tu modelo markoviano de máxima entropía.

Utilizar el notebook base: Ya cuentas con un notebook detallado como base. Analiza su estructura y lógica, y modifícalo según las necesidades específicas de tu modelo.
Ajuste personalizado: El poder de personalizar y modificar el código te permitirá adaptar las metodologías generales a las particularidades del marco de máxima entropía, optimizando su rendimiento.
Revisión de conceptos: Revisa los conceptos teóricos necesarios para esta fase si es necesario, con el fin de reforzar tu comprensión y enfoque.

¿Cómo abordar la decodificación con el algoritmo de Viterbi?

El algoritmo de Viterbi es crucial en la segunda fase del reto: la decodificación. Este paso es fundamental para determinar el camino óptimo de un sistema estocástico, y aquí te damos algunos consejos:

Partir del notebook detallado: De igual manera que en la fase de entrenamiento, se dispone de un código claro y detallado que puede servir de base. No dudes en adaptarlo para alinearlo con los requisitos de un modelo markoviano de máxima entropía.
Experimentación y ajuste: Asegúrate de experimentar con el código y realizar ajustes hasta lograr el desempeño deseado. Esto fomenta el aprendizaje incremental y puede llevarte a mejoras innovadoras.
Incorporación de métodos alternativos: La flexibilidad para probar otros recursos y comparar distintas metodologías te ayudará a enriquecer y afinar constantemente tu enfoque.

¿Por qué es importante compartir y comparar soluciones?

La riqueza de este reto radica en compartir tu trabajo y cotejarlo con las soluciones de tus compañeros y del instructor. Este intercambio no solo te permite aprender de otros enfoques, sino que también afina tus habilidades al identificar diferencias y similitudes.

Colaboración y retroalimentación: Compartir tu código en la sección de comentarios y con otros estudiantes fomentará un ambiente colaborativo. Aceptar críticas constructivas puede ayudarte a mejorar.
Análisis comparativo: Al comparar tu solución con otras, puedes descubrir nuevas oportunidades de optimización o estilos de programación que no habías considerado.

Muéstrate siempre dispuesto a aprender y ajustar tu enfoque. Al finalizar, podrás discutir y observar diversas formas de resolver el reto, enriqueciéndote así con una visión más amplia del problema.

En resumen, la buena programación es una combinación de conocimiento, creatividad y colaboración. ¡Sumérgete en este reto, da lo mejor de ti y sigue descubriendo el apasionante mundo del machine learning!

Omar Larasa

Hace 6 años

Hola, aquí deje mi solución al reto, al final traté de compactar todo en una clase para el modelo y una función extra para plotear la matriz de Viterbi. El código fue el siguiente:

Importación de librerías y recursos

###### COSAS IMPORTANTES, CORRER AL INICIO

# cargamos el dataset o corpus
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git
# librerias
!pip3 install conllu
!pip3 install stanza
import numpy as np # para el manejo de la mtriz de Viterbi
import stanza # queremos el tokenizador en español
stanza.download('es') # descargamos el paquete de español

# cosas para plotear la matriz de viterbi
import seaborn as sn # para plotear
import matplotlib.pyplot as plt
import pandas as pd # para organizar la matriz

# funcion para leer el conllu
from conllu import parse_incr

El modelo y la función para leer el corpus

 # todas las etiquetas
tags = {'ADJ','ADP','ADV','AUX','CCONJ','DET','INTJ','NOUN','NUM',
        'PART','PRON','PROPN','PUNCT','SCONJ','SYM','VERB','_'}

# instanciamos el tokenizador que sera de importancia
nlp = stanza.Pipeline('es', processors='tokenize')

class MEMM():

  # en el constructor que se definan los diccionarios
  def __init__(self):
    # diccionarios de conteos
    self.uniqueFeatureDict = {}
    self.contextDict = {}
    # diccionarios de las probabilidades
    self.posteriorProbDict = {}
    self.initialTagProb = {}
    # diccionario de tags con ids
    self.tagsDict = {}

  # ayudante para contar en diccionarios
  def __count_dict(self, dic, key):
    if key in dic.keys():
      # si ya esta le sumamos 1
      dic[key] += 1
    else:
      # si no la iniciamos en 1
      dic[key] = 1
    return dic

  # privado, conteo que se usara en entrenamiento
  def __counts(self, para_list): # paragraph_list*
    # uniqueFeatureDict = {} # C(tag|word,prevtag)
    # contextDict = {} # C(word|prevtag)
    # iterar los "parrafos" del dataset
    for para in para_list:
      prevtag = "None"# al inicio no hay tag previo
      # iterar las palabras del "parrafo"
      for token in para:
        # leemos la palabra y tag del token
        word, tag = token[0], token[1]

        ########## CONTEO PARA uniqueFeatureDict C(tag|word,prevtag)
        # definimos la clave para el diccionario
        ufd_key = tag + '|' + word + ',' + prevtag
        self.uniqueFeatureDict = self.__count_dict(self.uniqueFeatureDict, ufd_key)
        
        ########## CONTEO PARA contextDict C(word|prevtag)
        # definimos la clave para el diccionario
        cd_key = word + ',' + prevtag
        self.contextDict = self.__count_dict(self.contextDict, cd_key)

        # al final el tag será el prevtag
        prevtag = tag

  # probabilidades, igual privada, para el entrenamiento
  def __probs(self):
    # iteramos las claves del ciccionario
    for key in self.uniqueFeatureDict.keys():
      if len(key.split('|'))==3: # cae un caso, es algo raro por lo que vi
        # clave para el contextDict
        cd_key = '|'+key.split('|')[-1]
        # efectuamos el calculo
        self.posteriorProbDict[key] = self.uniqueFeatureDict[key]/self.contextDict[cd_key]
        # el caso que cayo fue [ SYM||,NOUN ], al parecer el dataset contuvo un
        # caso en el que el texto traia un |, y lo toma como palabra
      else:
        # clave para el contextDict
        cd_key = key.split('|')[1]
        # efectuamos el calculo
        self.posteriorProbDict[key] = self.uniqueFeatureDict[key]/self.contextDict[cd_key]
  
  def __initial_count(self, data):
    # hay que enumerarlas para que el modelo prediga segun el numero del tag
    # de modo que el tagDict traera tag: id, el id será la que use le modelo
    for i, tag in enumerate(tags):
      self.tagsDict[tag] = i

    for para in data: # iteramos los parrafos
      # buscamos el tag
      tag = para[0][1]
      # y hacemos el conteo mediante la funcion de contar
      self.__count_dict(self.initialTagProb, tag)
      # ayuda para las probabilidades
    total = len(data)
    # iteramos los conteos
    for key in self.initialTagProb.keys():
      # dividir el conteo entre el total
      self.initialTagProb[key] /= total

  # entrenamiento: conteos y probabilidades
  def fit(self, data):
    # realizamos los conteos
    self.__counts(data)
    # y el calculo de las probabilidades
    self.__probs()
    # sacar las distribuciones iniciales
    self.__initial_count(data)
  
  # plotear la matriz de viterbi
  def __plot_matrix(self, matrix, seq):
    # hay que hacer un dataframe para plotear mejor
    df = pd.DataFrame(matrix, index = self.tagsDict.keys(), columns = list(seq))
    # ploteamos
    plt.figure(figsize = (10,7))
    plt.title("Predicción")
    sn.heatmap(df, annot=True)

  # algoritmo de viterbi para las predicciones, será publico
  def Viterbi(self, string, plot=False):
    if string == '':
      raise ValueError('El mensaje no puede estar vacío')
    # primero hay que tokenizar la palabra
    tok = nlp(string)
    # como queremos solo las palabras hay que hacer esto
    seq = [word.text for word in tok.sentences[0].words]
    # matriz de ceros para comenzar
    viterbiProb = np.zeros((len(self.tagsDict), len(seq)))

    # calculo de la primera columna, la especial
    for tag in self.tagsDict.keys(): 
      # buscamos la llave para el diccionario inicial
      row = self.tagsDict[tag]
      # buscamos la otra probabilidad
      key = tag + '|' + seq[0].lower() + ',' + "None"
      # efectuamos el calculo de la probabilidad el try es por
      # que la palabra puede no corresponder a el tag de la key
      try:
        viterbiProb[row, 0] = self.initialTagProb[tag] * self.posteriorProbDict[key]
      except: # si no pos no
        pass

    # calculos para las siguientes columnas o palabras
    for col in range(1, len(seq)): # iteramos las columnas
      for tag in self.tagsDict.keys(): # iteramos los tags o filas
        tag_row = self.tagsDict[tag] # seleccionamos la fila
        possible_probs = []
        # se hace doble for y possible_probs por que tambien hay que
        # intentar todas las probabilidades previas y de esas ver la
        # mas probable es decir la maxima
        for prevtag in self.tagsDict.keys(): # buscamos el tag previo
          prevtag_row = self.tagsDict[prevtag] # buscamos el row del tag previo
          # key para la probabilidad previa de viterbi
          key = tag + '|' + seq[col].lower() + ',' + prevtag
          try:
            # tratamos de buscar la probabilidad previa
            possible_probs.append(
                viterbiProb[prevtag_row, col-1] * self.posteriorProbDict[key])
          except:
            # si no pos metemos un 0
            possible_probs.append(0)
        # de ahi metemos en la matriz aquella mas probable
        viterbiProb[tag_row, col] = max(possible_probs)

    # Buscamos el resultado de la predicción
    res = []
    for i, p in enumerate(seq): # enumaramos la cadena tokenizada
      for tag in self.tagsDict.keys(): # iteramos los tags
        # vemos si el tag es el argumento maximo de la columna i
        if self.tagsDict[tag] == np.argmax(viterbiProb[:, i]):
          # si es el maximo lo agregamos junto con la palabra
          res.append((p, tag))
    # si nos pidio plotear hacemos el plot
    if plot:
      self.__plot_matrix(viterbiProb, seq)
    return res

  # para predecir hacemos el algoritmo de viterbi
  def predict(self, string, plot=False):
    # usamos el algoritmo de Viterbi y pasamos el plot
    res = self.Viterbi(string, plot)
    return res


# función para leer el dataset
def get_word_list(path, encoding='utf-8', tagtype='upos', alert=True):
  # abrir el archivo
  data_file = open(path, 'r', encoding=encoding)
  word_list = []
  # iteramos las listas de tokens procesando el conllu
  for tokenlist in parse_incr(data_file): # con parse_incr()
      paragraph_list = [] # iteramos por parrafo
      # iteramos buscando la palabra y su tag segun tagtype
      for token in tokenlist:
          # agregamos la palabra y el tag seleccionado
          word = token['form'].lower()
          tag = token[tagtype]
          paragraph_list.append((word, tag))
      word_list.append(paragraph_list) # le agregamos el parrafo
  # si hay alerta ponemos eso
  if alert:
    print(word_list[0])
  return word_list

Usando el modelo y la función

######### Usando a la función
path = "UD_Spanish-AnCora/es_ancora-ud-train.conllu"
data = get_word_list(path, alert=False)
# [(palabra, tag), ...]

# instanciamos el modelo
model = MEMM()
# lo entrenamos
model.fit(data)
# y nos divertimos con el :D
model.predict('El mundo es muy pequeño', plot=True)

Desambiguación y etiquetado de palabras

Clasificación de Texto con Machine Learning

Etiquetado de Palabras en Python con NLTK y Stanza

Uso de Stanza para Procesamiento de Lenguaje Natural en Español

Modelos Markovianos Latentes (HMM)

Modelos Marcovianos Latentes en PLN: Fundamentos y Aplicaciones

Matemáticas de Cadenas de Markov y su Aplicación en Modelos Latentes

Modelos Marcovianos Latentes: Etiquetado Gramatical Automático

Implementación de Modelos Marcovianos Latentes en Python con Google Colab

Entrenamiento de Modelos Marcobianos Latentes en Python

Algoritmo de Viterbi

Decodificación de Secuencias con el Algoritmo de Viterbi

Cálculo de Probabilidades en el Algoritmo de Viterbi

Implementación del Algoritmo de Viterbi en Python con NumPy

Implementación del Algoritmo Viterbi para Modelos Ocultos de Markov

Implementación de Modelos Ocultos de Markov en NLTK y Python

Modelos Markovianos de máxima entropía (MEMM)

Modelos Marcovianos de Máxima Entropía en Clasificación de Etiquetas

Algoritmo BiTerbi en Modelos de Máxima Entropía

Entrenamiento y Decodificación de Modelos Marcobianos en Bitterbi

Clasificación de texto con NLTK

Clasificación de Texto en Machine Learning: Teorías y Aplicaciones

Clasificación de Nombres por Género con NLTK en Python

Clasificación de Nombres con Naive Bayes en Python

Clasificación de correos: Filtrado de spam con Naive Bayes

Implementación de un modelo de clasificación de texto

Funcionamiento Matemático del Clasificador Naive Bayes

Preparación de Datos para Modelo Naive Bayes en Python

Implementación del Algoritmo Naive Bayes en Python con spaCy

Implementación del Método Predict en Naive Bayes Clasificador

Métricas de Evaluación en Modelos de Clasificación: Accuracy, Precision y Recall

Clasificación de Sentimientos con Reviews de Amazon

Entrenamiento y Decodificación de Modelos Marcobianos en Bitterbi