def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') # create a class that scores only adjectives ds = sentdoc.BasicDocSentiScore() ds.verbose = False ds.set_active_pos(True, True, False, False) ds.set_lexicon(L) # score untagged doc - this should cause an exception self.assertRaises(AssertionError, ds.classify_document, TESTDOC_UNTAGGED, verbose=False) # this should work (dpos, dneg) = ds.classify_document(TESTDOC_UNTAGGED, verbose=False, tagged=False) self.assertTrue(dpos > 0, 'Did not score "good" in untagged doc') # score again, now changing all tags to false (dpos, dneg) = ds.classify_document(TESTDOC_UNTAGGED, verbose=False, tagged=False, a=False, v=False, n=False, r=False) self.assertTrue(dpos == 0 and dneg == 0, 'Scprng with no active tags should not happen')
def runTest(self): # empty list ds = sentdoc.PottsDocSentiScore() L = sentlex.MobyLexicon() ds.verbose = True ds.set_lexicon(L) negated_sent = 'not/DT good/JJ' ds.set_active_pos(True, False, False, False) ds.set_parameters(negation=True, negation_window=15) (dpos, dneg) = ds.classify_document(negated_sent) self.assertTrue(dneg > dpos, 'Negation did not invert scores.') ds.set_parameters(negation=True, negation_window=15, atenuation=True, at_pos=0.5, at_neg=0.5) (dpos, dneg) = ds.classify_document(negated_sent) ds.set_parameters(negation=True, negation_window=15, atenuation=True, at_pos=1.0, at_neg=1.0) (dposfull, dnegfull) = ds.classify_document(negated_sent) self.assertTrue(dpos > dneg, 'Negation did not atenuate scores.') self.assertTrue(dposfull > dpos, 'Negation did not atenuate scores.')
def runTest(self): # load lexicon L=sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') # create a class that scores only adjectives ds=sentdoc.SentenceDocSentiScore(L) ds.verbose=False ds.set_lexicon(L) # now score! (dpos, dneg) = ds.classify_document(TESTDOC_ADJ, verbose=False) self.assertTrue(ds.resultdata and ds.resultdata.has_key('doc') and ds.resultdata.has_key('annotated_doc')\ and ds.resultdata.has_key('resultpos') and ds.resultdata.has_key('resultneg'), 'Did not populate resultdata after scoring doc') self.assertTrue(dpos > 0.0, 'Did not find positive words on positive doc') # again, for negative text (dpos, dneg) = ds.classify_document(TESTDOC_BADADJ, verbose=False) self.assertTrue(dneg > 0.0, 'Did not find negative words on negative doc') # negated text (dpos, dneg) = ds.classify_document(TESTDOC_NEGATED, verbose=False) self.assertTrue(dpos > 0.0, 'Did not find positive words on TESTDOC_NEGATED') # currupt data - should still work (dpos, dneg) = ds.classify_document(TESTDOC_CORRUPT, verbose=False)
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') for algo in [ sentdoc.AV_LightTabSentiScore(L), sentdoc.AV_AggressiveTabSentiScore(L), ]: algo.verbose = False (p, n) = algo.classify_document(TESTDOC_NEGATED, verbose=False)
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') ds = sentdoc.BasicDocSentiScore() ds.verbose = False ds.set_active_pos(True, True, False, False) ds.set_lexicon(L) ds.set_parameters(score_function='linear') (dpos, dneg) = ds.classify_document(TESTDOC_ADJ, verbose=False)
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') print '=== Testing all sample algorithms===' for algo in [ sentdoc.AV_LightTabSentiScore(L), sentdoc.AV_AggressiveTabSentiScore(L), ]: algo.verbose = True print ' ==> ' + str(algo.__class__) (p, n) = algo.classify_document(TESTDOC_NEGATED, verbose=True)
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') for algo in [ sentdoc.AV_LightPottsSentiScore(L), sentdoc.A_LightPottsSentiScore(L), sentdoc.AV_AggressivePottsSentiScore(L), sentdoc.A_AggressivePottsSentiScore(L) ]: algo.verbose = False (p, n) = algo.classify_document(TESTDOC_NEGATED) self.assertTrue( n > 0.0, 'Sample document not scored correctly in %s' % str(algo.__class__))
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') print '=== Testing all sample algorithms===' for algo in [ sentdoc.AV_AllWordsDocSentiScore(L), sentdoc.A_AllWordsDocSentiScore(L), sentdoc.A_OnceWordsDocSentiScore(L), sentdoc.AV_OnceWordsDocSentiScore(L), sentdoc.AV_Lin_AllWordsDocSentiScore(L), sentdoc.A_Lin_AllWordsDocSentiScore(L), sentdoc.A_Cos_AllWordsDocSentiScore(L), sentdoc.AV_Cos_AllWordsDocSentiScore(L)]: algo.verbose=True (p,n) = algo.classify_document(TESTDOC_ADJ, verbose=True) self.assertTrue(p>n, 'Sample document not scored correctly in %s' % str(algo.__class__))
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') # create a class that scores only adjectives ds = sentdoc.PottsDocSentiScore() ds.verbose = True ds.set_active_pos(True, False, False, False) ds.set_parameters(score_mode=ds.SCOREALL, score_freq=False, negation=True, negation_adjustment=0.5) ds.set_lexicon(L) # separator ok? self.assertEqual(ds._detect_tag(TESTDOC_ADJ), '/', 'Unable to detect correct separator') # now score! (dpos, dneg) = ds.classify_document(TESTDOC_ADJ, verbose=True) self.assertTrue(ds.resultdata and ds.resultdata.has_key('doc') and ds.resultdata.has_key('annotated_doc')\ and ds.resultdata.has_key('resultpos') and ds.resultdata.has_key('resultneg'), 'Did not populate resultdata after scoring doc') self.assertTrue(dpos > 0.0, 'Did not find positive words on positive doc') print 'TESTDOC_ADJ (pos,neg): %2.2f %2.2f' % (dpos, dneg) # again, for negative text (dpos, dneg) = ds.classify_document(TESTDOC_BADADJ, verbose=True) self.assertTrue(dneg > 0.0, 'Did not find negative words on negative doc') print 'TESTDOC_BADADJ (pos,neg): %2.2f %2.2f' % (dpos, dneg) # negated text ds.set_neg_detection(True, 5) (dpos, dneg) = ds.classify_document(TESTDOC_NEGATED, verbose=True) self.assertTrue(dpos > 0.0, 'Did not find positive words on TESTDOC_NEGATED') print 'TESTDOC_NEGATED (pos,neg): %2.2f %2.2f' % (dpos, dneg) # currupt data - should still work (dpos, dneg) = ds.classify_document(TESTDOC_CORRUPT, verbose=True) self.assertTrue(dpos > dneg, 'Did not process corrupt document correctly')
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') ds = sentdoc.BasicDocSentiScore() ds.verbose=True ds.set_active_pos(True, True, False, False) ds.set_lexicon(L) print '=== cosine ===' ds.set_parameters(score_function='cosine') (dpos, dneg) = ds.classify_document(TESTDOC_ADJ, verbose=True) print '=== linear ===' ds.set_parameters(score_function='linear') (dpos, dneg) = ds.classify_document(TESTDOC_ADJ, verbose=True) for i in range(1,11): print ds._score_cosine(1.0, i, 10), print '\nLinear' for i in range(1,11): print ds._score_linear(1.0, i, 10),
def runTest(self): # load lexicon L = sentlex.MobyLexicon() self.assertTrue(L.is_loaded, 'Test lexicon did not load correctly') # create a class that scores only adjectives ds = sentdoc.BasicDocSentiScore() ds.verbose = False ds.set_active_pos(True, False, False, False) ds.set_parameters(score_mode=ds.SCOREALL, score_freq=False, negation=False) ds.set_lexicon(L) # separator ok? self.assertEqual(ds._detect_tag(TESTDOC_ADJ), '/', 'Unable to detect correct separator') # now score! (dpos, dneg) = ds.classify_document(TESTDOC_ADJ) self.assertTrue(ds.resultdata and ds.resultdata.has_key('doc') and ds.resultdata.has_key('annotated_doc')\ and ds.resultdata.has_key('resultpos') and ds.resultdata.has_key('resultneg'), 'Did not populate resultdata after scoring doc') self.assertTrue(dpos > dneg, 'Did not find positive words on positive doc') # again, for negative text (dpos, dneg) = ds.classify_document(TESTDOC_BADADJ) self.assertTrue(dneg > dpos, 'Did not find negative words on negative doc') # negated text ds.set_parameters(negation=True) ds.set_parameters(negation_window=15) (dpos, dneg) = ds.classify_document(TESTDOC_NEGATED) self.assertTrue(dpos > dneg, 'Did not find positive words on TESTDOC_NEGATED')