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(): cess_sents = cess.tagged_sents() unitag = ut(cess_sents) pass
#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 =[]