常用算法在Sklearn中的关键参数详解

聚类算法

K-Means算法基于Sklearn中的参数

from sklearn.cluster import KMeans
KMeans(n_clusters=8
       , init='k-means++'
       ,n_init=10
       ,max_iter=300
       , tol=0.0001
       , precompute_distances='auto'
       , verbose=0
       ,random_state=None
       , copy_x=True
       , n_jobs=None
       , algorithm='auto')
'''
参数：
1.n_clusters：整形，缺省值=8 生成的聚类数，即产生的质心（centroids）数。】
2.max_iter：整形，缺省值=300 执⾏一次k-means算法所进行的最大迭代数。
3.n_init：整形，缺省值=10
⽤不同的质心初始化值运行算法的次数，最终解是在inertia意义下选出的最优结果。
4.init：有三个可选值： ’k-means++’， ‘random’，或者传递⼀个ndarray向量。
此参数指定初始化⽅方法，默认值为 ‘k-means++’。
（１） ‘k-means++’ ⽤用⼀种特殊的方法选定初始质⼼从⽽能加速迭代过程的收敛（即上文中的kmeans++介绍）
（２） ‘random’ 随机从训练数据中选取初始质心。
（３）如果传递的是一个ndarray，则应该形如 (n_clusters, n_features) 并给出初始质心。
5.precompute_distances：三个可选值， ‘auto’， True 或者 False。预计算距离，计算速度更更快但占⽤用更更多内存。
（１） ‘auto’：如果 样本数乘以聚类数大于 12million 的话则不预计算距离。
This corresponds to about 100MB overhead per job using double precision.
（２） True：总是预先计算距离。
（３） False：永远不不预先计算距离。
6.tol： float形，默认值= 1e-4　与inertia结合来确定收敛条件。
7.n_jobs：整形数。　指定计算所⽤用的进程数。内部原理理是同时进行n_init指定次数的计算。
（１）若值为 -1，则⽤用所有的CPU进⾏运算。若值为1，则不进行并行运算，这样的话⽅便调试。
（２）若值⼩于-1，则⽤用到的CPU数为(n_cpus + 1 + n_jobs)。因此如果 n_jobs值为-2，则⽤到的CPU数为总CPU数减1。
8.random_state：整形或 numpy.RandomState 类型，可选⽤于初始化质心的⽣成器器（generator）。如果值为一个整数，则确定一个seed。此参数默认值为numpy的随机数生成器。
9.copy_x：布尔型，默认值=True
当我们precomputing distances时，将数据中⼼化会得到更准确的结果。如果把此参数值设为True，
则原始数据不会被改变。如果是False，则会直接在原始数据上做修改并在函数返回值时将其还原。但是在
计算过程中由于有对数据均值的加减运算，所以数据返回后，原始数据和计算前可能会有细小差别。
属性：
cluster_centers_：向量， [n_clusters, n_features] (聚类中⼼心的坐标)
Labels_: 每个点的分类
inertia_： float形
每个点到其簇的质⼼心的距离之和。
'''

分类算法

KNN分类基于Sklearn中的关键参数

from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5
                     , weights='uniform'
                     , algorithm='auto'
                     ,leaf_size=30
                     , p=2
                     , metric='minkowski'
                     , metric_params=None
                     , n_jobs=1
                     , **kwargs)
'''
参数:
1.n_neighbors: 一个整数，指定k值。
2.weights: 一字符串或者可调用对象，指定投票权重类型。即这些邻居投票权可以为相同或者不同。
uniform: 本节点的所有邻居节点的投票权重都相等。
distance: 本节点的所有邻居节点的投票权重与距离成反⽐，即越近节点，其投票权重越大。
[callable]: 一个可调⽤用对象，它传⼊入距离的数组，返回同样形状的权重数组。
3.algorithm: 一个字符串，指定最近邻的算法，可以为下: 
ball_tree: 使用BallTree算法。
kd_tree: 使用KDTree算法。
brute: 使用暴力搜索算法。
auto: 自动决定最合适算法。
4.leaf_size: 一个整数，指定BallTree或者KDTree叶节点的规模。它影响树的构建和查询速度。
5.metric: 一个字符串，指定距离度量。默认为‘minkowski’(闵可夫斯基)距离。
6.p: 整数值。
p=1: 对应曼哈顿距离。
p=2: 对应欧氏距离。
7.n_jobs: 并行性。默认为-1表示派发任务到所有计算机的CPU上。


使用方法:
1.fit(X,y): 训练模型。
2.predict(X): 预测模型。
3.score(X,y): 返回在(X,y)上预测的准确率(accuracy)。
4.predict_proba(X): 返回样本为每种标记的概率。
5.kneighbors([X,n_neighbors,return_distace]): 返回样本点的k邻近点。
如果return_distance=True，同时还返回到这些近邻点的距离。
6.kneighbors_graph([X,n_neighbors,mode]): 返回样本点的连接图。 '''

