• 【推荐系统】特征选择(单变量特征选择和基于模型的特征选择)

    单变量特征选择

    单变量特征选择能够对每一个特征进行测试，衡量该特征和响应变量之间的关系，根据得分丢弃不好的特征。单变量特征选择这种方法比较简单，易于运行，易于理解

    方法一：皮尔森相关系数

    衡量变量之间的线性相关性，结果取值区间为[1,-1]，-1表示完全的负相关，+1表示完全正相关，0表示没有线性相关。皮尔森相关系数表示两个变量之间的协方差与标准差的商。

    皮尔森相关系数计算速度快，易于计算，在经过清洗和特征提取之后的第一时间就可以执行。

    \rho _{X,Y} = \frac{E[(X-\mu _{X})(Y-\mu_{Y})]}{\sigma _{X}\sigma _{Y}}

    1. import numpy as np
    2. from scipy.stats import pearsonr
    3. np.random.seed(0)
    4. size = 300
    5. x = np.random.normal(0,1,size)
    6. print("lower noise",pearsonr(x,x + np.random.normal(0,1,size)))
    7. print("higher noise",pearsonr(x,x + np.random.normal(0,10,size)))
    8. # lower noise (0.7182483686213841, 7.324017312998504e-49)
    9. # higher noise (0.05796429207933814, 0.31700993885325246)

    噪音比较小的时候，相关性很强，P-value很低。皮尔森相关系数的缺点：只对线性关系敏感

     方法二：距离相关系数

    距离相关系数客服了皮尔森相关系数的弱点，它基于距离协方差进行变量间相关性度量，其优点为变量的大小不是必须一致的。计算距离相关系数通常使用的值为平方根。

    Dcor(X,Y) = \frac{dCov(X,Y)}{((dCov^{2}(X,X))^{\frac{1}{2}}\cdot((dCov^{2}(Y,Y))^{\frac{1}{2}} )^{\frac{1}{2}}}

    1. def dist(x,y):
    2.     return np.abs(x[:,None] - y)
    3.  
    4. def d_n(x):
    5.     d=  dist(x,x)
    6.     dn = d - d.mean(0) - d.mean(1)[:,None] + d.mean()
    7.     return dn
    8.  
    9. def dcov_all(x,y):
    10.     dnx = d_n(x)
    11.     dny = d_n(y)
    12.     
    13.     denom = np.product(dnx.shape)
    14.     dc = (dnx * dny).sum()/denom
    15.     dvx = (dnx **  2).sum()/denom
    16.     dvy = (dny **  2).sum()/denom
    17.     dr = dc/(np.sqrt(dvx)*np.sqrt(dvy))
    18.     return np.sqrt(sr)
    19.  
    20. x = np.random.uniform(-1,1,10000)
    21. dc = dcov_all(x,x**2)
    22. print(dc)

    方法三：卡方检验

    • 通过观察实际值和理论值得偏差来确定理论的正确与否，具体做的时候常常先假设两个变量确实是独立的，然后观察实际值和理论值得偏差程度，偏差小，则认为误差是很自然的样本误差，测量手段不够精确导致或偶然情况，认为二者独立，此时接受原假设。若偏差大到一定程度，使得这样的误差不大可能是偶然产生或测量导致，就认为二者实际上是相关的，即否定原假设而接受备择假设。

    基于模型的特征选择

    • 用回归模型的系数选择特征。越重要的特征在模型中对应的系数就会越大。与输出变量越无关的系数就会越接近于0。在噪音不多的数据上，或数据量远远大于特征数的数据上，如果特征之间相对比较独立，用最简单的线性回归也有较好的效果

    L1正则化

    • 将系数w的L1范数作为惩罚项加到损失函数上，正则项非零，就迫使弱的特征所对应的系数变为0。L1正则化往往会使学到的模型很稀疏，这个特性使L1正则化成为很好的特征选择方法。
    1. from sklearn.linear_model import Lasso
    2. from sklearn.preprocessing import StandardScaler
    3. from sklearn.datasets import load_boston
    4. data = load_boston()
    5. #
    6. scaler = StandardScaler()
    7. X = scaler.fit_transform(data.data)
    8. Y = data.target
    9. names = data.feature_names
    10.  
    11. lasso = Lasso(alpha = 0.3)
    12. lasso.fit(X,Y)
    13. print('Lasso model',lasso.coef_,names)
    14.  
    15. '''Lasso model [-0.24227912  0.081819   -0.          0.53987192 -0.69891258  2.99322993
    16.  -0.         -1.08091325  0.         -0.         -1.75561249  0.62831526  -3.70463287]
    17.  ['CRIM' 'ZN' 'INDUS' 'CHAS' 'NOX' 'RM' 'AGE' 'DIS' 'RAD' 'TAX' 'PTRATIO'
    18.  'B' 'LSTAT']'''

    可以看到，很多特征的系数都是0。如果继续增加alpha的值，得到的模型就会越来越稀疏，即越来越多的特征系数会变成0。然而， L1正则化像非正则化线性模型一样也是不稳定的，如果特征集合中具有相关联的特征，当数据发生细微变化时也有可能导致很大的模型差异。

    L2正则化

    将系数向量的L2范数添加到了损失函数中。由于L2惩罚项中系数是二次方的，L2和L1相较，L2正则化会让系数的取值变得平均。对于关联特征，这意味着他们能够获得更相近的对应系数。L2正则化对于特征选择来说一种稳定的模型，不像L1正则化那样，系数会因为细微的数据变化而波动。所以L2正则化和L1正则化提供的价值是不同的，L2正则化对于特征理解来说更加有用：表示能力强的特征对应的系数是非零。

    1. #3个互相关联的特征的例子，分别以10个不同的种子随机初始化运行10次
    2. #来观察L1和L2正则化的稳定性。
    3. from sklearn.linear_model import Ridge
    4. from sklearn.linear_model import LinearRegression
    5. from sklearn.metrics import r2_score
    6.  
    7. size  = 100
    8. for i in range(10):
    9.     print ("Random seed %s" % i)
    10.     np.random.seed(seed = i)
    11.     X_seed = np.random.normal(0,1,size)
    12.     X1 = X_seed + np.random.normal(0,.1,size)
    13.     X2 = X_seed + np.random.normal(0,.1,size)
    14.     X3 = X_seed + np.random.normal(0,.1,size)
    15.     Y = X1 + X2 + X3 + np.random.normal(0,1,size)
    16.     X = np.array([X1,X2,X3]).T
    17.     
    18.     lr = LinearRegression()
    19.     lr.fit(X,Y)
    20.     print('Linear model',lr.coef_)
    21.     
    22.     ridge = Ridge(alpha = 10)
    23.     ridge.fit(X,Y)
    24.     print('Ridge model',ridge.coef_)
    25.  
    26. '''Random seed 0
    27. Linear model [ 0.7284403   2.30926001 -0.08219169]
    28. Ridge model [0.93832131 1.05887277 0.87652644]
    29. 即：
    30. Linear model [ 0.7284403*X0 +  2.30926001*X1  -0.08219169*X2]
    31. Ridge model [0.93832131*X0 + 1.05887277*X1 + 0.87652644*X2]
    33. Random seed 1
    34. Linear model [ 1.15181561  2.36579916 -0.59900864]
    35. Ridge model [0.98409577 1.06792673 0.75855367]
    36. Random seed 2
    37. Linear model [0.69734749 0.32155864 2.08590886]
    38. Ridge model [0.97159124 0.94256202 1.08539406]
    39. Random seed 3
    40. Linear model [0.28735446 1.25386129 1.49054726]
    41. Ridge model [0.91891806 1.00474386 1.03276594]
    42. Random seed 4
    43. Linear model [0.18726691 0.77214206 2.1894915 ]
    44. Ridge model [0.96401621 0.98152524 1.0983599 ]
    45. Random seed 5
    46. Linear model [-1.2912413   1.59097473  2.74727029]
    47. Ridge model [0.75819864 1.01085804 1.1390417 ]
    48. Random seed 6
    49. Linear model [ 1.19909595 -0.0306915   1.91454912]
    50. Ridge model [1.01616507 0.89032238 1.0907386 ]
    51. Random seed 7
    52. Linear model [ 1.47386769  1.76236014 -0.15057274]
    53. Ridge model [1.0179376  1.03865514 0.90082373]
    54. Random seed 8
    55. Linear model [0.0840547  1.87985845 1.10688887]
    56. Ridge model [0.90685834 1.07119752 1.00837994]
    57. Random seed 9
    58. Linear model [0.71408648 0.77601368 1.36406398]
    59. Ridge model [0.89617178 0.90340866 0.98015958]'''

    从输出可以看出，不同数据上线性回归的模型系数波动较大而L2正则化模型结果中的系数非常稳定，差别较小，都较接近1，能够反应数据的内在结构。

    随机森林特征选择

    随机森林具有准确率高、鲁棒性好、易于使用等优点，这使得它成为了目前最流行的机器学习算法之一。

    随机森林提供了两种特征选择的方法mean：decrease accuracy和mean decrease impurity。

    在波士顿房价数据集上使用sklearn的随机森林回归给出一个单变量选择的例子：

    1. from sklearn.datasets import load_boston
    2. from sklearn.model_selection import cross_val_score,ShuffleSplit
    3. from sklearn.ensemble import RandomForestRegressor as RFR
    4. import numpy as np
    5.  
    6. data = load_boston()
    7. X = data.data
    8. y = data.target
    9. names = data.feature_names
    10. rf = RFR(n_estimators = 20,max_depth = 4)
    11. scores = []
    12. for i in range(X.shape[1]):
    13.     score = cross_val_score(rf,X[:,i:i+1],y,scoring = 'r2',cv = ShuffleSplit(len(X),3,.3))
    14.     scores.append((round(np.mean(score),3),names[i]))
    15. #     ShuffleSplit分割训练集和测试集，round 对结果进行四舍五入
    16. print (sorted(scores,reverse  = True))
    17.   
    18. '''[(-2.402, 'CHAS'), (-3.584, 'PTRATIO'), (-3.701, 'INDUS'), (-3.751, 'NOX'), (-4.113, 'LSTAT'), (-4.661, 'RAD'), (-4.807, 'DIS'), (-5.696, 'ZN'), (-5.836, 'TAX'), (-5.921, 'RM'), (-9.324, 'B'), (-24.344, 'CRIM'), (-34.624, 'AGE')]'''
    •  [(-2.402, 'CHAS'), (-3.584, 'PTRATIO'), (-3.701, 'INDUS'), (-3.751, 'NOX'), (-4.113, 'LSTAT'), (-4.661, 'RAD'), (-4.807, 'DIS'), (-5.696, 'ZN'), (-5.836, 'TAX'), (-5.921, 'RM'), (-9.324, 'B'), (-24.344, 'CRIM'), (-34.624, 'AGE')]
    • 由得出的每个特征的R^2的绝对值可知， 'B'   'AGE'  'CRIM' 这三个特征与输出变量相关性较强，是比较重要的的特征，可以选择这几个特征。

    XGBoost特征选择

    特征选择 XGBoost为工业级用的比较多的模型，其某个特征的重要性（feature score），等于它被选中为树节点分裂特征的次数的和，比如特征A在第一次迭代中（即第一棵树）被选中了1次去分裂树节点，在第二次迭代被选中2次，那么最终特征A的featurescore就是1＋2，可以利用其特征的重要性对特征进行选择。XGBoost的特征选择的代码如下：

    •  使用get_summies（），当一个feature几百种取值可能，, 如feature1取值有[“a”,“b”,…“z”]26种可能的话，那么显然用哑变量就会把这一个feature变为26列，增加数据的稀疏性，并且没有意义（视情况）。
    •  pd.factorize() 实现将字符串特征转化为数字特征,用pd.factorize()了。会分解为0-25种数字。同时1列字符串经过变换后仍是一列。不会使数据集看上去稀疏。
    • 使用XGBoost中的get_fscore这个函数获取每个特征的feature score，判断特征重要性。
    • fmap='xgb.fmap'：特征名字的映射文件
    • operator.itemgetter 用于获取对象的某些位置的数据，参数即为代表位置的序号值
    • sorted(iterable, key=None, reverse=False) ，iterable 表示指定的序列，key 参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted() 函数会返回一个排好序的列表。

     数据集：Allstate Claims Severity | Kaggle 

    1. import numpy as np
    2. import pandas as pd
    3. import xgboost as xgb
    4. import operator
    5. import matplotlib.pyplot as plt
    6.  
    7. def create_feature_map(features):
    8.     outfile = open('xgb.fmap','w')
    9.     i = 0
    10.     for feat in features:
    11.         outfile.write('{0}\t{1}\tq\n'.format(i,feat))
    12.         i = i+1
    13.     outfile.close()
    14.         
    15. if __name__ == '__main__':
    16.     train  = pd.read_csv('Allstate Claims Severity/train.csv')
    17.  
    18.     cat_sel = [n for n in train.columns if n.startswith('cat')]  
    19.     #类别特征数值化
    20.  
    21.     for column in cat_sel:
    22.         train[column] = pd.factorize(train[column].values , sort=True)[0] + 1
    23.  
    24. params ={
    25.     'min_child_weight': 100, 
    26.     'eta': 0.02,
    27.     'colsample_bytree':0.7,
    28.     'max_depth': 12,
    29.     'subsample': 0.7,
    30.     'alpha': 1, 
    31.     'gamma': 1,
    32.     'silent': 1,
    33.     'verbose_eval': True,
    34.     'seed':12
    35. }
    36.  
    37. rounds = 10
    38. y = train['loss']
    39. X = train.drop(['loss', 'id'], 1)
    40.  
    41. #构造xgb的训练集
    42. xgtrain = xgb.DMatrix(X, label=y)
    43. bst = xgb.train(params, xgtrain, num_boost_round=rounds)
    44.  
    45.  
    46. features = [x for x in train.columns if x not in ['id','loss']]
    47. create_feature_map(features)
    48.  
    49. importance = bst.get_fscore(fmap='xgb.fmap')
    50. #自定义key=operator.itemgetter(1)，按importance字典中的分数排序
    51. importance = sorted(importance.items(), key=operator.itemgetter(1))
    52.  
    53. #构建特征评分数据框
    54. df = pd.DataFrame(importance, columns=['feature', 'fscore'])
    55. df['fscore'] = df['fscore'] / df['fscore'].sum()
    56. #保存特征评分数据框文件
    57. df.to_csv("Allstate Claims Severity/feat_importance.csv", index=False)
    58.  
    59. #可视化特征重要程度
    60. plt.figure()
    61. df.plot(kind='barh', x='feature', y='fscore', legend=False, figsize=(6, 10))
    62. plt.title('XGBoost Feature Importance')
    63. plt.xlabel('relative importance')
    64. plt.show()

    Python operator.itemgetter函数理解

    get_fscore的参数fmap

  • 相关阅读:
    Dubbo 3 StateRouter：下一代微服务高效流量路由
    Selenium上传文件有多少种方式？不信你有我全
    Appium —— 初识移动APP自动化测试框架Appium
    Filter
    openssl创建CA证书教程
    Java 泛型中的通配符
    深入理解计算机网络-8网络层2
    每日一题——将一个正整数分解质因数
    Excelize 开源基础发布 2.8.1 版本，2024 年首个更新
    Direct3D颜色
  • 原文地址：https://blog.csdn.net/m0_51933492/article/details/126732118