特征工程学习01-sklearn单机特征工程

小书匠 kindle 

0.数据的导入

  1. from sklearn.datasets import load_iris 
  3. #导入IRIS数据集 
  4. iris=load_iris() 
  6. #特征矩阵 
  7. print(iris.data[:5],len(iris.data)) 
  9. #目标向量 
  10. print(iris.target[:5],len(iris.target)) 
  1. [[ 5.1 3.5 1.4 0.2] 
  2. [ 4.9 3. 1.4 0.2] 
  3. [ 4.7 3.2 1.3 0.2] 
  4. [ 4.6 3.1 1.5 0.2] 
  5. [ 5. 3.6 1.4 0.2]] 150 
  6. [0 0 0 0 0] 150 

1.数据预处理

1.1无量纲化

1.1.1标准化

  1. from sklearn.preprocessing import StandardScaler 
  3. #标准化，返回值为标准化后的值 
  4. iris_standar=StandardScaler().fit_transform(iris.data) 
  5. print(iris_standar[:5]) 
  1. [[-0.90068117 1.03205722 -1.3412724 -1.31297673] 
  2. [-1.14301691 -0.1249576 -1.3412724 -1.31297673] 
  3. [-1.38535265 0.33784833 -1.39813811 -1.31297673] 
  4. [-1.50652052 0.10644536 -1.2844067 -1.31297673] 
  5. [-1.02184904 1.26346019 -1.3412724 -1.31297673]] 

1.1.2区间缩放

  1. from sklearn.preprocessing import MinMaxScaler 
  3. # 区间缩放，返回值为已经缩放到[0,1]的值 
  4. iris_minmax=MinMaxScaler().fit_transform(iris.data) 
  5. print(iris_minmax[:5]) 
  1. [[ 0.22222222 0.625 0.06779661 0.04166667] 
  2. [ 0.16666667 0.41666667 0.06779661 0.04166667] 
  3. [ 0.11111111 0.5 0.05084746 0.04166667] 
  4. [ 0.08333333 0.45833333 0.08474576 0.04166667] 
  5. [ 0.19444444 0.66666667 0.06779661 0.04166667]] 

1.2对定量特征进行二值化

  1. from sklearn.preprocessing import Binarizer 
  3. #二值化，分界线设置为3，返回二值化后的特征 
  4. iris_binarizer=Binarizer(threshold=3).fit_transform(iris.data) 
  5. print(iris_binarizer[:5]) 
  1. [[ 1. 1. 0. 0.] 
  2. [ 1. 0. 0. 0.] 
  3. [ 1. 1. 0. 0.] 
  4. [ 1. 1. 0. 0.] 
  5. [ 1. 1. 0. 0.]] 

1.3对定性特征进行哑编码

  1. from sklearn.preprocessing import OneHotEncoder 
  3. # 哑编码，对iris的目标集进行哑编码，返回编码后的值 
  4. iris_onehotencoder=OneHotEncoder().fit_transform(iris.target.reshape((-1,1))) 
  5. print(iris.target[-5:]) 
  6. print(iris.target.reshape((-1,1))[-5:]) 
  7. print(iris_onehotencoder[-5:]) 
  1. [2 2 2 2 2] 
  2. [[2] 
  3. [2] 
  4. [2] 
  5. [2] 
  6. [2]] 
  7. (0, 2) 1.0 
  8. (1, 2) 1.0 
  9. (2, 2) 1.0 
  10. (3, 2) 1.0 
  11. (4, 2) 1.0 

