def negWords(headline,body):
b_count = 0
h_count = 0
for b in body:
if vader.negated(b):
b_count = b_count + 1
for h in headline:
if vader.negated(h):
h_count = h_count + 1
hlen = len(headline)
blen = len(body)
if hlen!=0 and blen!=0:
return abs((b_count/blen)-(h_count/hlen))
else:
#print("------------------------------------------------------")
return 0
def transform(self, X, y=None):
maxlen = self.maxlen
vecs = []
for tokens in X[self.column]:
vectors = []
negs = FeatureExtractor.negation_tagger(tokens.split())
for n in negs:
if str(n).endswith("_NEG"):
vectors.append(1)
else:
vectors.append(0)
if negated(tokens.split()):
vectors.append(3)
else:
vectors.append(4)
diff = maxlen - len(vectors)
if diff > 0:
for n in range(diff):
vectors.append(2)
elif diff < 0:
for n in range(abs(diff)):
vectors.pop()
vecs.append(vectors)
return vecs
def negWords(headline, body):
b_count = 0
h_count = 0
for b in body:
if vader.negated(b):
b_count = b_count + 1
for h in headline:
if vader.negated(h):
h_count = h_count + 1
hlen = len(headline)
blen = len(body)
if hlen != 0 and blen != 0:
return abs((b_count / blen) - (h_count / hlen))
else:
#print("------------------------------------------------------")
return 0
def bool_negation_tagger(sentence):
"""Tags negation for a sentence (not a list of tokens)
:param list sentences: the premise or hypothesis
:rtype: list
:return: True for sentences that contain negation, otherwise False
"""
return negated(sentence)
def negated(self):
'''
find if a sentence has negation word
store the True/false per sentence to negation.csv
'''
negation_result = [[self.id_column, 'sentence', 'hasNegation']]
for sent_id, sent in itertools.zip_longest(self.id, self.sentences):
negation_result.append(
[sent_id,
sent.encode('utf-8', 'ignore'),
negated(sent)])
return negation_result
def determineNegationFeature(texts):
"""
Creates feature (0 or 1) for whether the tweet contains negated segments or not
:param doc_name: Tweet as string
:return: Binary value (0 or 1)
"""
negated = []
for text in texts:
feature = vader.negated(text, include_nt=True)
if feature:
negated.append(float(1))
else:
negated.append(float(0))
return sparse.csr_matrix(negated, dtype='float').T
def determineNegationFeature(texts):
"""
Creates feature (0 or 1) for whether the tweet contains negated segments or not
:param doc_name: Tweet as string
:return: Binary value (0 or 1)
"""
negated = []
for text in texts:
feature = vader.negated(text, include_nt=True)
if feature:
negated.append(float(1))
else:
negated.append(float(0))
return sparse.csr_matrix(negated, dtype='float').T
def get_sentiment(response):
processed_response = response.replace('"','')
if vader.negated(processed_response):
sentiment = 'neg'
return 'neg'
sent = vader.SentimentIntensityAnalyzer()
score = sent.polarity_scores(processed_response)
sent_list = ['neg','neutral','pos']
neg = score['neg']
neutral = score['neu']
pos = score['pos']
sent_score = [neg,neutral,pos]
big_score = max(sent_score)
index = sent_score.index(big_score)
sentiment = sent_list[index]
return sentiment
def get_sentiment(response):
processed_response = response.replace('"','')
if vader.negated(processed_response):
sentiment = 'neg'
return 'neg'
sent = vader.SentimentIntensityAnalyzer()
score = sent.polarity_scores(processed_response)
sent_list = ['neg','neutral','pos']
neg = score['neg']
neutral = score['neu']
pos = score['pos']
sent_score = [neg,neutral,pos]
big_score = max(sent_score)
index = sent_score.index(big_score)
sentiment = sent_list[index]
return sentiment
def __init__(self, reviewtext):
self.reviewtext = reviewtext
self.tokens = [t.lower() for t in word_tokenize(reviewtext)]
self.ntokens = len(self.tokens)
# create a list of tokens including only those in the lexicon
self.lexicontokens = [t for t in self.tokens if t in lexicon]
# create a list of tuples of token, sentiment score
self.lextok_kvtup = [(t, lexicon[t]) for t in self.lexicontokens]
# sort by value
self.sorted_lextokens = sorted(self.lextok_kvtup,
key=lambda kvtup: kvtup[1])
self.ntokens_lexicon = len(self.lexicontokens)
self.sentiments = np.array([tv[1] for tv in self.sorted_lextokens])
self.createStats()
# using sentence tokenization
# if a sentence contains negation, flip the sentiment values.
self.sentences = [s for s in sent_tokenize(reviewtext)]
self.sentnegated = np.zeros(len(self.sentences))
self.sentlextok_kvtup_2 = []
self.lextok_kvtup_2 = []
for i, s in enumerate(self.sentences):
sentencetokens = [t.lower() for t in word_tokenize(s)]
sentntokens = len(sentencetokens)
sentlextokens = [t for t in sentencetokens if t in lexicon]
if negated(sentencetokens):
sentlextok_kvtup = [("NEG:" + t, negation * lexicon[t])
for t in sentlextokens]
self.sentnegated[i] = 1
else:
sentlextok_kvtup = [(t, lexicon[t]) for t in sentlextokens]
self.lextok_kvtup_2.extend(sentlextok_kvtup)
self.sentlextok_kvtup_2.append(sentlextok_kvtup)
# sort by value
self.sorted_lextokens_2 = sorted(self.lextok_kvtup_2,
key=lambda kvtup: kvtup[1])
self.sentiments_2 = np.array([tv[1] for tv in self.sorted_lextokens_2])
self.createStats_2()
def negated(self):
self.negation_result = [['sentence', 'hasNegation']]
for item in self.sent:
self.negation_result.append(
[item.encode('utf-8', 'ignore'),
negated(item)])
prem_fol, hypo_fol = [ pmb2fol(args.pmb, pd, sig=signature, drawDRS=args.draw_DRS)\
for pd in sick2pd[p[0]] ]
pred, details = solve_fol_inference(prem_fol, hypo_fol, str_axioms=kb.get(p[0],[]), p_number=p[0])
premis = p[-2].split()
hypothesis = p[-1].split()
premis_neg = mark_negation(premis)
hypo_neg = mark_negation(hypothesis)
for premis_token, hypo_token in zip(premis_neg, hypo_neg):
if premis_token.endswith('_NEG') or hypo_token.endswith('NEG'):
# using the sentiment.util package for token-level negation
pred = 'CONTRADICTION'
if negated(premis) or negated(hypothesis):
# using the sentiment.vader package for boolean
pred = 'CONTRADICTION'
# printing and recording answers
eureka = "Eureka!!!" if pred == p[1] and pred != 'NEUTRAL' else ''
info("Result for {:>4}: {} vs {} ({}) {}".format(p[0], p[1], pred.lower(), details, eureka))
count.update([details])
# Save only the first letter of the inference relations
gold_labs.append(p[1][0])
pred_labs.append(pred[0])
prob_ids.append(p[0])
# prints counts of the theorem proving details
print('{:=^100}'.format(' Status counts ({})'.format(sum(count.values()))))
