def classification_metrics(gold, predict):
'''
This function compute and print the classification metrics
precision, recall and f1 score for different classes using
the confusion matrix provided by NLTK.
gold- the gold standard/actual values
predict- the predicted values
'''
cm = ConfusionMatrix(gold, predict)
model_file = open('classification_metrics.txt', 'w')
sys.stdout = model_file
print("\t\t---------------------------------------")
print("\t\t\t\tConfusion Matrix 1")
print("\t\t---------------------------------------\n")
print(cm)
print("\t\t---------------------------------------")
print("\t\t\t\tConfusion Matrix 2")
print("\t\t----------------------------------------\n")
print(cm.pretty_format(sort_by_count=True, show_percents=True, truncate=10))
labels = tag_set
true_positives = Counter()
false_negatives = Counter()
false_positives = Counter()
for i in labels:
for j in labels:
if i == j:
true_positives[i] += cm[i, j]
else:
false_negatives[i] += cm[i, j]
false_positives[j] += cm[i, j]
print("\t---------------------------------------")
print("\tPrecision Recall F-score")
print("\t---------------------------------------\n")
for i in sorted(labels):
if true_positives[i] == 0:
fscore = 0
else:
precision = true_positives[i] / float(true_positives[i] + false_positives[i])
recall = true_positives[i] / float(true_positives[i] + false_negatives[i])
fscore = 2 * (precision * recall) / float(precision + recall)
print(i, "\t", "%.2f" % precision, "\t", "%.2f" % recall, "\t", "%.2f" % fscore)
def print_ConfusionMatrix(ref, predicted):
'''Prints confusion matrix with reference as row and predicted as column
:param ref:
List of actual genres of tests
:param predicted:
List of predicted genres of tests
:return:
None
prints a confusion matrix
'''
cm = ConfusionMatrix(ref, predicted)
Conf_mat = cm.pretty_format(sort_by_count=False, truncate=15)
print(Conf_mat)
def two_int(list1, list2):
matrix = ConfusionMatrix(list1, list2)
print(matrix)
labelSet = set(list1 + list2)
true_positives = Counter()
false_negatives = Counter()
false_positives = Counter()
for i in labelSet:
for j in labelSet:
if i == j:
true_positives[i] += matrix[i, j]
else:
false_negatives[i] += matrix[i, j]
false_positives[j] += matrix[i, j]
print("TP:", sum(true_positives.values()), true_positives)
print("FN:", sum(false_negatives.values()), false_negatives)
print("FP:", sum(false_positives.values()), false_positives)
print()
for i in sorted(labelSet):
if true_positives[i] == 0:
fscore = 0
else:
precision = true_positives[i] / float(true_positives[i] +
false_positives[i])
recall = true_positives[i] / float(true_positives[i] +
false_negatives[i])
fscore = 2 * (precision * recall) / float(precision + recall)
print("fscore")
print(i, fscore)
def eval2(ref, tagged):
cm = ConfusionMatrix(ref, tagged)
print cm
labels = set(ref)
true_positives = Counter()
false_negatives = Counter()
false_positives = Counter()
for i in labels:
for j in labels:
if i == j:
true_positives[i] += cm[i, j]
else:
false_negatives[i] += cm[i, j]
false_positives[j] += cm[i, j]
print "TP:", sum(true_positives.values()), true_positives
print "FN:", sum(false_negatives.values()), false_negatives
print "FP:", sum(false_positives.values()), false_positives
print
for i in sorted(labels):
if true_positives[i] == 0:
fscore = 0
else:
precision = true_positives[i] / float(true_positives[i] +
false_positives[i])
recall = true_positives[i] / float(true_positives[i] +
false_negatives[i])
fscore = 2 * (precision * recall) / float(precision + recall)
print i, precision, recall, fscore
def precision_recall(classifier, testfeats):
refsets = collections.defaultdict(set)
testsets = collections.defaultdict(set)
ref = []
pred = []
for i, (feats, label) in enumerate(testfeats):
refsets[label].add(i)
observed = classifier.classify(feats)
testsets[observed].add(i)
# Create 2 lists for Confusion Matrix
pred.append(observed)
ref.append(label)
cm = ConfusionMatrix(ref, pred)
print(cm)
precisions = {}
recalls = {}
for label in classifier.labels():
precisions[label] = precision(refsets[label], testsets[label])
recalls[label] = recall(refsets[label], testsets[label])
return precisions, recalls
def mp(t, clf, k=None):
trainI, testI = t
if k:
ch2 = SelectKBest(chi2, k=k)
#do chi2 fit on train data
best = ch2.fit(feat_vecs[trainI], labels[trainI])
# test data reduced to same k features
test_feats = best.transform(feat_vecs[testI]).toarray()
# train data reduced to same k features
train_feats = best.transform(feat_vecs[trainI]).toarray()
else:
test_feats = feat_vecs[testI]
train_feats = feat_vecs[trainI]
train_labels = labels[trainI]
test_labels = labels[testI]
# make NB model on train data
fitted = clf.fit(train_feats, train_labels)
pred = fitted.predict(test_feats) # predict labels for test
#set_trace()
f1 = f1_score(test_labels, pred, average='weighted')
pre = precision_score(test_labels, pred)
rec = recall_score(test_labels, pred)
prf1 = [pre, rec, f1]
r = []
m = confusion_matrix(test_labels, pred)
r.append(m)
r.append(ConfusionMatrix(test_labels.tolist(), pred.tolist()))
r.append(classification_report(test_labels, pred))
r.append(prf1)
return r
def metrics_array(complete_base_test, classified):
expected = []
provided = []
for (phrase, classes) in complete_base_test:
result = classified.classify(phrase)
expected.append(classes)
provided.append(result)
return ConfusionMatrix(expected, provided)
def main():
output_file = sys.argv[1] #passing my-line-answers.txt
key_file = sys.argv[2] #passing line-answers.txt
with open(output_file) as file: #read my-line-answers.txt
f1 = [line.rstrip('\n') for line in file
] #each line of file is converted into each element of list
var1 = [i.split(':"', 1)
for i in f1] #each line is split based on colon and quotes
predicted = {} #declaring dictionary
for a in range(
1, len(var1)
): #dictionary is created is passed instance id as key and sense id as value
key = var1[a][0]
value = var1[a][1]
predicted[key] = value
#Assuming a list and then using for loop reading the values from predicted and then appending them in the new list which is predicted_list.#
predicted_list = []
for v in predicted:
predicted_list.append(predicted[v])
with open(key_file) as myf1: #read line-answers.txt
f2 = [line.rstrip('\n') for line in myf1
] #each line of f1 is converted into each element of list
var2 = [i.split(':"', 1)
for i in f2] #each line is split based on colon and quotes
observed = {} #declaring dictionary
for a in range(1, len(var2)): # every value from key and value are read
key = var2[a][
0] #for every line in sentence, first part is considered as key
value = var2[a][1] #second part is considered as sentence
observed[key] = value
#Assuming a list and then using for loop reading the values from observed. and then appending them in the new list which is observed_list.#
observed_list = []
for v in observed:
observed_list.append(observed[v])
cm = ConfusionMatrix(observed_list,
predicted_list) #calculating the consfusion matrix
x = 0
for i in range(len(predicted_list)):
if predicted_list[i] == observed_list[
i]: #comparing both the list values and if it is equal x gets incremented.
x += 1
accuracy = (x / len(predicted_list) * 100) #calculating the accuracy
#Accuracy and confusion matrix is stored in output file viz wsdreport.txt
print(
'Accuracy of the classifier is:',
accuracy,
'\n\n'
'Confusion Matrix: ',
str(cm),
)
def print_confusion_matrix(classificador, base):
from nltk.metrics import ConfusionMatrix
esperado = []
previsto = []
for (frase, classe) in base:
resultado = classificador.classify(frase)
previsto.append(resultado)
esperado.append(classe)
print(ConfusionMatrix(esperado, previsto))
def printConfusionMatrix(classifier, testSet):
refList = []
testList = []
for (features, label) in testSet:
refList.append(label)
testList.append(classifier.classify(features))
print("---------Confusion Matrix---------")
confMat = ConfusionMatrix(refList, testList)
print(confMat)
def display_confusion_matrix(classifier_type, test_set):
reflist = []
testlist = []
for (features, label) in test_set:
reflist.append(label)
testlist.append(classifier_type.classify(features))
print "The confusion matrix"
cm = ConfusionMatrix(reflist, testlist)
print cm
def MatrizConfusao(base):
Esperado = []
Previsto = []
for (frase, classe) in base:
result = Classifier.classify(frase)
Previsto.append(result)
Esperado.append(classe)
MatrixConfus = ConfusionMatrix(Esperado, Previsto)
return MatrixConfus
def gerarMatrizConfusao(classificador, baseCompletaTeste):
esperado = []
previsto = []
for (frase, classe) in baseCompletaTeste:
resultado = classificador.classify(frase)
previsto.append(resultado)
esperado.append(classe)
matriz = ConfusionMatrix(esperado, previsto)
print(matriz)
def calculate_confusion_matrix(self, test_data):
"""
calculate confusion_matrix
"""
correct_tags = [l for txt, l in test_data]
predicted_tags = [self.classify(txt) for txt, l in test_data]
cm = ConfusionMatrix(correct_tags, predicted_tags)
logger.info(cm)
self.__confusion_matrix = cm
return cm
def mount_confusion_matrix(self, test_database, suicidal_label,
non_suicidal_label):
result_list = []
expected_list = []
to_label = lambda result: suicidal_label if result else non_suicidal_label
for (phrase, expected_class) in test_database:
result = to_label(self.is_suicidal(phrase))
result_list.append(result)
expected_list.append(to_label(expected_class))
return ConfusionMatrix(expected_list, result_list, True)
def confusion(delta, column):
gold = list()
test = list()
for col1, col2 in delta:
if col1 != '+' and col2 != '-' and 'newsent' not in col1:
gold.append(col1[column[0]])
test.append(col2[column[1]])
cm = ConfusionMatrix(gold, test)
return cm
def training(self, dataset, cv=1, n_iter=1):
if isinstance(dataset, basestring):
labeled_symbols, labeled_sequence, codes, labels = self.get_data(
dataset)
else:
labeled_symbols, labeled_sequence, codes, labels = dataset
self.model = self.learning_model.train(labeled_symbols)
if cv > 1:
cv_scores = []
for i in range(n_iter):
skf = cross_validation.KFold(len(labels),
n_folds=10,
shuffle=True)
iter_score = []
for train_index, test_index in skf:
train_data = list(
numpy.array(labeled_symbols)[train_index])
test_data = list(numpy.array(labeled_symbols)[test_index])
self.model = self.learning_model.train(train_data)
fold_score = self.model.evaluate(test_data)
iter_score.append(fold_score)
cv_scores.append(numpy.mean(iter_score))
return cv_scores
else:
skf = cross_validation.ShuffleSplit(len(labels),
n_iter=n_iter,
test_size=0.2,
random_state=0)
training_score = []
test_score = []
for train_index, test_index in skf:
train_data = list(numpy.array(labeled_symbols)[train_index])
test_data = list(numpy.array(labeled_symbols)[test_index])
self.model = self.learning_model.train(train_data)
training_score.append(self.model.evaluate(train_data))
test_score.append(self.model.evaluate(test_data))
if n_iter == 1:
predict_labels = []
for i in range(len(list(codes[test_index]))):
predicted_states = self.model.tag(
list(codes[test_index])[i])
predict_labels.append(predicted_states[0][1])
self.ConfusionMatrix = ConfusionMatrix(
list(labels[test_index]), predict_labels)
return training_score, test_score
def imprimir_matriz_confusao_base_teste():
sequencia_classes_esperadas = []
sequencia_palavras_obtidas = []
for (frase, classe) in base_teste_classificada:
sequencia_classes_esperadas.append(classe)
resultado_classificacao = classificador_treinamento.classify(frase)
sequencia_palavras_obtidas.append(resultado_classificacao)
matriz_cofusao = ConfusionMatrix(sequencia_classes_esperadas,
sequencia_palavras_obtidas)
print(matriz_cofusao)
def analiseSentimento(messageSenti):
frasescomstemmingtreinamento = aplicastemmer(basetreinamento)
frasescomstemmingteste = aplicastemmer(baseteste)
palavrastreinamento = buscapalavras(frasescomstemmingtreinamento)
palavrasteste = buscapalavras(frasescomstemmingteste)
frequenciatreinamento = buscafrequencia(palavrastreinamento)
frequenciateste = buscafrequencia(palavrasteste)
print(frequenciatreinamento)
print(frequenciateste)
#caracteristicasfrase = extratorpalavras(['am', 'nov', 'dia'])
basecompletatreinamento = nltk.classify.apply_features(extratorpalavras, frasescomstemmingtreinamento)
basecompletateste = nltk.classify.apply_features(extratorpalavras, frasescomstemmingteste)
classificador = nltk.NaiveBayesClassifier.train(basecompletatreinamento)
print(classificador.labels())
print(nltk.classify.accuracy(classificador, basecompletateste))
erros = []
for (frase, classe) in basecompletateste:
resultado = classificador.classify(frase)
if resultado != classe:
erros.append((classe, resultado, frase))
esperado = []
previsto = []
for (frase, classe) in basecompletateste:
resultado = classificador.classify(frase)
previsto.append(resultado)
esperado.append(classe)
matriz = ConfusionMatrix(esperado, previsto)
print(matriz)
testestemming = []
stemmer = nltk.stem.RSLPStemmer()
for (palavrastreinamento) in messageSenti.split():
comstem = [p for p in palavrastreinamento.split()]
testestemming.append(str(stemmer.stem(comstem[0])))
novo = extratorpalavras(testestemming)
distribuicao = classificador.prob_classify(novo)
resultado = classificador.classify(novo)
return resultado
def testing(self, inputFile, outputFile):
"fungsi testing menguji "
fileModel = xlrd.open_workbook(self.fileModel)
dataModel = fileModel.sheet_by_index(0)
fileResult = openpyxl.Workbook()
dataResult = fileResult.active
fileTest = xlrd.open_workbook(inputFile)
dataTest = fileTest.sheet_by_index(0)
dataTestLen = dataTest.nrows - 1
decisionTrue = 0
decisionError = 0
allCategory = []
allDec = []
for i in range(1, dataTestLen + 1):
# print (i)
article = dataTest.cell(i, 0).value
decision_actually = dataTest.cell(i, 1).value
decision_test = self.classify(article, dataModel)
dataResult.append([article, decision_actually, decision_test])
if decision_test == 'ERROR':
decisionError += 1
elif decision_actually == decision_test:
decisionTrue += 1
allCategory.append(decision_actually)
allDec.append(decision_test)
confisionMatrix = ConfusionMatrix(allCategory, allDec)
print(confisionMatrix)
accuracy = (decisionTrue / (dataTestLen - decisionError)) * 100
dataResult.append([
' ', 'DECISION TRUE', 'DECISION FALSE', 'DECISION ERROR',
'ACCURACY'
])
dataResult.append([
' ', decisionTrue, (dataTestLen - decisionError - decisionTrue),
decisionError, accuracy
])
fileResult.save(outputFile)
return
def evaluate(model, loss_fn, data_iterator, metrics, params, num_steps,hash_tb={}):
# set model to evaluation mode
model.eval()
# summary for current eval loop
summ = []
true = []
predicted = []
# compute metrics over the dataset
for _ in range(num_steps):
# fetch the next evaluation batch
data_batch, labels_batch = next(data_iterator)
# compute model output
output_batch = model(data_batch)
loss = loss_fn(output_batch, labels_batch)
var = labels_batch.view(-1).numpy().tolist()
var_indx = [var.index(i) for i in var if i >= 0]
pred = [torch.argmax(i).item() for i in output_batch]
tru = [var[i] for i in var_indx]
pre = [pred[i] for i in var_indx]
true += tru
predicted += pre
# extract data from torch Variable, move to cpu, convert to numpy arrays
output_batch = output_batch.data.cpu().numpy()
labels_batch = labels_batch.data.cpu().numpy()
# compute all metrics on this batch
summary_batch = {metric: metrics[metric](output_batch, labels_batch)
for metric in metrics}
summary_batch['loss'] = loss.item()
summ.append(summary_batch)
hash_t = dict((v,k) for k,v in hash_tb.items())
true = [hash_t[i] for i in true]
predicted = [hash_t[i] for i in predicted]
conf = ConfusionMatrix(true, predicted)
print(conf)
#print(Counter(true))
#print(Counter(predicted))
#print(len(predicted))
#print(len(true))
# compute mean of all metrics in summary
metrics_mean = {metric:np.mean([x[metric] for x in summ]) for metric in summ[0]}
metrics_string = " ; ".join("{}: {:05.3f}".format(k, v) for k, v in metrics_mean.items())
logging.info("- Eval metrics : " + metrics_string)
return metrics_mean
def _confusion_cached(self, gold):
"""
Inner function used after ``gold`` is converted to a
``tuple(tuple(tuple(str, str)))``. That way, we can use caching on
creating a ConfusionMatrix.
:param gold: The list of tagged sentences to run the tagger with,
also used as the reference values in the generated confusion matrix.
:type gold: tuple(tuple(tuple(str, str)))
:rtype: ConfusionMatrix
"""
tagged_sents = self.tag_sents(untag(sent) for sent in gold)
gold_tokens = [token for _word, token in chain.from_iterable(gold)]
test_tokens = [
token for _word, token in chain.from_iterable(tagged_sents)
]
return ConfusionMatrix(gold_tokens, test_tokens)
def evaluate3(ref, tagged):
print '\n Confusion matrix:\n',
cm = ConfusionMatrix(ref, tagged)
print cm
print
print 'Accuracy:', accuracy_score(ref, tagged)
print
print "Macro Averaged measures:"
print 'F1 score Macro:', f1_score(ref, tagged, average='macro')
print 'Recall Macro:', recall_score(ref, tagged, average='macro')
print 'Precision Macro:', precision_score(ref, tagged, average='macro')
print
print "Micro Averaged measures:"
print 'F1 score Micro:', f1_score(ref, tagged, average='micro')
print 'Recall Micro:', recall_score(ref, tagged, average='micro')
print 'Precision Micro:', precision_score(ref, tagged, average='micro')
print
print '\n Clasification report:\n', classification_report(ref, tagged)
print
def testOneFile(fileName):
fileResult = openpyxl.Workbook()
dataResult = fileResult.active
fileTest = xlrd.open_workbook(fileName)
dataTest = fileTest.sheet_by_index(0)
dataTestLen = dataTest.nrows - 1
decisionTrue = 0
decisionError = 0
allCategory = []
allDec = []
for i in range(1, dataTestLen + 1):
# print (i)
article = dataTest.cell(i, 0).value
decision_actually = dataTest.cell(i, 1).value
decision_test = testOneData(article)
# print decision_actually, decision_test
# print decision_actually, '----------', decision_test
dataResult.append([article, decision_actually, decision_test])
if decision_test == 'ERROR':
decisionError += 1
elif decision_actually == decision_test:
decisionTrue += 1
allCategory.append(decision_actually)
allDec.append(decision_test)
confisionMatrix = ConfusionMatrix(allCategory, allDec)
print(confisionMatrix)
accuracy = (decisionTrue / (dataTestLen - decisionError)) * 100
dataResult.append(
[' ', 'DECISION TRUE', 'DECISION FALSE', 'DECISION ERROR', 'ACCURACY'])
dataResult.append([
' ', decisionTrue, (dataTestLen - decisionError - decisionTrue),
decisionError, accuracy
])
fileResult.save("RESULT_train-train.xlsx")
def evaluate_f1(y_true, y_pred, verbose=False, preMsg=None):
print('verbose value is ', verbose)
if verbose:
print ConfusionMatrix(y_true, y_pred)
z_true = y_true
z_pred = y_pred
label_dict = {x: i for i, x in enumerate(list(set(z_true) | set(z_pred)))}
freq_dict = collections.Counter(z_true)
z_true = [label_dict[x] for x in z_true]
z_pred = [label_dict[x] for x in z_pred]
f1s = f1_score(z_true, z_pred, average=None)
print(str(preMsg) + 'F1 score' + str(f1s))
rs = recall_score(z_true, z_pred, average=None)
ps = precision_score(z_true, z_pred, average=None)
results = []
f1_none = []
print(str(preMsg) + str(label_dict))
for i in label_dict:
print(
"{5} The tag \'{0}\' has {1} elements and recall,precision,f1 ={3},{4}, {2}"
.format(i, freq_dict[i], f1s[label_dict[i]], rs[label_dict[i]],
ps[label_dict[i]], preMsg))
if i != 'None' and i != '|O':
f1_none = f1_none + [
(rs[label_dict[i]], ps[label_dict[i]], f1s[label_dict[i]],
freq_dict[i]),
]
all_medical_words = sum([z[3] for z in f1_none])
macro_averaged_recall = sum([float(z[0]) * float(z[3]) for z in f1_none
]) / sum([float(z[3]) for z in f1_none])
macro_averaged_precision = sum(
[float(z[1]) * float(z[3])
for z in f1_none]) / sum([float(z[3]) for z in f1_none])
if (macro_averaged_recall + macro_averaged_precision) == 0.0:
macro_averaged_f = 0.0
else:
macro_averaged_f = 2.0 * macro_averaged_recall * macro_averaged_precision / (
macro_averaged_recall + macro_averaged_precision)
print(
"{4} All medical tags have {0} elements and recall,precision,f1 ={1},{2}, {3}"
.format(all_medical_words, macro_averaged_recall,
macro_averaged_precision, macro_averaged_f, preMsg))
return macro_averaged_f
def classification_result(classifier, test_set):
refsets = collections.defaultdict(set)
testsets = collections.defaultdict(set)
reflist = []
testlist = []
for i, (tweet, label) in enumerate(test_set):
refsets[label].add(i)
reflist.append(label)
observed = classifier.classify(tweet)
testsets[observed].add(i)
testlist.append(observed)
print(len(refsets['1']))
print("Accuracy : ", nltk.classify.accuracy(classifier, test_set) * 100)
print("Precision Pos: ", precision(refsets['1'], testsets['1']) * 100)
print("Recall Pos: ", recall(refsets['1'], testsets['1']) * 100)
print("F Measure Pos: ", f_measure(refsets['1'], testsets['1']) * 100)
print("Precision Neg: ", precision(refsets['0'], testsets['0']) * 100)
print("Recall Neg: ", recall(refsets['0'], testsets['0']) * 100)
print("F Measure Neg: ", f_measure(refsets['0'], testsets['0']) * 100)
print("Confusion Metrics : \n", ConfusionMatrix(reflist, testlist))
def measuring_accuracy(self):
"""Testing the model *accuracy*"""
print(
"Accuracy:", nltk.classify.accuracy(self.classifier, self.test_set)
)
self.classifier.show_most_informative_features(20)
"""Measuring **Precision,Recall,F-Measure** of a classifier.
Finding **Confusion matrix**"""
actual_set = collections.defaultdict(set)
predicted_set = collections.defaultdict(set)
# cm here refers to confusion matrix
actual_set_cm = []
predicted_set_cm = []
for i, (feature, label) in enumerate(self.test_set):
actual_set[label].add(i)
actual_set_cm.append(label)
predicted_label = self.classifier.classify(feature)
predicted_set[predicted_label].add(i)
predicted_set_cm.append(predicted_label)
for category in self.data.keys():
print(
category,
"precision :",
precision(actual_set[category], predicted_set[category]),
)
print(
category,
"recall :",
recall(actual_set[category], predicted_set[category]),
)
print(
category,
"f-measure :",
f_measure(actual_set[category], predicted_set[category]),
)
confusion_matrix = ConfusionMatrix(actual_set_cm, predicted_set_cm)
print("Confusion Matrix")
print(confusion_matrix)
print "Loading test data..."
testset = np.load(path)
# Load model
print "Loading model..."
with open(model, 'rb') as fmodel:
cls = pickle.load(fmodel)
# Run test
sys.stdout.write("Testing:")
pred = []
idx = 0
for i in testset[:, 0]:
idx += 1
if idx % 1000 == 0:
sys.stdout.write(".")
sys.stdout.flush()
pred.append(str(cls.classify(i)))
# Result
# * Convert Ref Label to ASCII
ref = [str(label) for label in testset[:, 1]]
accuracy = scores.accuracy(ref, pred)
print "\nAccuracy: %.4f" % accuracy
cm = ConfusionMatrix(ref, pred)
print "Confusion Matrix: "
print (cm.pretty_format(sort_by_count=True, show_percents=True, truncate=9))
# Finished?
print "DONE!!"
def get_ConfusionMatrix(true, predicted):
print "Confusion Matrix of combined folds (partial evaluation)"
true_chain = list(itertools.chain.from_iterable(true))
predicted_chain = list(itertools.chain.from_iterable(predicted))
print ConfusionMatrix(true_chain, predicted_chain)
class TestAnalyser:
if __name__ == "__main__":
#método construtor
print("Teste de análise de sentimentos!")
sessionTemp = Sessao()
emailsTemp = sessionTemp.query()
#impressão dos result sets da query
print("Lista de emails")
print(emailsTemp)
'''
base = [('eu sou admirada por muitos','alegria'),
('me sinto completamente amado','alegria'),
('amar e maravilhoso','alegria'),
('estou me sentindo muito animado novamente','alegria'),
('eu estou muito bem hoje','alegria'),
('que belo dia para dirigir um carro novo','alegria'),
('o dia está muito bonito','alegria'),
('estou contente com o resultado do teste que fiz no dia de ontem','alegria'),
('o amor e lindo','alegria'),
('nossa amizade e amor vai durar para sempre', 'alegria'),
('estou amedrontado', 'medo'),
('ele esta me ameacando a dias', 'medo'),
('isso me deixa apavorada', 'medo'),
('este lugar e apavorante', 'medo'),
('se perdermos outro jogo seremos eliminados e isso me deixa com pavor', 'medo'),
('tome cuidado com o lobisomem', 'medo'),
('se eles descobrirem estamos encrencados', 'medo'),
('estou tremendo de medo', 'medo'),
('eu tenho muito medo dele', 'medo'),
('estou com medo do resultado dos meus testes', 'medo')]
'''
#print(base[1])
basetreinamento = [
('eu sou admirada por muitos', 'alegria'),
('me sinto completamente amado', 'alegria'),
('amar e maravilhoso', 'alegria'),
('estou me sentindo muito animado novamente', 'alegria'),
('eu estou muito bem hoje', 'alegria'),
('que belo dia para dirigir um carro novo', 'alegria'),
('o dia está muito bonito', 'alegria'),
('estou contente com o resultado do teste que fiz no dia de ontem',
'alegria'),
('o amor e lindo', 'alegria'),
('estou muito satisfeito com seu trabalho', 'alegria'),
('sinto prazer em trabalhar com voces', 'alegria'),
('sua equipe e otima', 'alegria'),
('recomendo seu trabalho', 'alegria'),
('voces são muito competentes', 'alegria'),
('ótimo trabalho', 'alegria'),
('se precisar é só chamar', 'alegria'),
('conte comigo', 'alegria'),
('obrigado', 'alegria'),
('estou feliz', 'alegria'),
('estou contente', 'alegria'),
('estou alegre', 'alegria'),
('tenha um bom dia', 'alegria'),
('voce é importante para nós', 'alegria'),
('nossa amizade e amor vai durar para sempre', 'alegria'),
('estou feliz', 'alegria'),
('estou tranquilo', 'alegria'),
('estou animado', 'alegria'),
('estou ótimo', 'alegria'),
('estou entusiasmado', 'alegria'),
('estou contente', 'alegria'),
('você e abominável', 'desgosto'),
('abomino a maneira como você age', 'desgosto'),
('estou adoentado', 'desgosto'),
('meu pai esta adoentado', 'desgosto'),
('estamos todos doentes', 'desgosto'),
('essa situação e muito amarga', 'desgosto'),
('disse adeus amargamente', 'desgosto'),
('tenho antipatia por aquela pessoa', 'desgosto'),
('como pode ser tão antipática!', 'desgosto'),
('que horrível seu asqueroso', 'desgosto'),
('tenho aversão agente como você', 'desgosto'),
('isso tudo e só chateação', 'desgosto'),
('estou muito chateada com suas mentiras', 'desgosto'),
('tão desagradável', 'desgosto'),
('isso me desagrada completamente', 'desgosto'),
('te desagrada isso', 'desgosto'),
('estou com enjôos terríveis', 'desgosto'),
('todos estão enfermos', 'desgosto'),
('foi uma enfermidade terrível', 'desgosto'),
('isso e muito grave', 'desgosto'),
('não seja tão grosseiro', 'desgosto'),
('você fez uma manobra ilegal', 'desgosto'),
('sua indecente, não tem vergonha?', 'desgosto'),
('você e malvado com as crianças', 'desgosto'),
('que comentário maldoso', 'desgosto'),
('sem escrúpulos você manipula a tudo', 'desgosto'),
('sinto repulsa por você', 'desgosto'),
('e repulsivo a maneira como olha para as pessoas', 'desgosto'),
('estou indisposta', 'desgosto'),
('a indisposição me atacou hoje', 'desgosto'),
('acho que vou vomitar', 'desgosto'),
('tem muito vomito lá', 'desgosto'),
('que incomodo essa dor', 'desgosto'),
('não me incomode nunca mais', 'desgosto'),
('suas bobagens estão nos incomodando', 'desgosto'),
('que nojo olha toda essa sujeira', 'desgosto'),
('como isso está sujo', 'desgosto'),
('tenho náuseas só de lembrar', 'desgosto'),
# ('me sinto nauseada com o cheiro desta comida','desgosto'),
# ('você esta obstruindo a passagem de ar','desgosto'),
# ('você esta terrivelmente doente','desgosto'),
# ('olhe que feia esta roupa','desgosto'),
# ('que atitude deplorável','desgosto'),
# ('nossa como você e feio','desgosto'),
# ('muito mau tudo isso','desgosto'),
# ('estou desgostoso com você','desgosto'),
# ('você cortou o meu assunto','desgosto'),
# ('para que tanta chateação?','desgosto'),
# ('esse perfume e enjoativo','desgosto'),
# ('ser perigoso não nada bom','desgosto'),
# ('você e perigoso demais para minha filhas','desgosto'),
# ('que fetido este esgoto','desgosto'),
# ('que fedido você esta','desgosto'),
# ('que cachorro malcheiroso','desgosto'),
# ('hora que ultraje','desgosto'),
# ('e ultrajante da sua parte','desgosto'),
# ('situação desagradável essa','desgosto'),
# ('você só me da desgosto','desgosto'),
# ('tenho aversão a pessoas assim','desgosto'),
# ('antipatia e um mal da sociedade','desgosto'),
# ('que criatura abominável','desgosto'),
# ('e depressiva a maneira como você vê o mundo','desgosto'),
# ('me desagrada sua presença na festa','desgosto'),
# ('sinto asco dessa coisa','desgosto'),
# ('que hediondo!','desgosto'),
# ('vou golfar o cafe fora','desgosto'),
# ('hora que garota detestável!','desgosto'),
# ('estou nauseada','desgosto'),
# ('isso que você disse foi muito grave','desgosto'),
# ('não seja obsceno na frente das crianças','desgosto'),
# ('não seja rude com as visitas','desgosto'),
# ('esse assunto me da repulsa','desgosto'),
# ('que criança terrivelmente travessa','desgosto'),
# ('que criança mal educada','desgosto'),
# ('estou indisposta te dar o divorcio','desgosto'),
# ('tão patetico, não tem nada mais rude para dizer?','desgosto'),
# ('por motivo torpe, com emprego de meio cruel e com impossibilidade de defesa para a vítima','desgosto'),
# ('a inveja e tão vil e vergonhosa que ninguem se atreve a confessá-la','desgosto'),
# ('o miserável receio de ser sentimental e o mais vil de todos os receios modernos','desgosto'),
# ('travesso gato quando fica com saudades do dono mija no sapato','desgosto'),
# ('isso e um ato detestável e covarde','desgosto'),
# ('revelam apenas o que e destrutivo e detestável para o povo','desgosto'),
# ('não sei como e a vida de um patife, mais a de um homem honesto e abominável','desgosto'),
# ('há coisas que temos que suportar para não acharmos a vida insuportável','desgosto'),
# ('as injurias do tempo e as injustiças do homem','desgosto'),
# ('odioso e desumano','desgosto'),
# ('você não publicará conteúdo odiento, pornográfico ou ameaçador','desgosto'),
# ('rancoroso e reprimido','desgosto'),
# ('não há animal mais degradante, estúpido, covarde, lamentável, egoísta, rancoroso e invejoso do que o homem','desgosto'),
# ('o virulento debate ente políticos','desgosto'),
('por favor não me abandone', 'tristeza'),
('não quero ficar sozinha', 'tristeza'),
('não me deixe sozinha', 'tristeza'),
('estou abatida', 'tristeza'),
('ele esta todo abatido', 'tristeza'),
('tão triste suas palavras', 'tristeza'),
('seu amor não e mais meu', 'tristeza'),
('estou aborrecida', 'tristeza'),
('isso vai me aborrecer', 'tristeza'),
('estou com muita aflição', 'tristeza'),
('me aflige o modo como fala', 'tristeza'),
('estou em agonia com meu intimo', 'tristeza'),
('não quero fazer nada', 'tristeza'),
('me sinto ansiosa e tensa', 'tristeza'),
('não consigo parar de chorar', 'tristeza'),
('não consigo segurar as lagrimas', 'tristeza'),
# ('e muita dor perder um ente querido','tristeza'),
# ('estou realmente arrependida','tristeza'),
# ('acho que o carma volta, pois agora sou eu quem sofro','tristeza'),
# ('você não cumpriu suas promessas','tristeza'),
# ('me sinto amargurada','tristeza'),
# ('coitado esta tão triste','tristeza'),
# ('já e tarde de mais','tristeza'),
# ('nosso amor acabou','tristeza'),
# ('essa noite machuca só para mim','tristeza'),
# ('eu não estou mais no seu coração','tristeza'),
# ('você mudou comigo','tristeza'),
# ('quando eu penso em você realmente dói','tristeza'),
# ('como se fosse nada você vê minhas lagrimas','tristeza'),
# ('você disse cruelmente que não se arrependeu','tristeza'),
# ('eu nunca mais vou te ver','tristeza'),
# ('ela esta com depressão','tristeza'),
# ('a depressão aflige as pessoas','tristeza'),
# ('estar depressivo e muito ruim','tristeza'),
# ('estou derrotada e deprimida depois deste dia','tristeza'),
# ('e comovente te ver dessa maneira','tristeza'),
# ('e comovente ver o que os filhos do brasil passam','tristeza'),
# ('como me sinto culpada','tristeza'),
# ('estou abatida','tristeza'),
# ('a ansiedade tomou conta de mim','tristeza'),
# ('as pessoas não gostam do meu jeito','tristeza'),
# ('adeus passamos bons momentos juntos','tristeza'),
# ('sinto sua falta','tristeza'),
# ('ele não gostou da minha comida','tristeza'),
# ('estou sem dinheiro para a comida','tristeza'),
# ('queria que fosse o ultimo dia da minha vida','tristeza'),
# ('você está com vergonha de mim','tristeza'),
# ('ela não aceitou a minha proposta','tristeza'),
# ('era o meu ultimo centavo','tristeza'),
# ('reprovei de ano na faculdade','tristeza'),
# ('afinal você só sabe me desfazer','tristeza'),
# ('eu falhei em tudo nessa vida','tristeza'),
# ('eu fui muito humilhado','tristeza'),
# ('e uma história muito triste','tristeza'),
# ('ninguem acredita em mim','tristeza'),
# ('eu não sirvo para nada mesmo','tristeza'),
# ('droga, não faço nada direito','tristeza'),
# ('sofrimento em dobro na minha vida','tristeza'),
# ('fui demitida essa semana','tristeza'),
('as crianças sofrem ainda mais que os adultos', 'tristeza'),
('pra mim um dia e ruim, o outro e pior', 'tristeza'),
('de repente perdi o apetite', 'tristeza'),
('oh que dia infeliz', 'tristeza'),
('estamos afundados em contas', 'tristeza'),
('nem um milagre pode nos salvar', 'tristeza'),
('só me resta a esperança', 'tristeza'),
('pior que isso não pode ficar', 'tristeza'),
('meu salário e baixo', 'tristeza'),
('não passei no vestibular', 'tristeza'),
('ninguem se importa comigo', 'tristeza'),
('ninguem lembrou do meu aniversário', 'tristeza'),
('tenho tanto azar', 'tristeza'),
# ('o gosto da vingança e amargo','tristeza'),
# ('sou uma mulher amargurada depois de que você me deixou','tristeza'),
# ('estou desanimada com a vida','tristeza'),
# ('e um desanimo só coitadinha','tristeza'),
# ('a derrota e depressiva','tristeza'),
# ('discriminar e desumano','tristeza'),
# ('que desanimo','tristeza'),
# ('e uma desonra para o pais','tristeza'),
# ('a preocupação deveria nos levar a ação não a depressão','tristeza'),
# ('passamos ao desalento e a loucura','tristeza'),
# ('aquele que nunca viu a tristeza nunca reconhecerá a alegria','tristeza'),
# ('cuidado com a tristeza ela e um vicio','tristeza'),
('eu imploro, não me matem!', 'medo'),
('tem certeza que não e perigoso?', 'medo'),
('não tenho certeza se e seguro', 'medo'),
('tenho que correr pra não me pegarem', 'medo'),
('socorro! ele queria roubar os meus doces!', 'medo'),
('esse cara está me perseguindo', 'medo'),
('não entro lá, e um lugar muito perigoso', 'medo'),
('este lugar continua assustador', 'medo'),
('na selva tem muitos animais perigosos', 'medo'),
('avancem com cautela', 'medo'),
('este lugar está silencioso de mais, cuidado!', 'medo'),
('por favor, deixe-me viver!', 'medo'),
('vou ficar sem mesada se tirar nota baixa', 'medo'),
('parece que tem olhos nos vigiando', 'medo'),
('eu temo que a sentença do juiz possa ser negativa', 'medo'),
('mas essa missão e arriscada', 'medo'),
('salvem-se quem puder!', 'medo'),
('meu plano pode ser descoberto', 'medo'),
('não tive culpa, juro não fui eu', 'medo'),
('tenho que tomar cuidado com o lobisomem', 'medo'),
('se eu não achar, ele vai descobrir a verdade', 'medo'),
('meu deus, ele desapareceu!', 'medo'),
('tomara que eles não me vejam daqui!', 'medo'),
('mantenha isso em segredo, se descobrirem estaremos ferrados',
'medo'),
('por favor, me soltem, eu sou inocente', 'medo'),
('estou ouvindo passos atrás de mim', 'medo'),
('eu vou pedir socorro!', 'medo'),
('cuidado com as curvas na estrada', 'medo'),
('não sei não, parece perigoso', 'medo'),
('estou tremendo de medo!', 'medo'),
('socorro, eu vou cair!', 'medo'),
# ('eu não vou ate a floresta negra, e muito perigoso','medo'),
# ('ouço passos na minha direção','medo'),
# ('acho que está arriscado de mais','medo'),
# ('vamos voltar, e muito perigoso','medo'),
# ('fuja, se não acabaremos mortos','medo'),
# ('receio por não me livrar desta situação','medo'),
# ('socorro! ele está armado!','medo'),
# ('ei cuidado, você vai bater no poste!','medo'),
# ('socorro, nós estamos afundando','medo'),
# ('e serio, cuidado com essa arma!','medo'),
# ('os tubarões estão atacando!','medo'),
# ('sinto arrepios quando fico sozinho no escuro','medo'),
# ('calma, eu não estou com o dinheiro','medo'),
# ('eu acho que estou sendo enganado','medo'),
# ('ligeiro, temos que fugir depressa','medo'),
# ('tem um crocodilo selvagem vindo para cá','medo'),
# ('se ficarmos quietos eles não vão nos achar','medo'),
# ('fuja! o tigre parece faminto','medo'),
# ('estou sem saída, preciso de um milagre','medo'),
# ('tire isso de mim! socorro!','medo'),
# ('não sei nadar, vou me afogar!','medo'),
# ('não tenho certeza se e seguro','medo'),
# ('vou apanhar se meus pais verem meu boletim','medo'),
# ('não consigo sair daqui!','medo'),
# ('se sair tão tarde, poderei ser assaltada','medo'),
# ('não me deixe por favor!','medo'),
# ('espere, não pode me largar aqui sozinho','medo'),
# ('temo pela sua segurança','medo'),
# ('eu te entrego o dinheiro, por favor não me mate!','medo'),
# ('ele vai levar todo o meu dinheiro','medo'),
# ('não dirija tão rápido assim','medo'),
# ('me descobriram, irão me prender!','medo'),
# ('só espero que não me façam nenhum mal','medo'),
# ('vou me afogar, me ajudem a sair da água','medo'),
# ('não estaremos a salvo aqui','medo'),
# ('não quero nem pensar no que pode acontecer','medo'),
# ('nessa cidade e uma desgraça atrás da outra','medo'),
# ('alguem esta me ligando, estou assustado','medo'),
# ('isso não e remedio, não me matem','medo'),
# ('eu não confio nele, tenho que ter cautela','medo'),
# ('muita cautela','medo'),
# ('vou ser descoberto, meu deus','medo'),
# ('receio que terei de ir','medo'),
# ('a noite e muito perigosa','medo'),
# ('estou estremecendo com essa casa','medo'),
# ('olha aquela criatura se movendo monstruosamente','medo'),
# ('não agüento este suspense','medo'),
# ('afugente os cães','medo'),
# ('estou chocado e amedrontado com este assassinato brutal','medo'),
# ('e preciso afugenta com ímpeto este medo do inferno','medo'),
# ('seu políticos usam suas forças para afugentar e amedrontar o povo','medo'),
# ('o objetivo disso e apenas me amedrontar mais','medo'),
('isso me apavora', 'medo')
]
baseteste = [
('muito obrigado por tudo', 'alegria'),
('agradeço de coração', 'alegria'),
('desejo paz', 'alegria'),
('desejo felicidades', 'alegria'),
('desejo afeto', 'alegria'),
('desejo carinho', 'alegria'),
('desejo respeito', 'alegria'),
('desejo um feliz aniversário', 'alegria'),
('sempre às ordens', 'alegria'),
('nosso trabalho é ajuda-lo', 'alegria'),
('vocês são excelente', 'alegria'),
('vocês são ótimos', 'alegria'),
('vocês são recomendáveis', 'alegria'),
('sempre vou recomendar vocês', 'alegria'),
('paragebéns pela equipe', 'alegria'),
('bela equipe vocês tem', 'alegria'),
('estou muito feliz', 'alegria'),
('estou muito contente', 'alegria'),
('estou muito alegre', 'alegria'),
('estou alegre', 'alegria'),
('se precisar é só chamar', 'alegria'),
('conte comigo', 'alegria'),
('obrigado', 'alegria'),
('estou feliz', 'alegria'),
('estou contente', 'alegria'),
('estou alegre', 'alegria'),
('tenha um bom dia', 'alegria'),
('voce é importante para nós', 'alegria'),
('nossa amizade e amor vai durar para sempre', 'alegria'),
('estou feliz', 'alegria'),
('estou tranquilo', 'alegria'),
('estou animado', 'alegria'),
('estou ótimo', 'alegria'),
('estou entusiasmado', 'alegria'),
('estou contente', 'alegria'),
('o mundo e feio como o pecado', 'desgosto'),
('a coisa mais difícil de esconder e aquilo que não existe',
'desgosto'),
('você errou feio aquele gol', 'desgosto'),
('nunca vou me casar sou muito feia', 'desgosto'),
('os golpes da adversidade são terrivelmente amargos', 'desgosto'),
('os homem ficam terrivelmente chatos', 'desgosto'),
('abominavelmente convencido', 'desgosto'),
('terrivelmente irritado', 'desgosto'),
('as instituições publicas estão terrivelmente decadentes',
'desgosto'),
('a população viveu em isolamento por muito tempo', 'desgosto'),
('estou terrivelmente preocupada', 'desgosto'),
('o nacionalismo e uma doença infantil', 'desgosto'),
('se me es antipático a minha negação esta pronta', 'desgosto'),
('muitos documentários sobre esse casal antipático', 'desgosto'),
('sua beleza não desfaça sua antipatia', 'desgosto'),
('esta e uma experiência desagradável', 'desgosto'),
('desagradável estrago nos banheiros', 'desgosto'),
('o mais irritante no amor e que se trata de um crime que precisa de um cúmplice',
'desgosto'),
('a situação nos causa grande incomodo', 'desgosto'),
('estou preocupado com o incomodo na garganta', 'desgosto'),
('simplesmente não quero amolação da policia', 'desgosto'),
('você e uma criaturinha muito impertinente', 'desgosto'),
('o peso e a dor da vida', 'desgosto'),
('me arrependo amargamente de minhas ações', 'desgosto'),
('o destino e cruel e os homens não são dignos de compaixão',
'desgosto'),
('o ódio conduz ao isolamento cruel e ao desespero', 'desgosto'),
('encerrou com o massacre mais repudiável e asqueroso que se conhece',
'desgosto'),
('de mal gosto e asqueroso', 'desgosto'),
('tudo e inserto neste mundo hediondo', 'desgosto'),
('o crime de corrupção e um crime hediondo', 'desgosto'),
('o rio esta fetido e de cor escura', 'desgosto'),
('muito lixo no rio o deixa malcheiroso', 'desgosto'),
('existe uma laranja podre no grupo e já desconfiamos quem e',
'desgosto'),
('foi de repente estou machucado e me sentindo enjoado',
'desgosto'),
('eu fiquei enojado', 'desgosto'),
('daqui alguns meses vou embora deste pais que já estou nauseado',
'desgosto'),
('isso tudo e um erro', 'tristeza'),
('eu sou errada eu sou errante', 'tristeza'),
('tenho muito dó do cachorro', 'tristeza'),
('e dolorida a perda de um filho', 'tristeza'),
('essa tragedia vai nos abalar para sempre', 'tristeza'),
('perdi meus filhos', 'tristeza'),
('perdi meu curso', 'tristeza'),
('sou só uma chorona', 'tristeza'),
('você e um chorão', 'tristeza'),
('se arrependimento matasse', 'tristeza'),
('me sinto deslocado em sala de aula', 'tristeza'),
('foi uma passagem fúnebre', 'tristeza'),
('nossa condolências e tristeza a sua perda', 'tristeza'),
('desanimo, raiva, solidão ou vazies, depressão', 'tristeza'),
('vivo te desanimando', 'tristeza'),
('estou desanimado', 'tristeza'),
('imperador sanguinário, depravado e temeroso', 'tristeza'),
('meu ser esta em agonia', 'tristeza'),
('este atrito entre nos tem que acabar', 'tristeza'),
('a escuridão desola meu ser', 'tristeza'),
('sua falsa preocupação', 'tristeza'),
('sua falsidade me entristece', 'tristeza'),
('quem esta descontente com os outros esta descontente consigo próprio',
'tristeza'),
('a torcida esta descontente com a demissão do tecnico',
'tristeza'),
# ('estou bastante aborrecido com o jornal','tristeza'),
# ('me sinto solitário e entediado','tristeza'),
# ('a vida e solitária para aqueles que não são falsos','tristeza'),
# ('como com compulsão depois da depressão','tristeza'),
# ('estou me desencorajando a viver','tristeza'),
# ('ele desencoraja minhas vontades','tristeza'),
# ('isso vai deprimindo por dentro','tristeza'),
# ('acho que isso e defeituoso','tristeza'),
# ('os remedios me derrubam na cama','tristeza'),
# ('a depressão vai me derrubar','tristeza'),
# ('suas desculpas são falsas','tristeza'),
# ('não magoe as pessoas','tristeza'),
('que abominável esse montro!', 'medo'),
('vamos alarmar a todos sobre a situação', 'medo'),
('estou amedrontada', 'medo'),
('estou com muito medo da noite', 'medo'),
('ele esta me ameaçando a dias', 'medo'),
('quanta angustia', 'medo'),
('estou angustiada', 'medo'),
('angustiadamente vou sair e casa', 'medo'),
('isso me deixa apavorada', 'medo'),
('você esta me apavorando', 'medo'),
('estou desconfiada de você', 'medo'),
('não confio em você', 'medo'),
('ate o cachorro está apavorado', 'medo'),
('estou assustado com as ações do meu colega', 'medo'),
('agora se sente humilhado, apavorado', 'medo'),
('assustou a população e provocou mortes', 'medo'),
('estou com dificuldades para respirar e muito assustado', 'medo'),
('os policiais se assustaram quando o carro capotou', 'medo'),
('o trabalhador e assombrado pelo temor do desemprego', 'medo'),
('este lugar e mal assombrado', 'medo'),
('estou assombrado pela crise financeira', 'medo'),
('mesmo aterrorizado lembro de você', 'medo'),
('aterrorizado e suando frio', 'medo'),
('um grupo de elefantes selvagens tem aterrorizado vilas', 'medo'),
('me sinto intimidada pela sua presença', 'medo'),
('tenho medo de ser advertida novamente', 'medo'),
('estou correndo o risco de ser advertido', 'medo'),
('estou correndo riscos de saúde', 'medo'),
('os riscos são reais', 'medo'),
('podemos perder muito dinheiro com essa investida', 'medo'),
('socorro, fui intimado a depor', 'medo'),
('fui notificado e estou com medo de perde a guarda da minha filha',
'medo'),
('estou angustiada com meus filhos na rua', 'medo'),
('e abominável o que fazem com os animais', 'medo'),
('foi terrível o tigre quase o matou', 'medo'),
('me advertiram sobre isso', 'medo')
]
stopwords = [
'a', 'agora', 'algum', 'alguma', 'aquele', 'aqueles', 'de', 'deu',
'do', 'e', 'estou', 'esta', 'esta', 'ir', 'meu', 'muito', 'mesmo',
'no', 'nossa', 'o', 'outro', 'para', 'que', 'sem', 'talvez', 'tem',
'tendo', 'tenha', 'teve', 'tive', 'todo', 'um', 'uma', 'umas',
'uns', 'vou'
]
stopwordsnltk = nltk.corpus.stopwords.words('portuguese')
stopwordsnltk.append('vou')
stopwordsnltk.append('tão')
#print(stopwordsnltk)
def removestopwords(texto):
frases = []
for (palavras, emocao) in texto:
semstop = [
p for p in palavras.split() if p not in stopwordsnltk
]
frases.append((semstop, emocao))
return frases
#print(removestopwords(base))
def aplicastemmer(texto):
stemmer = nltk.stem.RSLPStemmer()
frasessstemming = []
for (palavras, emocao) in texto:
comstemming = [
str(stemmer.stem(p)) for p in palavras.split()
if p not in stopwordsnltk
]
frasessstemming.append((comstemming, emocao))
return frasessstemming
frasescomstemmingtreinamento = aplicastemmer(basetreinamento)
frasescomstemmingteste = aplicastemmer(baseteste)
#print(frasescomstemming)
def buscapalavras(frases):
todaspalavras = []
for (palavras, emocao) in frases:
todaspalavras.extend(palavras)
return todaspalavras
palavrastreinamento = buscapalavras(frasescomstemmingtreinamento)
palavrasteste = buscapalavras(frasescomstemmingteste)
#print(palavras)
def buscafrequencia(palavras):
palavras = nltk.FreqDist(palavras)
return palavras
frequenciatreinamento = buscafrequencia(palavrastreinamento)
frequenciateste = buscafrequencia(palavrasteste)
#print(frequencia.most_common(50))
def buscapalavrasunicas(frequencia):
freq = frequencia.keys()
return freq
palavrasunicastreinamento = buscapalavrasunicas(frequenciatreinamento)
palavrasunicasteste = buscapalavrasunicas(frequenciateste)
#print(palavrasunicastreinamento)
#print(palavrasunicas)
def extratorpalavras(documento):
doc = set(documento)
caracteristicas = {}
for palavras in palavrasunicastreinamento:
caracteristicas['%s' % palavras] = (palavras in doc)
return caracteristicas
caracteristicasfrase = extratorpalavras(['am', 'nov', 'dia'])
#print(caracteristicasfrase)
basecompletatreinamento = nltk.classify.apply_features(
extratorpalavras, frasescomstemmingtreinamento)
basecompletateste = nltk.classify.apply_features(
extratorpalavras, frasescomstemmingteste)
#print(basecompleta[15])
# constroi a tabela de probabilidade
classificador = nltk.NaiveBayesClassifier.train(
basecompletatreinamento)
print(classificador.labels())
#print(classificador.show_most_informative_features(20))
print(nltk.classify.accuracy(classificador, basecompletateste))
erros = []
for (frase, classe) in basecompletateste:
#print(frase)
#print(classe)
resultado = classificador.classify(frase)
if resultado != classe:
erros.append((classe, resultado, frase))
#for (classe, resultado, frase) in erros:
# print(classe, resultado, frase)
from nltk.metrics import ConfusionMatrix
esperado = []
previsto = []
for (frase, classe) in basecompletateste:
resultado = classificador.classify(frase)
previsto.append(resultado)
esperado.append(classe)
#esperado = 'alegria alegria alegria alegria medo medo surpresa surpresa'.split()
#previsto = 'alegria alegria medo surpresa medo medo medo surpresa'.split()
matriz = ConfusionMatrix(esperado, previsto)
print(matriz)
# 1. Cenário
# 2. Número de classes - 16%
# 3. ZeroRules - 21,05%
teste = 'Boa Tarde, Favor verificar porque não consigo cadastrar um país, nem com senha mestre Aguardo'
testestemming = []
stemmer = nltk.stem.RSLPStemmer()
for (palavrastreinamento) in teste.split():
comstem = [p for p in palavrastreinamento.split()]
testestemming.append(str(stemmer.stem(comstem[0])))
print(testestemming)
novo = extratorpalavras(testestemming)
print(novo)
print(classificador.classify(novo))
distribuicao = classificador.prob_classify(novo)
for classe in distribuicao.samples():
print("%s: %f" % (classe, distribuicao.prob(classe)))
erros.append((classe, resultado, frase))
#for (classe, resultado, frase) in erros:
# print(classe, resultado, frase)
from nltk.metrics import ConfusionMatrix
esperado = []
previsto = []
for (frase, classe) in baseCompletaTeste:
resultado = classificador.classify(frase)
esperado.append(classe)
previsto.append(resultado)
#esperado = 'alegria alegria alegria alegria medo medo surpresa surpresa'.split()
#previsto = 'alegria alegria medo surpresa medo medo medo surpresa'.split()
matrix = ConfusionMatrix(esperado, previsto)
print(matrix)
teste = 'eu sinto amor por voce'
testeStemming = []
stemmer = nltk.stem.RSLPStemmer()
for palavras in teste.split():
comStem = [p for p in palavras.split()]
testeStemming.append(str(stemmer.stem(comStem[0])))
#print(testeStemming)
novo = extratorPalavras(testeStemming)
#print(novo)
'''
print(classificador.classify(novo))
distribuicao = classificador.prob_classify(novo)
def process(self, posWords, negWords, posI, negI, tokenizedComm,
train_file="./resources/train.txt", test_file="./resources/test.txt"):
comments = self.loadComments()
(train, test) = self.load_train_test_set(train_file, test_file)
N = 20
train_set = []
for i in train:
(com, value) = comments[i]
if value != self.Exc:
if value < 3:
splitted = tokenizedComm[i]
train_set.append((self.feature(N, com, splitted, posWords,
negWords, posI, negI), "neg"))
else:
splitted = tokenizedComm[i]
train_set.append((self.feature(N, com, splitted, posWords,
negWords, posI, negI), "pos"))
# clasificador
classifier = nltk.NaiveBayesClassifier.train(train_set)
# Para testing se han excluido comentarios con puntuacion 3, es decir
# se evaluan comentarios positivos y negativos.
dev_set = []
errorComments = []
refset = collections.defaultdict(set)
testset = collections.defaultdict(set)
ref_list = []
test_list = []
it = 0
for i in test:
(com, value) = comments[i]
if value != self.Exc:
it = it + 1
splitted = tokenizedComm[i]
evaluate = self.feature(N, com, splitted, posWords, negWords,
posI, negI)
if value < 3:
dev_set.append((evaluate, "neg"))
refset["neg"].add(it)
ref_list.append("neg")
else:
dev_set.append((evaluate, "pos"))
refset["pos"].add(it)
ref_list.append("pos")
res = classifier.classify(evaluate)
testset[res].add(it)
test_list.append(res)
if res == "neg":
if value < 3:
message = "OK"
else:
message = "ERROR"
else:
if value > 3:
message = "OK"
else:
message = "ERROR"
if(message == "ERROR"):
errorComments.append((com, value))
classifier.show_most_informative_features(50)
# confusion matrix
cm = ConfusionMatrix(ref_list, test_list)
cm = '\n' + cm.pp(sort_by_count=True, show_percents=False, truncate=9)
# data metrics
accuracy = nltk.classify.accuracy(classifier, dev_set)
pPos = nltk.metrics.precision(refset['pos'], testset['pos'])
rPos = nltk.metrics.recall(refset['pos'], testset['pos'])
pNeg = nltk.metrics.precision(refset['neg'], testset['neg'])
rNeg = nltk.metrics.recall(refset['neg'], testset['neg'])
Metrics = {'Accuracy': accuracy,
'Precision Pos': pPos,
'Recall Pos': rPos,
'Precision Neg': pNeg,
'Recall Neg': rNeg,
'Confusion Matrix': cm}
for m in sorted(Metrics.keys()):
print m, Metrics[m]
num = [accuracy, pPos, rPos, pNeg, rNeg]
return (Metrics, num)