1.4缺失值计算

  1. from numpy import vstack, array, nan 
  2. from sklearn.preprocessing import Imputer 
  4. #缺失值计算，返回值为计算缺失值后的数据 
  5. #参数missing_value为缺失值的表示形式，默认为NaN 
  6. #参数strategy为缺失值填充方式，默认为mean（均值） 
  7. iris_imputer=Imputer().fit_transform(vstack((array([nan, nan, nan, nan]), iris.data))) 
  8. print(iris_imputer[:5],len(iris_imputer)) 
  1. [[ 5.84333333 3.054 3.75866667 1.19866667] 
  2. [ 5.1 3.5 1.4 0.2 ] 
  3. [ 4.9 3. 1.4 0.2 ] 
  4. [ 4.7 3.2 1.3 0.2 ] 
  5. [ 4.6 3.1 1.5 0.2 ]] 151 

1.5数据变换

  1. from sklearn.preprocessing import PolynomialFeatures 
  3. #多项式转换 
  4. #参数degree为度，默认值为2 
  5. iris_pol=PolynomialFeatures().fit_transform(iris.data) 
  6. print(iris_pol[:5]) 
  1. [[ 1. 5.1 3.5 1.4 0.2 26.01 17.85 7.14 1.02 12.25 
  2. 4.9 0.7 1.96 0.28 0.04] 
  3. [ 1. 4.9 3. 1.4 0.2 24.01 14.7 6.86 0.98 9. 4.2 
  4. 0.6 1.96 0.28 0.04] 
  5. [ 1. 4.7 3.2 1.3 0.2 22.09 15.04 6.11 0.94 10.24 
  6. 4.16 0.64 1.69 0.26 0.04] 
  7. [ 1. 4.6 3.1 1.5 0.2 21.16 14.26 6.9 0.92 9.61 
  8. 4.65 0.62 2.25 0.3 0.04] 
  9. [ 1. 5. 3.6 1.4 0.2 25. 18. 7. 1. 12.96 
  10. 5.04 0.72 1.96 0.28 0.04]] 
  1. from numpy import log1p 
  2. from sklearn.preprocessing import FunctionTransformer 
  4. #自定义转换函数为对数函数的数据变换 
  5. #第一个参数是单变元函数 
  6. iris_ftf=FunctionTransformer(log1p).fit_transform(iris.data) 
  7. print(iris_ftf[:5]) 
  1. [[ 1.80828877 1.5040774 0.87546874 0.18232156] 
  2. [ 1.77495235 1.38629436 0.87546874 0.18232156] 
  3. [ 1.74046617 1.43508453 0.83290912 0.18232156] 
  4. [ 1.7227666 1.41098697 0.91629073 0.18232156] 
  5. [ 1.79175947 1.5260563 0.87546874 0.18232156]] 

2.特征选择

2.1Filter

