A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Entrenamiento directo de HMM con NLTK

13/26
Recursos

Aportes 17

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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