Changeset 162:ca1529c62df9

Show
Ignore:
Timestamp:
08/21/07 19:12:16 (9 months ago)
Author:
Tarek Ziad?? <tarek@…>
Message:

fixes

Location:
classifier
Files:
5 modified

Legend:

Unmodified
Added
Removed

  • classifier/classifier.py

    r159 r162  
    3131        self.backend = backend 
    3232        self.tokenizer = tokenizer 
     33        self._learnt = True 
     34        self._probs = None 
     35 
    3336        if options is None: 
    3437            self.options = {'lang': self.language} 
    … …  
    4245        wich means: store words in categories 
    4346        """ 
     47        self._learnt = True 
    4448        self.backend.add_category(name=category) 
    4549        data = self.tokenizer.transform(data, self.options) 
    … …  
    5256        wich means: remove words from categories 
    5357        """ 
     58        self._learnt = True 
    5459        data = self.tokenizer.transform(data, self.options) 
    5560        for element in data: 
    56             self.backend.delWord(element, category) 
     61            self.backend.del_word(element, category) 
    5762 
    5863    def guess(self, data): 
    … …  
    6267 
    6368        # XXX this will be cached 
    64         probabilities = self._buildWordProbabilities() 
     69        if self._learnt: 
     70            self._probs = self._buildWordProbabilities() 
     71        else: 
     72            if self._probs is None: 
     73                self._probs = self._buildWordProbabilities() 
     74 
     75        probabilities = self._probs 
     76        self._learnt = False 
    6577 
    6678        res = {} 
    … …  
    124136    def _buildWordProbabilities(self, language=None): 
    125137        probs = {} 
     138        corpus_size = self.corpusSize(language) 
     139        words = list(self.backend.list_words(language, complete=True)) 
    126140        for cat in self.backend.list_categories(): 
    127             probs[cat] = self._buildCategoryWordProbabilities(cat, language) 
     141 
     142            probs[cat] = self._buildCategoryWordProbabilities(cat, language, 
     143                                                              corpus_size, words) 
    128144        return probs 
    129145 
    130     def _buildCategoryWordProbabilities(self, category, language=None): 
     146    def _buildCategoryWordProbabilities(self, category, language=None, 
     147                                        corpus_size=None, words=None): 
    131148        """Merges corpora and computes probabilities 
    132149 
    133150        XXX to be cached later (invalidation on word adding) 
    134151        """ 
     152        if corpus_size is None: 
     153            corpus_size = self.corpusSize(language) 
     154        if words is None: 
     155            words = self.backend.list_words(language, complete=True) 
    135156        if language is None: 
    136157            language = self.language 
    137         corpus_size = self.corpusSize(language) 
     158 
    138159        category_size = float(self.categorySize(category, language)) 
    139160        them_count = float(max(corpus_size - category_size, 1)) 
    140161        probabilities = {} 
    141         words = self.backend.list_words(language, complete=True) 
    142162 
    143163        for word in words: 
    144             if category not in word[1][1].keys(): 
     164            the_word = word[1][1] 
     165 
     166            if category not in the_word.keys(): 
    145167                continue 
    146168 
    … …  
    149171                continue 
    150172 
    151             cat_word_count = float(word[1][1][category]) 
    152             other_count = cat_word_count - word_count 
     173            cat_word_count = float(the_word[category]) 
     174            other_count = word_count - cat_word_count 
    153175 
    154176            if category_size == 0: 

  • classifier/doc/classifier.txt

    r160 r162  
    2323  >>> tokenizer = AllFilters() 
    2424  >>> classifier = BayesClassifier('fr', backend, tokenizer) 
     25 
     26Le backend doit être vide au début:: 
     27 
     28  >>> backend.word_count() 
     29  0 
    2530 
    2631Le classificateur fait deux choses: apprendre et deviner, pour une langue 
    … …  
    5964  [(u'achetez', 0.99...), (u'kimouss', 0.99...)] 
    6065 
    61   >>> classifier.learn('savon kimouss par-ci, savon par-la, savon toujours', 
     66  >>> classifier.learn('savon kipouss par-ci, savon par-la, savon toujours', 
    6267  ...                  'song') 
    6368  >>> sorted(classifier._buildCategoryWordProbabilities('spam').items()) #2 
    64   [(u'achetez', 0.99...), (u'kimouss', 0.99...), (u'savon', 0.0001)] 
     69  [(u'achetez', 0.99...), (u'kimouss', 0.99...), (u'savon', 0.14...)] 
     70 
     71  >>> classifier.categorySize('song') 
     72  4 
    6573 
    6674  >>> sorted(classifier._buildCategoryWordProbabilities('song').items()) 
    67    [(u'kimouss', 0.0001), (u'par', 0.99...), (u'savon', 0.99...), (u'toujours', 0.99...)] 
     75   [(u'kipouss', 0.99...), (u'par', 0.99...), (u'toujours', 0.99...)] 
    6876 
    6977Ce calcul est fait pour toutes les catégories:: 
    … …  
    7381 
    7482 
    75 La reconnaissance se base sur ce filtrage de mots, puis applque l'algo de 
     83La reconnaissance se base sur ce filtrage de mots, puis applique l'algo de 
    7684Robinson-fisher:: 
    7785 
    7886  >>> classifier.guess('achetez mon savon KIPOUSS') 
    79   [(u'song', 0.99...), (u'spam', 0.5), ...] 
     87  [(u'song', 0.99...), (u'spam', 0.70...), (u'friend', 0.16...)] 
    8088 
    8189We lower default treshold first:: 
    … …  
    126134  >>> source2 = open(file).read() 
    127135  >>> classifier.guess(source2) 
    128   [(u'python', 1.0), (u'doctest', ...e-...)] 
     136  [(u'python', ...), ...] 
    129137 
    130138Le classificateur doit aussi savoir `désapprendre`:: 
    … …  
    133141  >>> classifier.unlearn(source2, 'python') 
    134142  >>> classifier.guess(source2) 
    135   [(u'doctest', 1.0)] 
     143  [(u'doctest', ...), ...] 
    136144 
    137145 

  • classifier/doc/storage.txt

    r157 r162  
    1010    >>> import settings 
    1111    >>> settings.SQLURI = 'sqlite:///%s' % db_file 
     12    >>> import os 
     13    >>> if os.path.exists(db_file): 
     14    ...     os.remove(db_file) 
     15 
    1216 
    1317It works with languages, words, categories, and words within categories:: 
    … …  
    1822bayesian data:: 
    1923 
    20     >>> storage = SQLStorage('tarek') 
    21  
     24    >>> storage = SQLStorage('tester') 
    2225 
    2326Next we can store languages, since each word is in a given language:: 

  • classifier/storage.py

    r159 r162  
    2525lang = Table('classifier_lang', _metadata, 
    2626             Column('iso', String(3), primary_key=True), 
    27              Column('user', String(40))) 
     27             Column('user', String(40), primary_key=True)) 
    2828 
    2929word = Table('classifier_word', _metadata, 
    … …  
    3131            Column('lang_iso', String(3), ForeignKey('classifier_lang.iso')), 
    3232            Column('count', Integer), 
    33             Column('user', String(40)) 
     33            Column('user', String(40), primary_key=True) 
    3434            ) 
    3535 
    … …  
    3737                 Column('name', String(50), primary_key=True), 
    3838                 Column('description', String(300)), 
    39                  Column('user', String(40))) 
     39                 Column('user', String(40), primary_key=True)) 
    4040 
    4141 
    4242word_category = Table('classifier_word_category', _metadata, 
    43                  Column('id', Integer, primary_key=True), 
     43                 #Column('id', Integer, primary_key=True), 
    4444                 Column('word_value', String(200), 
    45                         ForeignKey('classifier_word.value')), 
     45                        ForeignKey('classifier_word.value'), primary_key=True), 
    4646                 Column('count', Integer), 
    4747                 Column('category_name', String(50), 
    48                         ForeignKey('classifier_category.name')), 
    49                  Column('user', String(40))) 
     48                        ForeignKey('classifier_category.name'), primary_key=True), 
     49                 Column('user', String(40), primary_key=True)) 
    5050 
    5151 
    … …  
    151151        sel = word.select(and_(word.c.value==the_word, 
    152152                               word.c.user==self._user)) 
    153         selection = sel.execute().fetchall() 
     153        selection = sel.execute().fetchone() 
    154154        cat_insert = word_category.insert() 
    155155 
    156  
    157         if len(selection) == 0: 
     156        if selection is None: 
    158157            # new word, let's add it 
    159158            res = word.insert().execute(value=the_word, count=1, 
    … …  
    169168            res = word.update(and_(word.c.value==the_word, 
    170169                                   word.c.user==self._user)) 
    171             res.execute(count=selection[0].count+1) 
    172  
    173             sl = and_(word_category.c.word_value==the_word, 
    174                       word_category.c.user==self._user) 
    175             cat = word_category.select(sl) 
    176             cat = cat.execute().fetchall() 
     170            res.execute(count=selection.count+1) 
     171 
     172            #sl = and_(word_category.c.word_value==the_word, 
     173            #         word_category.c.user==self._user) 
     174            #cat = word_category.select(sl) 
     175            #cat = cat.execute().fetchall() 
    177176 
    178177            #for old_cat in cat: 
    … …  
    185184            #        word_category.delete(sl).execute() 
    186185 
     186            existing_cats = self.list_categories() 
    187187            for category in categories: 
    188188                # let's check if the category exists in category 
    189                 if category not in self.list_categories(): 
     189                if category not in existing_cats: 
    190190                    self.add_category(category) 
    191191 
    … …  
    194194                          word_category.c.word_value==the_word) 
    195195                cat = word_category.select(sl) 
    196                 cat = cat.execute().fetchall() 
    197  
    198                 if cat == []: 
     196 
     197                cat = cat.execute().fetchone() 
     198                if cat is None: 
    199199                    cat_insert.execute(word_value=the_word, 
    200200                                       category_name=category, 
    … …  
    202202 
    203203                else: 
    204                     cat_count = cat[0].count 
    205                     id_ = cat[0].id 
    206                     up = word_category.update(word_category.c.id==id_) 
    207                     up.execute(count=cat_count+1) 
     204                    up = word_category.update(and_(word_category.c.user==cat.user, 
     205                                   word_category.c.word_value==cat.word_value, 
     206                                   word_category.c.category_name==cat.category_name)) 
     207                    up.execute(count=cat.count+1) 
    208208 
    209209 
    … …  
    213213        selection = and_(word_category.c.word_value == word_value, 
    214214                         word_category.c.user==self._user) 
    215         catwords = word_category.select(selection).execute().fetchall() 
     215 
     216        catwords = word_category.select(selection).execute() 
     217 
    216218        word_sel =  and_(word.c.value == word_value, 
    217                          word_category.c.user==self._user) 
     219                         word.c.user==self._user) 
     220 
    218221        langs = [the_word.lang_iso for the_word in 
    219                  word.select(word_sel).execute().fetchall()] 
     222                 word.select(word_sel).execute()] 
    220223 
    221224        cats = {} 
    … …  
    240243        """Remove a word""" 
    241244        sl = and_(word.c.value==the_word, word.c.user==self._user) 
    242         results = word.select(sl).execute().fetchall() 
    243  
    244         if len(results) == 0: 
     245        the_word = word.select(sl).execute().fetchone() 
     246 
     247        if the_word is None: 
    245248            return None 
    246  
    247         the_word = results[0] 
    248249 
    249250        # picking up categorized words to work with 
    250251        if categories is None: 
    251252            sl = word_category.c.word_value == the_word.value 
    252             catwords = word_category.select(sl).execute(user=self._user).fetchall() 
     253            catwords = word_category.select(sl).execute(user=self._user) 
    253254        else: 
    254255            categories = _tuplify(categories) 
    255             sl =  word_category.c.word_id == word.id 
     256            sl =  word_category.c.word_value == the_word.value 
    256257            sl2 =  word_category.c.category_name.in_(*categories) 
    257258            sl = and_(sl, sl2) 
    258             catwords = \ 
    259                 word_category.select(sl).execute(user=self._user).fetchall() 
     259            catwords = word_category.select(sl).execute(user=self._user) 
    260260 
    261261        # remove categorized words 
    … …  
    272272                word_category.delete(sl).execute() 
    273273            else: 
    274                 rs = word_category.select(sl).execute().fetchall() 
    275                 if rs != []: 
     274                rs = word_category.select(sl).execute().fetchone() 
     275                rs_count = rs.count 
     276                rs.close() 
     277                if rs is not None: 
    276278                    sl2 = word_category.update(sl) 
    277                     sl2.execute(count=rs.count-1, user=self._user) 
     279                    sl2.execute(count=rs_count-1, user=self._user) 
    278280 
    279281        # remove empty categories 
    280282        for category in categories: 
    281             sl = and_(word_category.c.category_name == category, 
     283            sl = and_(word_category.c.category_name==category, 
    282284                      word_category.c.user==self._user) 
    283285 
    284             current_cat = word_category.select(sl).execute().fetchall() 
    285             if len(current_cat) > 0: 
    286                 current_cat = current_cat[0] 
     286            current_cat = word_category.select(sl).execute().fetchone() 
     287            if current_cat is not None: 
    287288                if current_cat.count == 0: 
    288                      word_category.delete(sl).execute() 
    289         else: 
    290             # remove categories 
    291             sl = and_(word_category.c.word_value==the_word.value, 
    292                       word_category.c.user==self._user) 
    293             word_category.delete(sl).execute() 
     289                    current_cat.close() 
     290                    word_category.delete(sl).execute() 
     291        #else: 
     292        #    # remove categories 
     293        #    sl = and_(word_category.c.word_value==the_word.value, 
     294        #              word_category.c.user==self._user) 
     295        #    word_category.delete(sl).execute() 
    294296 
    295297        # removing word if none use it 
    296298        sl = and_(word.c.value==the_word.value, word.c.user==self._user) 
    297  
    298         #if word.select(sl).execute().fetchall()[0].count == 0: 
    299         word.delete(sl).execute() 
     299        if word.select(sl).execute().fetchone().count == 0: 
     300            word.delete(sl).execute() 
    300301 
    301302    def word_count(self, category=None, language=None): 
    302  
    303303        if category is None: 
    304304            if language is None: 
    305305                sl = word.c.user == self._user 
    306                 return len(word.select(sl).execute().fetchall()) 
     306                #return len(word.select(sl).execute().fetchall()) 
     307                return word.select(sl).count().execute().fetchone()[0] 
    307308            else: 
    308309                sl = and_(word.c.user == self._user, 
    309310                          word.c.lang_iso == language) 
    310                 return len(word.select(sl).execute().fetchall()) 
     311                return word.select(sl).count().execute().fetchone()[0] 
     312                #return len(word.select(sl).execute().fetchall()) 
    311313        else: 
    312314            categories = _tuplify(category) 
    313315            in_ = word_category.c.category_name.in_(*categories) 
    314316            sl = and_(in_, word_category.c.user == self._user) 
    315             res = word_category.select(in_).execute() 
    316             return len(res.fetchall()) 
     317            return word_category.select(sl).count().execute().fetchone()[0] 
     318            #res = word_category.select(sl).execute() 
     319            #return len(res.fetchall()) 
    317320 
    318321 

  • classifier/tests/test_docs.py

    r157 r162  
    5454 
    5555 
    56 current_dir = os.path.dirname(__file__) 
     56#current_dir = os.path.dirname(__file__) 
     57current_dir = '.' 
    5758 
    5859def test_suite():