def check_concatenation(): #check with 2 HPK kl1 = HPK_generator(X_tr).make_a_list(n) kl2 = HPK_generator(X_tr).make_a_list(n) kl3 = kl1 + kl2 assert_array_equal(kl1[1], kl3[1]) assert_array_equal(kl1[7], kl3[7]) assert_array_equal(kl2[1], kl3[n + 1]) assert_array_equal(kl2[4], kl3[n + 4]) #check with HPK and SFK del kl2, kl3, kl1 kl1 = HPK_generator(X_tr).make_a_list(n) kl2 = SFK_generator(X_tr).make_a_list(n) kl3 = kl1 + kl2 assert_array_equal(kl1[1], kl3[1]) assert_array_equal(kl1[7], kl3[7]) assert_array_equal(kl2[1], kl3[n + 1]) assert_array_equal(kl2[4], kl3[n + 4]) #check iadd del kl2, kl3, kl1 kl1 = SFK_generator(X_tr).make_a_list(n) kl2 = kernel_list(X_tr) kl2 += kl1 assert_array_equal(kl1[3], kl2[3]) assert_array_equal(kl1[9], kl2[9]) kl3 = HPK_generator(X_tr).make_a_list(n) kl2 += kl3 assert_array_equal(kl2[4], kl1[4]) assert_array_equal(kl2[4 + n], kl3[4]) return
def check_toarray(): kl = HPK_generator(X_tr).make_a_list(n) ka = kl.to_array() #check if to_array return an array with the same shape of the original kernel list assert_equal(kl.shape, ka.shape) #check if ka is a ndarray assert_equal(type(ka), np.ndarray) #check if ka and kl have the same kernels assert_array_equal(kl[1], ka[1]) assert_array_equal(kl[9], ka[9]) return
def check_shape(): #check the shape with only tr kl = HPK_generator(X_tr).make_a_list(n) assert_equal(kl.shape, (n, X_tr.shape[0], X_tr.shape[0])) #check the shape with tr and test kl = HPK_generator(X_tr, X_te).make_a_list(n) assert_equal(kl.shape, (n, X_te.shape[0], X_tr.shape[0])) #check the shape with a klist generated from an other kr = kernel_list(X_tr, X_te, kl) assert_equal(kr.shape, (n, X_te.shape[0], X_tr.shape[0])) assert_equal(kl.shape, kr.shape) return
def check_init_from_klist(): #check if a list generated from an other has the same kernels with only tr kl = HPK_generator(X_tr).make_a_list(n) kr = kernel_list(X_tr, X_tr, kl) assert_array_almost_equal(kl[0], kr[0]) assert_array_almost_equal(kl[3], kr[3]) #check if a list generated from an other has the same kernels with tr and test kl = HPK_generator(X_tr, X_te).make_a_list(n) kr = kernel_list(X_tr, X_te, kl) assert_array_almost_equal(kl[2], kr[2]) assert_array_almost_equal(kl[7], kr[7]) return
def check_generated(): #check if kl can be generated by a generator with tr set kl = SFK_generator(X_tr).make_a_list(n) assert_equal(kl.__class__.__name__, 'kernel_list') kl = HPK_generator(X_tr).make_a_list(n) assert_equal(kl.__class__.__name__, 'kernel_list') #check if kl can be generated by a generator with tr and test as inoput kl = SFK_generator(X_tr, X_te).make_a_list(n) assert_equal(kl.__class__.__name__, 'kernel_list') kl = HPK_generator(X_tr, X_te).make_a_list(n) assert_equal(kl.__class__.__name__, 'kernel_list') #check if make_a_list(n) perform exactly n kernels in list assert_equal(len(kl), n) return
def check_HPKs(): #check a training list kl = HPK_generator(X_tr).make_a_list(10) assert_array_almost_equal(kl[0], linear_kernel(X_tr)) assert_array_almost_equal( kl[2], polynomial_kernel(X_tr, gamma=1, coef0=0, degree=3)) assert_array_almost_equal( kl[5], polynomial_kernel(X_tr, gamma=1, coef0=0, degree=6)) #check a test list kt = HPK_generator(X_tr, X_te).make_a_list(10) assert_array_almost_equal(kt[0], linear_kernel(X_te, X_tr)) assert_array_almost_equal( kt[2], polynomial_kernel(X_te, X_tr, gamma=1, coef0=0, degree=3)) assert_array_almost_equal( kt[5], polynomial_kernel(X_te, X_tr, gamma=1, coef0=0, degree=6))
def check_complex_operations(): ##check multiplication and division with a scalar value #check if normal division works and it does not change the operands v = [i for i in range(1, 11)] kl1 = HPK_generator(X_tr).make_a_list(n) k = kl1[3].copy() kl2 = kl1 / v assert_array_almost_equal(kl2[9], kl1[9] / v[9]) assert_array_almost_equal(kl2[0], kl1[0] / v[0]) assert_array_almost_equal(kl2[6], kl1[6] / v[6]) assert_array_almost_equal(kl2[3], k / v[3]) #normal div does not affect first operand assert_array_almost_equal(kl1[3], k) #check if idiv works correctly kl1 /= v assert_array_almost_equal(kl1[2], kl2[2]) #check if mul works correctly kl1 = SFK_generator(X_tr).make_a_list(n) k = kl1[1] kl2 = kl1 * v assert_array_almost_equal(kl2[1], k * v[1]) kk = kl1[1] assert_array_almost_equal(k, kk) assert_array_almost_equal(kl2[6], kl1[6] * v[6]) #check if imul works correctly kl1 *= v assert_array_almost_equal(kl1[2], kl2[2]) return
def check_HPKs(): kl = HPK_generator(X_tr).make_a_list(n) #check if the first kernel in list has degree 1 and correspond to linear kernel assert_array_almost_equal(kl[0], linear_kernel(X_tr)) assert_array_almost_equal( kl[0], polynomial_kernel(X_tr, degree=1, coef0=0, gamma=1)) #check if the 4-th element in list is a HPK with degree 4 assert_array_almost_equal(kl[3], linear_kernel(X_tr)**4) assert_array_almost_equal( kl[3], polynomial_kernel(X_tr, degree=4, coef0=0, gamma=1)) #the same test with tr and test sets kl = HPK_generator(X_tr, X_te).make_a_list(n) assert_array_almost_equal(kl[2], linear_kernel(X_te, X_tr)**3) assert_array_almost_equal( kl[2], polynomial_kernel(X_te, X_tr, degree=3, coef0=0, gamma=1)) return
def __init__(self, estimator=SVC(), step=1.0, generator=HPK_generator(n=10), multiclass_strategy='ova', max_iter=10000, tol=1e-9, verbose=False, n_folds=1, random_state=42,lam=0): super(self.__class__, self).__init__(estimator=estimator, generator=generator, multiclass_strategy=multiclass_strategy, how_to=summation, max_iter=max_iter, verbose=verbose) self.step = step self.lam = lam self.tol = tol self.n_folds = n_folds self.random_state = random_state
def check_getitem(): #check if getitem return a valid kernel kl = HPK_generator(X_tr).make_a_list(n) k = kl[3] #check if k is an ndarray assert_equal(type(k), np.ndarray) #check the shape of the single kernel assert_equal(k.shape, (X_tr.shape[0], X_tr.shape[0])) #the same with test and SFK kl = SFK_generator(X_tr, X_te).make_a_list(n) k = kl[4] assert_equal(k.shape, (X_te.shape[0], X_tr.shape[0])) assert np.min(k) >= 0, 'error: kernel matrix with a negative value' return
def __init__(self, estimator=KOMD(lam=0.1), lam=0.1, generator=HPK_generator(n=10), multiclass_strategy='ova', max_iter=100, verbose=False): super(self.__class__, self).__init__(estimator=estimator, generator=generator, multiclass_strategy=multiclass_strategy, how_to=summation, max_iter=max_iter, verbose=verbose) self.lam = lam
def __init__(self, estimator=SVC(), step=1, generator=HPK_generator(n=10), multiclass_strategy='ova', max_iter=1000, tol=1e-9, verbose=False): super(self.__class__, self).__init__(estimator=estimator, generator=generator, multiclass_strategy=multiclass_strategy, how_to=summation, max_iter=max_iter, verbose=verbose) self.step = step self.tol = tol
import sys import numpy as np from numpy.testing import assert_array_equal, assert_array_almost_equal, assert_equal from sklearn.datasets import load_iris, load_digits, load_breast_cancer from sklearn.model_selection import KFold, ShuffleSplit from MKLpy.lists import HPK_generator from MKLpy.model_selection import * from MKLpy.algorithms import EasyMKL data = load_breast_cancer() #digits()#iris() X, Y = data.data, data.target Y = np.array([1 if _y == Y[1] else -1 for _y in Y]) #Y = np.array([1 if _y < 5 else -1 for _y in Y]) n = X.shape[0] y = np.array(list(range(n))) KL = HPK_generator(X).make_a_list(10).to_array() def check_cv3(): return cv = KFold(3).split(Y) for train, test in cv: tr, te = cv3(train, test, 10) assert KL[tr].shape == (10, 100, 100) assert KL[te].shape == (10, 50, 100) def check_train_test_split(): #check shape with train_size (%) Ktr, Kte, Ytr, Yte = train_test_split(KL, Y, train_size=.3) assert Ktr.shape == (10, n * 0.3, n * 0.3), 'Shape error'
def check_edit(): #check 'edit' with a simple transformation def stuff(X): return X * 2 kl = HPK_generator(X_tr).make_a_list(10) K = kl[2] kl.edit(stuff) assert_array_almost_equal(K * 2, kl[2]) #check with normalization kl = HPK_generator(X_tr).make_a_list(10) K = kl[2] kl.edit(kernel_normalization) assert_array_almost_equal(kernel_normalization(K), kl[2]) #check with kernel centering kl = HPK_generator(X_tr).make_a_list(10) K = kl[2] kl.edit(kernel_centering) assert_array_almost_equal(kernel_centering(K), kl[2])
from MKLpy.algorithms.EasyMKL1 import EasyMKL as easy from MKLpy.algorithms import EasyMKL as old from MKLpy.lists import HPK_generator from sklearn.datasets import load_digits import numpy as np from sklearn.model_selection import train_test_split as tts from numpy.testing import assert_array_equal, assert_array_almost_equal, assert_equal import sys from sklearn.svm import SVC data = load_digits() X, Y = data.data, data.target Y = [1 if y == Y[0] else -1 for y in Y] Xtr, Xte, Ytr, Yte = tts(X, Y, train_size=200) KL = HPK_generator(Xtr).make_a_list(10).to_array() KLte = HPK_generator(Xtr, Xte).make_a_list(10).to_array() clf_new = easy(lam=0, kernel='precomputed') clf_old = old(lam=0, kernel='precomputed', tracenorm=False) K_new = clf_new.arrange_kernel(KL, Ytr) K_old = clf_old.arrange_kernel(KL, Ytr) assert_array_almost_equal(K_new, K_old) clf_new = easy(lam=0, kernel='precomputed').fit(KL, Ytr) clf_old = old(lam=0, kernel='precomputed', tracenorm=False).fit(KL, Ytr) y_new = clf_new.decision_function(KLte) y_old = clf_old.decision_function(KLte) assert_array_almost_equal(y_new, y_old)
from numpy.testing import assert_array_equal, assert_array_almost_equal, assert_equal from MKLpy.lists import HPK_generator from sklearn.datasets import load_iris import numpy as np import sys from MKLpy.arrange import * from sklearn.metrics.pairwise import polynomial_kernel as pk from sklearn.model_selection import train_test_split data = load_iris() X, Y = data.data, data.target Xtr, Xte, Ytr, Yte = train_test_split(X, Y, test_size=.3) K_list = [pk(Xtr, degree=i, coef0=0, gamma=1) for i in range(1, 6)] K_array = np.array(K_list) K_klist = HPK_generator(Xtr).make_a_list(5) K_list_te = [pk(Xte, Xtr, degree=i, coef0=0, gamma=1) for i in range(1, 6)] K_array_te = np.array(K_list_te) K_klist_te = HPK_generator(Xtr, Xte).make_a_list(5) def check_summation(): #check summation with 1 samples matrix truesum = K_list[0] + K_list[1] + K_list[2] + K_list[3] + K_list[4] sum_list = summation(K_list) sum_array = summation(K_array) sum_klist = summation(K_klist) assert_array_equal(sum_list, truesum) assert_array_equal(sum_list, sum_array) assert_array_equal(sum_list, sum_klist)