2.1.1方差选择法

  1. from sklearn.feature_selection import VarianceThreshold 
  3. #方差选择法，返回值为特征选择后的数据 
  4. #参数threshold为方差的阈值 
  5. iris_vt=VarianceThreshold(threshold=3).fit_transform(iris.data) 
  6. print(iris_vt,len(iris_vt)) 
  1. [[ 1.4] 
  2. [ 1.4] 
  3. [ 1.3] 
  4. [ 1.5] 
  5. [ 1.4] 
  6. [ 1.7] 
  7. [ 1.4] 
  8. [ 1.5] 
  9. [ 1.4] 
  10. [ 1.5] 
  11. [ 1.5] 
  12. [ 1.6] 
  13. [ 1.4] 
  14. [ 1.1] 
  15. [ 1.2] 
  16. [ 1.5] 
  17. [ 1.3] 
  18. [ 1.4] 
  19. [ 1.7] 
  20. [ 1.5] 
  21. [ 1.7] 
  22. [ 1.5] 
  23. [ 1. ] 
  24. [ 1.7] 
  25. [ 1.9] 
  26. [ 1.6] 
  27. [ 1.6] 
  28. [ 1.5] 
  29. [ 1.4] 
  30. [ 1.6] 
  31. [ 1.6] 
  32. [ 1.5] 
  33. [ 1.5] 
  34. [ 1.4] 
  35. [ 1.5] 
  36. [ 1.2] 
  37. [ 1.3] 
  38. [ 1.5] 
  39. [ 1.3] 
  40. [ 1.5] 
  41. [ 1.3] 
  42. [ 1.3] 
  43. [ 1.3] 
  44. [ 1.6] 
  45. [ 1.9] 
  46. [ 1.4] 
  47. [ 1.6] 
  48. [ 1.4] 
  49. [ 1.5] 
  50. [ 1.4] 
  51. [ 4.7] 
  52. [ 4.5] 
  53. [ 4.9] 
  54. [ 4. ] 
  55. [ 4.6] 
  56. [ 4.5] 
  57. [ 4.7] 
  58. [ 3.3] 
  59. [ 4.6] 
  60. [ 3.9] 
  61. [ 3.5] 
  62. [ 4.2] 
  63. [ 4. ] 
  64. [ 4.7] 
  65. [ 3.6] 
  66. [ 4.4] 
  67. [ 4.5] 
  68. [ 4.1] 
  69. [ 4.5] 
  70. [ 3.9] 
  71. [ 4.8] 
  72. [ 4. ] 
  73. [ 4.9] 
  74. [ 4.7] 
  75. [ 4.3] 
  76. [ 4.4] 
  77. [ 4.8] 
  78. [ 5. ] 
  79. [ 4.5] 
  80. [ 3.5] 
  81. [ 3.8] 
  82. [ 3.7] 
  83. [ 3.9] 
  84. [ 5.1] 
  85. [ 4.5] 
  86. [ 4.5] 
  87. [ 4.7] 
  88. [ 4.4] 
  89. [ 4.1] 
  90. [ 4. ] 
  91. [ 4.4] 
  92. [ 4.6] 
  93. [ 4. ] 
  94. [ 3.3] 
  95. [ 4.2] 
  96. [ 4.2] 
  97. [ 4.2] 
  98. [ 4.3] 
  99. [ 3. ] 
  100. [ 4.1] 
  101. [ 6. ] 
  102. [ 5.1] 
  103. [ 5.9] 
  104. [ 5.6] 
  105. [ 5.8] 
  106. [ 6.6] 
  107. [ 4.5] 
  108. [ 6.3] 
  109. [ 5.8] 
  110. [ 6.1] 
  111. [ 5.1] 
  112. [ 5.3] 
  113. [ 5.5] 
  114. [ 5. ] 
  115. [ 5.1] 
  116. [ 5.3] 
  117. [ 5.5] 
  118. [ 6.7] 
  119. [ 6.9] 
  120. [ 5. ] 
  121. [ 5.7] 
  122. [ 4.9] 
  123. [ 6.7] 
  124. [ 4.9] 
  125. [ 5.7] 
  126. [ 6. ] 
  127. [ 4.8] 
  128. [ 4.9] 
  129. [ 5.6] 
  130. [ 5.8] 
  131. [ 6.1] 
  132. [ 6.4] 
  133. [ 5.6] 
  134. [ 5.1] 
  135. [ 5.6] 
  136. [ 6.1] 
  137. [ 5.6] 
  138. [ 5.5] 
  139. [ 4.8] 
  140. [ 5.4] 
  141. [ 5.6] 
  142. [ 5.1] 
  143. [ 5.1] 
  144. [ 5.9] 
  145. [ 5.7] 
  146. [ 5.2] 
  147. [ 5. ] 
  148. [ 5.2] 
  149. [ 5.4] 
  150. [ 5.1]] 150 

