Entrenamiento directo de HMM con NLTK

Comparto el codigo del reto:

# Instalamos conllu para leer el corpus
!pip install conllu
from conllu import parse_incr 
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8") 

# Bajamos el corpus de AnCora
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git

# Hacemos la transformacion del corpus al formato requerido
wordList = []
for tokenlist in parse_incr(data_file): 
  wordList2 = []
  for token in tokenlist:
    tag = token['upos']
    valor = token['form']
    wordList2.append((valor,tag)) 
  wordList.append(wordList2)

import nltk
from nltk.tag import hmm
from sklearn.model_selection import train_test_split

# Separamos el corpus
wordList_train, wordList_test= train_test_split(wordList, test_size=0.20, random_state=42)

# Entrenamos el modelo
tagger = hmm.HiddenMarkovModelTrainer().train_supervised(wordList_train)
tagger

print(tagger.evaluate(wordList_test))
print(tagger.evaluate(wordList_train))```

Resultados:
0.31126978000771904 - Conjunto de pruebas 
0.9839608987591051 - Conjunto de entrenamiento

Pareciera que hay problemas de overfitting. En ambos casos con los conjuntos de entrenamiento obtengo resultados del 98%.

Pero con los datos de prueba no obtengo ni siquiera el 30%.

Cuando digo ambos casos me refiero tanto a el ejercicio que hizo el profe, como al ejercicio propuesto

La precisión del modelo usando datos de prueba arroja resultados alrededor del 35 - 36%, lo cual es bastante bajo. Para aumentar el rendimiento se puede usar
HiddenMarkovModelTagger en vez de HiddenMarkovModelTrainer(), obteniendo resultados de mas del 93%. El código quedarí así:

tagger = hmm.HiddenMarkovModelTagger.train(train_data)
tagger.evaluate(treebank.tagged_sents()[3900:])```

!pip install conllu
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git
from conllu import parse_incr

data_file = open("UD_Spanish-AnCora/es_ancora-ud-train.conllu", "r", encoding="utf-8")
data_array = []
for tokenlist in parse_incr(data_file):
  tokenized_text = []
  for token in tokenlist:
    tokenized_text.append((token['form'], token['upos']))
  data_array.append(tokenized_text)

from sklearn.model_selection import train_test_split
train_data, test_data = train_test_split(data_array, test_size=0.2, random_state=42)
print(len(train_data))
print(len(test_data))

from nltk.tag import hmm
tagger = hmm.HiddenMarkovModelTrainer().train_supervised(train_data)
tagger

tagger = hmm.HiddenMarkovModelTrainer().train_supervised(data_array)

data_file = open("UD_Spanish-AnCora/es_ancora-ud-train.conllu", "r", encoding="utf-8")
test_array = []
for tokenlist in parse_incr(data_file):
  tokenized_text = []
  for token in tokenlist:
    tokenized_text.append((token['form'], token['upos']))
  test_array.append(tokenized_text)
len(test_array)

Es un reto absorber todos los conceptos que manejamos, el reto ha sido excelente para afianzar conocimientos.

# Instalacion de dependencias
!pip install conllu
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git

# lectura del corpus AnCora 
from conllu import parse_incr 
wordList = []
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8")

# Creacion de dataset acorde estructura
corpusphrases = [corpusphrases for corpusphrases in parse_incr(data_file)]
tokenlist = [[(token['form'], token['upos']) for token in tokenlist] for tokenlist in corpusphrases]

# Split del dataset
from sklearn.model_selection import train_test_split
train_data, test_data = train_test_split(tokenlist, test_size=0.20)

# Entrenamiento del modelo HMM pre-construido en NLTK
from nltk.tag import hmm
tagger = hmm.HiddenMarkovModelTrainer().train_supervised(train_data)
tagger

Resultados

tagger.tag("El gobernante, con ganada fama desde que llegó hace 16 meses al poder".split())

[('El', 'DET'),
 ('gobernante,', 'DET'),
 ('con', 'DET'),
 ('ganada', 'DET'),
 ('fama', 'DET'),
 ('desde', 'DET'),
 ('que', 'DET'),
 ('llegó', 'DET'),
 ('hace', 'DET'),
 ('16', 'DET'),
 ('meses', 'DET'),
 ('al', 'DET'),
 ('poder', 'DET')]

Evaluacion de Accuracy del modelo

# Evaluacion del modelo 
print(f'Accuracy para test_Data {tagger.evaluate(test_data)}')
print(f'Accuracy para train_Data {tagger.evaluate(train_data)}')

Accuracy para test_Data 0.30348027842227376
Accuracy para train_Data 0.9838748322790876

Quiero compartir un resultado curioso,

Esta frase tiene una coma ( , )

tagger.tag("Hola, te hablo desde el planeta Marte".split())

Resultado:

[('Hola,', 'PROPN'),
 ('Te', 'PROPN'),
 ('hablo', 'PROPN'),
 ('desde', 'PROPN'),
 ('el', 'PROPN'),
 ('planeta', 'PROPN'),
 ('marte', 'PROPN')]

