Simple, fast classifier with continuous training

The Divmod Reverend package was the simplest pure-Python Naive Bayesian classifier I found that could be trained incrementally/online/continuously. It's written specifically for spam-filtering, but I was able to tweak it's code fairly easily for arbitrary classification. After the Divmod company went out of business, the code's gotten a little hard to find, but it's out there.

EDIT: To illustrate my "tweaks", they're not so much tweaks as they are defining a custom tokenizer. By default, Reverend expects to be given a chunk of text (e.g. an email), and the default tokenizer splits this into a list of words. I simply wanted to pass it a list of symbols, and not do any tokenizing, so I just created a "pass-through" tokenizer that essentially does no tokenizing. Download an install Reverend 0.4 from my link above, and then the following code should work.

import csv
from reverend.thomas import Bayes, BayesData

class PassThoughTokenizer:
    def tokenize(self, obj):
        return obj

# Train incrementally.
classifier = Bayes(tokenizer=PassThoughTokenizer())
examples = csv.DictReader(open('training_data.csv'))
for example in examples:
    features,cls = example['bags'],example['cls']
    features = features.split(',')
    classifier.train(cls, features)
    # Note, you could stop here and/or do additional testing.

# Test.
test_features ['how','now',123,'brown','cow',456]
for cls,prob in classifier.guess(test_features):
    print cls, prob

EDIT: One more note. since the above implementation stores a reference to an instance method, Python's default pickler can't serialize it. However, the following code explains how to pickle an instance method, so you can save your classifier by simply doing pickle.dump(classifier, open('model.dat','w')).

def _pickle_method(method):
    func_name = method.im_func.__name__
    obj = method.im_self
    cls = method.im_class
    return _unpickle_method, (func_name, obj, cls)

def _unpickle_method(func_name, obj, cls):
    for cls in cls.mro():
        try:
            func = cls.__dict__[func_name]
        except KeyError:
            pass
        else:
            break
    return func.__get__(obj, cls)

import copy_reg
import types
copy_reg.pickle(types.MethodType, _pickle_method, _unpickle_method)