2.1.2相关系数法(此处使用第二篇博客进行修改)

  1. from sklearn.feature_selection import SelectKBest,chi2 
  2. from scipy.stats import pearsonr 
  4. #选择K个最好的特征，返回选择特征后的数据 
  5. #第一个参数为计算评估特征是否好的函数，该函数输入特征矩阵和目标向量，输出二元组（评分，P值）的数组，数组第i项为第i个特征的评分和P值。在此定义为计算相关系数 
  6. #参数k为选择的特征个数 
  7. iris_pear=SelectKBest(chi2, k=2).fit_transform(iris.data, iris.target) 
  8. print(iris_pear,len(iris_pear)) 
  1. [[ 1.4 0.2] 
  2. [ 1.4 0.2] 
  3. [ 1.3 0.2] 
  4. [ 1.5 0.2] 
  5. [ 1.4 0.2] 
  6. [ 1.7 0.4] 
  7. [ 1.4 0.3] 
  8. [ 1.5 0.2] 
  9. [ 1.4 0.2] 
  10. [ 1.5 0.1] 
  11. [ 1.5 0.2] 
  12. [ 1.6 0.2] 
  13. [ 1.4 0.1] 
  14. [ 1.1 0.1] 
  15. [ 1.2 0.2] 
  16. [ 1.5 0.4] 
  17. [ 1.3 0.4] 
  18. [ 1.4 0.3] 
  19. [ 1.7 0.3] 
  20. [ 1.5 0.3] 
  21. [ 1.7 0.2] 
  22. [ 1.5 0.4] 
  23. [ 1. 0.2] 
  24. [ 1.7 0.5] 
  25. [ 1.9 0.2] 
  26. [ 1.6 0.2] 
  27. [ 1.6 0.4] 
  28. [ 1.5 0.2] 
  29. [ 1.4 0.2] 
  30. [ 1.6 0.2] 
  31. [ 1.6 0.2] 
  32. [ 1.5 0.4] 
  33. [ 1.5 0.1] 
  34. [ 1.4 0.2] 
  35. [ 1.5 0.1] 
  36. [ 1.2 0.2] 
  37. [ 1.3 0.2] 
  38. [ 1.5 0.1] 
  39. [ 1.3 0.2] 
  40. [ 1.5 0.2] 
  41. [ 1.3 0.3] 
  42. [ 1.3 0.3] 
  43. [ 1.3 0.2] 
  44. [ 1.6 0.6] 
  45. [ 1.9 0.4] 
  46. [ 1.4 0.3] 
  47. [ 1.6 0.2] 
  48. [ 1.4 0.2] 
  49. [ 1.5 0.2] 
  50. [ 1.4 0.2] 
  51. [ 4.7 1.4] 
  52. [ 4.5 1.5] 
  53. [ 4.9 1.5] 
  54. [ 4. 1.3] 
  55. [ 4.6 1.5] 
  56. [ 4.5 1.3] 
  57. [ 4.7 1.6] 
  58. [ 3.3 1. ] 
  59. [ 4.6 1.3] 
  60. [ 3.9 1.4] 
  61. [ 3.5 1. ] 
  62. [ 4.2 1.5] 
  63. [ 4. 1. ] 
  64. [ 4.7 1.4] 
  65. [ 3.6 1.3] 
  66. [ 4.4 1.4] 
  67. [ 4.5 1.5] 
  68. [ 4.1 1. ] 
  69. [ 4.5 1.5] 
  70. [ 3.9 1.1] 
  71. [ 4.8 1.8] 
  72. [ 4. 1.3] 
  73. [ 4.9 1.5] 
  74. [ 4.7 1.2] 
  75. [ 4.3 1.3] 
  76. [ 4.4 1.4] 
  77. [ 4.8 1.4] 
  78. [ 5. 1.7] 
  79. [ 4.5 1.5] 
  80. [ 3.5 1. ] 
  81. [ 3.8 1.1] 
  82. [ 3.7 1. ] 
  83. [ 3.9 1.2] 
  84. [ 5.1 1.6] 
  85. [ 4.5 1.5] 
  86. [ 4.5 1.6] 
  87. [ 4.7 1.5] 
  88. [ 4.4 1.3] 
  89. [ 4.1 1.3] 
  90. [ 4. 1.3] 
  91. [ 4.4 1.2] 
  92. [ 4.6 1.4] 
  93. [ 4. 1.2] 
  94. [ 3.3 1. ] 
  95. [ 4.2 1.3] 
  96. [ 4.2 1.2] 
  97. [ 4.2 1.3] 
  98. [ 4.3 1.3] 
  99. [ 3. 1.1] 
  100. [ 4.1 1.3] 
  101. [ 6. 2.5] 
  102. [ 5.1 1.9] 
  103. [ 5.9 2.1] 
  104. [ 5.6 1.8] 
  105. [ 5.8 2.2] 
  106. [ 6.6 2.1] 
  107. [ 4.5 1.7] 
  108. [ 6.3 1.8] 
  109. [ 5.8 1.8] 
  110. [ 6.1 2.5] 
  111. [ 5.1 2. ] 
  112. [ 5.3 1.9] 
  113. [ 5.5 2.1] 
  114. [ 5. 2. ] 
  115. [ 5.1 2.4] 
  116. [ 5.3 2.3] 
  117. [ 5.5 1.8] 
  118. [ 6.7 2.2] 
  119. [ 6.9 2.3] 
  120. [ 5. 1.5] 
  121. [ 5.7 2.3] 
  122. [ 4.9 2. ] 
  123. [ 6.7 2. ] 
  124. [ 4.9 1.8] 
  125. [ 5.7 2.1] 
  126. [ 6. 1.8] 
  127. [ 4.8 1.8] 
  128. [ 4.9 1.8] 
  129. [ 5.6 2.1] 
  130. [ 5.8 1.6] 
  131. [ 6.1 1.9] 
  132. [ 6.4 2. ] 
  133. [ 5.6 2.2] 
  134. [ 5.1 1.5] 
  135. [ 5.6 1.4] 
  136. [ 6.1 2.3] 
  137. [ 5.6 2.4] 
  138. [ 5.5 1.8] 
  139. [ 4.8 1.8] 
  140. [ 5.4 2.1] 
  141. [ 5.6 2.4] 
  142. [ 5.1 2.3] 
  143. [ 5.1 1.9] 
  144. [ 5.9 2.3] 
  145. [ 5.7 2.5] 
  146. [ 5.2 2.3] 
  147. [ 5. 1.9] 
  148. [ 5.2 2. ] 
  149. [ 5.4 2.3] 
  150. [ 5.1 1.8]] 150 

