def traintag(corpusname, corpus):
def savetagger(tagfilename,tagger):
outfile = open(tagfilename, 'wb')
dump(tagger,outfile,-1); outfile.close()
return
# Training UnigramTagger.
uni_tag = ut(corpus)
savetagger(corpusname+'_unigram.tagger',uni_tag)
# Training BigramTagger.
bi_tag = bt(corpus)
savetagger(corpusname+'_bigram.tagger',bi_tag)
print ("Tagger trained with",corpusname,"using" +\
"UnigramTagger and BigramTagger.")
return
def traintag(corpusname, corpus):
# Function to save tagger.
def savetagger(tagfilename, tagger):
outfile = open(tagfilename, 'wb')
dump(tagger, outfile, -1)
outfile.close()
return
# Training UnigramTagger.
uni_tag = ut(corpus)
savetagger(corpusname + '_unigram.tagger', uni_tag)
# Training BigramTagger.
bi_tag = bt(corpus)
savetagger(corpusname + '_bigram.tagger', bi_tag)
print "Tagger trained with",corpusname,"using" +\
"UnigramTagger and BigramTagger."
return
with open("sentence-pt") as content_file:
content = content_file.read()
content = normalize(content)
tokens = word_tokenize(content)
sents = floresta.tagged_sents()
uni_tag = ut(sents)
print uni_tag.tag(tokens)
# Split corpus into training and testing set.
train = int(len(sents) * 90 / 100) # 90%
# Train a bigram tagger with only training data.
bi_tag = bt(sents[:train])
# Evaluates on testing data remaining 10%
bi_tag.evaluate(sents[train + 1 :])
# Using the tagger.
print bi_tag.tag(tokens)
# tokens = word_tokenize(content)
# print tokens
#
# tagged = pos_tag(tokens)
#
# entities = chunk.ne_chunk(tagged)
# print entities
from nltk import BigramTagger as bt # El tagger (de a dos palabras)
# Leemos el corpus a una lista
# Cada entrada de la lista es una frase
cess_sents = cess.tagged_sents()
# Dividimos el corpus en dos partes: entrenamiento y testeo
train = int(len(cess_sents) * 90 / 100) # 90% entrenamiento
import pickle
crear_taggers = True
if crear_taggers:
# Entrenamos el tagger de unigramas (no tiene caso el testeo con unigramas)
uni_tag = ut(cess_sents)
# Entramos el tagger de bigramas con sólamente la data de entrenamiento
bi_tag = bt(cess_sents[:train])
# Guardamos los taggers en archivos para ahorrar tiempo la siguiente vez
with open('test/cess_unigram.tagger.pkl', 'wb') as output:
pickle.dump(uni_tag, output, pickle.HIGHEST_PROTOCOL)
with open('test/cess_bigram.tagger.pkl', 'wb') as output:
pickle.dump(bi_tag, output, pickle.HIGHEST_PROTOCOL)
# Evaluamos en los datos de testeo, el 10% restante
evaluacion = bi_tag.evaluate(cess_sents[train + 1:])
print u"\nEvaluación:"
print evaluacion
else:
# Si ya están generados los taggers podemos simplemente abrirlos
with open('test/cess_unigram.tagger.pkl', 'rb') as input:
uni_tag = pickle.load(input)
uni_tagger.evaluate(cess_sents[fraction+1:])
# Al final se obtiene la métrica de la asignación de etiquetas
"""Aplicamos el algoritmo previamente entrenado y evaluado"""
uni_tagger.tag("Yo soy una persona muy amable".split(" "))
"""## @title Entrenamiento del tagger por bigramas"""
# Obtenemos un fracción del Dataset
fraction = int(len(cess_sents)*90/100)
# Definimos una instancia del etiquetador por bigramas
# Le pasamos una francción del Dataset para realizar el entrenamiento
# Lo entrenamos con el 90% del conjunto de datos
bi_tagger = bt(cess_sents[:fraction])
# Despues de entrenar hacemos la evaluación con el resto del Dataset
bi_tagger.evaluate(cess_sents[fraction+1:])
# Al final se obtiene la métrica de la asignación de etiquetas
bi_tagger.tag("Yo soy una persona muy amable".split(" "))
"""<font color="green"> Al analizar las pruebas previamente descritas podemos decir que el etiquetador por `unigramas` es mejor que el etiquedador por `bigramas` y no se recomienda usar el segundo </font>
# Etiquetado mejorado con Stanza (StanfordNLP)
**¿Que es Stanza?**
* El grupo de investigacion en NLP de Stanford tenía una suite de librerias que ejecutaban varias tareas de NLP, esta suite se unifico en un solo servicio que llamaron **CoreNLP** con base en codigo java: https://stanfordnlp.github.io/CoreNLP/index.html
def __init__(self):
cess_sents = cess.tagged_sents()
self.uni_tag = ut(cess_sents)
train = int(len(cess_sents)*90/100) # 90%
self.bi_tag = bt(cess_sents[:train])
self.bi_tag.evaluate(cess_sents[train+1:])
reload(sys)
sys.setdefaultencoding('utf8')
cess_sents = cess.tagged_sents()
uni_tag = ut(cess_sents)
f = open('texto.txt')
tagged_words = nltk.word_tokenize(f.read())
uni_tag.tag(tagged_words)
train = int(len(cess_sents) * 90 / 100)
bi_tag = bt(cess_sents[:train], backoff=uni_tag)
bi_tag.evaluate(cess_sents[train + 1:])
taggedText = bi_tag.tag(tagged_words)
labeled_names = ([word, tag] for word, tag in taggedText)
featuresets = [(word_features(n), tag) for (n, tag) in labeled_names]
for item in featuresets:
print(item)
train_set, test_set = featuresets[250:], featuresets[:250]
clasiffier = nltk.NaiveBayesClassifier.train(train_set)
print(clasiffier.show_most_informative_features(10))
