def run(train, test, language, answer):
results = {}
if language == 'English':
_POS_TAGGER = 'taggers/maxent_treebank_pos_tagger/english.pickle'
tagger = load(_POS_TAGGER)
elif language == 'Spanish':
tagger = ut(cess_esp.tagged_sents())
elif language == 'Catalan':
tagger = ut(cess_cat.tagged_sents())
for lexelt in train:
train_features, y_train = extract_features(train[lexelt],language,tagger)
test_features, _ = extract_features(test[lexelt],language,tagger)
X_train, X_test = vectorize(train_features,test_features)
X_train_new, X_test_new = feature_selection(X_train, X_test,y_train)
results[lexelt] = classify(X_train_new, X_test_new,y_train)
"""
B1.c
for lexelt in train:
features = getBestWords(train[lexelt], 30)
train_features = countFeature(features, train[lexelt])
_, y_train = extract_features(train[lexelt], language)
test_features = countFeature(features, test[lexelt])
X_train, X_test = vectorize(train_features, test_features)
results[lexelt] = classify(X_train, X_test, y_train)
B1.c
"""
A.print_results(results, answer)
def tonkenier(text):
cess_sents = cess.tagged_sents()
uni_tag = ut(cess_sents)
words = text.replace(",",
"").replace(".",
"").replace("\n",
"").replace("\t",
"").split(" ")
annotated_text = uni_tag.tag(words)
return annotated_text
def handling_negation(self, row):
#Tokenize the row
words = word_tokenize(row)
# Read the corpus into a list,
# each entry in the list is one sentence.
tagged_cess_sents = cess_esp.tagged_sents()
# Train the unigram tagger
uni_tag = ut(tagged_cess_sents)
# Tagger reads a list of tokens.
#uni_tag.tag(words)
print("WORDS: ", words)
print("TAGGGGS: ", uni_tag.tag(words))
'''
# Split corpus into training and testing set.
train = int(len(tagged_cess_sents)*90/100)
# Train a bigram tagger with only training data
bi_tag = bt(tagged_cess_sents[:train], backoff=uni_tag)
# Evaluates on testing data remaining 10%
bi_tag.evaluate(tagged_cess_sents[train+1:])
# Using the tagger.
#bi_tag.tag(row)
print("TAGGGGS: ",bi_tag.tag(row))
'''
speach_tags = [
'JJ', 'JJR', 'JJS', 'NN', 'VB', 'VBD', 'VBG', 'VBN', 'VBP'
]
#We obtain the type of words that we have in the text, we use the pos_tag function
tags = nltk.pos_tag(words)
print("WORDS: ", words)
print("TAGS: ", tags)
#Now we ask if we found a negation in the words
tags_2 = ''
if "no" in words:
tags_2 = tags[words.index("no"):]
words_2 = words[words.index("no"):]
words = words[:words.index("no")]
print("tags_2 ", tags_2)
print("words_2 ", words_2)
print("words ", words)
for index, word_tag in enumerate(tags_2):
print("index ", index)
if word_tag[1] in speach_tags:
print("REPLACE", word_tag[0])
words = words + [replace_antonyms(word_tag[0])
] + words_2[index + 2:]
#break
#print("WORDS: ",words)
print("FINAL TAGS2: ", tags_2)
print("FINAL WORDS: ", ' '.join(words))
return ' '.join(words)
def main():
# Read the corpus into a list,
# each entry in the list is one sentence.
cess_sents = cess_esp.tagged_sents()
# Train the unigram tagger
uni_tag = ut(cess_sents)
output = open('uni_tag.pkl', 'wb')
dump(uni_tag, output, -1)
output.close()
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
def __init__(self):
cess_sents = cess.tagged_sents()
self.uni_tag = ut(cess_sents)
self.model = NgramModel(3, brown.words())
self.translation = []
self.dictionary = collections.defaultdict(lambda: 0)
dictionaryFile = open("../corpus/Dictionary.txt", 'r')
for translation in dictionaryFile:
spanish, english = translation.split(" - ")
spanish = spanish.decode('utf-8')
self.dictionary[spanish] = collections.defaultdict(lambda: [])
english = english.rstrip(';\n').split('; ')
for pos in english:
pos = pos.split(': ')
self.dictionary[spanish][pos[0]] = pos[1].split(', ')
self.sentences = []
sentencesFile = open("../corpus/TestSet.txt", 'r')
for sentence in sentencesFile:
self.sentences.append(sentence.rstrip('\n'))
def __init__(self):
cess_sents = cess.tagged_sents()
self.uni_tag = ut(cess_sents)
self.model = NgramModel(3, brown.words())
self.translation = []
self.dictionary = collections.defaultdict(lambda: 0)
dictionaryFile = open("../corpus/Dictionary.txt", 'r')
for translation in dictionaryFile:
spanish, english = translation.split(" - ")
spanish = spanish.decode('utf-8')
self.dictionary[spanish] = collections.defaultdict(lambda: [])
english = english.rstrip(';\n').split('; ')
for pos in english:
pos = pos.split(': ')
self.dictionary[spanish][pos[0]] = pos[1].split(', ')
self.sentences = []
sentencesFile = open("../corpus/TestSet.txt", 'r')
for sentence in sentencesFile:
self.sentences.append(sentence.rstrip('\n'))
def init():
cess_sents = cess.tagged_sents()
unitag = ut(cess_sents)
pass
def tonkenier(text):
cess_sents = cess.tagged_sents()
uni_tag = ut(cess_sents)
words = text.replace(",", "").replace(".", "").replace("\n", "").replace("\t", "").split(" ")
annotated_text = uni_tag.tag(words)
return annotated_text
#adaptacion SPANISH
from nltk.corpus import cess_esp
nltk.tag.mapping._load_universal_map("es-cast3lb")
mapdict = nltk.tag.mapping._MAPPINGS["es-cast3lb"]["universal"]
alltags = set(t for w, t in cess_esp.tagged_words())
for tag in alltags:
if len(tag) <= 2: # These are complete
continue
mapdict[tag] = mapdict[tag[:2]]
cess_esp._tagset = "es-cast3lb"
from nltk import UnigramTagger as ut
from nltk import BigramTagger as bt
cess_sents = cess_esp.tagged_sents(tagset='universal')
uni_tag = ut(cess_sents, backoff=nltk.DefaultTagger('X'))
class VoteClassifier(ClassifierI):
def __init__(self, *classifiers):
self._classifiers = classifiers
def classify(self, features):
votes = []
for c in self._classifiers:
v = c.classify(features)
votes.append(v)
return mode(votes)
def confidence(self, features):
votes = []
import A
from sklearn.feature_extraction import DictVectorizer
from sklearn import svm
from nltk import word_tokenize
from nltk.corpus import cess_esp
from nltk.corpus import cess_cat
from nltk.data import load
from sklearn import svm
import nltk
from nltk import UnigramTagger as ut
tagger_cat = ut(cess_cat.tagged_sents())
tagger_esp = ut(cess_esp.tagged_sents())
# You might change the window size
window_size = 15
def b1_base(data):
'''
:param data: list of instances for a given lexelt with the following structure:
{
[(instance_id, left_context, head, right_context, sense_id), ...]
}
:param s: list of words (features) for a given lexelt: [w1,w2,w3, ...]
:return: vectors: A dictionary with the following structure
{ instance_id: [w_1 count, w_2 count, ...],
...
}
labels: A dictionary with the following structure
{ instance_id : sense_id }
'''
from nltk.corpus import cess_esp as cess # El corpus
from nltk import UnigramTagger as ut # El tagger (de una palabra)
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
texto = ' coordinado por la Universidad Federal de Rio de Janeiro – Brasil. se con whith El Centro de Convenciones de la Universidad Técnica Particular de Loja, June, 2008-06-29 la Compañía de Teatro de la UTPL, College of Physicians presento el estreno de Puebla de las Mujeres bajo la direccion de Alain Chaviano Aldonza, es una obra teatral del genero de la comedia escrito por los brothers brother siblings hermanos Alvarez Quintero y estrenada en 1912.uesta en escena. El escenario estuvo ambientado en la epoca, 1912, simulaba la sala de la casa del cura parroco del pueblo junto a las luces y la musica transportaron a los asistentes a aquella epoca. Los actores fueron a pareciendo en escena de acuerdo al desarrollo de la historia, haciendo reir y divertir al publico con cada interpretacion. La historia se desarrolla en un pueblo donde mandan y reinan las mujeres como mismo lo menciona dentro de la trama el medico del pueblo, ellas hacen y deshacen a su antojo, siendo su único objetivo casar a todas las muchachas del pueblo con todos los hombres que llegan a el. thus asi Asi llega al pueblo el abogado Adolfo Adalid un muchacho apuesto y galante, cuyo error al llegar fue haber visto a una de las muchachas del Pueblo, Juanita la Rosa, desde ese momento todas se empeniaran en terminar casandolo con ella. Concha Puerto es una mujer muy impetuosa, entrometida en todo lo que no le importa, hara lo imposible para lograr que el abogado se interese por Juanita, y para realizar su cometido se valdra de todo y de todos, haciendo que cada situacion sea muy jocosa y entretenida por los enredos que ella genera. Andrea Pazminio, actriz, interpreta a Concha Puerto lleva ocho anios dentro de la Compania y nos comenta el teatro para mi es otro mundo, es meterse en otro papel y algo increible para cada actor. Con cada obra que realizo quiero dejar un mensaje a la gente, en esta ocasión Puebla de las Mujeres se asemeja al entorno lojano donde a las mujeres les gusta mandar, es una obra bien simpatica, fresca y sobre todo la gente vive muy estresada y con esta obra lograremos sacar una sonrisa a todo el publico indica Alain Chaviano, Director de la Compania de Teatro de la UTPL. Esta noche podremos disfrutar nuevamente de esta maravillosa obra a las 19h00 en el Centro de Convenciones de la UTPL, la entrada es gratuita.En el mes de noviembre del 2012, se dio a conocer el Proyecto BABEL en co-ordinación con la UTPL, que extendió la cordial invitación para la postulación de Becas a Europa, para Licenciatura, Master, Doctorado, Postdoctorado, Personal Académico y Administrativo. Dado que La Universidad Técnica Particular de Loja, es miembro asociado del Proyecto de la Unión Europea – Erasmus Mundus “BABEL” Building academic bounds between Europe and Latin American, coordinado por la Universidad de Porto – Portugal y co- coordinado por la Universidad Federal de Rio de Janeiro – Brasil. Por tal motivo más de 20 ex alumnos de las distintas Titulaciones de la UTPL, aplicaron para las becas del Proyecto Babel, siendo una gran oportunidad por los beneficios que otorga y oferta el proyecto BABEL, se hacen visibles en montos de dinero que cubren los gastos de estudio en las universidades a postular y son: licenciaturas (mil euros), doctorados (1.500), post doctorados (1.800) y personal académico y administrativo (2.500). Además cubrirá gastos de ida y vuelta, seguro de vida y se efectuará conjuntamente con el postulante el proceso de visado y el seguimiento durante el ciclo de estudios. La divulgación de los resultados será en abril de este año, por lo cual deseamos la mejor de las suertes a nuestros ex alumnos postulantes.' texto="""En el museo de Arqueología y Lojanidad de la UTPL, estarán expuestas las fotografías del ecuatoriano Pablo Palacios, en la muestra titulada: Las Cuatro Estaciones del Central Park de Nueva York. La exposición cuenta con 60 fotografías tomadas durante los últimos tres años y que muestran al parque más grande de Nueva York en sus cuatro estaciones. Su objetivo es concienciar a los estudiantes sobre el cuidado del medio ambiente, además de fomentar el intercambio cultural entre ambos países. El 4 de diciembre se llevó a cabo la inauguración con la presencia de Robert McInturff, agregado cultural de la Embajada de los Estados Unidos en Quito, quien habló sobre la importancia que tiene fraternizar con el pueblo ecuatoriano, ya que se puede llevar a cabo proyectos como becas e intercambios culturales. El Central Park ha sido escogido como punto para fotografiar, ya que es considerado como los pulmones de Nueva York. Es un lugar lleno de vitalidad, donde se puede observar gente paseando en bicicleta, personas mayores caminando y niños jugando. Este parque, que es uno de los más grandes del mundo, cuenta con lagos artificiales, praderas, un zoológico y tiendas. Recibe más de 20 millones de visitantes cada año. [email protected]""" cess_sents = cess.tagged_sents() # Train the unigram tagger uni_tag = ut(cess_sents) sentence = "caminar caminando caminara correr aprender aprendio conocer caminar, correr, escalar, saltar y explorar" # Tagger reads a list of tokens. #print nltk.corpus.cess_esp.words() nltk.corpus.cess_esp.tagged_words() #print uni_tag.tag(texto.split(" ")) #print pos_tag(word_tokenize('caminar caminando caminara correr aprender aprendio conocer caminar, correr, escalar, saltar y explorar')) #print stopwords.words('spanish') #archivo=codecs.open("contenidonoticia.txt","r",encoding="utf-8") #texto = archivo.read()
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:])
Python 3.6.3 (v3.6.3:2c5fed8, Oct 3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> from nltk
SyntaxError: invalid syntax
>>> import nltk
>>> from nltk.corpus import cess_esp as cess
>>> from nltk import UnigramTagger as ut
>>> sents = cess.tagged_sents()
>>>
>>> sents
[[('El', 'da0ms0'), ('grupo', 'ncms000'), ('estatal', 'aq0cs0'), ('Electricité_de_France', 'np00000'), ('-Fpa-', 'Fpa'), ('EDF', 'np00000'), ('-Fpt-', 'Fpt'), ('anunció', 'vmis3s0'), ('hoy', 'rg'), (',', 'Fc'), ('jueves', 'W'), (',', 'Fc'), ('la', 'da0fs0'), ('compra', 'ncfs000'), ('del', 'spcms'), ('51_por_ciento', 'Zp'), ('de', 'sps00'), ('la', 'da0fs0'), ('empresa', 'ncfs000'), ('mexicana', 'aq0fs0'), ('Electricidad_Águila_de_Altamira', 'np00000'), ('-Fpa-', 'Fpa'), ('EAA', 'np00000'), ('-Fpt-', 'Fpt'), (',', 'Fc'), ('creada', 'aq0fsp'), ('por', 'sps00'), ('el', 'da0ms0'), ('japonés', 'aq0ms0'), ('Mitsubishi_Corporation', 'np00000'), ('para', 'sps00'), ('poner_en_marcha', 'vmn0000'), ('una', 'di0fs0'), ('central', 'ncfs000'), ('de', 'sps00'), ('gas', 'ncms000'), ('de', 'sps00'), ('495', 'Z'), ('megavatios', 'ncmp000'), ('.', 'Fp')], [('Una', 'di0fs0'), ('portavoz', 'nccs000'), ('de', 'sps00'), ('EDF', 'np00000'), ('explicó', 'vmis3s0'), ('a', 'sps00'), ('EFE', 'np00000'), ('que', 'cs'), ('el', 'da0ms0'), ('proyecto', 'ncms000'), ('para', 'sps00'), ('la', 'da0fs0'), ('construcción', 'ncfs000'), ('de', 'sps00'), ('Altamira_2', 'np00000'), (',', 'Fc'), ('al', 'spcms'), ('norte', 'ncms000'), ('de', 'sps00'), ('Tampico', 'np00000'), (',', 'Fc'), ('prevé', 'vmm02s0'), ('la', 'da0fs0'), ('utilización', 'ncfs000'), ('de', 'sps00'), ('gas', 'ncms000'), ('natural', 'aq0cs0'), ('como', 'cs'), ('combustible', 'ncms000'), ('principal', 'aq0cs0'), ('en', 'sps00'), ('una', 'di0fs0'), ('central', 'ncfs000'), ('de', 'sps00'), ('ciclo', 'ncms000'), ('combinado', 'aq0msp'), ('que', 'pr0cn000'), ('debe', 'vmip3s0'), ('empezar', 'vmn0000'), ('a', 'sps00'), ('funcionar', 'vmn0000'), ('en', 'sps00'), ('mayo_del_2002', 'W'), ('.', 'Fp')], ...]
>>> tag = ut(sents)
>>> oracion = "Las TICs en la actualidad son fuente de conocimiento y de sabiduría de muchas personas que han generado y compartido sus logros."
>>> tagged = tag.tag(oracion.split(" "))
>>> tagged
[('Las', 'da0fp0'), ('TICs', None), ('en', 'sps00'), ('la', 'da0fs0'), ('actualidad', 'ncfs000'), ('son', 'vsip3p0'), ('fuente', 'ncfs000'), ('de', 'sps00'), ('conocimiento', 'ncms000'), ('y', 'cc'), ('de', 'sps00'), ('sabiduría', 'ncfs000'), ('de', 'sps00'), ('muchas', 'di0fp0'), ('personas', 'ncfp000'), ('que', 'pr0cn000'), ('han', 'vaip3p0'), ('generado', 'vmp00sm'), ('y', 'cc'), ('compartido', 'aq0msp'), ('sus', 'dp3cp0'), ('logros.', None)]
>>> Tree01 = nltk.corpus.cess_esp.tagged.draw()
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
Tree01 = nltk.corpus.cess_esp.tagged.draw()
AttributeError: 'BracketParseCorpusReader' object has no attribute 'tagged'
>>> Tree01 = nltk.corpus.cess_esp.parsed_sents(tagged).draw()
Traceback (most recent call last):
File "<pyshell#12>", line 1, in <module>
Tree01 = nltk.corpus.cess_esp.parsed_sents(tagged).draw()
File "C:\Users\UPTC\AppData\Local\Programs\Python\Python36-32\lib\site-packages\nltk\corpus\reader\api.py", line 403, in parsed_sents
for fileid, enc in self.abspaths(fileids, True)])
File "C:\Users\UPTC\AppData\Local\Programs\Python\Python36-32\lib\site-packages\nltk\corpus\reader\api.py", line 193, in abspaths
paths = [self._root.join(f) for f in fileids]
File "C:\Users\UPTC\AppData\Local\Programs\Python\Python36-32\lib\site-packages\nltk\corpus\reader\api.py", line 193, in <listcomp>
nltk.download('cess_esp')
from nltk.corpus import cess_esp as cess
from nltk import UnigramTagger as ut
from nltk import BigramTagger as bt
"""## @title Entrenamiendo del tagger por unigramas"""
#Separamos las frases del corpus
cess_sents = cess.tagged_sents()
# Obtenemos un fracción del Dataset
fraction = int(len(cess_sents)*90/100)
# Definimos una instancia del etiquetador por unigramas
# Le pasamos una francción del Dataset para realizar el entrenamiento
# Lo entrenamos con el 90% del conjunto de datos
uni_tagger = ut(cess_sents[:fraction])
# Despues de entrenar hacemos la evaluación con el resto del Dataset
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
def main():
cess_sents = cess.tagged_sents()
uni_tag = ut(cess_sents)
with open('unigramTagger.json', 'wb') as output:
pickle.dump(uni_tag, output, pickle.HIGHEST_PROTOCOL)
def normalize(s, punctuation="!?.:;,()[] "):
s = s.decode("iso-8859-1")
s = s.strip()
s = s.strip(punctuation)
return s
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)
import json # To be able to read json files
import urllib2 # To be able to read url (speech) containing json
import collections # The collection module has useful functions to count automatically frequencies
from collections import Counter # Module useful for frequencies in a list
import MySQLdb # Module for Mysql database
import datetime # Module to use date and time
from config import DB_USER,DB_PWD,DB_NAME # Database Settings
languages = ["ar","de","en","es","fr","it","ko","no","pt","sv","zh"] # languages supported by this parser
punctuation = [",",";",".",":","!","?","(",")","-","%","\"","[","]"] # all marks of punctuation
sent_detector = nltk.data.load('tokenizers/punkt/english.pickle') # Loading English file to detect sentences
cess_sents = cess.tagged_sents() # Spanish sentences
uni_tag = ut(cess_sents) # Tagging spanish sentences
st_tag_english = NERTagger('english.all.3class.distsim.crf.ser.gz','stanford-ner.jar') # Entities for English
st_pos_french = POSTagger('french.tagger', 'stanford-postagger.jar') # French Grammar
st_pos_german = POSTagger('german-fast.tagger', 'stanford-postagger.jar') # German Grammar
st_tag_german = NERTagger('hgc_175m_600.crf.ser.gz','stanford-ner.jar') # Entities for German
chunker = nltk.data.load('chunkers/maxent_ne_chunker/english_ace_multiclass.pickle') # Loads the Chunk Parser
maxEnt = chunker._tagger.classifier() # The tag classifier for entities
# Please note that at the moment English, French, German and Sapnish are the only languages supported by this program
# It is slower in German and better in English: in English it is possible to define a probability for entities (with the Chunk Parser)
#--------------------------------------------------------------------------------------------------------------------------------------
# Global variables
my_entities =[]