2.1.3卡方检验

  1. from sklearn.feature_selection import SelectKBest 
  2. from sklearn.feature_selection import chi2 
  4. #选择K个最好的特征，返回选择特征后的数据 
  5. iris_chi2=SelectKBest(chi2, k=2).fit_transform(iris.data, iris.target) 
  6. print(iris_chi2[:5],len(iris_chi2)) 
  1. [[ 1.4 0.2] 
  2. [ 1.4 0.2] 
  3. [ 1.3 0.2] 
  4. [ 1.5 0.2] 
  5. [ 1.4 0.2]] 150 

2.1.4互信息法

  1. from sklearn.feature_selection import SelectKBest 
  2. from minepy import MINE 
  4. #由于MINE的设计不是函数式的，定义mic方法将其为函数式的，返回一个二元组，二元组的第2项设置成固定的P值0.5 
  5. def mic(x, y): 
  6. m = MINE() 
  7. m.compute_score(x, y) 
  8. return (m.mic(), 0.5) 
  10. #选择K个最好的特征，返回特征选择后的数据 
  11. SelectKBest(lambda X, Y: array(map(lambda x:mic(x, Y), X.T)).T, k=2).fit_transform(iris.data, iris.target) 
  1. --------------------------------------------------------------------------- 
  3. ImportError Traceback (most recent call last) 
  5. <ipython-input-47-807ad1fcacee> in <module>() 
  6. 1 from sklearn.feature_selection import SelectKBest 
  7. ----> 2 from minepy import MINE 
  8. 3  
  9. 4 #由于MINE的设计不是函数式的，定义mic方法将其为函数式的，返回一个二元组，二元组的第2项设置成固定的P值0.5 
  10. 5 def mic(x, y): 
  13. ImportError: No module named 'minepy' 

