sklearn 逻辑回归调参 sklearn lasso回归

机器学习–线性回归模型（sklearn）

线性回归模型有：一般形式的一元线性回归和多元线性回归，使用L2范数的岭回归（Ridge），使用L1范数的套索回归(Lasso)，使用L1和L2范数的ElasticNet回归（是对Lasso回归和岭回归的融合），逻辑回归。

线性回归-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。

属性

1. coef_:权重向量
2. 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越大，预测性能越好。

加入L2正则化的线性回归-sklearn库调用方式及参数解释

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越大，预测性能越好。

加入L1正则化的线性回归-sklearn库调用方式及参数解释

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越大，预测性能越好。

ElasticNet回归是对Lasso回归和岭回归的融合，其正则化项是L1范数和L2范数的一个权衡。-sklearn库调用方式及参数解释

正则化项为: $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. 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越大，预测性能越好。

逻辑回归-sklearn库调用方式及参数解释

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): 返回预测的准确率。

实战案例：

多元线性回归

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn import datasets,linear_model,model_selection
from sklearn.model_selection import train_test_split
def load_data():
    diabetes = datasets.load_diabetes()
    return train_test_split(diabetes.data,diabetes.target,test_size=0.2)

def test_LineearRegression(*data):
    X_train,X_test,y_train,y_test = data
    regr = linear_model.LinearRegression()
    regr.fit(X_train,y_train)
    print('Coefficients:{},intercept:{}'.format(regr.coef_,regr.intercept_))
    print('Residual sum of squares:{}'.format(np.mean(regr.predict(X_test)-y_test)**2))
    print('Scores:{}'.format(regr.score(X_test,y_test)))
    
if __name__ == '__main__':
    X_train,X_test,y_train,y_test = load_data()
    test_LineearRegression(X_train,X_test,y_train,y_test)

Lasso回归

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets,linear_model
from sklearn.model_selection import train_test_split

def load_data():
    diabetes = datasets.load_diabetes()
    return train_test_split(diabetes.data,diabetes.target,test_size=0.2)

def test_Lasso(*data):
    X_train,X_test,y_train,y_test = data
    regr = linear_model.Lasso()
    regr.fit(X_train,y_train)
    print('Coefficients:{},intercept:{}'.format(regr.coef_,regr.intercept_))
    print('Residual sum of squares:{}'.format(np.mean(regr.predict(X_test)-y_test)**2))
    print('Scores:{}'.format(regr.score(X_test,y_test)))
    
def test_Lasso_alpha(*data):
    X_train,X_test,y_train,y_test = data
    alphas = [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500,1000]
    scores = []
    for i,alpha in enumerate(alphas):
        regr = linear_model.Lasso(alpha=alpha)
        regr.fit(X_train,y_train)
        scores.append(regr.score(X_test,y_test))
    
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    ax.plot(alphas,scores)
    ax.set_xlabel("alpha")
    ax.set_ylabel("score")
    ax.set_xscale("log")
    ax.set_title('Lasso')
    plt.show()
    
if __name__ == '__main__':
    X_train,X_test,y_train,y_test = load_data()
    test_Lasso(X_train,X_test,y_train,y_test)
    test_Lasso_alpha(X_train,X_test,y_train,y_test)

岭回归（Ridge）

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets,linear_model
from sklearn.model_selection import train_test_split

def load_data():
    diabetes = datasets.load_diabetes()
    return train_test_split(diabetes.data,diabetes.target,test_size=0.2,random_state=0)

def test_Ridge(*data):
    X_train,X_test,y_train,y_test = data
    regr = linear_model.Ridge()
    regr.fit(X_train,y_train)
    print('Coefficients:{},intercept:{}'.format(regr.coef_,regr.intercept_))
    print('Residual sum of squares:{}'.format(np.mean(regr.predict(X_test)-y_test)**2))
    print('Scores:{}'.format(regr.score(X_test,y_test)))
    
def test_Ridge_alpha(*data):
    X_train,X_test,y_train,y_test = data
    alphas = [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500,1000]
    scores = []
    for i,alpha in enumerate(alphas):
        regr = linear_model.Lasso(alpha=alpha)
        regr.fit(X_train,y_train)
        scores.append(regr.score(X_test,y_test))
    
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    ax.plot(alphas,scores)
    ax.set_xlabel("alpha")
    ax.set_ylabel("score")
    ax.set_xscale("log")
    ax.set_title('Ridge')
    plt.show()
    
if __name__ == '__main__':
    X_train,X_test,y_train,y_test = load_data()
    test_Ridge(X_train,X_test,y_train,y_test)
    test_Ridge_alpha(X_train,X_test,y_train,y_test)

逻辑回归

from math import exp
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

def create_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data,columns=iris.feature_names)
    df['label'] = iris.target
    df.columns =['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
    data = np.array(df.iloc[:100,[0,1,-1]])
    return data[:,:2],data[:,-1]

X,y = create_data()
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3)

class LogisticRegressionClassifier(): #自定义方式
    def __init__(self,max_iter=700,learning_rate=0.01):
        self.max_iter = max_iter
        self.learning_rate = learning_rate
    
    def sigmoid(self,x):
        return x / (1+exp(-1))
    
    def data_matrix(self,X):
        data_mat = []
        for d in X:
            data_mat.append([1.0,*d])
        return data_mat
    
    def fit(self, X, y):
        data_mat = self.data_matrix(X)
        self.weights = np.zeros((len(data_mat[0]), 1), dtype=np.float32)
        
        for iter_ in range(self.max_iter):
            for i in range(len(X)):
                result = self.sigmoid(np.dot(data_mat[i], self.weights))
                error = y[i] - result
                self.weights += self.learning_rate * error * np.transpose([data_mat[i]])
        print('LogisticRegression Model(learning_rate={}, max_iter={})'.
                            format(self.learning_rate, self.max_iter))

    def score(self, X_test, y_test):
        right = 0
        X_test = self.data_matrix(X_test)
        for x, y in zip(X_test, y_test):
            result = np.dot(x, self.weights)
            if (result > 0 and y == 1) or (result < 0 and y == 0):
                right += 1
        return right / len(X_test)
 
lr_clf = LogisticRegressionClassifier()
lr_clf.fit(X_train, y_train)
lr_clf.score(X_test, y_test)
x_points = np.arange(4, 8)
y_ = -(lr_clf.weights[1] * x_points + lr_clf.weights[0]) / lr_clf.weights[2]
plt.plot(x_points, y_)
plt.scatter(X[:50, 0], X[:50, 1], label='0')
plt.scatter(X[50:, 0], X[50:, 1], label='1')
plt.legend()     

#调用方式
Logitic_model = linear_model.LogisticRegression()
Logitic_model.fit(X_train,y_train)     

Logitic_model.score(X_test,y_test)