伯努利朴素贝叶斯

from sklearn.naive_bayes import BernoulliNB
BernoulliNB(alpha=1.0
            , binarize=0.0
            ,fit_prior=True
            ,class_prior=None)
'''
参数：
1.alpha:先验平滑因⼦，默认等于1，当等于1时表示拉普拉斯平滑。
2.binarize:样本特征二值化的阈值，默认是0。如果不输入，则模型会认为所有特征都已经是二值化形式了；如果输入具体的值，则模型会把大于该值的部分归为一类，小于的归为另一类。
3.fit_prior:是否去学习类的先验概率，默认是True。
4.class_prior:各个类别的先验概率，如果没有指定，则模型会根据数据自动学习， 每个类别的先验概率相同，等于类标记总个数N分之一。
属性：
1.class_log_prior_:每个类别平滑后的先验对数概率。
2.feature_log_prob_:给定特征类别的经验对数概率。
3.class_count_:拟合过程中每个样本的数量。
4.feature_count_:拟合过程中每个特征的数量。


方法：
贝叶斯的方法和其他模型的方法一致。
1.fit(X,y) : 训练模型。
2.predict(X) : ⽤用模型预测，返回预测值。
3.predict_log_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值的对数值。
4.predict_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值。
5.score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。
'''

高斯朴素贝叶斯

from sklearn.naive_bayes import GaussianNB
GaussianNB(priors=None, var_smoothing=1e-09)
'''
参数：
1.priors:先验概率⼤小，如果没有给定，模型则根据样本数据⾃己计算（利用极大似然法）。
2.var_smoothing:浮点数，可不填（默认值= 1e-9）
在估计方差时，为了追求估计的稳定性，将所有特征的方差中最⼤的⽅差以某个比例添加到估计的方差中。
这个⽐例，由var_smoothing参数控制。
属性：
1.class_prior_:每个样本的概率。
2.class_count:每个类别的样本数量。
3.theta_:每个类别中每个特征的均值。
4.sigma_:每个类别中每个特征的⽅差。
'''

多项式朴素贝叶斯

from sklearn.naive_bayes import MultinomialNB
MultinomialNB(alpha=1.0
              ,fit_prior=True
              ,class_prior=None)
'''
参数：
1.alpha:先验平滑因⼦，默认等于1，当等于1时表示拉普拉斯平滑。
2.fit_prior:是否去学习类的先验概率，默认是True。
3.class_prior:各个类别的先验概率，如果没有指定，则模型会根据数据自动学习，每个类别的先验概率相同，等于类标记总个数N分之一。
属性：
1.class_log_prior_:每个类别平滑后的先验概率。
2.intercept_:是朴素⻉叶斯对应的线性模型，其值和class_log_prior_相同。
3.feature_log_prob_:给定特征类别的对数概率(条件概率)。 特征的条件概率=（指定类下指定特征出现的次数+alpha） /（指定类下所有特征出现次数之和+类的可能取值个数*alpha）。
4.coef_: 是朴素⻉贝叶斯对应的线性模型，其值和feature_log_prob相同。
5.class_count_: 训练样本中各类别对应的样本数。
6.feature_count_: 每个类别中各个特征出现的次数。
'''

逻辑回归算法

from sklearn.linear_model import LogisticRegression
LogisticRegression(penalty='l2'
                   ,dual=False
                   ,tol=1e-4
                   ,C=1.0
                   ,fit_intercept=True
                   ,intercept_scaling=1
                   ,class_weight=None
                   ,random_state=None
                   ,solver='liblinear'
                   ,max_iter=100
                   ,multi_class='ovr'
                   ,verbose=0
                   ,warm_start=False
                   ,n_jobs=1)