2.2Wrapper

3.2.1 递归特征消除法

  1. from sklearn.feature_selection import RFE 
  2. from sklearn.linear_model import LogisticRegression 
  4. #递归特征消除法，返回特征选择后的数据 
  5. #参数estimator为基模型 
  6. #参数n_features_to_select为选择的特征个数 
  7. iris_pfe=RFE(estimator=LogisticRegression(), n_features_to_select=2).fit_transform(iris.data, iris.target) 
  8. print(iris_pfe[:5]) 
  1. [[ 3.5 0.2] 
  2. [ 3. 0.2] 
  3. [ 3.2 0.2] 
  4. [ 3.1 0.2] 
  5. [ 3.6 0.2]] 

3.3 Embedded

3.3.1 基于惩罚项的特征选择法

  1. from sklearn.feature_selection import SelectFromModel 
  2. from sklearn.linear_model import LogisticRegression 
  4. #带L1惩罚项的逻辑回归作为基模型的特征选择 
  5. iris_sfm=SelectFromModel(LogisticRegression(penalty="l1", C=0.1)).fit_transform(iris.data, iris.target) 
  6. print(iris_sfm[:5]) 
  1. [[ 5.1 3.5 1.4] 
  2. [ 4.9 3. 1.4] 
  3. [ 4.7 3.2 1.3] 
  4. [ 4.6 3.1 1.5] 
  5. [ 5. 3.6 1.4]] 
  1. from sklearn.linear_model import LogisticRegression 
  3. class LR(LogisticRegression): 
  4. def __init__(self, threshold=0.01, dual=False, tol=1e-4, C=1.0, 
  5. fit_intercept=True, intercept_scaling=1, class_weight=None, 
  6. random_state=None, solver='liblinear', max_iter=100, 
  7. multi_class='ovr', verbose=0, warm_start=False, n_jobs=1): 
  9. #权值相近的阈值 
  10. self.threshold = threshold 
  11. LogisticRegression.__init__(self, penalty='l1', dual=dual, tol=tol, C=C, 
  12. fit_intercept=fit_intercept, intercept_scaling=intercept_scaling, class_weight=class_weight, 
  13. random_state=random_state, solver=solver, max_iter=max_iter, 
  14. multi_class=multi_class, verbose=verbose, warm_start=warm_start, n_jobs=n_jobs) 
  15. #使用同样的参数创建L2逻辑回归 
  16. self.l2 = LogisticRegression(penalty='l2', dual=dual, tol=tol, C=C, fit_intercept=fit_intercept, intercept_scaling=intercept_scaling, class_weight = class_weight, random_state=random_state, solver=solver, max_iter=max_iter, multi_class=multi_class, verbose=verbose, warm_start=warm_start, n_jobs=n_jobs) 
  18. def fit(self, X, y, sample_weight=None): 
  19. #训练L1逻辑回归 
  20. super(LR, self).fit(X, y, sample_weight=sample_weight) 
  21. self.coef_old_ = self.coef_.copy() 
  22. #训练L2逻辑回归 
  23. self.l2.fit(X, y, sample_weight=sample_weight) 
  25. cntOfRow, cntOfCol = self.coef_.shape 
  26. #权值系数矩阵的行数对应目标值的种类数目 
  27. for i in range(cntOfRow): 
  28. for j in range(cntOfCol): 
  29. coef = self.coef_[i][j] 
  30. #L1逻辑回归的权值系数不为0 
  31. if coef != 0: 
  32. idx = [j] 
  33. #对应在L2逻辑回归中的权值系数 
  34. coef1 = self.l2.coef_[i][j] 
  35. for k in range(cntOfCol): 
  36. coef2 = self.l2.coef_[i][k] 
  37. #在L2逻辑回归中，权值系数之差小于设定的阈值，且在L1中对应的权值为0 
  38. if abs(coef1-coef2) < self.threshold and j != k and self.coef_[i][k] == 0: 
  39. idx.append(k) 
  40. #计算这一类特征的权值系数均值 
  41. mean = coef / len(idx) 
  42. self.coef_[i][idx] = mean 
  43. return self 
  1. from sklearn.feature_selection import SelectFromModel 
  3. #带L1和L2惩罚项的逻辑回归作为基模型的特征选择 
  4. #参数threshold为权值系数之差的阈值 
  5. iris_sfm2=SelectFromModel(LR(threshold=0.5, C=0.1)).fit_transform(iris.data, iris.target) 
  6. print(iris_sfm2[:5]) 
  1. [[ 5.1 3.5 1.4 0.2] 
  2. [ 4.9 3. 1.4 0.2] 
  3. [ 4.7 3.2 1.3 0.2] 
  4. [ 4.6 3.1 1.5 0.2] 
  5. [ 5. 3.6 1.4 0.2]] 

