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