'''
参数含义:
1.penalty:字符串，指定了正则化策略。默认为"l2"
(1)如果为"l2",则优化的⽬标函数为:0.5*||w||^2_2+C*L(w),C>0, L(w)为极⼤似然函数。
(2)如果为"l1",则优化的⽬标函数为||w||_1+C*L(w),C>0, L(w)为极⼤似然函数。
2.dual:布尔值。默认为False。如果等于True，则求解其对偶形式。
只有在penalty="l2"并且solver="liblinear"时才有对偶形式。如果为False，则求解原始形式。
当n_samples > n_features，偏向于dual=False。
3.tol:阈值。判断迭代是否收敛或者是否满⾜精度的要求。
4.C:float,默认为1.0.指定了正则化项系数的倒数。必须是⼀个正的浮点数。 C值越⼩,正则化项就越大。
5.fit_intercept:bool值。默认为True。如果为False,就不会计算b值。
6.intercept_scaling:float, default 1。
只有当solver="liblinear"并且 fit_intercept=True时，才有意义。
在这种情况下，相当于在训练数据最后⼀列增加一个特征，该特征恒为1。其对应的权重为b。
7.class_weight:dict or 'balanced', default: None。
(1)如果是字典，则给出每个分类的权重。按照{class_label: weight}这种形式。
(2)如果是"balanced":则每个分类的权重与该分类在样本集中出现的频率成反比。n_samples / (n_classes * np.bincount(y))
(3)如果未指定，则每个分类的权重都为1。
8.random_state: int, RandomState instance or None, default: None
(1):如果为整数，则它指定了随机数⽣成器的种⼦。
(2):如果为RandomState实例，则它指定了了随机数⽣成器。
(3):如果为None，则使⽤默认的随机数⽣成器。
9.solver: 字符串串，指定求解最优化问题的算法。
{'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'},default: 'liblinear'
(1)solver='liblinear',对于⼩数据集， 'liblinear'是很好的选择。 对于⼤规模数据集， 'sag'和'saga'处理起来速度更快。
(2)solver='newton-cg',采⽤用⽜牛顿法
(3)solver='lbfgs',采⽤用L-BFGS拟⽜牛顿法。
(4)solver='sag',采⽤用Stochastic Average Gradient descent算法。
(5)对于多分类问题，只有'newton-cg'， 'sag'， 'saga'和'lbfgs'处理理多项损失;'liblinear'仅限于'ovr'⽅方案。
(6)newton-cg', 'lbfgs' and 'sag' 只能处理 L2 penalty,'liblinear' and 'saga' 能处理 L1 penalty。
10.max_iter: 指定最⼤迭代次数。 default: 100。只对'newton-cg', 'sag' and 'lbfgs'适用。 
11.multi_class:{'ovr', 'multinomial'}, default: 'ovr'。指定对分类问题的策略略。
(1)multi_class='ovr',采⽤用'one_vs_rest'策略略。
(2)multi_class='multinomal',直接采⽤用多分类逻辑回归策略略。
12.verbose: ⽤用于开启或者关闭迭代中间输出⽇日志功能。
13.warm_start: 布尔值。如果为True，那么使⽤前⼀次训练结果继续训练。否则从头开始训练。
14.n_jobs: int, default: 1。指定任务并行时的CPU数量。如果为-1，则使⽤用所有可⽤的CPU。
属性:
1.coef_:权重向量。
2.intercept_:截距b值。
3.n_iter_:实际迭代次数。
⽅方法:
1.fit(X,y): 训练模型。
2.predict(X): ⽤训练好的模型进⾏预测，并返回预测值。
3.predict_log_proba(X): 返回⼀个数组，数组元素依次是X预测为各个类别的概率的对数值。
4.predict_proba(X): 返回⼀个数组，数组元素依次是X预测为各个类别的概率值。
5.score(X,y):返回预测的准确率。
'''

套索回归(lasso回归,L1正则化)

