TCA.zip_TCA+_TCA算法_domain adaptation_半监督_迁移学习算法

# -*- coding: utf-8 -*- """ Created on Thu Jan 24 14:12:08 2019 @author: 11583 """ import numpy as np import torch import sklearn.neighbors from sklearn.svm import SVC import scipy.linalg #from ELM import HiddenLayer from sklearn import metrics DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu') def kernel(ker, X, X2, gamma): if not ker or ker == 'primal': return X elif ker == 'linear': if not X2: K = torch.dot(X.T, X) else: K = torch.dot(X.T, X2) elif ker == 'rbf': n1sq = torch.sum(X ** 2, dim=0) n1 = X.shape[1] if not X2: D = ((torch.ones((n1, 1)).to(DEVICE) * n1sq).t()).to(DEVICE) + (torch.ones((n1, 1)).to(DEVICE) * n1sq) - 2 * torch.mm(X.t(), X) else: n2sq = torch.sum(X2 ** 2, dim=0) n2 = X2.shape[1] D = (torch.ones((n2, 1)) * n1sq).t() + torch.ones((n1, 1)) * n2sq - 2 * torch.dot(X.t(), X) K = torch.exp(-gamma * D) elif ker == 'sam': if not X2: D = torch.dot(X.T, X) else: D = torch.dot(X.T, X2) K = torch.exp(-gamma * torch.arccos(D) ** 2) return K class TCA: def __init__(self, kernel_type='primal', dim=30, lamb=1, gamma=1): ''' Init func :param kernel_type: kernel, values: 'primal' | 'linear' | 'rbf' | 'sam' :param dim: dimension after transfer :param lamb: lambda value in equation :param gamma: kernel bandwidth for rbf kernel ''' self.kernel_type = kernel_type self.dim = dim self.lamb = lamb self.gamma = gamma #@cuda.jit(argtypes=(float32[:], float32[:]),restype=(float32[:],float32[:]), device=True, inline=True) def fit(self, Xs, Xt): ''' Transform Xs and Xt :param Xs: ns * n_feature, source feature :param Xt: nt * n_feature, target feature :return: Xs_new and Xt_new after TCA ''' X = torch.cat((Xs.t(),Xt.t()),1) X /= torch.norm(X, dim=0) m, n = X.shape ns, nt = len(Xs), len(Xt) aa = (1 / ns * torch.ones(ns, 1)) bb = (-1 / nt * torch.ones(nt, 1)) e = torch.cat((aa,bb),0) #e = torch.squeeze(e) M = e * e.t() #######M的类型必须为浮点型####### #M = torch.from_numpy(M) #M = M / np.linalg.norm(M, 'fro') M = (M / torch.norm(M,p='fro')).to(DEVICE) #M = torch.from_numpy(M) H = torch.eye(n).to(DEVICE) - (1 / n * torch.ones((n, n))).to(DEVICE) K = kernel(self.kernel_type, X, None, gamma=self.gamma) n_eye = m if self.kernel_type == 'primal' else n #print(K.shape) #print(M.shape) t = torch.mm(K, M) p = torch.mm(K, H) a, b = torch.mm(t,K.t()) + self.lamb * torch.eye(n_eye).to(DEVICE), torch.mm(p, K.t()) a = a.cpu().numpy() b = b.cpu().numpy() w, V = scipy.linalg.eig(a, b) # print(w.shape) # print(V.shape) # ind = np.argsort(w) # A = V[:, ind[:self.dim]] # Z = np.dot(A.T, K) # Z /= np.linalg.norm(Z, axis=0) # Xs_new, Xt_new = Z[:, :ns].T, Z[:, ns:].T # cc = torch.mm(torch.inverse(b),a) # #print(cc.shape) # gg = torch.eig(cc,eigenvectors=True) # w = gg[0] # V = gg[1] # print(V.shape) #print(w.dtype) w = w.astype(np.float32) V = V.astype(np.float32) w = torch.from_numpy(w) #print(w.shape) V = torch.from_numpy(V) #print(w.shape) ind = torch.argsort(w) A = V[:, ind[:self.dim]] #print(A.dtype) #print(K.dtype) Z = torch.mm(A.t().cpu(), K.cpu()) Z /= torch.norm(Z, dim=0) #dist = torch.trace(Z) Xs_new, Xt_new = torch.t(Z[:, :ns]), torch.t(Z[:, ns:]) # Xs_new = Xs_new.numpy() # Xt_new = Xt_new.numpy() #dist = dist.numpy() #print(type(Xs_new)) #print(Xt_new.shape) return Xs_new, Xt_new#,dist #@cuda.jit(argtypes=(float32[:], float32[:],float32[:], float32[:]),restype=(float32[:],float32[:]), device=True, inline=True) def fit_predict(self, Xs_new, Ys, Xt_new, Yt): ''' Transform Xs and Xt, then make predictions on target using 1NN :param Xs: ns * n_feature, source feature :param Ys: ns * 1, source label :param Xt: nt * n_feature, target feature :param Yt: nt * 1, target label :return: Accuracy and predicted_labels on the target domain ''' #Xs_new, Xt_new = self.fit(Xs, Xt) ####model select ##### #clf = sklearn.neighbors.KNeighborsClassifier(n_neighbors=10) # clf = GridSearchCV(SVC(kernel='rbf', gamma=0.1), cv=5, # param_grid={"C": [1e0, 1e1, 1e2, 1e3], # "gamma": np.logspace(-2, 2, 5)},scoring="accuracy") #clf = SVC(kernel='linear',C=19,gamma=0.1)#linear #clf = SVC(kernel='linear',C=10,gamma=0.1)#sigmoid clf = SVC(C=10.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma=1.0, kernel='rbf', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False) # clf = GridSearchCV(SVC(kernel='rbf', gamma=0.1), cv=5, # param_grid={"C": [1e0, 1e1, 1e2, 1e3], # "gamma": np.logspace(-2, 2, 5)},scoring="accuracy") #######线性逻辑回归方法###### #clf = linear_model.LogisticRegression(C=1.0) clf.fit(Xs_new, Ys.ravel()) y_pred = clf.predict(Xt_new) #acc = accuracy_score(Yt,y_pred) acc = sklearn.metrics.accuracy_score(Yt, y_pred) # a = HiddenLayer(Xs_new,50) # a.classifisor_train(Ys) # result = a.classifisor_test(Xt_new) # acc = metrics.accuracy_score(Yt,result) #return acc return acc, y_pred #return Xs_new,Ys, Xt_new,Yt