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_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_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 test_embedded(self): classifier = LinearClassifier(embedded=True)
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))