迁移学习

最新推荐文章于 2025-05-09 19:35:16 发布

howardact

最新推荐文章于 2025-05-09 19:35:16 发布

阅读量4k

点赞数 5

CC 4.0 BY-SA版权

分类专栏： machineLearning

本文链接：https://blog.youkuaiyun.com/howardact/article/details/79740075

迁移学习Tradaboost，TCA，JDA算法简介

1、迁移学习简介

1.1 迁移学习定义

这里写图片描述

1.2 迁移学习数学表示

这里写图片描述

1.3. 迁移学习的矩阵形式

s o u r c e d o m a i n : ⎡ ⎣ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ x 11 x 21 ⋮ ⋮ x n 1 \dots \dots ⋱ ⋱ \dots x 1 k x 2 k ⋮ ⋮ x n k ⎤ ⎦ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎡ ⎣ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ y 1 y 2 ⋮ ⋮ y n ⎤ ⎦ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥

$source \ domain:\begin{bmatrix} x_{11} & \cdots & x_{1k}\\ x_{21} & \cdots & x_{2k}\\ \vdots & \ddots & \vdots \\ \vdots & \ddots & \vdots \\ x_{n1} & \cdots & x_{nk} \end{bmatrix} \begin{bmatrix} y_{1}\\y_{2}\\ \vdots \\ \vdots \\y_{n} \end{bmatrix}$

T a r g e t d o m a i n : ⎡ ⎣ ⎢ ⎢ ⎢ ⎢ ⎢ x 11 x 21 ⋮ x m 1 \dots \dots ⋱ \dots x 1 k x 2 k ⋮ x m k ⎤ ⎦ ⎥ ⎥ ⎥ ⎥ ⎥ ⎡ ⎣ ⎢ ⎢ ⎢ ⎢ y 1 y 2 ⋮ y m ⎤ ⎦ ⎥ ⎥ ⎥ ⎥

$Target \ domain: \begin{bmatrix} x_{11} & \cdots & x_{1k}\\ x_{21} & \cdots & x_{2k}\\ \vdots & \ddots & \vdots \\ x_{m1} & \cdots & x_{mk} \end{bmatrix} \begin{bmatrix} y_{1}\\y_{2}\\ \vdots \\y_{m} \end{bmatrix}$

1.4 传统解决方案

方案1，只用源域数据做训练集 X: X_src， Y : Y_src
方案2，只用目标域数据做训练集合 X：X_tar, Y: Y_tar
方案3，同时利用源域数据和目标域数据做训练集合: [X_src; X_tar] Y: [Y_src;Y_tar]
方案4： X: X_src, Y: Y_src -> model_src ; X: X_tar, Y: Y_tar -> model_tar ; 然后进行模型融合
方案5：利用xgboost，

Trate=0.15 
params = {
  'booster':'gbtree',
              'eta': 0.5, 
              'max_depth': 5,                  
              'max_delta_step': 0,
              'subsample':0.8,              
              'colsample_bytree': 0.8,      
              'base_score': Trate, 
              'objective': 'binary:logistic', 
              'lambda':3,
              'alpha':8
              }
params['eval_metric'] = 'auc'  
model_phase_1 = xgb.train(params,xgb.DMatrix(a_train_dummy_final,label=a_labels),num_boost_round=1000,evals=watchlist,early_stopping_rounds=100,maximize=True,verbose_eval=True)

Trate=0.2 
params = {
  'booster':'gbtree',
              'eta': 0.05, 
              'max_depth': 4,                  
              'max_delta_step': 0,
              'subsample':1,              
              'colsample_bytree': 0.9,      
              'base_score': Trate, 
              'objective': 'binary:logistic', 
              'lambda':3,
              'alpha':5
              }
params['eval_metric'] = 'auc' 
model_phase_1_cla_1 = xgb.train(params,xgb.DMatrix(b_train_dummy_final,b_labels),\
    num_boost_round=25,xgb_model =model_phase_1,maximize=True,verbose_eval=True)

1.5. 迁移学习分类

这里写图片描述

2 Tradaboost 算法

2.1 Tradaboost算法简介

Tradaboost算法属于基于样本的迁移学习。利用AdaBoost算法的思想原理来解决这个问题，起初给训练数据T中的每一个样例都赋予一个权重，当一个目标域中的样本被错误的分类之后，我们认为这个样本是很难分类的，于是乎可以加大这个样本的权重，这样在下一次的训练中这个样本所占的比重就更大了，这一点和基本的AdaBoost算法的思想是一样的。如果源域数据集中的一个样本被错误的分类了，我们认为这个样本对于目标数据是很不同的，我们就降低这个数据在样本中所占的权重，降低这个样本在分类器中所占的比重。

2.2 Tradaboost 算法流程

这里写图片描述

2.3 Tradaboost算法核心代码

def tradaboost(Ta,label_a,Tb,label_b,test,N = 10):
    T = np.concatenate([Ta,Tb], axis = 0)
    label = np.concatenate([label_a,label_b], axis = 0)
    n = Ta.shape[0] #n为老样本量
    m = Tb.shape[0] #m为新样本量
    N = 10 # N为迭代次数
    w = np.concatenate([np.ones(n)/n,np.ones(m)/m],axis=0)
    betas = np.zeros(N)
    beta_0 = 1.0/(1.0 + np.sqrt(2.0 * np.log(float(n)/N)))
    clf = tree.DecisionTreeClassifier(criterion="gini", \
        max_features="log2", splitter="random",random_state = 99)
    #clf = LogisticRegression(penalty='l1',C=0.003,random_state = 99)
    for t in range(N):
        p = w / sum(w)
        clf = clf.fit(T, label, sample_weight=p)
        T_pred = clf.predict(T)  #待优化
        Ta_pred = T_pred[:n]
        Tb_pred = T_pred[n:]
        error_rate = sum(w[n:] * np.abs(Tb_pred - label_b) / sum(w[n:]))
        print 'error_rate: ', error_rate
        if error_rate > 0.5:
            error_rate = 0.5
        if error_rate == 0:
            N = t
            break  # 防止过拟合
        beta = error_rate/(1-error_rate)
        betas[t] = beta
        w[:n] = w[:n] * np.power(beta_0, np.abs(Ta_pred - label_a))
        w[n:] = w[n:] * np.power(beta, -np.abs(Tb_pred - label_b))
    sN2b = sum(np.log(1.0/betas[N/2:]))
    htx = clf.predict(test)
    y_predict = [1 if i >