# 加⼊入L1正则化的线性回归
from sklearn.linear_model import Lasso
Lasso(alpha=1.0, fit_intercept=True, normalize=False, precompute=False,
copy_X=True, max_iter=1000,tol=1e-4, warm_start=False,
positive=False,random_state=None,selection='cyclic')
'''
1.alpha:正则化项系数
2.fit_intercept:布尔值，指定是否需要计算截距b值。 False则不不计算b值。
3.max_iter:指定最⼤迭代次数。
4.normalize:布尔值。如果等于True，模型训练之前会把数据归一化。
这⾥归⼀化有两个好处:
(1)提升模型的收敛速度,减少寻找最优解的时间。
(2)提升模型的精度。
5.precompute:一个布尔值或者⼀个序列。它决定是否提前计算Gram矩阵来加速计算。
6.tol:阈值。判断迭代是否收敛或者是否满⾜精度的要求。
7.warm_start:布尔值。如果为True，那么使⽤用前⼀次训练结果继续训练。否则从头开始训练。
8.positive:布尔值。如果为True，那么强制要求权重向量的分量都为正数。
9.selection:字符串，可以是"cyclic"或"random"。它指定了了当每轮迭代的时候，选择权重向量的哪个分量来更新。
(1)"random":更新的时候，随机选择权重向量的⼀个分量来更更新。
(2)"cyclic":更新的时候，从前向后依次选择权重向量的⼀个分量来更新。
10.random_state:⼀个整数或者⼀个RandomState实例，或者None。
(1):如果为整数，则它指定了随机数生成器的种子。
(2):如果为RandomState实例，则它指定了了随机数⽣成器。
(3):如果为None，则使⽤默认的随机数⽣成器。
属性:
1.coef_:权重向量。
2.intercept_:截距b值。
3.n_iter_:实际迭代次数。
⽅法:
1.fit(X,y):训练模型。
2.predict(X):⽤用模型进⾏预测，返回预测值。
3.score(X,y):返回预测性能的得分。计算公式为:score=(1 - u/v)
其中u=((y_true - y_pred) ** 2).sum()， v=((y_true - y_true.mean()) **2).sum()
score最⼤值是1，但有可能是负值(预测效果太差)。 score越大，预测性能越好。
'''

岭回归算法(Ridge回归,L2回归)

# 加入L2正则化的线性回归
from sklearn.linear_model import Ridge
 
Ridge(alpha=1.0, fit_intercept=True, normalize=False,copy_X=True, max_iter=None, tol=1e-3, 
	  solver="auto",random_state=None)
'''
参数含义：
1.alpha:正则项系数，值越大正则项占比越大。初始值建议一开始设置为0，这样先确定一个比较好的学习率，
学习率一旦确定，给alpha一个较小的值，然后根据验证集上的准确率，增大或减小10倍。10倍是粗调节，
当确定了合适的数量级后，再在同一个数量级内细调节。
2.fit_intercept：布尔值，指定是否需要计算截距b值。False则不计算b值。
3.normalize:布尔值。如果等于True，模型训练之前会把数据归一化。
这里归一化有两个好处：(1):提升模型的收敛速度,减少寻找最优解的时间。(2)提升模型的精度
4.copy_X:布尔值。如果设置为True，则会复制一份训练数据。
5.max_iter：整数。指定了最大迭代次数。如果为None，则采用默认值。
6.tol:阈值。判断迭代是否收敛或者是否满足精度的要求。
7.solver:字符串。指定求解最优化问题的算法。
    (1).solver='auto',根据数据集自动选择算法。
    (2).solver='svd',采用奇异值分解的方法来计算
    (3).solver='cholesky',采用scipy.linalg.solve函数求解最优解。
    (4).solver='sparse_cg',采用scipy.sparse.linalg.cg函数来求取最优解。
    (5).solver='sag',采用Stochastic Average Gradient descent算法求解最优化问题。
8.random_state:一个整数或者一个RandomState实例，或者为None。它在solver="sag"时使用。
    (1).如果为整数，则它指定了随机数生成器的种子。
    (2).如果为RandomState实例，则指定了随机数生成器。
    (3).如果为None，则使用默认的随机数生成器。

属性：
1.coef_：权重向量。
2.intercept_：截距b的值。
3.n_iter_:实际迭代次数。

方法：
1.fit(X,y)：训练模型。
2.predict(X):用训练好的模型去预测，并且返回预测值。
3.score(X,y):返回预测性能的得分。计算公式为：score=(1 - u/v)
其中u=((y_true - y_pred) ** 2).sum()，v=((y_true - y_true.mean()) ** 2).sum()
score最大值是1，但有可能是负值(预测效果太差)。score越大，预测性能越好。
'''

弹性网络回归(ElasticNet,L1与L2的融合)

'''
ElasticNet回归是对Lasso回归和岭回归的融合，其正则化项是L1范数和L2范数的一个权衡。
正则化项为: alpha * l1_ratio * ||w||_1
            + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2
'''
from sklearn.linear_model import ElasticNet
 
ElasticNet(alpha=1.0, l1_ratio=0.5, fit_intercept=True, normalize=False, precompute=False, 
		   max_iter=1000,copy_X=True, tol=1e-4, warm_start=False, positive=False,
		   random_state=None, selection='cyclic')
