def test_rf():
from milksets import wine
features, labels = wine.load()
features = features[labels < 2]
labels = labels[labels < 2]
learner = randomforest.rf_learner()
model = learner.train(features[::5], labels[::5])
test = [model.apply(f) for f in features]
assert np.mean(labels == test) > .7
def leave_one_out(y, x, param=None, n=None):
results = []
for i, test in enumerate(zip(y, x)):
training_y = y[:i] + y[i+1:]
training_x = x[:i] + x[i+1:]
training_y = np.array(training_y)
training_x = np.array([np.array(tx) for tx in training_x])
learner = mil_rf.rf_learner()
learner = mil_multi.one_against_one(learner)
model = learner.train(training_x, training_y)
result = model.apply(np.array(x[i:i+1][0]))
results.append((result,) + (test[0],
make_d.decode(x[i], DECODE_DIC)))
return results
def random_forest(X, Y):
from milk.supervised import randomforest
from milk.supervised.multi import one_against_one
import milk.nfoldcrossvalidation
features = np.array(X)
labels = np.array(Y)
rf_learner = randomforest.rf_learner()
# rf is a binary learner, so we transform it into a multi-class classifier
learner = one_against_one(rf_learner)
# learner = rf_learner
# result
# cross validate with this learner and return predictions on left-out elements
cmat, names, preds = milk.nfoldcrossvalidation(features, labels, nfolds=4, classifier=learner, return_predictions=1)
print 'cross-validation accuracy:', cmat.trace() / float(cmat.sum())
return
def run_rf(x, y):
x2 = array(x, float)
y2 = array(y, int)
#x2[x>0] = True
#x2[x<=0] = False
y2[y>0] = 1
y2[y<=0] = 0
features = squeeze(x2.T)
labels = squeeze(y2.T)
f2 = np.random.randn(100,20)
f2[:50] *= 2
l2 = np.repeat((0,1), 50)
t = 'rf'
if t == 'rf':
obj = rf.rf_learner()
else:
obj = milk.supervised.tree.tree_learner()
model = obj.train(features, labels)
predictions = []
for fs in features:
predictions.append( model.apply(fs))
predictions = array(predictions)
print array(labels,int)
print array(predictions,int)
#print shape(f2), shape(features)
#print shape(l2), shape(labels)
#print predictions
#print shape(predictions)
# raise Exception()
return predictions
def random_forest(X, Y):
from milk.supervised import randomforest
from milk.supervised.multi import one_against_one
import milk.nfoldcrossvalidation
features = np.array(X)
labels = np.array(Y)
rf_learner = randomforest.rf_learner()
# rf is a binary learner, so we transform it into a multi-class classifier
learner = one_against_one(rf_learner)
# learner = rf_learner
# result
# cross validate with this learner and return predictions on left-out elements
cmat, names, preds = milk.nfoldcrossvalidation(features,
labels,
nfolds=4,
classifier=learner,
return_predictions=1)
print 'cross-validation accuracy:', cmat.trace() / float(cmat.sum())
return
from milk.supervised import randomforest
from milk.supervised.multi import one_against_one
import milk.nfoldcrossvalidation
import milk.unsupervised
import pylab
from milksets import wine
# Load 'wine' dataset
features, labels = wine.load()
# random forest learner
rf_learner = randomforest.rf_learner()
# rf is a binary learner, so we transform it into a multi-class classifier
learner = one_against_one(rf_learner)
# cross validate with this learner and return predictions on left-out elements
cmat,names, preds = milk.nfoldcrossvalidation(features, labels, classifier=learner, return_predictions=1)
print('cross-validation accuracy:', cmat.trace()/float(cmat.sum()))
# dimensionality reduction for display
x,v = milk.unsupervised.pca(features)
colors = "rgb" # predicted colour
marks = "xo" # whether the prediction was correct
for (y,x),p,r in zip(x[:,:2], preds, labels):
c = colors[p]
m = marks[p == r]
pylab.plot(y,x,c+m)
pylab.show()
def m_randomforest(): rf_learner = randomforest.rf_learner() return multi.multi_tree_learner(rf_learner)
def BuildModel(self):
# Create and train the classifier.
rf_learner = randomforest.rf_learner(**self.opts)
learner = one_against_one(rf_learner)
return learner
logging.basicConfig(level=logging.DEBUG)
###############################################################################
# Load training data
moto_vq_train, plane_vq_train = [np.load(file)
for file
in ['moto_vq_train.npy','plane_vq_train.npy']]
labels = [0]* moto_vq_train.shape[0] + [1]* plane_vq_train.shape[0]
###############################################################################
# Train Random Forrest
learner = rf.rf_learner()
#learner = rf.one_against_one(rf_learner)
model = learner.train(np.vstack([moto_vq_train,plane_vq_train]),
np.array(labels))
###############################################################################
# Evaluation
moto_vq_eval, plane_vq_eval = [np.load(file)
for file
in ['moto_vq_eval.npy','plane_vq_eval.npy']]
errors = 0
errors += len([vq for vq in moto_vq_eval if model.apply(vq) != 0 ])
errors += len([vq for vq in plane_vq_eval if model.apply(vq) != 1 ])
def BuildModel(self): # Create and train the classifier. rf_learner = randomforest.rf_learner(**self.opts) learner = one_against_one(rf_learner) return learner
def m_randomforest():
rf_learner = randomforest.rf_learner()
return multi.multi_tree_learner(rf_learner)
