特征工程学习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. 【dfs】Sequence Decoding

    Sequence Decoding 题目描述 The amino acids in proteins are classified into two types of elements, hydrop ...

  2. javascript Ajax 学习

    前言:这是笔者学习之后自己的理解与整理.如果有错误或者疑问的地方,请大家指正,我会持续更新! AJAX是asynchronousjavascript and XML的简写,就是异步的javascrip ...

  3. kubernets 证书过期的问题

    .问题起源 kubeadm 是 kubernetes 提供的一个初始化集群的工具,使用起来非常方便.但是它创建的apiserver.controller-manager等证书默认只有一年的有效期,同时 ...

  4. JAVA多线程之UncaughtExceptionHandler——处理非正常的线程中止

    JAVA多线程之UncaughtExceptionHandler——处理非正常的线程中止 背景 当单线程的程序发生一个未捕获的异常时我们可以采用try....catch进行异常的捕获,但是在多线程环境 ...

  5. ASP.NET使用window.event.keycode来获取按下的键盘值！

    window.event.keycode-获取按下的键盘值 这里只列出了一些较常用的键盘值更加详细的键盘值请访问此人博客:https://www.cnblogs.com/z-sm/p/3597592. ...

  6. jenkins的理解及安装

    目录 一.理论概述 二.安装 一.理论概述 Jenkins的介绍 ​ Jenkins是一个基于MIT License协议的开源软件项目,是基于Java开发的一种持续集成(CI)工具,用于监控持续重复的 ...

  7. django内置缓存

    由于Django是动态网站,所有每次请求均会去数据进行相应的操作,当程序访问量大时,耗时必然会更加明显,最简单解决方式是使用:缓存,缓存将一个某个views的返回值保存至内存或者memcache中,5 ...

  8. [ansible-playbook]4 持续集成环境之分布式部署利器 ansible playbook学习

    3 ansible-play讲的中太少了,今天稍微深入学习一点 预计阅读时间:15分钟 一: 安装部署 参考 http://getansible.com/begin/an_zhuang_ansile ...

  9. STM32 HAL库学习系列第8篇---回调函数总结

    普通函数与回调函数的区别:就是ST将中断封装,给使用者的API,就是标准库的中断函数 对普通函数的调用: 调用程序发出对普通函数的调用后,程序执行立即转向被调用函数执行,直到被调用函数执行完毕后,再返 ...

  10. Django：CSRF(Cross-request forgery)跨站请求伪造

    一.CSRF是什么 二.CSRF攻击原理 三.CSRF攻击防范 一.CSRF是什么 CSRF(Cross-site request forgery)跨站请求伪造,也被称为“One Click Atta ...