Y sin la coma funciona mejor
tagger.tag("Hola Te hablo desde el planeta marte".split())

Resultado:

[('Hola', 'INTJ'),
 ('Te', 'PRON'),
 ('hablo', 'VERB'),
 ('desde', 'ADP'),
 ('el', 'DET'),
 ('planeta', 'NOUN'),
 ('marte', 'PROPN')]

Qué opinión les merece?

# Instalamos conllu para leer el corpus
!pip install conllu
from conllu import parse_incr 
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8") 

# Pre-procesamos para que coincidan los formatos
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8")
for tokenlist in parse_incr(data_file):
    line = []
    for token in tokenlist:
        line.append((token["form"],token["upos"]))
    if(len(data) == 0):
        data = [line]
    else:
        data.append(line)

# Dividimos train y validation data
train_data = data[:round(len(data) * 0.9)]
validation_data = data[round(len(data) * 0.9):]

# Entrenamiento
from nltk.tag import hmm
tagger = hmm.HiddenMarkovModelTrainer().train_supervised(train_data)
tagger.tag("El mundo es pequeño".split())

# Validación
tagger.evaluate(validation_data)
##  El resultado es: 0.9857319695094143

Comparto mi solución al reto 😃

0. Dependencias Previas

# traer el corpus y la libreria para leerlo
!pip install conllu
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git

# libreria para leer el corpus
from conllu import parse_incr
# importar el modelo
from nltk.tag import hmm

1. Pre-procesamiento:

# abrimos el archivo
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8")

corpus = [] # esta sera esa estructura
tag_type = 'upos' # convencion para los tags

# iteramos el corpus de palabras
for tokenlist in parse_incr(data_file):
  frase = []
  for token in tokenlist:
    frase.append(tuple([token['lemma'], token[tag_type]]))
  corpus.append(frase)

sample = int(len(corpus)*.8) # porcentaje de entrenamiento
train_data = corpus[:sample] # 80% de entrenamiento
test_data = corpus[sample-len(corpus):] # 20 para testeo

2. Entrenamiento

tagger = hmm.HiddenMarkovModelTrainer().train_supervised(train_data)

3. Validación del modelo:

# @title Training accuracy
tagger.evaluate(train_data)

# @title Test accuracy
tagger.evaluate(test_data)

Este es mi ejercicio. espero les ayude

#Obtenemos el corpus 
!pip install conllu
from conllu import parse_incr  #Leer dato en archivo conlu
sentences = []
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8")
#Leemos las oraciones que se presentan
for tokenlist in parse_incr(data_file):
    #obtenemos oración individual	
    sentence = []
    for token in tokenlist:
      sentence.append((token['form'], token['upos']))
    #Agregamos a lista de oraciones 
    sentences.append(sentence)

# Separamos el corpus en train y test
from sklearn.model_selection import train_test_split

sentences_train, sentences_test= train_test_split(sentences, test_size=0.20, random_state=12)

#Realizamos el entrenamiento con NLTK
import nltk
from nltk.tag import hmm

tagger = hmm.HiddenMarkovModelTrainer().train_supervised(sentences_train)
tagger

#Probamos alguna oración
print(tagger.tag('los días pasan bien'.split()))

#Observamos el porcentaje del modelo 
accuracy_train =  tagger.evaluate(sentences_train)
accuracy_test = tagger.evaluate(sentences_test)

print(accuracy_train)
print(accuracy_test)

Probe test del corpus del ingles aunque solo son 15 documentos se obtuvo 35%

tagger.evaluate(treebank.tagged_sents()[3900:])

Mi código del reto es el siguiente:

from conllu import parse_incr
from sklearn.model_selection import train_test_split
from nltk.tag import hmm

ancora = open('UD_Spanish-AnCora/es_ancora-ud-dev.conllu', 'r', encoding='utf-8')
corpus_tag = []
token_tag = []
for tokenlist in parse_incr(ancora):
  for token in tokenlist:
    token_tag.append((token['form'], token['upos']))
  corpus_tag.append(token_tag)
  token_tag = []

data_train, data_test = train_test_split(corpus_tag, test_size=0.2, random_state=1)

tagger = hmm.HiddenMarkovModelTrainer().train_supervised(data_train)

tagger.evaluate(data_train) # 0.9840099556223438
tagger.evaluate(data_test) # 0.359907276758718

tagger.tag('el partido de futbol'.split())

Resultado:

[('el', 'DET'), ('partido', 'NOUN'), ('de', 'ADP'), ('futbol', 'ADP')]

Usé como prueba la frase “Mr. Vinken is chairman of Elsevier N.V., the Dutch publishing group.” con la siguiente línea de código

tagger.tag("Mr. Vinken is chairman of Elsevier N.V., the Dutch publishing group.".split())

el resultado fue

[('Mr.', 'NNP'),
 ('Vinken', 'NNP'),
 ('is', 'VBZ'),
 ('chairman', 'NN'),
 ('of', 'IN'),
 ('Elsevier', 'NNP'),
 ('N.V.,', 'NNP'),
 ('the', 'NNP'),
 ('Dutch', 'NNP'),
 ('publishing', 'NNP'),
 ('group.', 'NNP')]

