def test_predict(self): X = np.array([[1,1], [0,0]]) y = np.array([1,2]) classifier = LinearClassifier() self.assertRaises(RuntimeError, classifier.predict, X) classifier.fit(X, y) y_pred = classifier.predict(X) self.assertEqual(y_pred.shape[0], X.shape[0])
def test_predict(self):
X = np.array([[1, 1], [0, 0]])
y = np.array([1, 2])
classifier = LinearClassifier()
self.assertRaises(RuntimeError, classifier.predict, X)
classifier.fit(X, y)
y_pred = classifier.predict(X)
self.assertEqual(y_pred.shape[0], X.shape[0])
def test_decision_function(self): X = np.array([[1,1], [0,0]]) y = np.array([1,2]) c = np.unique(y) classifier = LinearClassifier() self.assertRaises(RuntimeError, classifier.predict, X) classifier.fit(X, y) y_pred = classifier.decision_function(X) self.assertEqual(y_pred.shape, (X.shape[0], c.shape[0]))
def test_partial_fit(self): X = np.array([[1,1], [0,0]]) y = np.array([1,2]) classifier = LinearClassifier() self.assertTrue(classifier.clf_ is None) self.assertEqual(classifier.fitted_, False) classifier.partial_fit(X, y) self.assertTrue(classifier.clf_ is not None) self.assertEqual(classifier.fitted_, True)
def test_decision_function(self):
X = np.array([[1, 1], [0, 0]])
y = np.array([1, 2])
c = np.unique(y)
classifier = LinearClassifier()
self.assertRaises(RuntimeError, classifier.predict, X)
classifier.fit(X, y)
y_pred = classifier.decision_function(X)
self.assertEqual(y_pred.shape, (X.shape[0], c.shape[0]))
def test_partial_fit(self):
X = np.array([[1, 1], [0, 0]])
y = np.array([1, 2])
classifier = LinearClassifier()
self.assertTrue(classifier.clf_ is None)
self.assertEqual(classifier.fitted_, False)
classifier.partial_fit(X, y)
self.assertTrue(classifier.clf_ is not None)
self.assertEqual(classifier.fitted_, True)
def test_get_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'softmax': True,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
classifier = LinearClassifier(**params)
self.assertDictEqual(params, classifier.get_params())
classifier.stop()
def test_get_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'softmax': True,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
classifier = LinearClassifier(**params)
self.assertDictEqual(params, classifier.get_params())
classifier.stop()
def test_class_params(self):
classifier = LinearClassifier()
params = [
'method', 'regularization_weight', 'softmax', 'n_iter', 'shuffle',
'embedded', 'seed'
]
for param in params:
self.assertTrue(param in classifier.__dict__)
self.assertTrue('invalid_param' not in classifier.__dict__)
def test_set_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'softmax': True,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
classifier = LinearClassifier()
classifier.set_params(**params)
self.assertEqual(classifier.method, params['method'])
self.assertEqual(classifier.regularization_weight, params['regularization_weight'])
self.assertEqual(classifier.softmax, params['softmax'])
self.assertEqual(classifier.n_iter, params['n_iter'])
self.assertEqual(classifier.shuffle, params['shuffle'])
self.assertEqual(classifier.embedded, params['embedded'])
self.assertEqual(classifier.seed, params['seed'])
def test_set_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'softmax': True,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
classifier = LinearClassifier()
classifier.set_params(**params)
self.assertEqual(classifier.method, params['method'])
self.assertEqual(classifier.regularization_weight,
params['regularization_weight'])
self.assertEqual(classifier.softmax, params['softmax'])
self.assertEqual(classifier.n_iter, params['n_iter'])
self.assertEqual(classifier.shuffle, params['shuffle'])
self.assertEqual(classifier.embedded, params['embedded'])
self.assertEqual(classifier.seed, params['seed'])
def test_simple(self): classifier = LinearClassifier() classifier.stop()
def launch_classifier(method): classifier = LinearClassifier(method=method) classifier._launch_classifier()
def test_save(self): name = 'test' classifier = LinearClassifier() classifier.save(name)
def launch_classifier(method):
classifier = LinearClassifier(method=method)
classifier._launch_classifier()
def test_embedded(self):
classifier = LinearClassifier(embedded=True)
def test_simple(self):
classifier = LinearClassifier()
classifier.stop()
def test_save(self):
name = 'test'
classifier = LinearClassifier()
classifier.save(name)
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
from sklearn.pipeline import Pipeline
from sklearn.utils import shuffle
# load hand-writtern number recognition dataset
digits = load_digits()
# shuffle and separate the dataset
X, y = shuffle(digits.data, digits.target, random_state=42)
n_train = int(X.shape[0] / 2)
X_train, y_train = X[:n_train], y[:n_train]
X_test, y_test = X[n_train:], y[n_train:]
# launch linear classifier (AROW)
clf = LinearClassifier(method='AROW', embedded=False, seed=42)
# scale dataset
scaled_pipeline = Pipeline([('scaler', StandardScaler()), ('classifier', clf)])
# decompose dataset
pca_pipeline = Pipeline([('pca', PCA()), ('classifier', clf)])
# evaluate each pipelines
pipelines = [clf, scaled_pipeline, pca_pipeline]
for pipeline in pipelines:
print(pipeline)
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(classification_report(y_test, y_pred))