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 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()))))