'''

参数含义：
1.alpha:正则化项中alpha值。
2.l1_ratio:正则化项中的l1_ratio值。
3.fit_intercept:布尔值，指定是否需要计算截距b值。False则不计算b值。
4.max_iter：指定最大迭代次数。
5.normalize：布尔值。如果等于True，模型训练之前会把数据归一化。
这里归一化有两个好处：(1):提升模型的收敛速度,减少寻找最优解的时间。(2)提升模型的精度。
6.copy_X:布尔值。如果设置为True，则会复制一份训练数据。
7.precompute:一个布尔值或者一个序列。它决定是否提前计算Gram矩阵来加速计算。
8.tol:阈值。判断迭代是否收敛或者是否满足精度的要求。
9.warm_start:布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练。
10.positive:布尔值。如果为True，那么强制要求权重向量的分量都为正数。
11.selection:字符串，可以是"cyclic"或"random"。它指定了当每轮迭代的时候，选择权重向量的
哪个分量来更新。
    (1)"random":更新的时候，随机选择权重向量的一个分量来更新。
    (2)"cyclic":更新的时候，从前向后依次选择权重向量的一个分量来更新。
12.random_state:一个整数或者一个RandomState实例，或者None。
    (1):如果为整数，则它指定了随机数生成器的种子。
    (2):如果为RandomState实例，则它指定了随机数生成器。
    (3):如果为None，则使用默认的随机数生成器。

属性：
1.coef_：权重向量。
2.intercept_：截距b值。
3.n_iter_：实际迭代次数。

方法：
1.fit(X,y)：训练模型。
2.predict(X):用模型进行预测，返回预测值。
3.score(X,y):返回预测性能的得分。计算公式为：score=(1 - u/v)
其中u=((y_true - y_pred) ** 2).sum()，v=((y_true - y_true.mean()) ** 2).sum()
score最大值是1，但有可能是负值(预测效果太差)。score越大，预测性能越好。
'''

决策树(分类树)

from sklearn.tree import DecisionTreeClassifier

DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None,min_samples_split=2, 	
					   min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, 		
					   random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, 
					   min_impurity_split=1e-07, class_weight=None, presort=False)

'''
参数:
1.criterion : 一个字符串，指定切分质量的评价标准。可以为：
   ‘gini’ ：表示切分标准是Gini系数。切分时选取基尼系数小的属性切分。
   ‘entropy’ ： 表示切分标准是熵。
2.splitter : 一个字符串，指定切分原则，可以为：
   best : 表示选择最优的切分。
   random ： 表示随机切分。
   默认的"best"适合样本量不大的时候，而如果样本数据量非常大，此时决策树构建推荐"random"。
3.max_features : 可以为整数、浮点、字符或者None，指定寻找best split时考虑的特征数量。 
   如果是整数，则每次切分只考虑max_features个特征。
   如果是浮点数，则每次切分只考虑max_features*n_features个特征(max_features指定了百分比)。
   如果是字符串‘auto’，则max_features等于n_features。
   如果是字符串‘sqrt’，则max_features等于sqrt(n_features)。
   如果是字符串‘log2’，则max_features等于log2(n_features)。
   如果是字符串None，则max_features等于n_features。
4.max_depth : 可以为整数或者None，指定树的最大深度，防止过拟合
   如果为None，表示树的深度不限(知道每个叶子都是纯的，即叶子结点中的所有样本点都属于一个类，
   或者叶子中包含小于min_sanples_split个样本点)。
   如果max_leaf_nodes参数非None，则忽略此项。
5.min_samples_split : 为整数，指定每个内部节点(非叶子节点)包含的最少的样本数。
6.min_samples_leaf : 为整数，指定每个叶子结点包含的最少的样本数。
7.min_weight_fraction_leaf : 为浮点数，叶子节点中样本的最小权重系数。
8.max_leaf_nodes : 为整数或None，指定叶子结点的最大数量。 
   如果为None，此时叶子节点数不限。
   如果非None，则max_depth被忽略。
9.min_impurity_decrease=0.0 如果该分裂导致不纯度的减少大于或等于该值，则将分裂节点。
10.min_impurity_split=1e-07, 限制决策树的增长，
11.class_weight : 一个字典、字典的列表、字符串‘balanced’或者None，他指定了分类的权重。
   权重形式为：{class_label:weight} 如果为None，则每个分类权重都为1.
   字符串‘balanced’表示每个分类的权重是各分类在样本出现的频率的反比。
12.random_state : 一个整数或者一个RandomState实例，或者None。 
   如果为整数，则它指定了随机数生成器的种子。
   如果为RandomState实例，则指定了随机数生成器。
   如果为None，则使用默认的随机数生成器。
13.presort : 一个布尔值，指定了是否要提前排序数据从而加速寻找最优切分的过程。
  设置为True时，对于大数据集会减慢总体训练过程，但对于小数据集或者设定了最大深度的情况下，则会加速训练过程。
    
属性:
1.classes_ : 分类的标签值。
2.feature_importances_ : 给出了特征的重要程度。该值越高，则特征越重要(也称为Gini 
  importance)。
3.max_features_ : max_feature的推断值。
4.n_classes_ : 给出了分类的数量。
5.n_features_ : 当执行fit后，特征的数量。
6.n_outputs_ : 当执行fit后，输出的数量。
7.tree_ : 一个Tree对象，即底层的决策树。

方法: 
1.fit(X,y) : 训练模型。
2.predict(X) : 用模型预测，返回预测值。
3.predict_log_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值的对数 
  值。
4.predict_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值。
5.score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。
'''

