Python机器学习--算法实现--常用算法在Sklearn中的聚类算法和分类算法关键参数详解

常用算法在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++’。
(1) ‘k-means++’ ⽤用⼀种特殊的方法选定初始质⼼从⽽能加速迭代过程的收敛(即上文中的kmeans++介绍)
(2) ‘random’ 随机从训练数据中选取初始质心。
(3)如果传递的是一个ndarray,则应该形如 (n_clusters, n_features) 并给出初始质心。
5.precompute_distances:三个可选值, ‘auto’, True 或者 False。预计算距离,计算速度更更快但占⽤用更更多内存。
(1) ‘auto’:如果 样本数乘以聚类数大于 12million 的话则不预计算距离。
This corresponds to about 100MB overhead per job using double precision.
(2) True:总是预先计算距离。
(3) False:永远不不预先计算距离。
6.tol: float形,默认值= 1e-4 与inertia结合来确定收敛条件。
7.n_jobs:整形数。 指定计算所⽤用的进程数。内部原理理是同时进行n_init指定次数的计算。
(1)若值为 -1,则⽤用所有的CPU进⾏运算。若值为1,则不进行并行运算,这样的话⽅便调试。
(2)若值⼩于-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,python,算法,分类算法,聚类算法)