sklearn常用机器学习算法总结（附python代码） - 简书 (jianshu.com)https://www.jianshu.com/p/641707e4e72c

 注意：在使用XGBoost算法的时候，需要将X_train,y_train等Tensor类型变量数据类型置为nd array类型，而其他算法可以直接使用Tensor数据类型，即：

features = features.numpy()
labels = labels.numpy()
idx_train = idx_train.numpy()
idx_test = idx_test.numpy()

以下为原文：

sklearn是python中比较常用也是非常好用的机器学习库，总结几个比较常用的机器学习算法，非常简单，对于想快速入门的小白可以看看哦~

1. 拆分训练集和测试集

from sklearn.model_selection import train_test_split
#X是训练样本；y是label（目标值）；test_size为要训练集和测试集的比例，通常为0.2或0.3；random_state为是随机数的种子，其实就是该组随机数的编号，在需要重复试验的时候，保证得到一组一样的随机数。比如你每次都填1，其他参数一样的情况下你得到的随机数组是一样的。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=20)

2. logistic回归

from sklearn import linear_model
logistic = linear_model.LogisticRegression()  
#如果用正则化，可以添加参数penalty，可以是l1正则化（可以更有效的抵抗共线性），也可以是l2正则化，如果是类别不均衡的数据集，可以添加class_weight参数，这个可以自己设置，也可以让模型自己计算
logistic = linear_model.LogisticRegression( penalty='l1', class_weight='balanced')
logistic.fit(X_train,y_train)
y_pred = logistic.predict( X_test)
#如果只想预测概率大小，可以用下面这个函数
y_pred = logistic.predict_proba(X_test)

sklearn中与逻辑回归有关的主要有2个类，分别是LogisticRegression和LogisticRegressionCV，它们的主要区别是LogisticRegressionCV使用了交叉验证来选择正则化系数C。而LogisticRegression需要自己每次指定一个正则化系数。除了交叉验证，以及选择正则化系数C以外， LogisticRegression和LogisticRegressionCV的使用方法基本相同。
逻辑回归有很多参数可以调试，总结几个比较重要的参数：

• penalty： 正则化选项。penalty可选择的值为"l1"和"l2".分别对应L1的正则化和L2的正则化，默认是L2正则化。L1正则化可以抵抗共线性，还会起到特征选择的作用，不重要的特征会将系数变为0；L2正则化一般不会将系数变为0，但会将不重要的特征系数变的很小，起到避免过拟合的作用。
  　　penalty参数的选择会影响我们损失函数优化算法的选择。即参数solver的选择，如果是L2正则化，那么5种可选的算法{‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’，‘saga’}都可以选择。但是如果penalty是L1正则化的话，就只能选择‘liblinear’和‘saga’了。这是因为L1正则化的损失函数不是连续可导的，而{‘newton-cg’, ‘lbfgs’,‘sag’}这三种优化算法时都需要损失函数的一阶或者二阶连续导数。而‘liblinear’并没有这个依赖。
• solver: 损失函数优化方法。默认是“liblinear”，有5中方法可供选择：
  a) liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。
  b) lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
  c) newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
  d) sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本非常大的时候。
  e)saga: saga是sag的变体，它支持L1正则化，很多时候saga的效果是最好的。
  　　从上面的描述可以看出，newton-cg, lbfgs和sag这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear通吃L1正则化和L2正则化，但liblinear也有一个局限，就是在选择分类方式的选择时，只支持ovr，下面multi_class参数会有详细解释。
  　　同时，sag每次仅仅使用了部分样本进行梯度迭代，所以当样本量少的时候不要选择它，而如果样本量非常大，比如大于10万，sag是第一选择。但是sag不能用于L1正则化，所以当你有大量的样本，又需要L1正则化的话就要自己做取舍了。要么通过对样本采样来降低样本量，要么提前做好特征选择，要么回到L2正则化。
• multi_class:分类方式的选择，有 ovr和multinomial两个值可以选择，默认是 ovr。
  　　ovr即one-vs-rest(OvR)，而multinomial即many-vs-many(MvM)。如果是二元逻辑回归，ovr和multinomial并没有任何区别，区别主要在多元逻辑回归上。
  　　OvR的思想很简单，无论你是多少元逻辑回归，我们都可以看做二元逻辑回归。具体做法是，对于第K类的分类决策，我们把所有第K类的样本作为正例，除了第K类样本以外的所有样本都作为负例，然后在上面做二元逻辑回归，得到第K类的分类模型。一共需要做T次分类。
  　　而MvM则相对复杂，这里举MvM的特例one-vs-one(OvO)作讲解。如果模型有T类，我们每次在所有的T类样本里面选择两类样本出来，不妨记为T1类和T2类，把所有的输出为T1和T2的样本放在一起，把T1作为正例，T2作为负例，进行二元逻辑回归，得到模型参数。我们一共需要T(T-1)/2次分类。
  　　从上面的描述可以看出OvR相对简单，但分类效果相对略差（这里指大多数样本分布情况，某些样本分布下OvR可能更好）。而MvM分类相对精确，但是分类速度没有OvR快。
  　　如果选择了ovr，则4种损失函数的优化方法liblinear，newton-cg, lbfgs和sag都可以选择。但是如果选择了multinomial,则只能选择newton-cg, lbfgs，saga和sag了。
