精华内容
下载资源
问答
  • 我假设您已经知道如何使用Logistic回归实现进制分类。如果您尚未使用Logistic回归进行进制分类,那么建议您先阅读本文,然后再深入研究本文。因为多类分类是建立在进制分类之上的。您将在本文中学习进制分类...

    Logistic回归的两种方法:梯度下降法和优化函数

    逻辑回归是一种非常流行的机器学习技术。当因变量是分类的时,我们使用逻辑回归。本文将重点介绍针对多类分类问题的逻辑回归的实现。我假设您已经知道如何使用Logistic回归实现二进制分类。

    如果您尚未使用Logistic回归进行二进制分类,那么建议您先阅读本文,然后再深入研究本文。

    231G44042-0.jpg

    因为多类分类是建立在二进制分类之上的。

    您将在本文中学习二进制分类的概念,公式和工作示例

    多类别分类

    多类分类的实现遵循与二进制分类相同的思想。如您所知,在二进制分类中,我们解决了是或否问题。就像上述文章中的示例一样,输出回答了一个人是否患有心脏病的问题。我们只有两类:心脏病和无心脏病。

    如果输出为1,则该人患有心脏病,如果输出为0,则该人没有心脏病。

    在多类别分类中,我们有两个以上的类别。这是一个例子。说,我们具有汽车,卡车,自行车和船的不同特征和特性作为输入特征。我们的工作是预测标签(汽车,卡车,自行车或船)。

    如何解决呢?

    我们将以解决心脏病或无心脏病的方式将每个类别视为二元分类问题。

    这种方法称为"一对多"方法。

    在one vs all方法中,当我们使用一个类时,该类用1表示,其余类变为0。

    例如,如果我们有四个类别:汽车,卡车,自行车和船。当我们在汽车上工作时,我们将汽车用作1,将其余类别用作零。同样,当我们在卡车上工作时,卡车的元素将为1,其余类别为零。

    231G431U-1.png

    当您将其实现时,它将更加易于理解。我建议您在阅读时继续编码并运行代码。

    在这里,我将以两种不同的方式实现此算法:

    梯度下降法。

    优化功能方法。

    重要方程式及其运作方式:

    Logistic回归使用S形函数来预测输出。S形函数返回0到1的值。通常,我们采用一个阈值,例如0.5。如果sigmoid函数返回的值大于或等于0.5,则将其视为1;如果sigmoid函数返回的值小于0.5,则将其视为0。

    231G4F91-2.png

    z是输入要素乘以表示为theta的随机初始化值的乘积。

    231G41244-3.png

    X是输入要素。在大多数情况下,有几种输入功能。因此,此公式变得很大:

    231G4K04-4.png

    X1,X2,X3是输入要素,并且将为每个输入要素随机初始化一个theta。开头的Theta0是偏差项。

    该算法的目标是在每次迭代时更新此theta,以便它可以在输入要素和输出标签之间建立关系。

    成本函数和梯度下降

    成本函数给出的想法是,我们的预测与原始输出相差多远。这是该公式:

    231G410J-5.png

    这里:

    m是训练示例数或训练数据数,

    y是原始输出标签,

    h是假设或预测的输出。

    这是梯度下降的方程式。使用此公式,我们将在每次迭代中更新theta值:

    231G45530-6.png

    梯度下降法的实现

    先决条件:

    您需要能够舒适地读取和编写python代码。

    基本的Numpy和Pandas库。

    在这里,我将逐步展示实现。

    (1) 导入必要的包和数据集。我从安德鲁·伍(Andrew Ng)在Coursera的机器学习课程中获取了数据集。这是一个手写识别数据集。从1到10的数字。

    从像素数据集中,我们需要识别数字。在此数据集中,输入变量和输出变量在Excel文件中的不同工作表中组织。请随时从本页末尾的链接下载数据集。

    如果您正在阅读本文,请运行每段代码以学习该算法。

    让我们导入必要的包和数据集,

    import pandas as pd

    import numpy as np

    xl=pd.ExcelFile('ex3d1.xlsx')

    df=pd.read_excel(xl, 'X',header=None)

    231G41413-7.png

    (2) 导入y,它是输出变量

    y=pd.read_excel(xl, 'y',header=None)

    231G41128-8.png

    (3) 定义采用输入变量和theta的假设。它返回计算出的输出变量。

    def hypothesis(theta, X):

    return 1 / (1 + np.exp(-(np.dot(theta, X.T)))) - 0.0000001

    (4) 构建使用输入变量,输出变量和theta的成本函数。它返回假设的成本。这意味着它给出了关于预测距原始输出有多远的想法。

    def cost(X, y, theta):

    y1=hypothesis(X, theta)

    return -(1/len(X)) * np.sum(y*np.log(y1) + (1-y)*np.log(1-y1))

    (5) 现在,该进行数据预处理了。

    数据是干净的。不需要太多预处理。我们需要在输入变量中添加一个偏差列。请检查df和y的长度。如果长度不同,则该模型将不起作用。

    print(len(df))

    print(len(y))

    X=pd.concat([pd.Series(1,index=df.index,name='00'), df],axis=1)

    (6) y列的数字从1到10。这意味着我们有10个类别。

    y是一个不需要的DataFrame。我只会将列保留为包含值的系列。

    yy= y.iloc[:, 0]

    我们将为每个类创建与y相同长度的一列。当类为5时,请为该行创建一个包含1的列,否则为5和0。

    检查一下,我们有几个类,

    y.unique()

    输出:

    array([10, 1, 2, 3, 4, 5, 6, 7, 8, 9],dtype=int64)

    因此,我们有10个班级。启动一个具有10列和df.shape [0]行数的DataFrame。

    y1=np.zeros([df.shape[0], len(y.unique())])

    y1=pd.DataFrame(y1)

    我们将使用一些简单的代码以编程方式进行操作:

    for i in range(0, len(y.unique())):

    for j in range(0, len(y1)):

    if y[j] == y.unique()[i]:

    y1.iloc[j, i] = 1

    else: y1.iloc[j, i] = 0

    y1.head()

    (7) 现在定义函数" gradient_descent"。此函数将输入变量,输出变量,θ,alpha和历元数作为参数。在这里,alpha是学习率。

    您应该根据需要选择它。太小或太大的学习率可能会使您的算法变慢。我喜欢针对不同的学习率运行该算法,并获得正确学习率的想法。选择正确的学习率可能需要几次迭代。

    对于y1中的每一列,我们将实现一个二进制分类。

    例如,当我考虑数字2时,数字2应该返回1,其余数字应该返回0。因此,由于我们有10个类,所以每个epoch(iteration)运行了10次。因此,我们在这里有一个嵌套的for循环。

    def gradient_descent(X, y, theta, alpha, epochs):

    m=len(X)

    for i in range(0, epochs):

    for j in range(0, 10):

    theta=pd.DataFrame(theta)

    h=hypothesis(theta.iloc[:,j], X)

    for k in range(0, theta.shape[0]):

    theta.iloc[k, j] -= (alpha/m) * np.sum((h-y.iloc[:, j])*X.iloc[:, k])

    theta=pd.DataFrame(theta)

    return theta, cost

    (8) 初始化theta。记住,我们将为每个类实现逻辑回归。每个课程也会有一系列的theta。

    我正在运行1500个纪元。我敢肯定,随着时间的推移,准确率会更高。

    theta=np.zeros([df.shape[1]+1, y1.shape[1]])

    theta=gradient_descent(X, y1, theta, 0.02, 1500)

    (9) 使用此更新的theta,计算输出变量。

    output= []

    for i in range(0, 10):

    theta1=pd.DataFrame(theta)

    h=hypothesis(theta1.iloc[:,i], X)

    output.append(h)

    output=pd.DataFrame(output)

    (10) 比较计算出的输出和原始输出变量,以计算模型的准确性。

    accuracy=0

    for col in range(0, 10):

    for row in range(len(y1)):

    if y1.iloc[row, col] == 1 and output.iloc[col, row] >= 0.5:

    accuracy += 1

    accuracyaccuracy= accuracy/len(X)

    准确度是72%。我相信,准确度会更高。因为花费了很多时间,所以我没有重新运行算法。

    如果您正在运行此程序,请随时尝试更多的纪元,并在注释部分中告知我您的准确度。

    除了梯度下降方法外,您还可以使用已经为您内置的优化功能。

    在这种方法中,您可以使用优化函数来优化算法的theta。这是一种更快的方法。

    具有优化功能的实现

    (1) 我们将使用与以前相同的数据集。如果使用相同的笔记本,请使用其他名称导入数据集:

    xls=pd.ExcelFile('ex3d1.xlsx')

    df=pd.read_excel(xls, 'X',header=None)

    231G43443-9.png

    (2) 我们仍然需要为df中的偏差项添加一列全为1的列。

    X=np.c_[np.ones((df.shape[0], 1)), df]

    231G4H62-10.png

    (3) 导入" y"的数据。

    y=pd.read_excel(xls, 'y',header=None)

    231G4D46-11.png

    由于这是一个DataFrame,因此只需将列零作为一个序列并将其设为二维以将维与X的维匹配。

    yy= y[0]

    yy= y[:, np.newaxis]

    231G4H53-12.png

    在这里," y"只有一列。将其设为10列,以供10个班级使用。每列将处理一个类。例如,当我们处理类10时,我们将保留10的位置,并将其余值替换为零。这是函数y_change,它将使用y本身和一个类(例如3)。然后它将用其他所有类将1替换为3,将其替换为0。此功能将在以后的步骤中很快使用。

    def y_change(y, cl):

    y_pr=[]

    for i in range(0, len(y)):

    if y[i] == cl:

    y_pr.append(1)

    else:

    y_pr.append(0)

    return y_pr

    数据准备完成。现在开发模型:

    (4) 定义假设函数。这与以前的方法相同。

    def hypothesis(X, theta):

    z=np.dot(X, theta)

    return 1/(1+np.exp(-(z)))

    (5) 开发成本函数。此方法也与以前的方法相同:

    def cost_function(theta, X, y):

    m=X.shape[0]

    y1=hypothesis(X, theta)

    return -(1/len(X)) * np.sum(y*np.log(y1) + (1-y)*np.log(1-y1))

    (6) 定义渐变。这是不同的。此函数定义如何更新theta。

    def gradient(theta, X, y):

    m=X.shape[0]

    y1=hypothesis(X, theta)

    return (1/m) * np.dot(X.T, y1 - y)

    (7) 现在,导入优化函数并初始化theta。我将零作为初始theta值。任何其他值也应该起作用。

    from scipy.optimize import minimize, fmin_tnc

    theta=np.zeros((X.shape[1], 1))

    8.让我们做一个拟合函数,将X,y和theta作为输入。它将使用优化函数并为我们输出优化的theta。

    它采用以下三个参数:

    需要最小化的功能

    要优化的参数,

    用于优化的参数。

    在此示例中,应将成本函数最小化,并且为此需要优化theta。输入和输出变量X和y是要使用的参数。

    该优化函数采用另一个参数,即渐变。但这是可选的。在这里,我们有一个用于渐变的公式或函数。因此,我们正在通过它。

    def fit(X, y, theta):

    opt_weigths=fmin_tnc(func=cost_function,

    x0=theta,fprime=gradient,

    args=(X, y.flatten()))

    return opt_weigths[0]

    (9) 使用这种拟合方法来找到优化的theta。我们必须分别为每个类优化theta。让我们开发一个函数,其中对于每个类,将在步骤3中使用y_change方法相应地修改" y"。

    def find_param(X, y, theta):

    y_uniq=list(set(y.flatten()))

    theta_list= []

    for i in y_uniq:

    y_tr=pd.Series(y_change(y, i))

    y_try_tr= y_tr[:, np.newaxis]

    theta1=fit(X, y, theta)

    theta_list.append(theta1)

    return theta_list

    使用此方法找到最终theta

    theta_list=find_param(X, y, theta)

    (10) 现在是时候预测输出了。我们还必须单独预测类别。

    def predict(theta_list, x, y):

    y_uniq=list(set(y.flatten()))

    y_hat= [0]*len(y)

    for i in range(0, len(y_uniq)):

    y_tr=y_change(y, y_uniq[i])

    y1=hypothesis(X, theta_list[i])

    for k in range(0, len(y)):

    if y_tr[k] == 1 and y1[k] >= 0.5:

    y_hat[k] = y_uniq[i]

    return y_hat

    使用上面的预测方法并计算预测输出y_hat:

    y_hat=predict(theta_list, X, y)

    (11) 计算精度

    accuracy=0

    for i in range(0, len(y)):

    if y_hat[i] == y.flatten()[i]:

    accuracy += 1print(accuracy/len(df)*100)

    此过程可提供100%的准确性。现在。您可以自己决定要在项目中使用哪种逻辑回归方法。

    本文还使用神经网络解决了相同的问题。

    检查此GitHub页面以获取数据集:

    https://github.com/rashida048/Machine-Learning-With-Python/blob/master/ex3d1.xlsx

    展开全文
  • 逻辑回归与线性回归算法梳理

    千次阅读 2019-03-31 16:19:11
    逻辑回归算法梳理逻辑回归与线性回归算法1线性回归2 逻辑回归2.1 逻辑回归原理2.2 逻辑回归损失函数2.3 简化后的逻辑回归损失函数3 联系与区别3.1 联系3.2 区别4 正则化与模型评估指标4.1 正则化作用4.2 线性回归...

    逻辑回归与线性回归算法

    分析LR原理之前,先分析一下线性回归。线性回归能将输入数据通过对各个维度的特征分配不同的权重来进行表征,使得所有特征协同作出最后的决策。但是,这种表征方式是对模型的一个拟合结果,不能直接用于分类。
    在LR中,将线性回归的结果通过sigmod函数映射到0到1之间,映射的结果刚好可以看做是数据样本点属于某一类的概率,如果结果越接近0或者1,说明分类结果的可信度越高。这样做不仅应用了线性回归的优势来完成分类任务,而且分类的结果是0~1之间的概率,可以据此对数据分类的结果进行打分。对于线性不可分的数据,可以对非线性函数进行线性加权,得到一个不是超平面的分割面
    https://blog.csdn.net/touch_dream/article/details/79371462

    1线性回归

    线性回归一般用于预测连续值变量,如房价预测问题。
    线性回归的一般表达式为:
    在这里插入图片描述
    代价函数为MSE(均方误差):
    在这里插入图片描述
    其中权重theta的更新,一般可选用梯度下降等相关优化方法。由于MSE对特征值的范围比较敏感,一般情况下对会对特征进行归一化处理。
    具体线性回归相关内容见我的上一篇博客https://blog.csdn.net/wehung/article/details/88899615

    2 逻辑回归

    逻辑回归虽然叫做回归,但是其主要解决分类问题。可用于二分类,也可以用于多分类问题。
    由于线性回归其预测值为连续变量,其预测值在整个实数域中。
    而对于预测变量y为离散值时候,可以用逻辑回归算法(Logistic Regression)
    逻辑回归的本质是将线性回归进行一个变换,该模型的输出变量范围始终在 0 和 1 之间。

    2.1 逻辑回归原理

    逻辑回归模型的假设是:
    在这里插入图片描述
    其中,g代表逻辑函数,逻辑函数在逻辑回归中为sigmoid函数,简称S型函数
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.2 逻辑回归损失函数

    逻辑回归的代价函数为交叉熵函数:
    在这里插入图片描述
    其中,
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.3 简化后的逻辑回归损失函数

    在这里插入图片描述

    3 联系与区别

    综上,联系与区别如下

    3.1 联系

    • 本质上,逻辑回归就是线性回归再进行了sigmod变换,其值变化到(0,1).

    3.2 区别

    • 任务定位:线性回归 用于回归任务;逻辑回归用于分类任务
    • 输出值 线性回归输出连续值;逻辑回归输出概率值;本质是因为逻辑回归使用了sigmod函数进行了映射 ,将值域映射到(0,1),在二类任务中,若大于0.5,则为某个类,小于0.5,为另一类。
    • 损失函数:线性回归采用MSE损失函数,逻辑回归采用交叉熵损失函数。
      损失函数不同的原因:
      在这里插入图片描述
      将最后的sigmoid函数输出值与实际值差别用交叉熵函数衡量。相等时候,损失为0,不相等的时候损失很大。见1.2.2图

    4 正则化与模型评估指标

    4.1 正则化作用

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    lambda正则化参数 是超参数,一般很难选择,通常使用random search或者Grid Search等方法 进行参数选择。

    4.2 线性回归模型正则化

    在这里插入图片描述
    在这里插入图片描述

    4.3 正则化的逻辑回归模型

    代价函数:

    在这里插入图片描述
    在这里插入图片描述
    注意:
    在这里插入图片描述
    正则化中多了一个sigmoid函数。

    5.逻辑回归优缺点

    LR是解决工业规模问题最流行的算法。在工业应用上,如果需要分类的数据拥有很多有意义的特征,每个特征都对最后的分类结果有或多或少的影响,那么最简单最有效的办法就是将这些特征线性加权,一起参与到决策过程中。比如预测广告的点击率,从原始数据集中筛选出符合某种要求的有用的子数据集等等。

    优点:1)适合需要得到一个分类概率的场景。2)计算代价不高,容易理解实现。LR在时间和内存需求上相当高效。它可以应用于分布式数据,并且还有在线算法实现,用较少的资源处理大型数据。3)LR对于数据中小噪声的鲁棒性很好,并且不会受到轻微的多重共线性的特别影响。(严重的多重共线性则可以使用逻辑回归结合L2正则化来解决,但是若要得到一个简约模型,L2正则化并不是最好的选择,因为它建立的模型涵盖了全部的特征。)

    缺点:1)容易欠拟合,分类精度不高。2)数据特征有缺失或者特征空间很大时表现效果并不好。3)不能用 logistic 回归来解决非线性问题,
    https://blog.csdn.net/touch_dream/article/details/79371462

    6 类别不均衡问题

    类别不平衡问题是指分类任务重不同类别的训练样例数目差别很大。

    如有998个反例,2个正例。则一个学习模型只需返回反例,则正确率就有99.8%。
    西瓜书中提到对本节假设负样本更多,正样本更少:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    解决方法:

    • 欠采样
    • 过采样
    • 阈值移动
      在这里插入图片描述
      在这里插入图片描述

    7.sklearn参数解释

    class sklearn.linear_model.LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver=’warn’, max_iter=100, multi_class=’warn’, verbose=0, warm_start=False, n_jobs=None)
    Logistic回归(aka logit,MaxEnt)分类器。

    在多类情况下,如果’multi_class’选项设置为’ovr’,则训练算法使用one-vs-rest(OvR)方案,如果’multi_class’选项设置为’multincial’,则使用交叉熵丢失”。 (目前’‘多项’选项仅受’lbfgs’,'sag’和’newton-cg’解算器的支持。)

    该类使用’liblinear’库,‘newton-cg’,'sag’和’lbfgs’求解器实现正则化逻辑回归。 它可以处理密集和稀疏输入。 使用包含64位浮点数的C有序数组或CSR矩阵以获得最佳性能; 任何其他输入格式将被转换(和复制)。

    ‘newton-cg’,'sag’和’lbfgs’求解器仅支持使用原始公式的L2正则化。 'liblinear’求解器支持L1和L2正则化,具有仅针对L2惩罚的双重公式。

    penalty : str, ‘l1’ or ‘l2’, default: ‘l2’
    惩罚项:字符型 'l1’正则化或者’l2’正则化,默认‘’l2’

    dual : bool, default: False
    对偶:布尔值,默认False
    Dual or primal formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features.
    双重或原始配方。 使用liblinear解算器,双重公式仅实现l2惩罚。 当n_samples> n_features时,首选dual = False。

    tol : float, default: 1e-4
    Tolerance for stopping criteria.停止参数、

    C : float, default: 1.0
    C:浮点数。1.0
    Inverse of regularization strength; must be a positive float. Like in support vector machines, smaller values specify stronger regularization.
    正则项的倒数.必须是正的浮点类型.像SVM一样,C越小则,正则化程度越强

    fit_intercept : bool, default: True
    fit_intercept:布尔值,默认:True
    Specifies if a constant (a.k.a. bias or intercept) should be added to the decision function.
    指定常量(偏差或者截距)是否添加到决策函数.

    intercept_scaling : float, default 1.
    intercept_scaling:float,默认值为1。
    仅在使用求解器“liblinear”且self.fit_intercept设置为True时有用。 在这种情况下,x变为[x,self.intercept_scaling],即具有等于intercept_scaling的常数值的“合成”特征被附加到实例矢量。 截距变为intercept_scaling * synthetic_feature_weight。
    注意! 合成特征权重与所有其他特征一样经受l1 / l2正则化。 为了减小正则化对合成特征权重(并因此对截距)的影响,必须增加intercept_scaling。

    class_weight : dict or ‘balanced’, default: None
    class_weight:dict或’balanced’,默认值:无
    与{class_label:weight}形式的类相关联的权重。 如果没有给出,所有课程都应该有一个权重。
    “平衡”模式使用y的值来自动调整与输入数据中的类频率成反比的权重,如n_samples /(n_classes * np.bincount(y))。
    请注意,如果指定了sample_weight,这些权重将与sample_weight(通过fit方法传递)相乘。
    版本0.17中的新功能:class_weight =‘balanced’ 意思是所有类权重一样

    random_state : int, RandomState instance or None, optional, default: None
    random_state:int,RandomState实例或None,可选,默认值:None
    伪随机数生成器的种子,用于在混洗数据时使用。 如果是int,则random_state是随机数生成器使用的种子; 如果是RandomState实例,则random_state是随机数生成器; 如果为None,则随机数生成器是np.random使用的RandomState实例。 在求解器=='sag’或’liblinear’时使用。

    solver : str, {‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’, ‘saga’}, default: ‘liblinear’.
    求解器:str,{‘newton-cg’,‘lbfgs’,‘liblinear’,‘sag’,‘saga’},默认:‘liblinear’。
    用于优化问题的算法。

    对于小数据集,'liblinear’是一个不错的选择,而’sag’和’saga’对于大数据集来说更快。
    对于多类问题,只有’newton-cg’,‘sag’,‘saga’和’lbfgs’处理多项式损失; 'liblinear’仅限于一对一其他方案
    ‘newton-cg’,‘lbfgs’和’sag’只处理L2惩罚,而’liblinear’和’saga’处理L1惩罚。
    请注意,“sag”和“saga”快速收敛仅在具有大致相同比例的要素上得到保证。 您可以使用sklearn.preprocessing中的缩放器预处理数据。
    版本0.17中的新功能:随机平均梯度下降求解器。
    版本0.19中的新功能:SAGA求解器。
    版本0.20更改:默认值将在0.22中从’liblinear’更改为’lbfgs’。
    max_iter : int, default: 100
    Useful only for the newton-cg, sag and lbfgs solvers. Maximum number of iterations taken for the solvers to converge.
    max_iter:int,默认值:100
    仅适用于newton-cg,sag和lbfgs求解器。 求解器收敛的最大迭代次数。
    multi_class:str,{‘ovr’,‘multinomial’,‘auto’},默认值:‘ovr’
    如果选择的选项是’ovr’,那么二进制问题适合每个标签。 对于“多项式”,最小化的损失是整个概率分布中的多项式损失拟合,即使数据是二进制的。 当solver ='liblinear’时,‘multinomial’不可用。 如果数据是二进制的,或者如果solver =‘liblinear’,‘auto’选择’ovr’,否则选择’multinomial’。

    版本0.18中的新功能:用于“多项式”情况的随机平均梯度下降求解器。

    版本0.20更改:默认值将在0.22中从“ovr”更改为“auto”。
    verbose:int,默认值:0
    对于liblinear和lbfgs求解器,将详细设置为任何正数以表示详细程度。
    warm_start:bool,默认值:False
    设置为True时,重用上一次调用的解决方案以适合初始化,否则,只需擦除以前的解决方案。 对于liblinear解算器没用。 请参阅词汇表。

    版本0.17中的新功能:warm_start支持lbfgs,newton-cg,sag,saga求解器。
    b_jobs:CPU个数。
    如果multi_class =‘ovr’“,则在对类进行并行化时使用的CPU核心数。 无论是否指定了“multi_class”,当求解器设置为“liblinear”时,都会忽略此参数。 除非在joblib.parallel_backend上下文中,否则表示1。 -1表示使用所有处理器。 有关详细信息,请参阅词汇表。
    参考资料:
    1 机器学习 周志华老师
    2 机器学习 coursera Andrew Ng
    3 博客中所附链接https://blog.csdn.net/touch_dream/article/details/79371462

    展开全文
  • :逻辑回归+正则化

    2019-08-06 18:40:47
    建立一逻辑回归模型来预测一学生是否被大学录取,根据两次考试的结果来决定每申请人的录取机会,有以前的申请人的历史数据, 可以用它作为逻辑回归的训练集。 python实现逻辑回归 目标: 建立分类器(求解出...

    建立一个逻辑回归模型来预测一个学生是否被大学录取,根据两次考试的结果来决定每个申请人的录取机会,有以前的申请人的历史数据, 可以用它作为逻辑回归的训练集。

    python实现逻辑回归 目标: 建立分类器(求解出三个参数θ0θ1θ2)即得出界线。备注:θ1对应Exam1成绩,θ2对应Exam2 设定阈值,根据阈值判断录取结果 备注:阈值指的是最终得到的概率值,将概率值转化成一个类别,一般是>0.5是被录取,<0.5未被录取。

    一:__init__.py (逻辑回归主函数)

    #逻辑回归主函数
    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns #绘制散点图
    plt.style.use('fivethirtyeight') #样式美化
    import matplotlib.pyplot as plt
    from sklearn.metrics import classification_report#这个包是评价报告
    import sigmoid as sg #sigmoid函数
    import Cost_function as cf #代价函数
    import gradient_descent as gd #梯度下降
    import scipy.optimize as opt #在这里寻找高级优化算法
    
    data = pd.read_csv(r'******', names = ['exam1', 'exam2', 'admitted'])
    print(data.head())
    #画出散点图
    sns.set(context = "notebook", style = "darkgrid", palette = sns.color_palette("RdBu", 2), color_codes = False) #设置参数样式,默认主题darkgrid(灰色背景+白网格)
    sns.lmplot('exam1', 'exam2', hue = 'admitted', data = data,
               height = 6,
               fit_reg = False,  #fit_feg 参数,控制是否显示拟合的直线
               scatter_kws = {"s": 50}
              )     #hue参数是将name所指定的不同类型的数据叠加在一张图中显示
    #plt.show()
    def get_X(df): #读取特征值
        ones = pd.DataFrame({'Ones': np.ones(len(df))})
        data = pd.concat([ones, df], axis = 1) #以上两行相当于添加了X0=1 的一列
        return data.iloc[:, :-1].values #这个操作返回ndarray,不是矩阵。 as_matrix()已经被淘汰
    def get_y(df): #读取标签
        return np.array(df.iloc[:, -1])
    def normalize_feature(df):
        return df.apply(lambda column: (column - column.mean()) / column.std()) #特征归一化(特征缩放)
    
    #设置X,y,theta
    X = get_X(data)
    y = get_y(data)
    theta = np.zeros(3) #np.zeros(k) 创建的是矩阵,并存在向量,为k*1的矩阵
    # print(X.shape)
    # print(y.shape)
    print(cf.cost(theta, X, y))
    print(gd.gradient(theta, X, y)) #使用梯度下降算法优化θ
    
    #使用scipy.optimize.minimize 里的高级优化算法去寻找参数θ
    res = opt.minimize(fun= cf.cost, x0 = theta, args = (X, y), method = 'Newton-CG', jac = gd.gradient)
    print(res)
    
    # 用训练集预测和验证
    def predict(x, theta): # 实现变量类型转换
        y_pred = sg.sigmoid(X.dot(theta))
        return (y_pred >= 0.5).astype(int)
    final_theta = res.x
    y_pred = predict(X, final_theta)
    print(classification_report(y, y_pred))
    
    #寻找决策边界
    #θ2对应的是exam2的成绩在这里把x2用y代替,为了方便画图,同时 把θ参数y为基准归一 便于画图。
    coef = -(res.x / res.x[2])
    x = np.arange(130, step = 0.1)
    y = coef[0] + coef[1] * x
    #画出散点图和决策分界线
    sns.set(context="notebook", style="ticks", font_scale=1.5)
    sns.lmplot('exam1', 'exam2', hue='admitted', data=data,
               height=6,
               fit_reg=False,
               scatter_kws={"s": 25}
              )
    plt.plot(x, y, 'grey')
    plt.xlim(0, 130)
    plt.ylim(0, 130)
    plt.title('Decision Boundary')

    二:Regularized.py(正则化主函数)

    #正则化主函数
    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns #绘制散点图
    plt.style.use('fivethirtyeight') #样式美化
    import matplotlib.pyplot as plt
    from sklearn.metrics import classification_report#这个包是评价报告
    import feature_mapping as fm
    import regularized_function as rf
    import sigmoid as sg #sigmoid函数
    import scipy.optimize as opt #用高级算法拟合参数
    
    def predict(x, theta): # 实现变量类型转换
        y_pred = sg.sigmoid(X.dot(theta))
        return (y_pred >= 0.5).astype(int)
    
    df = pd.read_csv(r'******', names = ['test1', 'test2', 'accepted'])
    #print(df.head())
    #绘制散点图
    sns.set(context="notebook", style="ticks", font_scale=1.5)
    sns.lmplot('test1', 'test2', hue='accepted', data=df,
               height=6,
               fit_reg=False,
               scatter_kws={"s": 50}
              )
    plt.title('Regularized Logistic Regression')
    #plt.show()
    
    x1 = np.array(df.test1)
    x2 = np.array(df.test2)
    
    data2 = fm.feature_mapping(x1, x2, power = 6)
    theta = np.zeros(data2.shape[1])
    X = fm.feature_mapping(x1, x2, power = 6, as_ndarray=True)
    y = np.array(df.iloc[:, -1])
    # print(X.shape)
    # print(y.shape)
    
    print(rf.regularized_cost(theta, X, y, l = 1)) #正则化代价函数
    print(rf.regularized_gradient(theta, X, y)) #正则化梯度
    
    #拟合参数
    print('init cost = {}'.format(rf.regularized_cost(theta, X, y)))
    
    res = opt.minimize(fun = rf.regularized_cost, x0 = theta, args = (X, y), method = 'Newton-CG', jac = rf.regularized_gradient)
    print(res)
    final_theta = res.x
    y_pred = predict(X, final_theta)
    print(classification_report(y, y_pred)) #预测
    
    #使用不同的?  画出决策边界
    def draw_boundary(power, l): #展示一个画图
        density = 1000
        threshhold = 2 * 10 ** -3
    
        final_theta = feature_mapped_logistic_regression(power, l)
        x, y = find_decision_boundary(density, power, final_theta, threshhold)
    
        df = pd.read_csv(r'******', names=['test1', 'test2', 'accepted'])
        sns.lmplot('test1', 'test2', hue='accepted', data=df, height=6, fit_reg=False, scatter_kws={"s": 100})
    
        plt.scatter(x, y, c='R', s=10)
        plt.title('Decision boundary')
        plt.show()
    
    def feature_mapped_logistic_regression(power, l):
        df = pd.read_csv(r'******', names=['test1', 'test2', 'accepted'])
        x1 = np.array(df.test1)
        x2 = np.array(df.test2)
        y = np.array(df.iloc[:, -1])
    
        X = fm.feature_mapping(x1, x2, power, as_ndarray=True)
        theta = np.zeros(X.shape[1])
    
        res = opt.minimize(fun=rf.regularized_cost,
                           x0=theta,
                           args=(X, y, l),
                           method='TNC',
                           jac=rf.regularized_gradient)
        final_theta = res.x
    
        return final_theta
    
    #寻找决策边界函数
    def find_decision_boundary(density, power, theta, threshhold):
        t1 = np.linspace(-1, 1.5, density)
        t2 = np.linspace(-1, 1.5, density)
    
        cordinates = [(x, y) for x in t1 for y in t2]
        x_cord, y_cord = zip(*cordinates)
        mapped_cord = fm.feature_mapping(x_cord, y_cord, power)  # this is a dataframe
    
        inner_product = mapped_cord.values @ theta
    
        decision = mapped_cord[np.abs(inner_product) < threshhold]
    
        return decision.f10, decision.f01
    
    draw_boundary(power=6, l=0)     #set lambda = 1

     

    三:sigmoid.py(sigmoid函数)

    import numpy as np
    import matplotlib.pyplot as plt
    
    def sigmoid(z):
        gz = 1 / (1 + np.exp(-z))
        return gz
    
    #绘制sigmoid函数的图像
    # fig, ax = plt.subplots(figsize=(8, 6))
    # ax.plot(np.arange(-10, 10, step=0.01),
    #         sigmoid(np.arange(-10, 10, step=0.01)))
    # ax.set_ylim((-0.1,1.1))
    # ax.set_xlabel('z', fontsize=18)
    # ax.set_ylabel('g(z)', fontsize=18)
    # ax.set_title('sigmoid function', fontsize=18)
    # plt.show()

    四: Cost_function.py(代价函数)

    #代价函数
    import numpy as np
    import sigmoid as sg #sigmoid函数
    
    def cost(theta, X, y):
        h = sg.sigmoid(X.dot(theta))
        costf = np.sum((-y * np.log(h)) - (1 - y) * np.log(1 - h)) / len(X)
        return costf

    五:gradient_descent.py(梯度下降函数)

    #梯度下降函数
    import sigmoid as sg
    
    def gradient(theta, X, y):
        h = sg.sigmoid(X.dot(theta))
        grad = X.T.dot(h - y) / len(X)
        return grad

    六:feature_mapping.py(特征映射)

    #特征映射
    #如果样本量多,逻辑回归问题很复杂,而原始特征只有x1,x2可以用多项式创建更多的特征x1、x2、x1x2、x1^2、x2^2、... X1^nX2^n。
    #因为更多的特征进行逻辑回归时,得到的分割线可以是任意高阶函数的形状。
    import numpy as np
    import pandas as pd
    
    def feature_mapping(x, y, power, as_ndarray=False):
    #     """return mapped features as ndarray or dataframe"""
    
        data = {"f{}{}".format(i - p, p): np.power(x, i - p) * np.power(y, p)
                    for i in np.arange(power + 1)
                    for p in np.arange(i + 1)
                }
    
        if as_ndarray:
            return pd.DataFrame(data).values
        else:
            return pd.DataFrame(data)

    七:regularized_function.py(正则化相关函数)

    #正则化的相关函数
    import numpy as np
    import Cost_function as cf
    import gradient_descent as gd
    
    #正则化代价函数
    def regularized_cost(theta, X, y, l = 1):
        theta_j1_to_n = theta[1:]
        regularized_term = (l / (2*len(X))) * np.power(theta_j1_to_n, 2).sum() #注意这个地方 len前后的括号要括号
        regu_cost = cf.cost(theta, X, y) + regularized_term
        return regu_cost
    
    #正则化梯度
    def regularized_gradient(theta, X, y, l = 1):
        theta_j1_to_n = theta[1:]
        regularized_theta = (l / len(X)) * theta_j1_to_n
        # 因为θ从1开始 所以需要将0数组和以计算好的数组进行拼接,达到与参数数量一致
        regularized_term = np.concatenate([np.array([0]), regularized_theta])
        return gd.gradient(theta, X, y) + regularized_term
    
    

     

     

     

     

    展开全文
  • 寻找决策边界、正则化逻辑回归1.准备数据2.特征映射3.正则化代价函数4.正则化梯度5.拟合参数6.预测7.画出决策边界 这次的笔记紧接着上两次对逻辑回归模型和正则化笔记,将一分类问题用逻辑回归和正则化的方法...

    课程链接:https://www.bilibili.com/video/BV164411b7dx?from=search&seid=5329376196520099118

    这次的笔记紧接着上两次对逻辑回归模型和正则化笔记,将一个分类问题用逻辑回归和正则化的方法解决。机器学习在我看来,理论和代码需要两手抓,即使理论搞懂,代码也将是又一个门槛,所以多多尝试。

    这次笔记用到的数据集:https://pan.baidu.com/s/1h5Ygse5q2wkTeXA9Pwq2RA
    提取码:5rd4

    一、无正则项的逻辑回归

    1.问题描述

    建立一个逻辑回归模型来预测一个学生是否被大学录取。根据两次考试的结果来决定每个申请人的录取机会。有以前的申请人的历史数据, 可以用它作为逻辑回归的训练集

    python实现逻辑回归 目标:建立分类器(求解出三个参数 θ0 θ1 θ2)即得出分界线 备注:θ1对应’Exam 1’成绩,θ2对应’Exam 2’ 设定阈值,根据阈值判断录取结果 备注:阈值指的是最终得到的概率值.将概率值转化成一个类别.一般是>0.5是被录取了,<0.5未被录取.

    2.导入模块

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns
    plt.style.use('fivethirtyeight') #样式美化
    import matplotlib.pyplot as plt
    from sklearn.metrics import classification_report#这个包是评价报告
    

    1.Seaborn是基于matplotlib的图形可视化python包。它提供了一种高度交互式界面,便于用户能够做出各种有吸引力的统计图表。

    Seaborn是在matplotlib的基础上进行了更高级的API封装,从而使得作图更加容易,在大多数情况下使用seaborn能做出很具有吸引力的图,而使用matplotlib就能制作具有更多特色的图。应该把Seaborn视为matplotlib的补充,而不是替代物。同时它能高度兼容numpy与pandas数据结构以及scipy与statsmodels等统计模式。

    2.plt.style.use()函数;可以对图片的整体风格进行设置。可以通过plt.style.availabel知道一共有多少种主题。具体参考plt.style.use()函数介绍

    3.sklearn中的classification_report函数用于显示主要分类指标的文本报告.在报告中显示每个类的精确度,召回率,F1值等信息。具体参考classification_report函数介绍

    3.准备数据

    data = pd.read_csv('work/ex2data1.txt', names=['exam1', 'exam2', 'admitted'])
    data.head()#看前五行
    

    在这里插入图片描述

    data.describe()
    

    在这里插入图片描述
    数据读入后,通过可视化查看一下数据分布:

    sns.set(context="notebook", style="darkgrid", palette=sns.color_palette("RdBu", 2)) #设置样式参数,默认主题 darkgrid(灰色背景+白网格),调色板 2色
    
    sns.lmplot('exam1', 'exam2', hue='admitted', data=data,   
               size=6, 
               fit_reg=False,                         #fit_reg'参数,控制是否显示拟合的直线
               scatter_kws={"s": 50}
              )                                       #hue参数是将name所指定的不同类型的数据叠加在一张图中显示
    plt.show()#看下数据的样子
    

    在这里插入图片描述
    定义了下面三个函数,分别用于从数据中提取特征X,提取标签y,以及对特征进行标准化处理。

    def get_X(df):#读取特征
    #     """
    #     use concat to add intersect feature to avoid side effect
    #     not efficient for big dataset though
    #     """
        ones = pd.DataFrame({'ones': np.ones(len(df))})#ones是m行1列的dataframe
        data = pd.concat([ones, df], axis=1)  # 合并数据,根据列合并 axis = 1的时候,concat就是行对齐,然后将不同列名称的两张表合并 加列
        return data.iloc[:, :-1].as_matrix()  # 这个操作返回 ndarray,不是矩阵
    
    def get_y(df):#读取标签
    #     '''assume the last column is the target'''
        return np.array(df.iloc[:, -1])#df.iloc[:, -1]是指df的最后一列
    
    def normalize_feature(df):
    #     """Applies function along input axis(default 0) of DataFrame."""
        return df.apply(lambda column: (column - column.mean()) / column.std())#特征缩放在逻辑回归同样适用
    

    提取特征和标签:

    X = get_X(data)
    print(X.shape)
    
    y = get_y(data)
    print(y.shape)
    

    在这里插入图片描述

    4.假设函数

    逻辑回归模型的假设函数:
    在这里插入图片描述

    def sigmoid(z):
        # your code here  (appro ~ 1 lines)
        return 1 / (1 + np.exp(-z))
    

    绘制一下sigmoid函数的图像:

    fig, ax = plt.subplots(figsize=(8, 6))
    ax.plot(np.arange(-10, 10, step=0.01),
            sigmoid(np.arange(-10, 10, step=0.01)))
    ax.set_ylim((-0.1,1.1))     #lim 轴线显示长度
    ax.set_xlabel('z', fontsize=18)
    ax.set_ylabel('g(z)', fontsize=18)
    ax.set_title('sigmoid function', fontsize=18)
    plt.show()
    

    在这里插入图片描述

    5.代价函数

    在这里插入图片描述
    初始化参数:

    theta = theta=np.zeros(3) # X(m*n) so theta is n*1
    theta
    

    在这里插入图片描述
    定义代价函数:

    def cost(theta, X, y):
        ''' cost fn is -l(theta) for you to minimize'''
        costf = np.mean(-y * np.log(sigmoid(X @ theta)) - (1 - y) * np.log(1 - sigmoid(X @ theta)))
        return costf
    # Hint:X @ theta与X.dot(theta)等价
    

    计算一下初始的代价函数值:

    cost(theta, X, y)
    

    在这里插入图片描述

    6.梯度下降

    在这里插入图片描述
    这是批量梯度下降(batch gradient descent)
    转化为向量化计算:
    在这里插入图片描述
    依次定义梯度:

    def gradient(theta, X, y):
        # your code here  (appro ~ 2 lines)
        return (1 / len(X)) * X.T @ (sigmoid(X @ theta) - y)
    

    计算梯度初始值:

    gradient(theta, X, y)
    

    在这里插入图片描述

    7.拟合参数

    这里不再自定义更新参数的函数,而是使用scipy.optimize.minimize 去自动寻找参数。

    import scipy.optimize as opt
    
    res = opt.minimize(fun=cost, x0=theta, args=(X, y), method='Newton-CG', jac=gradient)
    print(res)
    

    在这里插入图片描述
    其中fun是指优化后的代价函数值,x是指优化后的三个参数值。以上,算是已经训练完成。

    8.用训练集预测和验证

    因为这里没有提供验证集,所以使用训练集进行预测和验证。就是用训练好的模型对训练集进行预测,将结果与真实结果进行比较评估。

    def predict(x, theta):
        prob = sigmoid(x @ theta)
        return (prob >= 0.5).astype(int)   #实现变量类型转换
    
    final_theta = res.x
    y_pred = predict(X, final_theta)
    
    print(classification_report(y, y_pred))
    

    在这里插入图片描述

    9.寻找决策边界

    决策边界就是下面这样一条线:
    在这里插入图片描述

    print(res.x) # this is final theta
    

    在这里插入图片描述

    coef = -(res.x / res.x[2])  # find the equation
    print(coef)
    
    x = np.arange(130, step=0.1)
    y = coef[0] + coef[1]*x
    

    在这里插入图片描述
    在看一下数据描述,确定一下x和y的范围:

    data.describe()  # find the range of x and y
    

    在这里插入图片描述

    sns.set(context="notebook", style="ticks", font_scale=1.5)  默认使用notebook上下文 主题 context可以设置输出图片的大小尺寸(scale)
    
    sns.lmplot('exam1', 'exam2', hue='admitted', data=data, 
               size=6, 
               fit_reg=False, 
               scatter_kws={"s": 25}
              )
    
    plt.plot(x, y, 'grey')
    plt.xlim(0, 130) 
    plt.ylim(0, 130)
    plt.title('Decision Boundary')
    plt.show()
    

    在这里插入图片描述

    二、正则化逻辑回归

    1.准备数据

    这边使用一个新的数据集:

    df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])
    df.head()
    

    在这里插入图片描述

    sns.set(context="notebook", style="ticks", font_scale=1.5)
    
    sns.lmplot('test1', 'test2', hue='accepted', data=df, 
               size=6, 
               fit_reg=False, 
               scatter_kws={"s": 50}
              )
    
    plt.title('Regularized Logistic Regression')
    plt.show()
    

    在这里插入图片描述
    从这个数据分布来看,不可能使用一条直线做到很好的划分数据集两个类别。所以我们需要做一个特征映射,就是在已有的两个特征的基础上添加一些高次幂的特征组合,使得决策边界可以变成一条能较好划分的曲线。

    2.特征映射

    在这里我把它映射成这样的一组特征:
    在这里插入图片描述
    一共有28个项,那么我们可以将这些组合特征看成一个个独立的特征,即看成x1、x2。。。x28,然后通过逻辑回归的方法来求解。

    def feature_mapping(x, y, power, as_ndarray=False):
    #     """return mapped features as ndarray or dataframe"""
    
        data = {"f{}{}".format(i - p, p): np.power(x, i - p) * np.power(y, p)
                    for i in np.arange(power + 1)
                    for p in np.arange(i + 1)
                }
    
        if as_ndarray:
            return pd.DataFrame(data).as_matrix()
        else:
            return pd.DataFrame(data)
    
    x1 = np.array(df.test1)
    x2 = np.array(df.test2)
    
    data = feature_mapping(x1, x2, power=6)
    print(data.shape)
    data.head()
    

    下面是特征映射之后的数据集,特征变成了28维:
    在这里插入图片描述

    data.describe()
    

    在这里插入图片描述

    3.正则化代价函数

    在这里插入图片描述
    相比之前的表达式,多了正则化的惩罚项。

    theta = np.zeros(data.shape[1])
    X = feature_mapping(x1, x2, power=6, as_ndarray=True)
    print(X.shape)
    
    y = get_y(df)
    print(y.shape)
    

    在这里插入图片描述

    def regularized_cost(theta, X, y, l=1):
        theta_j1_to_n = theta[1:]
        regularized_term = (l / (2 * len(X))) * np.power(theta_j1_to_n, 2).sum()
        
        return  cost(theta, X, y) + regularized_term
    

    计算一下初始代价函数值:

    regularized_cost(theta, X, y, l=1)
    

    在这里插入图片描述
    因为我们设置theta为0,所以这个正则化代价函数与代价函数的值应该相同

    4.正则化梯度

    在这里插入图片描述

    def regularized_gradient(theta, X, y, l=1):
        theta_j1_to_n = theta[1:]      #不加theta0
        regularized_theta = (l / len(X)) * theta_j1_to_n
        
        regularized_term = np.concatenate([np.array([0]), regularized_theta])
        return gradient(theta, X, y) + regularized_term
    

    计算一下梯度的初始值:

    regularized_gradient(theta, X, y)
    

    在这里插入图片描述

    5.拟合参数

    import scipy.optimize as opt
    
    print('init cost = {}'.format(regularized_cost(theta, X, y)))
    
    res = opt.minimize(fun=regularized_cost, x0=theta, args=(X, y), method='Newton-CG', jac=regularized_gradient)
    res
    

    在这里插入图片描述

    6.预测

    final_theta = res.x
    y_pred = predict(X, final_theta)
    
    print(classification_report(y, y_pred))
    

    在这里插入图片描述

    7.画出决策边界

    我们需要找到所有满足 X×θ=0 的x,这里不求解多项式表达式,而是创造一个足够密集的网格,对网格里的每一个点进行 X×θ的计算,若结果小于一个很小的值,如10 ^ -3,则可以当做是边界上的一点,遍历该网格上的每一点,即可得到近似边界。

    def draw_boundary(power, l):
    #     """
    #     power: polynomial power for mapped feature
    #     l: lambda constant
    #     """
        density = 1000
        threshhold = 2 * 10**-3
    
        final_theta = feature_mapped_logistic_regression(power, l)
        x, y = find_decision_boundary(density, power, final_theta, threshhold)
    
        df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])
        sns.lmplot('test1', 'test2', hue='accepted', data=df, size=6, fit_reg=False, scatter_kws={"s": 100})
    
        plt.scatter(x, y, c='R', s=10)
        plt.title('Decision boundary')
        plt.show()
    
    def feature_mapped_logistic_regression(power, l):
    #     """for drawing purpose only.. not a well generealize logistic regression
    #     power: int
    #         raise x1, x2 to polynomial power
    #     l: int
    #         lambda constant for regularization term
    #     """
        df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])
        x1 = np.array(df.test1)
        x2 = np.array(df.test2)
        y = get_y(df)
    
        X = feature_mapping(x1, x2, power, as_ndarray=True)
        theta = np.zeros(X.shape[1])
    
        res = opt.minimize(fun=regularized_cost,
                           x0=theta,
                           args=(X, y, l),
                           method='TNC',
                           jac=regularized_gradient)
        final_theta = res.x
    
        return final_theta
    
    def find_decision_boundary(density, power, theta, threshhold):
        t1 = np.linspace(-1, 1.5, density)  #1000个样本
        t2 = np.linspace(-1, 1.5, density)
    
        cordinates = [(x, y) for x in t1 for y in t2]
        x_cord, y_cord = zip(*cordinates)
        mapped_cord = feature_mapping(x_cord, y_cord, power)  # this is a dataframe
    
        inner_product = mapped_cord.as_matrix() @ theta
    
        decision = mapped_cord[np.abs(inner_product) < threshhold]
    
        return decision.f10, decision.f01
    #寻找决策边界函数
    

    下面我们看一下正则化系数不同,导致的决策边界有什么不同?

    draw_boundary(power=6, l=1)     #set lambda = 1
    

    在这里插入图片描述

    draw_boundary(power=6, l=0)  # set lambda < 0.1
    

    在这里插入图片描述

    draw_boundary(power=6, l=100)  # set lambda > 10
    

    在这里插入图片描述
    上面三个例子分别展示了较好拟合、过拟合和欠拟合的三种情况。

    展开全文
  • pytorch线性回归Your first step towards deep learning 您迈向深度学习的第一步 In my previous posts we have gone through 在我以前的帖子中,我们已经看过 Deep Learning — Artificial Neural Network(ANN) ...
  • 吴恩达机器学习练习:逻辑回归 1. 逻辑回归(logistic regression) 在这部分的练习中,你将建立一逻辑回归模型来预测一学生是否能进入大学。假设你是一所大学的行政管理人员,你想根据两门考试的结果,来决定...
  • 编程作业2 logistic_regression(逻辑回归)(吴恩达)

    多人点赞 热门讨论 2020-04-17 18:24:00
    文章目录编程作业2 logistic_regression(逻辑回归)1.准备数据2.sigmoid 函数3.cost function(代价函数)4.gradient descent(梯度下降)5....推荐运行环境:python 3.6 建立一逻辑回归模型来预测一学生是否被...
  • 这意味着,与其显式地编写程序来执行某些任务,不如教计算机如何开发一算法来完成任务。有三种主要类型的机器学习:监督学习、非监督学习和强化学习,所有这些都有其特定的优点和缺点1。 监督学习涉及一组标记数据...
  • 吴恩达机器学习作业Python实现():logistic回归

    万次阅读 多人点赞 2018-05-08 23:25:10
    你有以前申请人的历史数据,可以将其用作逻辑回归训练集。对于每一训练样本,你有申请人两次测评的分数以及录取的结果。为了完成这预测任务,我们准备构建一可以基于两次测试评分来评估录取可能性的分...
  • 你有以前申请人的历史数据,可以将其用作逻辑回归训练集。对于每一训练样本,你有申请人 两次测评的分数以及录取的结果。为了完成这预测任务,我们准备构建一可以基于两次测试 评分来评...
  • 机器学习之回归算法

    万次阅读 2018-06-29 16:52:16
    回归算法是机器学习中最常见也是使用最广的一算法,回归算法主要有线性回归和逻辑回归2种。下面我将分别介绍线性回归和逻辑回归。1线性回归 线性回归是有监督学习的一种算法,科学的介绍这里就不做说明了。通俗的...
  • 线性回归模型

    千次阅读 2019-01-28 14:21:18
    监督学习:通过标注数据进行学习的方法 ...线性回归:一种通过属性的线性组合来进行预测的线性模型,其目的是找到一条直线或者一平面或者更高维的超平面,使得预测值与真实值之间的误差最小化。 方差:表示一...
  • 1.1 scikit-learn参数介绍 1.1.1 导入 from sklearn.linear_model import LogisticRegression 1.1.2 版本 scikit-learn==0.21.3 1.1.3 参数 1.1.3.1 penalty l1、l2、elasticnet、...l1: l1正则,邻回归 l2...
  • 逻辑回归总结

    千次阅读 2018-09-02 21:36:26
    一句话概括逻辑回归:逻辑回归假设数据服从伯努利分布,通过极大化似然函数的方法运用梯度下降来求解参数,以达到将数据分类的目的。(求解参数时常见的算法还有:随机梯度下降法,牛顿法,拟牛顿法等) 逻辑回归的...
  • 机器学习实战:逻辑回归+梯度下降

    千次阅读 2020-03-06 10:28:43
    假设你是一大学的管理员,你想根据两次考试的结果来决定每申请人的录取机会,你有以前的申请人的历史数据。可以用历史数据作为逻辑回归的训练集。对于每一样本,有两次考试的申请人的成绩和录取决定。建立一...
  • 蛋(codeegg) 第 1070 次推文作者:Bartosz Walacik链接:https://allegro.tech/2018/05/From-Java-to-Kotlin-...
  • 点击上方“码农突围”,马上关注这里是码农充电第一站,回复“666”,获取一份专属大礼包真爱,请设置“星标”或点“在看”作者:Bartosz Walacik | 来自:CSDN原文:h...
  • 你有以前的申请人的历史数据,你可以用它作为逻辑回归的训练集。对于每一培训例子,你有两考试的申请人的分数和录取决定。为了做到这一点,我们将建立一分类模型,根据考试成绩估计入学概率。 ...
  • Glmnet是一通过惩罚最大似然来拟合广义线性模型的包。正则化路径是针对正则化参数λ的值网格处的套索或弹性网络罚值计算的。该算法速度极快,可以利用输入矩阵中的稀疏性x。它符合线性,逻辑和多项式,泊松和Cox...
  • 机器学习_线性回归

    千次阅读 2019-03-25 20:25:18
    人工智能是一宽泛概念 , 它只是计算机科学的分支之一 .目前我们认为只要在应用中嵌入一智能模块 , 我们就可以把他定义为人工智能 . 目前它的实际应用包含机器视觉,指纹识别,人脸识别,视网膜识别,虹膜识别,...
  • 早期的博客中写过一篇逻辑回归的介绍,这篇博文中对逻辑回归的“输入为何能代表概率“这问题做了浅层的探讨,但碍于当年太过年轻,对问题理解不够深刻,这次回过头来把这问题重新梳理一遍。 这问题还可以换种...
  • 根据两次考试的结果来决定每申请人的录取机会,有以前申请人的历史数据,用它作为逻辑回归的训练集,建立一 分类模型,根据考试成绩估计入学概率。 #准备工作,导入包 import numpy as np import pandas as pd ...
  • scikit-learn--逻辑回归应用

    千次阅读 2018-11-18 13:15:34
    sikit-learn--逻辑回归信息整理
  • 编程作业2 logistic_regression(逻辑回归) 推荐运行环境:python 3.6 建立一逻辑回归模型来预测一学生是否被大学录取。根据两次考试的结果来决定每申请人的录取机会。有以前的申请人的历史数据, 可以用它...
  • 机器学习4logistic回归

    2014-02-16 20:52:19
    对于线性回归、logistic回归,在以前准备学习深度学习的时候看过一点,当时的数学基础有点薄弱,虽然现在还是有点差,当时看到神经网络之后就看不下去了。 不过这次是通过python对logistic回归进行编码实现。 线性...
  • 机器学习——回归算法 一、线性回归算法概述 1.背景引入 银行贷款,如下图,共有5组数据,每组...我们做下面的规定:x1,x2x_1,x_2x1​,x2​是我们的两特征(年龄,工资),yyy是银行最终会贷款给我们多少。我们要做
  • 二个问题,当你读取一个方法声明时,你首先看到的是名字和返回类型,然后才是参数。 在 Kotlin 中,方法的返回类型可能远在行尾,所以需要浏览很多代码才能看到: private fun getMetricValue(kafkaTemplate ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,486
精华内容 1,394
关键字:

回归返回2个以前标签