Analizando del original, falló en etiquetar tres palabras de once: Elsevier, publishing y group..

Mi código del reto:

# Instalación de dependencias previas
!pip install conllu
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git
from conllu import parse_incr 
from sklearn.model_selection import train_test_split
import nltk
from nltk.tag import hmm

# 1. FASE DE PRE-PROCESAMIENTO
tagtype = 'upos'
wordtype = 'from'
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8")

lista_AnCora = []
for tokenlist in parse_incr(data_file): # For para recorrer el corpus.
  lista_prov = []
  for token in tokenlist:  # For para recorrer cada lista de tokens de forma individual.
    word = token[wordtype].lower()
    tag = token[tagtype]
    wordtag = (word, tag)
    lista_prov.append(wordtag)
  lista_AnCora.append(lista_prov)

print(lista_AnCora)

# 2. FASE DE ENTRENAMIENTO
lista_AnCora_train, lista_AnCora_test = train_test_split(lista_AnCora, test_size=0.2, random_state=1)
modelo = hmm.HiddenMarkovModelTrainer().train_supervised(lista_AnCora_train)

# 3. FASE DE VALIDACIÓN DEL MODELO
print('Precisión set de entrenamiento: ', modelo.evaluate(lista_AnCora_train))
print('Precisión set de validación:    ', modelo.evaluate(lista_AnCora_test))

RESULTADOS:
0.9753457465542745 - Train
0.37714170530135055 - Test

En el notebook alterno donde se cargó la solución se evalúa nuevamente con el set de train para ancora. Aunque cuando se usa el Ancora-test el accuracy es bastante pobre, cerca de 0.5.

Comparto mi codigo del reto, use el archivo es_ancora_ud_train.conllu:

# funcion que nos permite leer los datos que viene de un archivo en formato conllu
from conllu import parse_incr
dataList = []
data_file = open("UD_Spanish-AnCora/es_ancora-ud-train.conllu", "r", encoding="utf-8")
for tokenlist in parse_incr(data_file):
    #print(tokenlist.serialize())
    tokenized_text = []
    for token in tokenlist:
        tokenized_text.append((token['form'], token['upos']))
    dataList.append(tokenized_text)

from sklearn.model_selection import train_test_split
train_data, test_data = train_test_split(dataList, test_size=0.2, random_state=42)
print(len(train_data))
print(len(test_data))
print(len(dataList))

11444
2861
14305

tagger = hmm.HiddenMarkovModelTrainer().train_supervised(train_data)
tagger

<HiddenMarkovModelTagger 18 states and 34205 output symbols>```

# training accuracy
print("The accuracy of the Training set is {:.1f}%".format(tagger.evaluate(train_data) * 100))

The accuracy of the Training set is 98.0%

# test accuracy
print("The accuracy of the Test set is {:.1f}%".format(tagger.evaluate(test_data) * 100))

The accuracy of the Test set is 50.2%

Les adjunto mi código espero que les sirva. Solo recuerden que el doble for se usa porque son diccionarios dentro de otro diccionario.

Parte 1A.

!pip install conllu # me permite trabajar con corpus estandarizados.
!git clone https://github.com/UniversalDependencies/UD_Spanish-AnCora.git
!pip install nltk

import nltk
from conllu import parse_incr

data_file = open('/content/UD_Spanish-AnCora/es_ancora-ud-dev.conllu', 'r', encoding='utf-8')

Parte 1B.

# formato solicitado [ (word, tag), (word, tag), ***, (word, tag) ]
tag = 0
word = 0

wordsWithTag = []

for tokenList in parse_incr(data_file):

  wordList = []
  for token in tokenList:

    tag = token['upos']
    word = token['form']
    wordList.append( (word, tag) )

  wordsWithTag.append( wordList )

wordsWithTag

Parte 2A.

import nltk 

from nltk.tag import hmm
from sklearn.model_selection import train_test_split

Parte 2B.

wordsWithTag_train, wordsWithTag_test = train_test_split(wordsWithTag, test_size=0.20)

Parte 3A.

#tagger = hmm.HiddenMarkovModelTrainer().train(wordsWithTag_train) - no usar
tagger = hmm.HiddenMarkovModelTagger.train(wordsWithTag_train)
tagger

Parte 3B.

print('TEST: ', tagger.evaluate(wordsWithTag_test) )
print('TRAIN: ', tagger.evaluate(wordsWithTag_train) )

TEST:  0.8982876391877983
TRAIN:  0.9703041315990819

Mi código:

#pre-procesamiento
from conllu import parse_incr 
wordList = []
data_file = open("UD_Spanish-AnCora/es_ancora-ud-dev.conllu", "r", encoding="utf-8")

for tokenlist in parse_incr(data_file):
  temp = []
  for token in tokenlist:
   temp.append((token['form'],token['upos']))
  wordList.append(temp)
train_data = wordList[:1489]
train_data
#Entrenamiento
tagger = hmm.HiddenMarkovModelTagger.train(train_data)
tagger
#validación
tagger.evaluate(wordList[1489:]) #Accuracy = 0.88