精华内容
下载资源
问答
  • 2021-07-22 09:49:45

    @正规方程


    前言

    斯坦福大学吴恩达老师的机器学习课程几乎是每位热爱人工智能领域同学的必修课。网上虽然有许多基于python实现的代码,但大多使用python交互模式解释器ipython实例讲解。本人基于自己的理解采用pycharm提供源代码及个人理解,部分代码可能参考他人代码部分,如有侵权请私信我

    一、问题探讨

    参考视频4-6 ,到目前为止,我们都在使用梯度下降算法寻找局部最优解。但是对于某些线性回归问题,正规方程方法是更好的解决方案:它相较梯度下降算法而言,可以一次计算得出theta且代码简易方便。且不需要我们人为定义学习率a

    而正规方程是通过求解下面的方程来找出使得代价函数最小的参数的在这里插入图片描
    假设我们的训练集特征矩阵为 X,并且我们的训练集结果为向量 y,则利用正规方程解出向量在这里插入图片描述
    注:可以看到由于向量theta需要我们求出逆矩阵在这里插入图片描述
    所以对于那些不可逆矩阵(通常是因为矩阵之间不独立,如包含英尺为单位的尺寸和米为单位的尺寸两个特征,也有可能是特征数量大于训练集的数量),正规方程方法是不可用的

    二、代码解析

    1.引入库

    代码如下(示例):

    def normalEqn(X, y):
        theta = np.linalg.inv(X.T@X)@X.T@y#X.T@X等价于X.T.dot(X)
        return theta
    final_theta2=normalEqn(x2, y2)
    print(final_theta2)
    

    注:使用了原数据x2,y2

    C:\Users\33696\AppData\Local\Programs\Python\Python39\python.exe D:/pythonProject/Include/机器学习.py
    0.4893617021276595
    [[-1.10845139e-16  8.84042349e-01 -5.24551809e-02]](梯度下降算法结果)
    0.130686706060959
    [[-1.11022302e-16]
     [ 8.84765988e-01]
     [-5.31788197e-02]](正规方程算法结果)
    

    pycharm计算结果如上图所示,可以看到两个计算方法得到的结果相差不大,因而对于读者而言,根据具体的问题,以及特征变量的数量,这两种算法都是值得学习的

    总结

    在这里插入图片描述
    总结一下,只要特征变量的数目并不大,标准方程是一个很好的计算参数𝜃的替代方法。
    具体地说,只要特征变量数量小于一万,我通常使用标准方程法,而不使用梯度下降法。(吴恩达老师课程讲义)

    更多相关内容
  • 一共8个课时的数据
  • csdn上一些吴恩达机器学习作业数据集都是需要积分下载,我在其他网站收集了所有的作业以及数据集,帮助大家学习和交流。
  • coursera吴恩达机器学习课程作业自写Python版本+Matlab原版
  • 吴恩达机器学习课程作业完整版详细,非常详细,包含所有需要的材料文件,值得下载!解压密码是rothschild666。
  • Course mechine-learning 斯坦福 吴恩达 机器学习 编程作业答案
  • 机器学习课后作业文档说明和答案解析,配套2014年的视频
  • 吴恩达机器学习全部课件及编程练习题ex1-ex8
  • 吴恩达机器学习作业

    2019-03-29 16:46:02
    吴恩达机器学习课程的python语言代码,包括大佬改进的代码,jupyter notebook完美运行
  • 斯坦福教授、人工智能和机器学习领域国际最权威学者之一吴恩达机器学习课程的全部编程作业,内不含答案。
  • 吴恩达机器学习coursera题目+答案,matlab版。感觉还可以,可以跟课程一起学习。
  • 压缩包内含吴恩达老师《Machine Learning》课程全部的编程作业中需要自己完成的部分,解压放进课程作业原始压缩包中即可。压缩包中所有编程作业均为本人独立完成,并尽量使用向量化计算,全部满分通过。
  • 已经学习吴恩达机器学习课程,这个是编程作业,带答案自己写的,所有答案全部通过。
  • 压缩包内含吴恩达老师《Machine Learning》课程第五周的编程作业ex4所需完成的三个m文件。压缩包中所有编程作业均为本人独立完成,并尽量使用向量化计算,全部满分通过。
  • 压缩包内含吴恩达老师《Machine Learning》课程第八周的编程作业ex7所需完成的六个m文件,解压放进课程作业原始压缩包中即可。压缩包中所有编程作业均为本人独立完成,并尽量使用向量化计算,全部满分通过。
  • 本资源是coursera课程中斯坦福吴恩达教授的机器学习课程中课后编程习题的资源及答案,全部代码是本人积累验证得来,均为满分答案,可供各位学者参考。
  • 吴恩达机器学习公开课作业中文版本 几点说明 有关翻译中存在的不足之处,恳请各位大佬批评指正,我会随时修改! 为了追求翻译进度,嵌套在正文中的数学表达式没有做特殊处理(主要是上标和下标),但是不影响阅读...
  • 本文件是网易云课堂吴恩达老师机器学习课程课后作业的Python实现,本部分是逻辑回归的作业,其他部分的作用也会陆续上传。
  • 本文档包括吴恩达机器学习视频百度网盘(视频+PPT+个人笔记+作业
  • 吴恩达公开课机器学习课堂作业完整版代码,使用octave练习代码,已经做过,可靠。
  • 网易云课堂吴恩达老师的第三次作业的答案,亲自写的,而且都是向量化操作,没有用for循环来做。
  • 开始面对Coursera的编程作业的提交可能会让人有些摸不着头脑,不知道下载的文件都有什么用,以及怎么去提交作业。 下面写一个简单的介绍。 就拿第一个编程作业:线性回归 举个例子。 首先就是在这个页面。 ...

    开始面对Coursera的编程作业的提交可能会让人有些摸不着头脑,不知道下载的文件都有什么用,以及怎么去提交作业。

    下面写一个简单的介绍。

    就拿第一个编程作业:线性回归   举个例子。

    首先就是在这个页面。

    按照上面的要求,因为我用的是Octave,所以就需要单击下载下面这个压缩包。

    将压缩包解压到一个不含中文的路径。

    打开ex1.pdf,它将告诉你全部的东西。

    你将了解到ex1.m是一个用来展示你完成的作业的脚本,ex1data1和data2都是训练数据,warmUpExercise.m是你要完成的第一个函数。

    按照要求将warmUpExercise.m补全.

    接下来尝试去执行这个完成的函数,看看结果对不对。

    没有问题,那你就可以尝试去提交作业了。

    在Octave中输入submit()

    然后依次输入你的邮箱和Token,按下回车。

    你可以在Coursera作业界面找到你的Token,如果没有就单击"生成新的识别码"来生成。

    然后Octave就会显示你的作答情况。

    我这里只做了一道题,所以当然只有部分分。

    这里的提交也会同步到你的Coursera作业网页。

    如果你像我一样最后写完了,就会出现这样的界面,舒服了ヾ(•ω•`)o

     

    展开全文
  • 吴恩达的2014机器学习课程对应的作业,还有相关代码以及题目说明文档。内容清楚
  • 吴恩达2014机器学习课程对应全部作业,内有详细代码以及题目说明文档!!代码清晰,亲自做过无任何问题!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  • 压缩包内含吴恩达老师《Machine Learning》课程第九周的编程作业ex8所需完成的三个m文件,解压放进课程作业原始压缩包中即可。压缩包中所有编程作业均为本人独立完成,并尽量使用向量化计算,全部满分通过。
  • 吴恩达机器学习课程有点老了,当时吴教授选的octave/matlab来编程,我也尝试了安装octave,不仅编程语法不熟悉,就是submission也没搞明白,幸运的是github上的Gerges大神,搞了个python版交作业神器,直接在jupyter...

    本文主要包含两个部分:

    1.吴恩达机器学习如何提交python作业并得到分数

    2.week 2 编程作业——线性回归 python 代码

    一、吴恩达机器学习如何提交python作业并得到分数

    吴恩达机器学习课程有点老了,当时吴教授选的octave/matlab来编程,我也尝试了安装octave,不仅编程语法不熟悉,就是submission也没搞明白,幸运的是github上的Gerges大神,搞了个python版交作业神器,直接在jupyter notebook上运行代码就能提交作业。

    传送门:

    GitHub - dibgerge/ml-coursera-python-assignments: Python assignments for the machine learning class by andrew ng on coursera with complete submission for grading capability and re-written instructions.Python assignments for the machine learning class by andrew ng on coursera with complete submission for grading capability and re-written instructions. - GitHub - dibgerge/ml-coursera-python-assignments: Python assignments for the machine learning class by andrew ng on coursera with complete submission for grading capability and re-written instructions.https://github.com/dibgerge/ml-coursera-python-assignments以week2为例:

    week2 的练习分成两个部分,一个是算分的required exercises,一个是不算分的附加题 

    Gerges 大神已经给大家整理好了,我们只需要在your code 部分写上代码,再运行grader.grade()后填上email,以及token就行了。比如 warm up exercise, 这个地方我们需要把A=[] 改为 A = np.eye(5)

    然后再运行(不需要自己写,已经放在jupter notebook上了)

     运行完这段代码,会让我们填couresa绑定的邮箱地址以及token

     token 在我们的couresa assignment里面,点generate new token 就能自动生成,但是每次token只有30分钟有效。(可以提前写好solution,每道题都做好了,最后再来run 每个部分的grader.grade()  )

     运行完之后直接就能看到分数: 

    每交一道,就会显示当前累计得分, 写这个教程时我已经交完作业了,所以看到的分数是100。

    二、week 2 编程作业——线性回归 python 代码

    先来导包吧

    # used for manipulating directory paths
    import os
    
    # Scientific and vector computation for python
    import numpy as np
    
    # Plotting library
    from matplotlib import pyplot
    from mpl_toolkits.mplot3d import Axes3D  # needed to plot 3-D surfaces
    
    # library written for this exercise providing additional functions for assignment submission, and others
    import utils 
    
    # define the submission/grader object for this exercise
    grader = utils.Grader()
    
    # tells matplotlib to embed plots within the notebook
    %matplotlib inline

    1.第一题 warm up exercise 

    要求:生成一个对角矩阵。

    方案:numpy 里的eye()函数就能实现这个功能

    def warmUpExercise():
        """
        Example function in Python which computes the identity matrix.
        
        Returns
        -------
        A : array_like
            The 5x5 identity matrix.
        
        Instructions
        ------------
        Return the 5x5 identity matrix.
        """    
        # ======== YOUR CODE HERE ======
        A = np.eye(5)   # modify this line
        
        # ==============================
        return A

    2.第二题Computing the cost 

    要求:补全Computing the cost函数

     

    # 导入数据
    data = np.loadtxt(os.path.join('Data', 'ex1data1.txt'), delimiter=',')
    X, y = data[:, 0], data[:, 1]  #数据切片
    m = y.size   # 训练集的个数
    
    #数据可视化
    def plotData(x, y):
        """
        Plots the data points x and y into a new figure. Plots the data 
        points and gives the figure axes labels of population and profit.
        
        Parameters
        ----------
        x : array_like
            Data point values for x-axis.
    
        y : array_like
            Data point values for y-axis. Note x and y should have the same size.
        
        Instructions
        ------------
        Plot the training data into a figure using the "figure" and "plot"
        functions. Set the axes labels using the "xlabel" and "ylabel" functions.
        Assume the population and revenue data have been passed in as the x
        and y arguments of this function.    
        
        Hint
        ----
        You can use the 'ro' option with plot to have the markers
        appear as red circles. Furthermore, you can make the markers larger by
        using plot(..., 'ro', ms=10), where `ms` refers to marker size. You 
        can also set the marker edge color using the `mec` property.
        """
        fig = pyplot.figure()  # open a new figure
        
        # ====================== YOUR CODE HERE ======================= 
        pyplot.plot(x, y, 'ro', ms=10, mec='k')
        pyplot.ylabel('Profit in $10,000')
        pyplot.xlabel('Population of City in 10,000s')
    
        # =============================================================
    
    plotData(X, y)
    
    #生成 computecost函数
    #给x添加值为1的列(吴教授在课程里有讲,这里相当于添加偏置,y=w0*1+w1*x )
    X = np.stack([np.ones(m), X], axis=1)
    
    def computeCost(X, y, theta):
        """
        Compute cost for linear regression. Computes the cost of using theta as the
        parameter for linear regression to fit the data points in X and y.
        
        Parameters
        ----------
        X : array_like
            The input dataset of shape (m x n+1), where m is the number of examples,
            and n is the number of features. We assume a vector of one's already 
            appended to the features so we have n+1 columns.
        
        y : array_like
            The values of the function at each data point. This is a vector of
            shape (m, ).
        
        theta : array_like
            The parameters for the regression function. This is a vector of 
            shape (n+1, ).
        
        Returns
        -------
        J : float
            The value of the regression cost function.
        
        Instructions
        ------------
        Compute the cost of a particular choice of theta. 
        You should set J to the cost.
        """
        
        # initialize some useful values
        m = y.size  # number of training examples
        
        # You need to return the following variables correctly
        J = 0
        
        # ====================== YOUR CODE HERE =====================
        h = np.dot(X, theta)
        
        J = (1/(2 * m)) * np.sum(np.square(np.dot(X, theta) - y))
        
        # ===========================================================
        return J

    3.第三题gradientdescent

    def gradientDescent(X, y, theta, alpha, num_iters):
        """
        Performs gradient descent to learn `theta`. Updates theta by taking `num_iters`
        gradient steps with learning rate `alpha`.
        
        Parameters
        ----------
        X : array_like
            The input dataset of shape (m x n+1).
        
        y : arra_like
            Value at given features. A vector of shape (m, ).
        
        theta : array_like
            Initial values for the linear regression parameters. 
            A vector of shape (n+1, ).
        
        alpha : float
            The learning rate.
        
        num_iters : int
            The number of iterations for gradient descent. 
        
        Returns
        -------
        theta : array_like
            The learned linear regression parameters. A vector of shape (n+1, ).
        
        J_history : list
            A python list for the values of the cost function after each iteration.
        
        Instructions
        ------------
        Peform a single gradient step on the parameter vector theta.
    
        While debugging, it can be useful to print out the values of 
        the cost function (computeCost) and gradient here.
        """
        # Initialize some useful values
        m = y.shape[0]  # number of training examples
        
        # make a copy of theta, to avoid changing the original array, since numpy arrays
        # are passed by reference to functions
        theta = theta.copy()
        
        J_history = [] # Use a python list to save cost in every iteration
        
        for i in range(num_iters):
            # ==================== YOUR CODE HERE =================================
            theta = theta - (alpha / m) * (np.dot(X, theta) - y).dot(X)
    
            # =====================================================================
            
            # save the cost J in every iteration
            J_history.append(computeCost(X, y, theta))
        
        return theta, J_history
    
    
    # 初始化theta
    theta = np.zeros(2)
    
    # 初始化迭代次数和学习率
    iterations = 1500
    alpha = 0.01
    
    theta, J_history = gradientDescent(X ,y, theta, alpha, iterations)
    print('Theta found by gradient descent: {:.4f}, {:.4f}'.format(*theta))
    print('Expected theta values (approximately): [-3.6303, 1.1664]')
    
    # 可视化
    plotData(X[:, 1], y)
    pyplot.plot(X[:, 1], np.dot(X, theta), '-')
    pyplot.legend(['Training data', 'Linear regression']);

    展开全文
  • 机器学习 | 吴恩达机器学习第七周编程作业(Python版)-附件资源
  • 作业及数据下载网址:吴恩达机器学习课程 2.逻辑回归实现 逻辑回归的作业主要包含两个任务:对决策边界进行可视化以及进行预测。下面附上代码,有详细的注释,这里就不一一解释了。 import pandas as pd import ...

    1.写在前面

    吴恩达机器学习的课后作业及数据可以在coursera平台上进行下载,只要注册一下就可以添加课程了。所以这里就不写题目和数据了,有需要的小伙伴自行去下载就可以了。
    作业及数据下载网址:吴恩达机器学习课程

    2.逻辑回归实现

    逻辑回归的作业主要包含两个任务:对决策边界进行可视化以及进行预测。下面附上代码,有详细的注释,这里就不一一解释了。

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import math
    from collections import OrderedDict
    
    
    #用于导入数据的函数
    def inputData():
        #从txt文件中导入数据,注意最好标明数据的类型
        data = pd.read_csv('MachineLearning\\machine-learning-ex2\\machine-learning-ex2\\ex2\\ex2data1.txt'
                    ,dtype={0:float,1:float,2:int})
        #插入一列全为1的列
        data.insert(0,"one",[1 for i in range(0,data.shape[0])])
        #分别取出X和y
        X=data.iloc[:,0:3].values
        y=data.iloc[:,3].values
        y=y.reshape(y.shape[0],1)
        return X,y
    
    #用于最开始进行数据可视化的函数
    def showData(X,y):
        #分开考虑真实值y是1和0的行,分别绘制散点,并注意使用不同的label和marker
        for i in range(0,X.shape[0]):
            if(y[i,0]==1):
                plt.scatter(X[i,1],X[i,2],marker='+',c='black',label='Admitted')
            elif(y[i,0]==0):
                plt.scatter(X[i,1],X[i,2],marker='o',c='yellow',label='Not admitted')
        #设置坐标轴和图例
        plt.xticks(np.arange(30,110,10))
        plt.yticks(np.arange(30,110,10))
        plt.xlabel('Exam 1 score')
        plt.ylabel('Exam 2 score')
        #因为上面绘制的散点不做处理的话,会有很多重复标签
        #因此这里导入一个集合类消除重复的标签
        handles, labels = plt.gca().get_legend_handles_labels()     #获得标签
        by_label = OrderedDict(zip(labels, handles))            #通过集合来删除重复的标签
        plt.legend(by_label.values(), by_label.keys())          #显示图例
        plt.show()
    
    #定义sigmoid函数
    def sigmoid(z):
        return 1/(1+np.exp(-z))
    
    #计算代价值的函数
    def showCostsJ(X,y,theta,m):
        #根据吴恩达老师上课讲的公式进行书写
        #注意式子中加了1e-6次方是为了扩大精度,防止出现除0的警告
        costsJ = ((y*np.log(sigmoid(X@theta)+ 1e-6))+((1-y)*np.log(1-sigmoid(X@theta)+ 1e-6))).sum()/(-m)
        return costsJ
    
    #用于进行梯度下降的函数
    def gradientDescent(X,y,theta,m,alpha,iterations):
        for i in range(0,iterations):       #进行迭代
            #根据吴恩达老师的公式,进行向量化的计算。
            #注意下面第二行使用X.T@ys可以替代掉之前的同步更新方式,写起来更简洁
            ys=sigmoid(X@theta)-y
            theta=theta-alpha*(X.T@ys)/m
    
            #以下完全根据吴恩达老师视频中进行编写代码,可以代替上面两行的代码
            # temp0=theta[0][0]-alpha*(ys*(X[:,0].reshape(X.shape[0],1))).sum()  #注意这里一定要将X[:,1]reshape成向量
            # temp1=theta[1][0]-alpha*(ys*(X[:,1].reshape(X.shape[0],1))).sum()
            # temp2=theta[2][0]-alpha*(ys*(X[:,2].reshape(X.shape[0],1))).sum()
            # theta[0][0]=temp0          #进行同步更新θ0和θ1和θ2
            # theta[1][0]=temp1
            # theta[2][0]=temp2
            
        return theta
    
    #对决策边界进行可视化的函数
    def evaluateLogisticRegression(X,y,theta):
    
        #这里和上面进行数据可视化的函数步骤是一样的,就不重复阐述了
        for i in range(0,X.shape[0]):
            if(y[i,0]==1):
                plt.scatter(X[i,1],X[i,2],marker='+',c='black',label='Admitted')
            elif(y[i,0]==0):
                plt.scatter(X[i,1],X[i,2],marker='o',c='yellow',label='Not admitted')
        plt.xticks(np.arange(30,110,10))
        plt.yticks(np.arange(30,110,10))
        plt.xlabel('Exam 1 score')
        plt.ylabel('Exam 2 score')
        handles, labels = plt.gca().get_legend_handles_labels()
        by_label = OrderedDict(zip(labels, handles))
        plt.legend(by_label.values(), by_label.keys())
    
    
        minX=np.min(X[:,1])         #取得x1中的最小值
        maxX=np.max(X[:,1])         #取得x1中的最大值
        xx=np.linspace(minX,maxX,100)   #创建等间距的数100个
        yy=(theta[0][0]+theta[1][0]*xx)/(-theta[2][0])      #绘制决策边界
        plt.plot(xx,yy)
        plt.show()
    
    #利用训练集数据判断准确率的函数
    def judge(X,y,theta):
        ys=sigmoid(X@theta)         #根据假设函数计算预测值ys
        yanswer=y-ys                #使用真实值y-预测值ys
        yanswer=np.abs(yanswer)     #对yanswer取绝对值
        print('accuary:',(yanswer<0.5).sum()/y.shape[0]*100,'%')   #计算准确率并打印结果
    
    
    X,y = inputData()           #输入数据   
    theta=np.zeros((3,1))       #初始化theta数组
    alpha=0.004                 #设定alpha值
    iterations=200000           #设定迭代次数
    theta=gradientDescent(X,y,theta,X.shape[0],alpha,iterations)        #进行梯度下降
    judge(X,y,theta)            #计算准确率
    evaluateLogisticRegression(X,y,theta)       #决策边界可视化
    
    

    结果展示:
    决策边界的绘制
    在这里插入图片描述
    针对训练集的预测准确率
    在这里插入图片描述

    3.正则化逻辑回归

    正则化逻辑回归的作业主要包含两个任务:进行数据映射、实现正则化的梯度下降,绘制决策边界以及进行预测。下面附上代码,有详细的注释,这里就不一一解释了。

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    from collections import OrderedDict
    
    #用于导入数据的函数
    def inputData():
        #从txt文件中导入数据,注意最好标明数据的类型
        data=pd.read_csv('MachineLearning\\machine-learning-ex2\\machine-learning-ex2\\ex2\\ex2data2.txt'
                    ,dtype={0:float,1:float,2:int})
        #插入一列全为1的列
        data.insert(0,"ones",np.ones((data.shape[0],1)))
        #分别取出X和y
        X=data.iloc[:,0:3]
        X=X.values
        y=data.iloc[:,3]
        y=(y.values).reshape(y.shape[0],1)
        return X,y
    
    #用于最开始进行数据可视化的函数
    def showData(X,y):
        #分开考虑真实值y是1和0的行,分别绘制散点,并注意使用不同的label和marker
        for i in range(0,X.shape[0]):
            if(y[i][0]==1):
                plt.scatter(X[i][1],X[i][2],marker="+",c='b',label='y=1')
            else:
                plt.scatter(X[i][1],X[i][2],marker='o',c='y',label='y=0')
        #设置坐标轴和图例
        plt.xticks(np.arange(-1,1.5,0.5))
        plt.yticks(np.arange(-0.8,1.2,0.2))
        plt.xlabel('Microchip Test 1')
        plt.ylabel('Microchip Test 2')
        #因为上面绘制的散点不做处理的话,会有很多重复标签
        #因此这里导入一个集合类消除重复的标签
        handles, labels = plt.gca().get_legend_handles_labels()     #获得标签
        by_label = OrderedDict(zip(labels, handles))                #通过集合来删除重复的标签
        plt.legend(by_label.values(), by_label.keys())              #显示图例
        plt.show()
    
    #定义sigmoid函数
    def sigmoid(z):
        return 1/(1+np.exp(-z))
    
    #计算代价值的函数
    def computeCostsJ(X,y,theta,lamda,m):
        #根据吴恩达老师上课讲的公式进行书写
        hx=sigmoid(X@theta)
        costsJ=-(np.sum(y*np.log(hx)+(1-y)*np.log(1-hx)))/m+lamda*np.sum(np.power(theta,2))/(2*m)
        return costsJ
    
    #进行特征映射
    def featureMapping(x1,x2,level):
        answer = {}         #定义一个字典
        for i in range(1,level+1):      #外层循环,映射的阶数
            for j  in range(0,i+1):     #内存循环,x1的次数
                answer['F{}{}'.format(i-j,j)]=np.power(x1,i-j)*np.power(x2,j)    #形成字典中的key-value   
        answer = pd.DataFrame(answer)       #转换为一个dataframe
        answer.insert(0,"ones",np.ones((answer.shape[0],1)))        #插入第一列全1
        return answer.values
    
    #进行梯度下降的函数
    def gradientDescent(X,y,theta,alpha,iterations,m,lamda):
        for i in range(0,iterations+1):
            hx=sigmoid(X@theta)
            temp0=theta[0][0]-alpha*np.sum(hx-y)/m          #因为x0是不需要进行正则化的,因此需要单独计算
            theta=theta-alpha*(X.T@(hx-y)+lamda*theta)/m    #根据公式进行同步更新theta
            theta[0][0]=temp0                           #单独修改theta0
        return theta
    
    #利用训练集数据判断准确率的函数
    def judge(X,y,theta):
        ys=sigmoid(X@theta)         #根据假设函数计算预测值ys
        yanswer=y-ys                #使用真实值y-预测值ys
        yanswer=np.abs(yanswer)     #对yanswer取绝对值
        print('accuary',(yanswer<0.5).sum()/y.shape[0]*100,'%')    #计算准确率并打印结果
    
    #对决策边界进行可视化的函数
    def evaluateLogisticRegression(X,y,theta):
        #这里和上面进行数据可视化的函数步骤是一样的,就不重复阐述了
        for i in range(0,X.shape[0]):
            if(y[i][0]==1):
                plt.scatter(X[i][1],X[i][2],marker="+",c='b',label='y=1')
            else:
                plt.scatter(X[i][1],X[i][2],marker='o',c='y',label='y=0')
        plt.xticks(np.arange(-1,1.5,0.5))
        plt.yticks(np.arange(-0.8,1.2,0.2))
        plt.xlabel('Microchip Test 1')
        plt.ylabel('Microchip Test 2')
        handles, labels = plt.gca().get_legend_handles_labels()
        by_label = OrderedDict(zip(labels, handles))
        plt.legend(by_label.values(), by_label.keys())
        
        #通过绘制等高线图来绘制决策边界
        x=np.linspace(-1,1.5,250)       #创建一个从-1到1.5的等间距的数
        xx,yy = np.meshgrid(x,x)        #形成一个250*250的网格,xx和yy分别对应x值和y值
        #利用ravel()函数将xx和yy变成一个向量,也就是62500*1的向量
        answerMapping=featureMapping(xx.ravel(),yy.ravel(),6)   #进行特征映射
        answer=answerMapping@theta      #代入映射后的数据进行计算预测值
        answer=answer.reshape(xx.shape) #将answer换成一样格式
        plt.contour(xx,yy,answer,0)     #绘制等高线图,0代表绘制第一条等高线
        plt.show()
    
    
    X,y = inputData()       #导入数据
    theta=np.zeros((28,1))      #初始化theta数组
    iterations=200000       #定义迭代次数
    alpha=0.001             #定义alpha值
    lamda=100             #定义lamda
    mappingX = featureMapping(X[:,1],X[:,2],6)      #进行特征映射
    theta=gradientDescent(mappingX,y,theta,alpha,iterations,X.shape[0],lamda)   #进行正则化的梯度下降
    judge(mappingX,y,theta)         #计算预测的准确率
    evaluateLogisticRegression(X,y,theta)       #绘制决策边界
    

    结果展示:
    λ=1时的决策边界以及基于训练集的预测精确度
    在这里插入图片描述
    在这里插入图片描述
    λ=0时的决策边界以及基于训练集的预测精确度

    在这里插入图片描述
    在这里插入图片描述
    λ=100时的决策边界以及基于训练集的预测精确度
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 斯坦福大学吴恩达老师的机器学习课程几乎是每位热爱人工智能领域同学的必修。网上虽然有许多基于python实现的代码,但大多使用python交互模式解释器ipython实例讲解。本人基于自己的理解采用pycharm提供源代码及...
  • Coursera吴恩达机器学习课程作业资料_matlab版本,课程地址:https://www.coursera.org/learn/machine-learning/home/welcome,我自己写的大部分对应算法的Python版本地址:...

空空如也

空空如也

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

吴恩达机器学习课程作业