• class_weight:分类模型中各种类型的权重。可以不输入，即不考虑权重，或者说所有类型的权重一样，默认是None。
  　　如果选择输入的话，可以选择balanced让类库自己计算类型权重，或者我们自己输入各个类型的权重，比如对于0,1的二元模型，我们可以定义class_weight={0:0.9, 1:0.1}，这样类型0的权重为90%，而类型1的权重为10%。如果class_weight选择balanced，那么类库会根据训练样本量来计算权重。某种类型样本量越多，则权重越低，样本量越少，则权重越高。处理类别不均衡问题可以考虑调节这个参数。
  参考sklearn逻辑回归(Logistic Regression,LR)类库使用小结_sun_shengyun的专栏-CSDN博客

3. SVM分类

from sklearn import svm
model = svm.SVC()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

4. RandomForest分类

from sklearn.ensemble import RandomForestClassifier 
#采用袋外样本来评估模型的好坏，提高泛化能力
rf0 = RandomForestClassifier(oob_score=True) 
rf0.fit(X_train,y_train)
y_pred = rf0.predict(X_test)

随机森林也是平时经常用到的模型，既可以做分类，也可以做回归（回归的时候用RandomForestRegressor），简单介绍几个比较重要的参数：

• n_estimators：森林中树的数量，默认是10棵，如果资源足够可以多设置一些
• max_features：寻找最优分隔的最大特征数，默认是"auto"，一般设置为特征数的对数，或者特征数的算术平方根，也可以设置成特征数的40%-50%，这个也可以用来避免过拟合，特征数越多越容易过拟合
• max_ depth：树的最大深度，默认是None，如果是默认，则节点将展开到所有的叶子都是纯净的，或者直到所有的叶子都少于最小分割样本（min_samples_split）。可以避免过拟合，分类越深越容易过拟合
• min_ samples_split：树中一个节点所需要用来分裂的最少样本数，默认是2。可以避免过度拟合(over-fitting)，如果用于分类的样本数太小，模型可能只适用于用来训练的样本的分类，而用较多的样本数则可以避免这个问题。但如果设置的数字过大，又可能会导致欠拟合，因此要根据你的最终结果进行微调
• min_ samples_leaf：树中叶子节点所需要的最少的样本数，默认是1。也可以用来防止过拟合，但如果是不均等分类问题(imbalanced class problems)，一般这个参数需要设定较小的值，因为大部分少数类别含有的样本都比较小
• min_weight_fraction_leaf：与min_ samples_split类似，只是这个设置的是比例，默认是0.
• max_ leaf_ nodes：树中最多能有多少个叶子节点，默认是None。这个与上面的max_ depth可能会有冲突，因此在设置的时候设置一个就好了

5. adaboost分类

from sklearn.ensemble import AdaBoostClassifier  
 #迭代100次 ,学习率为0.1
clf = AdaBoostClassifier(n_estimators=100,learning_rate=0.1)
clf.fit(X_train,y_train)
y_pred = clf.predict( X_test)

6. GBDT分类

from sklearn.ensemble import GradientBoostingClassifier
 #迭代100次 ,学习率为0.1
clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
clf.fit(X_train,y_train)
y_pred = clf.predict( X_test)

7. 神经网络

from sklearn import linear_model
from sklearn.neural_network import BernoulliRBM  
from sklearn.pipeline import Pipeline 
logistic = linear_model.LogisticRegression()  
rbm = BernoulliRBM(random_state=0, verbose=True)  
classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])  
rbm.learning_rate = 0.1
rbm.n_iter = 20   
rbm.n_components = 100  
#正则化强度参数
logistic.C = 1000   
classifier.fit(X_train, y_train)  
y_pred = classifier.predict(X_test)

8. XGboost