GBDT分类

from sklearn.ensemble import GradientBoostingClassifier

GradientBoostingClassifier(loss='deviance', learning_rate=0.1, n_estimators=100, subsample=1.0, 
						   criterion='friedman_mse', min_samples_split=2, min_samples_leaf=1, 
						   min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_decrease=0.0, 
						   min_impurity_split=None, init=None, random_state=None, max_features=None, 
						   verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto', 
						   validation_fraction=0.1, n_iter_no_change=None, tol=0.0001)

'''
1.loss: 损失函数，'deviance'：对数损失函数，'exponential'：指数损失函数，只能用于二分类。
2.learning_rate：学习率
3.n_ estimators: 基学习器的个数，这里是树的颗数
4.subsample: 取值在(0, 1)之间，取原始训练集中的一个子集用于训练基础决策树
5.criterion: 'friedman_mse'改进型的均方误差;'mse'标准的均方误差; 'mae'平均绝对误差。
6.min_samples_split:一个整数，指定了每个基础决策树模型分裂所需最小样本数。
7.min_samples_leaf:一个整数，指定了每个基础决策树模型叶节点所包含的最小样本数。
8.min_weight_fraction_leaf:一个浮点数。叶节点的最小加权权重。当不提供sample_weight时，
  样本的权重是相等的。
9.max_depth:一个整数或者None，指定每一个基础决策树模型的最大深度。如果max_leaf_noeds不是None，则忽略此参数。
10.max_features:一个整数，浮点数或者None。代表节点分裂是参与判断的最大特征数。整数为个数，
  浮点数为所占比重。
11.max_leaf_nodes:为整数或者None，指定了每个基础决策树模型的最大叶节点数量。
12.min_impurity_split:一个浮点数，指定在树生长的过程中，节点分裂的阈值，默认为1e-7。
13.init：一个基础分类器对象或者None
14.verbose：如果为0则不输出日志，如果为1，则每隔一段时间输出日志
15.warm_start：热启动，当你训练GBM到一定程度停止时，如果你想在这个基础上接着训练，就需要用到该参数减少重复训练

属性 
1.n_estimators_ : 基学习器的个数，这里是树的颗数
2.feature_importance_:一个数组，给出了每个特征的重要性（值越高重要性越大）。
3.oob_improvement_:一个数组，给出了每增加一棵基础决策树，在包外估计（即测试集）的损失函数的减少值。
4.train_score_:一个数组，给出每增加一棵基础决策树，在训练集上的损失函数的值。
5.loss:具体损失函数对象。
6.init:初始预测使用的分类器。
7.estimators_:一个数组，给出了每个基础决策树。

方法 
1.apply(X)	Apply trees in the ensemble to X, return leaf indices.
2.decision_function(X)	Compute the decision function of X.
3.fit(X,y):训练模型。
4.get_params([deep])	Get parameters for this estimator.
5.predict(X):用模型进行预测，返回预测值。
6.predict_log_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率的对数 
  值。
7.predict_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率值。
8.score(X,y):返回在（X,y）上预测的准确率。
9.set_params(**params)	Set the parameters of this estimator.
10.staged_predict(X):返回一个数组，数组元素依次是每一轮迭代结束时尚未完成的集成分类器的预测值。
11.staged_predict_proba(X):返回一个二维数组，
  数组元素依次是每一轮迭代结束时尚未完成的集成分类器预测X为各个类别的概率值。
'''

随机森林(分类森林)

rom sklearn.ensemble import RandomForestClassifier

RandomForestClassifier(n_estimators='warn', criterion='gini', max_depth=None, min_samples_split=2, 
					   min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto', 
					   max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, 
					   bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, 
					   warm_start=False, class_weight=None)

