def test_set(self):
from secml.ml.kernels import CKernelRBF
multiclass = CClassifierMulticlassOVA(classifier=CClassifierSVM,
C=1,
kernel=CKernelRBF())
# Test set before training
multiclass.set_params({'C': 100, 'kernel.gamma': 20})
for clf in multiclass._binary_classifiers:
self.assertEqual(clf.C, 100.0)
self.assertEqual(clf.kernel.gamma, 20.0)
# Restoring kernel
multiclass.set('kernel', CKernelRBF(gamma=50))
# Setting different parameter in single trained_classifiers
multiclass.prepare(num_classes=4)
different_c = (10, 20, 30, 40)
multiclass.set('C', different_c)
different_gamma = (50, 60, 70, 80)
multiclass.set('kernel.gamma', different_gamma)
# Fit multiclass classifier than test set after training
multiclass.fit(self.dataset)
for clf_idx, clf in enumerate(multiclass._binary_classifiers):
self.assertEqual(clf.C, different_c[clf_idx])
self.assertEqual(clf.kernel.gamma, different_gamma[clf_idx])
# Test set after training
multiclass.set_params({'C': 30, 'kernel.gamma': 200})
for clf in multiclass._binary_classifiers:
self.assertEqual(clf.C, 30.0)
self.assertEqual(clf.kernel.gamma, 200.0)
for clf in multiclass._binary_classifiers:
self.assertEqual(clf.C, 30.0)
self.assertEqual(clf.kernel.gamma, 200.0)
# Setting parameter in single trained_classifiers
multiclass._binary_classifiers[0].kernel.gamma = 300
for i in range(1, multiclass.num_classifiers):
self.assertNotEqual(multiclass._binary_classifiers[i].kernel.gamma,
300.0)
# Setting different parameter in single trained_classifiers
different_c = (100, 200, 300)
# ValueError is raised as not enough binary classifiers are available
with self.assertRaises(ValueError):
multiclass.set('C', different_c)
multiclass.prepare(num_classes=3)
multiclass.set('C', different_c)
for clf_idx, clf in enumerate(multiclass._binary_classifiers):
self.assertEqual(clf.C, different_c[clf_idx])
def test_set_get_state(self):
"""Test for set_state and get_state."""
pre = CPreProcess.create_chain(['pca', 'mean-std'], [{}, {}])
multi = CClassifierMulticlassOVA(
classifier=CClassifierSVM,
kernel='rbf',
class_weight='balanced',
preprocess=pre)
# Setting different parameter in single trained_classifiers
multi.prepare(num_classes=4)
different_c = (10, 20, 30, 40)
multi.set('C', different_c)
different_gamma = (50, 60, 70, 80)
multi.set('kernel.gamma', different_gamma)
multi.fit(self.dataset.X, self.dataset.Y)
pred_y = multi.predict(self.dataset.X)
self.logger.info(
"Predictions before restoring state:\n{:}".format(pred_y))
state = multi.get_state()
self.logger.info("State of multiclass:\n{:}".format(state))
# Create an entirely new clf
pre_post = CPreProcess.create_chain(['pca', 'mean-std'], [{}, {}])
multi_post = CClassifierMulticlassOVA(
classifier=CClassifierSVM,
kernel='rbf',
class_weight='balanced',
preprocess=pre_post)
# Restore state but not enough binary classifiers
with self.assertRaises(ValueError):
multi_post.set_state(state)
# Restore state
multi_post.prepare(num_classes=4)
multi_post.set_state(state)
for clf_idx, clf in enumerate(multi_post._binary_classifiers):
self.assertEqual(clf.C, different_c[clf_idx])
self.assertEqual(clf.kernel.gamma, different_gamma[clf_idx])
pred_y_post = multi_post.predict(self.dataset.X)
self.logger.info(
"Predictions after restoring state:\n{:}".format(pred_y_post))
self.assert_array_equal(pred_y, pred_y_post)