3.3.2 基于树模型的特征选择法

  1. from sklearn.feature_selection import SelectFromModel 
  2. from sklearn.ensemble import GradientBoostingClassifier 
  4. #GBDT作为基模型的特征选择 
  5. iris_sfm3=SelectFromModel(GradientBoostingClassifier()).fit_transform(iris.data, iris.target) 
  6. print(iris_sfm3[:5]) 
  1. [[ 1.4 0.2] 
  2. [ 1.4 0.2] 
  3. [ 1.3 0.2] 
  4. [ 1.5 0.2] 
  5. [ 1.4 0.2]] 

4 降维

4.1 主成分分析法（PCA）

  1. from sklearn.decomposition import PCA 
  3. #主成分分析法，返回降维后的数据 
  4. #参数n_components为主成分数目 
  5. iris_pca=PCA(n_components=2).fit_transform(iris.data) 
  6. print(iris_pca[:5]) 
  1. [[-2.68420713 0.32660731] 
  2. [-2.71539062 -0.16955685] 
  3. [-2.88981954 -0.13734561] 
  4. [-2.7464372 -0.31112432] 
  5. [-2.72859298 0.33392456]] 

4.2 线性判别分析法（LDA）

  1. from sklearn.lda import LDA 
  3. #线性判别分析法，返回降维后的数据 
  4. #参数n_components为降维后的维数 
  5. LDA(n_components=2).fit_transform(iris.data, iris.target) 
  1. --------------------------------------------------------------------------- 
  3. ImportError Traceback (most recent call last) 
  5. <ipython-input-56-21fd5d727aec> in <module>() 
  6. ----> 1 from sklearn.lda import LDA 
  7. 2  
  8. 3 #线性判别分析法，返回降维后的数据 
  9. 4 #参数n_components为降维后的维数 
  10. 5 LDA(n_components=2).fit_transform(iris.data, iris.target) 
  13. ImportError: No module named 'sklearn.lda' 

参考文章

1.使用sklearn做单机特征工程

2.利用scikit-learn进行FeatureSelection

