def pos_tag(self):
tokenize_obj = NLTKTokenize(self.options)
res = tokenize_obj.tokenize()
tokens = res['result']
tags = []
# Performs Bigram / Unigram / Regex Tagging
if self.options.get('tagger') in ['unigram', 'bigram', 'regex']:
trainer = self.options['train'] if self.options.get(
'train') in TRAINERS else DEFAULT_TRAIN
train = brown.tagged_sents(categories=trainer)
# Create your custom regex tagging pattern here
regex_tag = RegexpTagger([(r'^[-\:]?[0-9]+(.[0-9]+)?$', 'CD'),
(r'.*able$', 'JJ'),
(r'^[A-Z].*$', 'NNP'), (r'.*ly$', 'RB'),
(r'.*s$', 'NNS'), (r'.*ing$', 'VBG'),
(r'.*ed$', 'VBD'), (r'.*', 'NN')])
current = os.path.dirname(os.path.abspath(__file__))
# Unigram tag training data load / dump pickle
pkl_name = current + '/trained/unigram_' + trainer + '.pkl'
if os.path.isfile(pkl_name):
with open(pkl_name, 'rb') as pkl:
unigram_tag = load(pkl)
else:
unigram_tag = UnigramTagger(train, backoff=regex_tag)
with open(pkl_name, 'wb') as pkl:
dump(unigram_tag, pkl, -1)
# Bigram tag training data load / dump pickle
if self.options['tagger'] == 'bigram':
pkl_name = current + '/trained/bigram_' + trainer + '.pkl'
if os.path.isfile(pkl_name):
with open(pkl_name, 'rb') as pkl:
bigram_tag = load(pkl)
else:
bigram_tag = BigramTagger(train, backoff=unigram_tag)
with open(pkl_name, 'wb') as pkl:
dump(bigram_tag, pkl, -1)
tags = bigram_tag.tag(tokens) # Bigram tagging performed here
elif self.options['tagger'] == 'unigram':
tags = unigram_tag.tag(
tokens) # Unigram tagging performed here
else:
tags = regex_tag.tag(tokens) # Regex tagging performed here
# Performs default pos_tag
elif self.options.get('tagger', DEFAULT_TAGGER) == 'pos':
tags = pos_tag(tokens)
return self._dump(tags)
class BigramChunker(ChunkParserI):
def __init__(self, train_sentences):
train_data = [[(t, c) for w, t, c in tree2conlltags(sent)]
for sent in train_sentences]
self.tagger = BigramTagger(train_data)
def parse(self, sentence):
pos_tags = [pos for (word, pos) in sentence]
tagged_pos_tags = self.tagger.tag(pos_tags)
chunk_tags = [chunk_tag for (pos, chunk_tag) in tagged_pos_tags]
conll_tags = [(word, pos, chunk_tag) for ((word, pos), chunk_tag) in zip(sentence, chunk_tags)]
return conlltags2tree(conll_tags)
class BigramChunker(ChunkParserI):
def __init__(self, train_sentences):
train_data = [[(t, c) for w, t, c in tree2conlltags(sent)]
for sent in train_sentences]
self.tagger = BigramTagger(train_data)
def parse(self, sentence):
pos_tags = [pos for (word, pos) in sentence]
tagged_pos_tags = self.tagger.tag(pos_tags)
chunk_tags = [chunk_tag for (pos, chunk_tag) in tagged_pos_tags]
conll_tags = [(word, pos, chunk_tag)
for ((word, pos),
chunk_tag) in zip(sentence, chunk_tags)]
return conlltags2tree(conll_tags)
tmp = open("/tmp/proper.txt", "w")
from nltk import DefaultTagger, UnigramTagger, BigramTagger
from nltk.corpus import brown
# This section is recompiled from the Natural Language Processing Book: http://nltk.googlecode.com/svn/trunk/doc/book/book.html
brown_news_tagged = brown.tagged_sents(categories='news') # Automatic tagging of a sentence, based on Brown News corpus
size = int(len(brown_news_tagged) * 0.9)
brown_news_train = brown_news_tagged[:size]
unigram_tagger = UnigramTagger(brown_news_train)
# Uses BigramTagger -- if it fails, it uses the UnigramTagger -- if it fails, it uses DefaultTagger
t0 = DefaultTagger('NN')
t1 = UnigramTagger(brown_news_train, backoff=t0)
tagger = BigramTagger(brown_news_train, backoff=t1)
for line in text:
tagged = tagger.tag(line.split(" "))
is_np = re.compile(r"NP")
for w in tagged:
if (is_np.match(w[1])):
#print w[0]
tmp.write(w[0] + "\n")
tmp.close()
# Sort list and remove duplicates
os.system("cat /tmp/proper.txt | sort | uniq")
tagger1.evaluate(test_tsents) from nltk import BigramTagger # Define um tagger Bigram (falaremos mais sobre isso depois) tagger2 = BigramTagger(train_tsents, backoff=tagger1) tagger2.evaluate(test_tsents) # Existe ainda mais um POS-Tagger no NLTK, o TnT from nltk.tag import tnt tnt_pos_tagger = tnt.TnT() tnt_pos_tagger.train(train_tsents) tnt_pos_tagger.evaluate(test_tsents) # Se deseja apenas realizar o POS-Tagging, e não avaliar tagger2.tag(tokenize.word_tokenize(texto, language='portuguese')) """Caso queira armazenar o modelo treinado para evitar o re-treinamento veja a seção 5.6 deste [link](https://www.nltk.org/book/ch05.html). ##**ATIVIDADE PRÁTICA** A seguir algumas práticas relacionadas às operações básicas de PLN, NLTK e expressões regulares. """ # Texto de exemplo texto = """A morte supersônica O Concorde era um avião incrível. Inclusive no quesito segurança. Até que, um dia, aconteceu algo que ninguém poderia prever. Com asas alongadas e viradas para trás, cabine bem estreita e bico fino – que deslizava para baixo durante o pouso, para melhorar a visibilidade do piloto –, o Concorde é um dos aviões mais bonitos de todos os tempos. E um dos mais avançados também. Desenvolvido nos anos 1960 por um consórcio de empresas francesas e inglesas (que hoje se chama Airbus), ele foi um dos únicos dois aviões supersônicos a operar comercialmente (o outro foi o soviético Tupolev Tu-144). Tinha quatro motores ultrapotentes, que queimavam 25 mil litros de combustível por hora – quase o dobro de um Boeing 747 -, e viajava a 60 mil pés de altitude, 20 mil a mais que os outros aviões. Usava tecnologias revolucionárias, como um sistema que desacelerava a passagem do ar dentro das turbinas (do contrário, elas explodiriam antes que o avião atingisse sua velocidade máxima). Tudo para alcançar a glória de voar a 2.179 km/h, duas vezes a velocidade do som. É o dobro dos aviões comuns, e permitia atravessar o planeta com uma rapidez que até hoje impressiona – ir de Londres a Nova York em três horas, por exemplo. O Concorde começou a operar em 1976. Uma das primeiras linhas fazia o trajeto Paris-Rio de Janeiro, com dois voos semanais. O público ficou maravilhado com a aeronave, mas voar nela era para poucos: as passagens eram ainda mais caras que as dos voos de primeira classe, e ultrapassavam US$ 10 mil em valores de hoje. Mas manter a frota de Concordes era ainda mais caro, e a British Airways e a Air France, que operavam os aviões, tinham prejuízo com eles. É que, para que os voos dessem lucro, cada avião precisava decolar com pelo menos 90% dos assentos ocupados, o que nem sempre acontecia (a linha brasileira tinha ocupação média de 50%, e por isso foi uma das primeiras a deixarem de existir, em 1982).
print("The text after POS tagging: \n")
print(tokens_tagged)
# # Question 2(b): To understand tagging errors we compare the pos_tag() method with a combined Bigram, Unigram tagger
from nltk import DefaultTagger, UnigramTagger, BigramTagger
from nltk.corpus import brown
nltk.download('brown')
text = brown.tagged_sents(categories='news')
t0 = DefaultTagger('NN')
t1 = UnigramTagger(text, backoff=t0)
t2 = BigramTagger(text, backoff=t1)
bigram_tagged = t2.tag(tokens_updated)
ref_tag_set = [word[1] for word in bigram_tagged]
print("********************\n")
print("*** UNDERSTANDING TAGGING ERRORS ***\n")
print("POS tags from the default pos_tag() method: \n", tags_set)
print("POS tags from the Bigram tagger in nltk: \n", ref_tag_set)
from nltk.metrics import ConfusionMatrix
from collections import Counter
cm = ConfusionMatrix(ref_tag_set, tags_set) #Creating a Confusion Matrix
labels = set(ref_tag_set + tags_set) #Getting all the tags present
true_positives = Counter()