机器学习sklearn中常见的线性模型参数释义

from sklearn.linear_model import LinearRegression
LinearRegression(fit_intercept=True,normalize=False,copy_X=True,n_jobs=1)

'''
参数含义：
1.fit_intercept:布尔值，指定是否需要计算线性回归中的截距，即b值。如果为False,
那么不计算b值。
2.normalize:布尔值。如果为False，那么训练样本会进行归一化处理。
3.copy_X：布尔值。如果为True，会复制一份训练数据。
4.n_jobs:一个整数。任务并行时指定的CPU数量。如果取值为-1则使用所有可用的CPU。
5.coef_:权重向量
6.intercept_:截距b值

方法：
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.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，则使用默认的随机数生成器。

9.coef_：权重向量。
10.intercept_：截距b的值。
11.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.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，则使用默认的随机数生成器。
11.coef_：权重向量。
12.intercept_：截距b值。
13.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.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')
'''
ElasticNet回归是对Lasso回归和岭回归的融合，其正则化项是L1范数和L2范数的一个权衡。
正则化项为: alpha * l1_ratio * ||w||_1
            + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2
参数含义：
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，则使用默认的随机数生成器。

13.coef_:权重向量。
14.intercept_：b值。
15.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.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.指定了正则化项系数的倒数。必须是一个正的浮点数。他的值越小，正则化项就越大。
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。

15.coef_:权重向量。
16.intercept_：b值。
17.n_iter_:实际迭代次数。

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

参考：《Python大战机器学习》