from xgboost import XGBClassifier
from matplotlib import pyplot
model = XGBClassifier()
model.fit(X_train,y_train)
y_pred = model.predict(X_test)
#查看预测准确率
accuracy_score(y_test, y_pred)
#绘制特征的重要性
from xgboost import plot_importance
plot_importance(model)
pyplot.show()

 

 

9. 岭回归

岭回归是通过在普通最小二乘线性回归的RSS（残差平方和RSS（residual sum of squares），别称SSE（Sum of Squares for Error））基础上加上正则项（L2范数）来实现对系数进行压缩惩罚，从而比避免过拟合和产生共线性。
尽管系数较小可以有效减小方差，但不能保证系数为0，所以依然留着一大长串特征会使模型不便于解释。这是岭回归的缺点。

# 岭回归（Ridge 回归）
from sklearn import linear_model
X = [[0, 0], [1, 1], [2, 2]]
y = [0, 1, 2]
clf = linear_model.Ridge(alpha=0.1)  # 设置正则化强度
clf.fit(X, y)  # 参数拟合
print(clf.coef_)  # 系数
print(clf.intercept_)  # 常量系数
print(clf.predict([[3, 3]]))  # 求预测值
print(clf.decision_function(X))  # 求预测，等同predict
print(clf.score(X, y))  # R^2，拟合优度
print(clf.get_params())  # 获取参数信息
print(clf.set_params(fit_intercept=False))  # 重新设置参数，如将是否使用截距设置为false，即不使用截距。

10. Lasso回归

Lasso是通过在普通最小二乘线性回归的RSS基础上加上正则项（L1范数）来实现对系数进行压缩惩罚，从而比避免过拟合和产生共线性。
Lasso回归的系数可以为0，这样可以起到真正的特征筛选效果。

# Lasso回归
from sklearn import linear_model
X = [[0, 0], [1, 1], [2, 2]]
y = [0, 1, 2]
clf = linear_model.Lasso(alpha=0.1)  # 设置正则化强度
clf.fit(X, y)  # 参数拟合
print(clf.coef_)  # 系数
print(clf.intercept_)  # 常量系数
print(clf.predict([[3, 3]]))  # 求预测值
print(clf.decision_function(X))  # 求预测，等同predict
print(clf.score(X, y))  # R^2，拟合优度
print(clf.get_params())  # 获取参数信息
print(clf.set_params(fit_intercept=False))  # 重新设置参数，如将是否使用截距设置为false，即不使用截距。

11. 参数调整

每种分类或者回归算是都有很多可以设置的参数，那这些应该设置为多少才会比较合适呢，sklearn也有模块可以帮助我们设置一个比较好的参数，这个模块叫GridSearchCV。下面以adaboost算法，用iris数据集，找最好的learning_rate为例。

from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import StratifiedKFold
learning_rate = [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3]
model = AdaBoostClassifier()
param_grid = dict(learning_rate=learning_rate)
#设置10折交叉验证
kfold = StratifiedKFold(n_splits=10, shuffle=True)
grid_search = GridSearchCV(model, param_grid, scoring="neg_log_loss", n_jobs=-1, cv=kfold)
learning_rate = [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3]
model = AdaBoostClassifier()
param_grid = dict(learning_rate=learning_rate)
#设置10折交叉验证
kfold = StratifiedKFold(n_splits=10, shuffle=True)
grid_search = GridSearchCV(model, param_grid, scoring="neg_log_loss", n_jobs=-1, cv=kfold)
grid_result = grid_search.fit( iris, iris_y)
#打印最好的learning_rate
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
Out[349]: Best: -0.160830 using {'learning_rate': 0.3}
#在给定的6个学习率中，最好的学习率是0.3
#还可以打印其它的参数
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))
Out[350]:-0.462098 (0.000000) with: {'learning_rate': 0.0001}
-0.347742 (0.106847) with: {'learning_rate': 0.001}
-0.237053 (0.056082) with: {'learning_rate': 0.01}
-0.184642 (0.085079) with: {'learning_rate': 0.1}
-0.163586 (0.117306) with: {'learning_rate': 0.2}
-0.160830 (0.135698) with: {'learning_rate': 0.3}

12. 查看结果准确率、混淆矩阵、auc等

from sklearn.metrics import accuracy_score
from sklearn.metrics import roc_auc_score
from sklearn.metrics import confusion_matrix
#计算准确率
accuracy = accuracy_score(y_test, y_pred)
#计算auc，一般针对两类分类问题
auc = roc_auc_score(y_test, y_pred)
#计算混淆矩阵，一般针对两类分类问题
conMat = confusion_matrix(y_test, y_pred)

作者：小小韩_小小红
链接：https://www.jianshu.com/p/641707e4e72c
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。