'''
参数:
1.n_estimators :一个整数，指定基础决策树的数量（默认为10）.
2.criterion:字符串。指定分裂的标准，可以为‘entory’或者‘gini’。
3.max_depth:一个整数或者None，指定每一个基础决策树模型的最大深度。如果max_leaf_nodes不是None，则忽略此参数。
4.min_samples_split:一个整数，指定了每个基础决策树模型分裂所需最小样本数。
5.min_samples_leaf:一个整数，指定了每个基础决策树模型叶节点所包含的最小样本数。
6.min_weight_fraction_leaf:一个浮点数。叶节点的最小加权权重。当不提供sample_weight时，样本的权重是相等的。
7.max_features:一个整数，浮点数或者None。代表节点分裂是参与判断的最大特征数。整数为   个数，浮点数为所占比重。
8.max_leaf_nodes:为整数或者None，指定了每个基础决策树模型的最大叶节点数量。
9.bootstrap:为布尔值。如果为True，则使用采样法bootstrap sampling来产生决策树的训练数据。
10.oob_score：为布尔值。如果为True，则使用包外样本来计算泛化误差。
11.n_jobs：一个整数，指定并行性。如果为-1，则表示将训练和预测任务派发到所有CPU上。
12.verbose:一个整数，如果为0则不输出日志，如果为1，则每隔一段时间输出日志，大于1输出日志会更频繁。
13.warm_start:布尔值。当为True是，则继续使用上一次训练结果。否则重新开始训练。
14.random_state:一个整数或者一个RandomState实例，或者None。 
  如果为整数，指定随机数生成器的种子。
  如果为RandomState，指定随机数生成器。
  如果为None，指定使用默认的随机数生成器。
15.class_weight:一个字典，或者字典的列表，或者字符串‘balanced’，或者字符串
  ‘balanced_subsample’，或者为None。 
  如果为字典，则字典给出每个分类的权重，如{class_label：weight}
  如果为字符串‘balanced’，则每个分类的权重与该分类在样本集合中出现的频率成反比。
  如果为字符串‘balanced_subsample’，则样本为采样法bootstrap sampling产生的决策树的训练数据，
  每个分类的权重与该分类在样本集合中出现的频率成反比。
  如果为None，则每个分类的权重都为1。

属性 
1.estimators_:一个数组，存放所有训练过的决策树。
2.classes_:一个数组，形状为[n_classes]，为类别标签。
3.n_classes_:一个整数，为类别数量。
4.n_features_:一个整数，在训练时使用的特征数量。
5.n_outputs_:一个整数，在训练时输出的数量。
6.feature_importances_:一个数组，形状为[n_features]。如果base_estimator支持，
  则他给出每个特征的重要性。
7.oob_score_:一个浮点数，训练数据使用包外估计时的得分。

方法 
1.fit(X,y):训练模型。 
2.predict(X):用模型进行预测，返回预测值。
3.predict_log_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率的对数
  值。
4.predict_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率值。
5.score(X,y):返回在（X,y）上预测的准确度。
'''

XGBoost分类

from xgboost import XGBClassifier

XGBClassifier(max_depth=3, learning_rate=0.1, n_estimators=100, silent=True, 
			  objective='binary:logistic', booster='gbtree', n_jobs=1, nthread=None, gamma=0, 
			  min_child_weight=1, max_delta_step=0, subsample=1, colsample_bytree=1, 
			  colsample_bylevel=1, reg_alpha=0, reg_lambda=1, scale_pos_weight=1, base_score=0.5, 
			  random_state=0, seed=None, missing=None, **kwargs)