特征工程学习01-sklearn单机特征工程的更多相关文章

  1. zynq学习01 新建一个Helloworld工程

    1,好早买了块FPGA板,zynq 7010 .终极目标是完成相机图像采集及处理.一个Window C++程序猿才开始学FPGA,一个小菜鸟,准备转行. 2,关于这块板,卖家的官方资料学起来没劲.推荐 ...

  2. 使用sklearn做单机特征工程（Performing Feature Engineering Using sklearn）

    本文转载自使用sklearn做单机特征工程 目录 目录 特征工程是什么 数据预处理 1 无量纲化 11 标准化 12 区间缩放法 13 标准化与归一化的区别 2 对定量特征二值化 3 对定性特征哑编码 ...

  3. 使用sklearn做单机特征工程

    目录 1 特征工程是什么?2 数据预处理 2.1 无量纲化 2.1.1 标准化 2.1.2 区间缩放法 2.1.3 标准化与归一化的区别 2.2 对定量特征二值化 2.3 对定性特征哑编码 2.4 缺 ...

  4. 【转】使用sklearn做单机特征工程

    这里是原文 说明:这是我用Markdown编辑的第一篇随笔 目录 1 特征工程是什么? 2 数据预处理 2.1 无量纲化 2.1.1 标准化 2.1.2 区间缩放法 2.1.3 无量纲化与正则化的区别 ...

  5. 转载：使用sklearn做单机特征工程

    目录 1 特征工程是什么?2 数据预处理 2.1 无量纲化 2.1.1 标准化 2.1.2 区间缩放法 2.1.3 标准化与归一化的区别 2.2 对定量特征二值化 2.3 对定性特征哑编码 2.4 缺 ...

  6. [特征工程]-------使用sklearn做单机特征工程[转载]

    https://www.cnblogs.com/jasonfreak/p/5448385.html 使用sklearn做单机特征工程 目录 1 特征工程是什么?2 数据预处理 2.1 无量纲化 2.1 ...

  7. Python机器学习笔记 使用sklearn做特征工程和数据挖掘

    特征处理是特征工程的核心部分,特征工程是数据分析中最耗时间和精力的一部分工作,它不像算法和模型那样式确定的步骤,更多的是工程上的经验和权衡,因此没有统一的方法,但是sklearn提供了较为完整的特征处 ...

  8. Sklearn与特征工程

    Scikit-learn与特征工程 “数据决定了机器学习的上限,而算法只是尽可能逼近这个上限”,这句话很好的阐述了数据在机器学习中的重要性.大部分直接拿过来的数据都是特征不明显的.没有经过处理的或者说 ...

  9. 【转】使用sklearn做特征工程

    1 特征工程是什么? 有这么一句话在业界广泛流传:数据和特征决定了机器学习的上限,而模型和算法只是逼近这个上限而已.那特征工程到底是什么呢?顾名思义,其本质是一项工程活动,目的是最大限度地从原始数据中 ...

随机推荐

  1. 通过 Kubeadm 安装 K8S 与高可用，版本1.13.4

    环境介绍: CentOS: 7.6 Docker: 18.06.1-ce Kubernetes: 1.13.4 Kuberadm: 1.13.4 Kuberlet: 1.13.4 Kuberctl: ...

  2. 编写Postgres扩展之二：类型和运算符

    原文:http://big-elephants.com/2015-10/writing-postgres-extensions-part-ii/ 编译:Tacey Wong 在上一篇关于编写Postg ...

  3. java封装数据类型——Byte

    Byte 是基本类型byte的封装类型.与Integer类似,Byte也提供了很多相同的方法,如 decode.toString.intValue.floatValue等,而且很多方法还是直接类型转换 ...

  4. Sass和Compass学习笔记系列之Sass

    最近在慕课网学习Sass和Compass,学习链接地址:https://www.imooc.com/learn/364,现在整理笔记如下: 一.使用Sass和Compass的优点: a.使用Sass和 ...

  5. Java集合框架介绍。Java Collection Frameworks = JCF

    Java集合框架 = Java Collection Frameworks  = JCF . 为了方便理解,我画了一张思维脑图.

  6. mycat-rule

    <?xml version="1.0" encoding="UTF-8"?> <!-- - - Licensed under the Apac ...

  7. 第十八篇：简易版web服务器开发

    在上篇有实现了一个静态的web服务器,可以接收web浏览器的请求,随后对请求消息进行解析,获取客户想要文件的文件名,随后根据文件名返回响应消息:那么这篇我们对该web服务器进行改善,通过多任务.非阻塞 ...

  8. c# 方法成员

  9. CentOS7.X+LAMP环境下安装zabbix4.X

    1.安装zabbix仓库 rpm -ivh https://repo.zabbix.com/zabbix/4.2/rhel/7/x86_64/zabbix-release-4.2-1.el7.noar ...

  10. Python_比较运算符

    1.比较运算符