'''
三种参数
General parameters：参数控制在提升（boosting）过程中使用哪种booster，
常用的booster有树模型（tree）和线性模型（linear model）。
Booster parameters：这取决于使用哪种booster。
Task parameters：控制学习的场景，例如在回归问题中会使用不同的参数控制排序。

通用参数
这些参数用来控制XGBoost的宏观功能。
1、booster[默认gbtree]
选择每次迭代的模型，有两种选择：gbtree：基于树的模型和gbliner：线性模型
2、silent[默认0]
当这个参数值为1时，静默模式开启，不会输出任何信息。
3、nthread[默认值为最大可能的线程数] 用来进行多线程控制，应当输入系统的核数。

booster参数
尽管有两种booster可供选择，这里只介绍tree booster，因为它的表现远远胜过linear booster，所以linear booster很少用到。
1、learning_rate[默认0.1]
和GBM中的learning rate参数类似。通过减少每一步的权重，可以提高模型的鲁棒性。
典型值为0.01-0.2。
2、min_child_weight[默认1]
决定最小叶子节点样本权重和。
和GBM的 min_child_leaf 参数类似，但不完全一样。XGBoost的这个参数是最小样本权重的和，而GBM参数是最小样本总数。
值越大，越容易欠拟合；值越小，越容易过拟合（值较大时，避免模型学习到局部的特殊样本）。
3、max_depth[默认6]
为树的最大深度。值越大，越容易过拟合；值越小，越容易欠拟合。典型值：3-10
4、max_leaf_nodes
树上最大的节点或叶子的数量。
可以替代max_depth的作用。因为如果生成的是二叉树，一个深度为n的树最多生成n2个叶子。
如果定义了这个参数，GBM会忽略max_depth参数。
5、gamma[默认0]
在节点分裂时，只有分裂后损失函数的值下降了，才会分裂这个节点。Gamma指定了节点分裂所需的最小损失函数下降值。
这个参数的值越大，算法越保守。这个参数的值和损失函数息息相关，所以是需要调整的。
6、max_delta_step[默认0]
这参数限制每棵树权重改变的最大步长。如果这个参数的值为0，那就意味着没有约束。如果它被赋予了某个正值，
那么它会让这个算法更加保守。
通常，这个参数不需要设置。但是当各类别的样本十分不平衡时，它对逻辑回归是很有帮助的。
这个参数一般用不到，但是你可以挖掘出来它更多的用处。
7、subsample[默认1]
训练每棵树时，使用的数据占全部训练集的比例。默认值为1，典型值为0.5-1。
减小这个参数的值，算法会更加保守，避免过拟合。但是，如果这个值设置得过小，它可能会导致欠拟合。
8、colsample_bytree[默认1]
和GBM里面的max_features参数类似。训练每棵树时，使用的特征占全部特征的比例。默认值为1，典型值为0.5-1。
9、colsample_bylevel[默认1]
用来控制树的每一级的每一次分裂，对列数的采样的占比。
我个人一般不太用这个参数，因为subsample参数和colsample_bytree参数可以起到相同的作用。
但是如果感兴趣，可以挖掘这个参数更多的用处。
10、reg_lambda[默认1]
权重的L2正则化项。
11、reg_alpha[默认1]
权重的L1正则化项。可以应用在很高维度的情况下，使得算法的速度更快。
12、scale_pos_weight[默认1]
在各类别样本十分不平衡时，把这个参数设定为一个正值，可以使算法更快收敛。

学习目标参数
这个参数用来控制理想的优化目标和每一步结果的度量方法。
1、objective[默认binary:logistic]
这个参数定义需要被最小化的损失函数。最常用的值有： 
binary:logistic 二分类的逻辑回归，返回预测的概率(不是类别)。
multi:softmax 使用softmax的多分类器，返回预测的类别(不是概率)。 
在这种情况下，你还需要多设一个参数：num_class(类别数目)。
multi:softprob 和multi:softmax参数一样，但是返回的是每个数据属于各个类别的概率。
2、eval_metric[默认值取决于objective参数的取值]
对于有效数据的度量方法。
对于回归问题，默认值是rmse，对于分类问题，默认值是error。
典型值有： 
rmse、mae、logloss 负对数似然函数值、error 二分类错误率(阈值为0.5)
merror 多分类错误率、mlogloss 多分类logloss损失函数、auc 曲线下面积
3、seed(默认0)
随机数的种子。设置它可以复现随机数据的结果，也可以用于调整参数

属性
1.feature_importances_  给出每个特征的重要性。

用法
1.apply(X[, ntree_limit])	Return the predicted leaf every tree for     
  each sample.
2.evals_result()	Return the evaluation results.
3.fit(X[, y])	Fit a gradient boosting classifier
4.get_booster()	Get the underlying xgboost Booster of this model.
5.get_params([deep])	Get parameters.
6.get_xgb_params()	Get xgboost type parameters.
7.predict(X)	Predict with data.
8.predict_proba(data[, ntree_limit])	Predict the probability of each 
  data example being of a given class.
9.score(X, y[, sample_weight])	Returns the mean accuracy on the given 
  test data and labels.
10.set_params(**params)	Set the parameters of this estimator.
'''

最后

以上就是开朗小虾米为你收集整理的Python机器学习--算法实现--常用算法在Sklearn中的聚类算法和分类算法关键参数详解常用算法在Sklearn中的关键参数详解的全部内容，希望文章能够帮你解决Python机器学习--算法实现--常用算法在Sklearn中的聚类算法和分类算法关键参数详解常用算法在Sklearn中的关键参数详解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。