精华内容
下载资源
问答
  • 本节主要将吴恩达机器学习中的Octave教程操作用Python实现,主要内容包括: 1.基本操作(Basic Operations) 2.移动数据(Moving Data Around) 3.计算数据(Computing on Data) 4.绘图数据(Plotting Data) 5.控制...

    前言

     本节主要将吴恩达机器学习中的Octave教程操作用Python实现,主要内容包括:
     1.基本操作(Basic Operations)
     2.移动数据(Moving Data Around)
     3.计算数据(Computing on Data)
     4.绘图数据(Plotting Data)
     5.控制语句:for,while,if语句
    

    基本操作(Basic Operations)

    (一)算术运算和逻辑运算

    # 算术运算
    print("5 + 6 = %d" % (5+6))
    print("3 - 2 = %d" % (3-2))
    print("5 * 8 = %d" % (5*8))
    print("1/2 = %f" % (1/2))
    print("2^6 = %d" % (pow(2, 6)))
    
    # 逻辑运算
    print("1 & 0 = %d" % int(1&0))
    print("1 | 0 = %d" % int(1|0))
    

           运行结果

    5 + 6 = 11
    3 - 2 = 1
    5 * 8 = 40
    1/2 = 0.500000
    2^6 = 64
    1 & 0 = 0
    1 | 0 = 1
    
    

    (二)变量赋值

    import math
    import numpy as np
    
    # 变量赋值
    a = 3
    print("a = %d" % a)
    b = 'hi'
    print("b = %s" % b)
    c = (3 >= 1)
    print("c = %d" % int(c))
    
    a = math.pi
    print("pi = %f" % a)
    print("保留六位小数的pi= %.6f" % a)
    
    # 建立矩阵
    A = np.mat([[1, 2], [3, 4], [5, 6]])
    print("A = ", A)
    V = np.mat([[1], [2], [3]])
    print("V = ",  V)
    
    # 建立特殊矩阵
    A = np.ones((2, 3))
    print("A = ", A)
    B = np.zeros((2, 3))
    print("B = ", B)
    I = np.eye(6)
    print("I = ", I)
    
    C = np.random.rand(3, 3)
    print("C = ", C)
    D = np.random.randn(1, 3)
    print("D = ", D)
    

           运行结果

    a = 3
    b = hi
    c = 1
    pi = 3.141593
    保留六位小数的pi= 3.141593
    A =  [[1 2]
     [3 4]
     [5 6]]
    V =  [[1]
     [2]
     [3]]
    A =  [[1. 1. 1.]
     [1. 1. 1.]]
    B =  [[0. 0. 0.]
     [0. 0. 0.]]
    I =  [[1. 0. 0. 0. 0. 0.]
     [0. 1. 0. 0. 0. 0.]
     [0. 0. 1. 0. 0. 0.]
     [0. 0. 0. 1. 0. 0.]
     [0. 0. 0. 0. 1. 0.]
     [0. 0. 0. 0. 0. 1.]]
    C =  [[0.32699556 0.12524207 0.58057881]
     [0.64533286 0.84355689 0.77487524]
     [0.48110471 0.38639891 0.80057691]]
    D =  [[-0.91338325  0.72946901 -1.07624459]]
    

    移动数据(Moving Data Around)

    import numpy as np
    import pandas as pd
    
    # 矩阵大小
    A = np.mat([[1, 2], [3, 4], [5, 6]])
    print("矩阵A的大小为: ", A.shape)
    print("矩阵A的行数的大小为: ", A.shape[0])
    print("矩阵A的列数的大小为: ", A.shape[1])
    
    V = np.mat([1, 2, 3, 4])
    print("矩阵V的最大维度为: ", max(V.shape))
    
    # 加载数据
    path = r'C:\Users\Administrator\Desktop\ML\machine-learning-ex1\ex1\ex1data1.txt'           # 文件路径,内容为两列
    data = pd.read_csv(path, header = None, names = ['data1', 'data2'])
    print("加载的数据的大小为: ", data.shape)
    
    # 从加载的数据中裁剪一部分存储到V中
    V = data.iloc[:10, :]
    print(V)
    
    # 操作数据
    A = np.mat([[1, 2], [3, 4], [5, 6]])
    print(A[2, 1])          # 索引为(2,1)的值
    print(A[1, :])          # 第二行所有元素
    print(A[:, 1])          # 第二列所有元素
    
    A[:, 1] = [[1], [2], [3]]      # 把第二列替换掉
    B = [[10], [11], [12]]
    C = [[10, 11]]
    print(np.c_[A, B])             # 为矩阵加上列
    print(np.r_[A, C])             # 为矩阵加上行
    

           运行结果

    矩阵A的大小为:  (3, 2)
    矩阵A的行数的大小为:  3
    矩阵A的列数的大小为:  2
    矩阵V的最大维度为:  4
    加载的数据的大小为:  (97, 2)
        data1    data2
    0  6.1101  17.5920
    1  5.5277   9.1302
    2  8.5186  13.6620
    3  7.0032  11.8540
    4  5.8598   6.8233
    5  8.3829  11.8860
    6  7.4764   4.3483
    7  8.5781  12.0000
    8  6.4862   6.5987
    9  5.0546   3.8166
    6
    [[3 4]]
    [[2]
     [4]
     [6]]
    [[ 1  1 10]
     [ 3  2 11]
     [ 5  3 12]]
    [[ 1  1]
     [ 3  2]
     [ 5  3]
     [10 11]]
    

    计算数据(Computing on Data)

    import numpy as np
    import math
    
    A = np.mat([[1, 2], [3, 4], [5, 6]])
    B = np.ones((3, 2))
    C = np.mat([[1, 1], [2, 2]])
    
    print("A*C = ", np.dot(A, C))             # 直接A*B也可以
    print("A.*B = ", np.multiply(A, B))
    print(A+1)
    
    # 转置和逆
    print("矩阵A的转置为: ", A.T)
    print("矩阵A的逆为: ", A.I)
    
    print("矩阵A的最大值: ", np.max(A))
    print("矩阵A各元素之和为: ", np.sum(A))
    

           运行结果

    A*C =  [[ 5  5]
     [11 11]
     [17 17]]
    A.*B =  [[1. 2.]
     [3. 4.]
     [5. 6.]]
    [[2 3]
     [4 5]
     [6 7]]
    矩阵A的转置为:  [[1 3 5]
     [2 4 6]]
    矩阵A的逆为:  [[-1.33333333 -0.33333333  0.66666667]
     [ 1.08333333  0.33333333 -0.41666667]]
    矩阵A的最大值:  6
    矩阵A各元素之和为:  21
    

    绘图数据(Plotting Data)

    import numpy as np
    import math
    import matplotlib.pyplot as plt
    
    t = np.arange(0, 0.98, 0.01)
    
    y1 = np.sin(2*math.pi*4*t)
    y2 = np.cos(2*math.pi*4*t)
    
    plt.plot(t, y1)
    plt.plot(t, y2)
    
    plt.xlabel('time')                  # 横坐标
    plt.ylabel('value')                 # 纵坐标
    plt.legend(['sin', 'cos'])          # 标注名称
    plt.title('myplot')                 # 标题
    
    plt.show()
    

           运行结果

    在这里插入图片描述

    import numpy as np
    import math
    import matplotlib.pyplot as plt
    
    t = np.arange(0, 0.98, 0.01)
    
    y1 = np.sin(2*math.pi*4*t)
    y2 = np.cos(2*math.pi*4*t)
    
    plt.subplot(1, 2, 1)
    plt.plot(t, y1, 'r')
    plt.title('sin')
    
    plt.subplot(1, 2, 2)
    plt.plot(t, y2, 'b')
    plt.title('cos')
    
    plt.show()
    

           运行结果
    在这里插入图片描述

    控制语句:for,while,if语句

    • for,while,if语句以最简单的例子展示用法
    # if语句判断成绩
    score = 79
    if 90 < score <= 100:
        grade = '优秀'
    elif 80 < score <= 90:
        grade = '良好'
    elif 60 < score <= 80:
        grade = '一般'
    else:
        grade = '不及格'
    
    print(grade)
    
    # for语句求1到100的和
    sum = 0
    for i in range(101):
        sum += i
    print(sum)
    
    # while语句求1到100的和
    sum = 0
    i = 1
    while(i<101):
        sum += i
        i += 1
    print(sum)
    

           运行结果

    一般
    5050
    5050
    

           最后补充一下Python的函数定义,以代价函数为例:

    import numpy as np
    
    def CostFunction(X, y, theta):
        m = X.shape[0]
        predictions = X*theta
        cost = predictions - y
        sqrErrors = [[cost[i][j] ** 2 for j in range(len(cost[i]))] for i in range(len(cost))]
    
        J = 1/(2*m)*np.sum(sqrErrors)
        return J
    
    
    # 给出例子
    X = np.mat([[1, 1], [1, 2], [1, 3]])
    y = np.mat([[1], [2], [3]])
    theta = np.mat([[0], [0]])
    
    print("代价函数的结果的为 ", CostFunction(X, y, theta))
    

           运行结果

    代价函数的结果的为  2.333333333333333
    
    展开全文
  • 吴恩达机器学习编程作业machine-learning-ex1(Octave版),自己写的。
  • https://blog.csdn.net/meijie2018_1/article/details/89921499 https://blog.csdn.net/meijie2018_1/article/details/90201184
  • 语言简介python 2017年GitHub 上...octave 可以理解为matlab免费版,适合可视化仿真,快速实现算法,吴恩达在其机器学习课程中强力推荐!附上2017年GitHub流行语言排行语言对比对三种语言进行了一个基本的比较(...

    语言简介

    • python  2017年GitHub 上python超过Java位列第二,Python 近年得益于人工智能相关领域十分火爆,stormzhang在「未来五年最具前景的一门编程语言是什么?」中强力推荐!
    • octave   可以理解为matlab免费版,适合可视化仿真,快速实现算法,吴恩达在其机器学习课程中强力推荐!
    • 附上2017年GitHub流行语言排行

    语言对比

    • 对三种语言进行了一个基本的比较(表格来自lifeiaidajia)
    项目
    R语言
    Ocatave
    Python
    不需要非常高深的编程能力
    Y
    Y
    Y
    入门简单
    N
    Y
    Y
    适合处理大量数据
    N
    N
    Y
    适合算法开发
    Y
    Y
    Y
    可视化方面做得好
    Y
    Y
    N

    语言选择

    • python由于人工智能便能异常火爆说明该语言被当前IT界主流所采纳,使用python能获得超量的学习和编程资源,所以尽管python在可视化方面不如octave, 这里依然推荐使用python作为机器学习的入门语言!
    • octava类似matlab,使用过matlab的人一定能感受matlab在数值计算语法简单等方面的巨大优势,所以在入门后研究和改进算法实现时,可学习octava,用于快速验证!

    本文原创发布于微信公众号「mjautoman」,stormzhang粉丝,分享编程、生活、思维,关注并回复关键字「Python」、「「AI」等获取免费学习资料。

    版权声明:本文已在我的公众号 mjautoman原创首发,转载请务必注明出处! https://mp.csdn.net/postedit/80012253





    展开全文
  • ex2.m-Octave/MATLAB脚本,该脚本引导您完成ex2 reg.m-Octave/MATLAB脚本,用于ex2data1.txt练习的后面部分- Ex2data1.txt练习的前半部分的训练集- ex2data2.txt练习的后半部分的训练集提交。m-提交脚本,用于将您的...
  • 源 / 新智元“吴恩达的Coursera机器学习课程可以完全用Python完成!”这是Reddit论坛的机器学习看板出现一条热帖。可以说,吴恩达(Andrew Ng)的机...

    640?wx_fmt=png

    源 / 新智元

    “吴恩达的Coursera机器学习课程可以完全用Python完成!”这是Reddit论坛的机器学习看板出现一条热帖。


    可以说,吴恩达(Andrew Ng)的机器学习课程是很多人、尤其是中国学生进入机器学习世界的引路人,被认为是入门机器学习的最好课程。截至目前,有超过80000人在Coursera上完成了这门课的学习。


    640?wx_fmt=png

    吴恩达Machine Learning课的评分


    不过,这门课推荐使用Matlab/Octave来完成作业,对于不会Matlab/Octave,或者对Matlab/Octave不感兴趣的人来说,要完成作业获取证书可能难度加大。虽然吴恩达强烈推荐大家使用 Octave 来学习机器学习,并且用了完整的一个章节“Octave and Matlab Tutorial”来讲述 Octave 的基本操作。


    那么,全部用Python完成是怎么回事?Reddit用户rsdsdsr的帖子如下:


    一句话总结:吴恩达的Coursera ML课程可以用Python完成,而且你不必是Python专家就可以做到。但你需要有很好的数学基础,这将是非常耗时的,而且用Python写作业不会得到证书。”


    我最近在Coursera上完成了吴恩达的ML课程,但我没有使用推荐的Matlab/Octave,而是完全用Python来完成。你可以在这里查看我作业的Jupyter notebooks:

    https://github.com/seddonr/Ng_ML


    我绝不是第一个这样做的人,但我认为应该发这个帖子,作为给那些正在考虑参加这门课程,但像我一样对学习Matlab/Octave不感兴趣的人的鼓励,也可以了解用Python学这门课的好处和缺点。


    用Python完成这门课程非常耗时,因为这意味着我必须从头开始构建所有东西,而如果你用Matlab/Octave完成课程,则会得到大量预编写的代码。另一方面,这是一次很棒的学习经历,我学到了大量的Python技能。


    你不必成为Python专家——在完成这门课程之前,我的Python经验仅限于“使用Python自动化枯燥的东西”,以及学过一些关于NumPy和Matplotlib基础知识的非常简短的教程。但是,你需要有良好的数学基础才能跟上课程——有很多矩阵代数和微积分。


    另一个问题是,由于这门课程是为Matlab/Octave设计的,因此无法提交用Python完成的作业,所以你无法对你的作业进行评分或获得证书。证书对我来说并不重要,但如果对你很重要,那么Matlab/Octave可能是更好的选择。


    总的来说,我觉得这门课程很有趣,也很享受,我觉得它很好地覆盖了ML的许多主题。 Andrew Ng能以一种愉快的语调把知识点讲得很清楚,他的课也很容易学。如果你决定尝试用Python完成这门课程,祝你好运,我希望这个帖子是令人鼓舞的!


    Python作业代码


    rsdsdsr公开了他的作业代码:

    https://github.com/seddonr/Ng_ML


    内容:

    Ex1:线性回归

    有一个变量和多个变量。


    Ex2:逻辑回归

    包括正则化。


    Ex3: Multi-class 分类和神经网络

    使用两种不同的方法识别手写数字:one-vs-all逻辑回归,以及前向传播预训练的神经网络。


    Ex4:神经网络学习

    构建和训练神经网络,包括反向传播,并将其用于手写数字识别。


    Ex5:正则化线性回归和偏差与方差

    包括学习曲线和多项式回归。


    Ex6:支持向量机

    6.1:在一些样本2D数据集上展示scikit-learn SVM,其中包含线性和高斯核函数。

    6.2:使用自然语言处理和scikit-learn SVM构建电子邮件垃圾邮件分类器。


    Ex7:K-means聚类和主成分分析

    7.1:构建k-means聚类算法并将其用于图像压缩。 

    7.2:构建PCA算法并将其用于图像压缩和可视化。


    Ex8:异常检测和推荐系统

    8.1:使用多元高斯模型进行异常检测。 Precision, recall, F1 score.
    8.2:构建推荐系统并用它来推荐电影。


    最佳入门教程


    吴恩达在Coursera上开设的Machine Learning课程,经过数年的改进和传播,目前已有许多中文学习资料。吴恩达本人对这门课也很有感情,他曾表示自己保留斯坦福教职,很大程度上是因为想教这门课。


    这门课也是技巧和实践并重,“你不仅可以学习到学习的理论基础,还可以获得所需的实用知识,快速有效地将这些技术应用于新的问题”。课程中还将介绍了硅谷在机器学习和人工智能方面创新的一些最佳实践。本课程还将从大量的案例研究和应用中吸取教训,以便学习如何将学习算法应用于构建智能机器人(感知,控制),文本理解(网络搜索,反垃圾邮件),计算机视觉,医学信息学,音频,数据库挖掘等领域。


    主题包括:

    1、监督学习:参数/非参数算法,支持向量机,Kernels,神经网络

    2、无监督学习:聚类,降维,推荐系统,深度学习

    3、机器学习的最佳实践:偏差/方差理论;机器学习和人工智能的创新过程


    最后,该课最新一期从10月15日开始,持续约11周,2019年1月7日结束。


    640?wx_fmt=png


    课程地址:

    https://www.coursera.org/learn/machine-learning


    今日推荐

    《深度学习》

    适合各类读者阅读

    包括相关专业的大学生或研究生

    以及不具有机器学习或统计背景、但是想要快速补充深度学习知识

    以便在实际产品或平台中应用的软件工程师。


    展开全文
  • 吴恩达机器学习作业Python实现(二):logistic回归

    万次阅读 多人点赞 2018-05-08 23:25:10
    吴恩达机器学习系列作业目录 1 Logistic regression 在这部分的练习中,你将建立一个逻辑回归模型来预测一个学生是否能进入大学。假设你是一所大学的行政管理人员,你想根据两门考试的结果,来决定每个申请人...

    吴恩达机器学习系列作业目录

    1 Logistic regression

    在这部分的练习中,你将建立一个逻辑回归模型来预测一个学生是否能进入大学。假设你是一所大学的行政管理人员,你想根据两门考试的结果,来决定每个申请人是否被录取。你有以前申请人的历史数据,可以将其用作逻辑回归训练集。对于每一个训练样本,你有申请人两次测评的分数以及录取的结果。为了完成这个预测任务,我们准备构建一个可以基于两次测试评分来评估录取可能性的分类模型。

    1.1 Visualizing the data

    在开始实现任何学习算法之前,如果可能的话,最好将数据可视化。

    %matplotlib inline
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    
    data = pd.read_csv('ex2data1.txt', names=['exam1', 'exam2', 'admitted'])
    data.head()
    
    exam1exam2admitted
    034.62366078.0246930
    130.28671143.8949980
    235.84740972.9021980
    360.18259986.3085521
    479.03273675.3443761
    data.describe()
    
    exam1exam2admitted
    count100.000000100.000000100.000000
    mean65.64427466.2219980.600000
    std19.45822218.5827830.492366
    min30.05882230.6032630.000000
    25%50.91951148.1792050.000000
    50%67.03298867.6823811.000000
    75%80.21252979.3606051.000000
    max99.82785898.8694361.000000

    让我们创建两个分数的散点图,并使用颜色编码来可视化,如果样本是正的(被接纳)或负的(未被接纳)。

    positive = data[data.admitted.isin(['1'])]  # 1
    negetive = data[data.admitted.isin(['0'])]  # 0
    
    fig, ax = plt.subplots(figsize=(6,5))
    ax.scatter(positive['exam1'], positive['exam2'], c='b', label='Admitted')
    ax.scatter(negetive['exam1'], negetive['exam2'], s=50, c='r', marker='x', label='Not Admitted')
    # 设置图例显示在图的上方
    box = ax.get_position()
    ax.set_position([box.x0, box.y0, box.width , box.height* 0.8])
    ax.legend(loc='center left', bbox_to_anchor=(0.2, 1.12),ncol=3)
    # 设置横纵坐标名
    ax.set_xlabel('Exam 1 Score')
    ax.set_ylabel('Exam 2 Score')
    plt.show()
    

    image.png

    看起来在两类间,有一个清晰的决策边界。现在我们需要实现逻辑回归,那样就可以训练一个模型来预测结果。

    1.2 Sigmoid function

    首先来回顾下 logistic回归的假设函数:
    h θ ( x ) = g ( θ T x ) = 1 1 + e − θ T X {{h}_{\theta }}\left( x \right)=g(\theta^{T}x)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}} hθ(x)=g(θTx)=1+eθTX1
    其中的 g代表一个常用的logistic function为S形函数(Sigmoid function):
    g ( z ) = 1 1 + e − z g\left( z \right)=\frac{1}{1+e^{-z}} g(z)=1+ez1

    def sigmoid(z):
        return 1 / (1 + np.exp(- z))
    

    让我们做一个快速的检查,来确保它可以工作。

    x1 = np.arange(-10, 10, 0.1)
    plt.plot(x1, sigmoid(x1), c='r')
    plt.show()
    

    image.png

    感觉很不错~~~

    1.3 Cost function

    逻辑回归的代价函数如下,和线性回归的代价函数不一样,因为这个函数是凸的。

    J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − h θ ( x ( i ) ) ) ] J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{[-{{y}^{(i)}}\log \left( {{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)-\left( 1-{{y}^{(i)}} \right)\log \left( 1-{{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)]} J(θ)=m1i=1m[y(i)log(hθ(x(i)))(1y(i))log(1hθ(x(i)))]

    h θ ( x ) = g ( θ T x ) {{h}_{\theta }}\left( x \right)=g(\theta^{T}x) hθ(x)=g(θTx)

    def cost(theta, X, y):
        first = (-y) * np.log(sigmoid(X @ theta))
        second = (1 - y)*np.log(1 - sigmoid(X @ theta))
        return np.mean(first - second)
    

    现在,我们要做一些设置,获取我们的训练集数据。

    # add a ones column - this makes the matrix multiplication work out easier
    if 'Ones' not in data.columns:
        data.insert(0, 'Ones', 1)
    
    # set X (training data) and y (target variable)
    X = data.iloc[:, :-1].as_matrix()  # Convert the frame to its Numpy-array representation.
    y = data.iloc[:, -1].as_matrix()  # Return is NOT a Numpy-matrix, rather, a Numpy-array.
    
    theta = np.zeros(X.shape[1])
    

    让我们来检查矩阵的维度,确保一切良好。

    X.shape, theta.shape, y.shape
    # ((100, 3), (3,), (100,))
    
    cost(theta, X, y)
    # 0.6931471805599453
    

    看起来不错,接下来,我们需要一个函数来计算我们的训练数据、标签和一些参数thate的梯度。

    1.4 Gradient

    • 这是批量梯度下降(batch gradient descent)
    • 转化为向量化计算: 1 m X T ( S i g m o i d ( X θ ) − y ) \frac{1}{m} X^T( Sigmoid(X\theta) - y ) m1XT(Sigmoid(Xθ)y)
      ∂ J ( θ ) ∂ θ j = 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) \frac{\partial J\left( \theta \right)}{\partial {{\theta }_{j}}}=\frac{1}{m}\sum\limits_{i=1}^{m}{({{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}})x_{_{j}}^{(i)}} θjJ(θ)=m1i=1m(hθ(x(i))y(i))xj(i)
    def gradient(theta, X, y):
        return (X.T @ (sigmoid(X @ theta) - y))/len(X)  
    # the gradient of the cost is a vector of the same length as θ where the jth element (for j = 0, 1, . . . , n)
    
    gradient(theta, X, y)
    # array([ -0.1, -12.00921659, -11.26284221])
    

    1.5 Learning θ parameters

    注意,我们实际上没有在这个函数中执行梯度下降,我们仅仅在计算梯度。在练习中,一个称为“fminunc”的Octave函数是用来优化函数来计算成本和梯度参数。由于我们使用Python,我们可以用SciPy的“optimize”命名空间来做同样的事情。

    这里我们使用的是高级优化算法,运行速度通常远远超过梯度下降。方便快捷。
    只需传入cost函数,已经所求的变量theta,和梯度。cost函数定义变量时变量tehta要放在第一个,若cost函数只返回cost,则设置fprime=gradient。

    import scipy.optimize as opt
    

    这里使用fimin_tnc或者minimize方法来拟合,minimize中method可以选择不同的算法来计算,其中包括TNC

    result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
    result
    
    # (array([-25.16131867,   0.20623159,   0.20147149]), 36, 0)
    

    下面是第二种方法,结果是一样的

    res = opt.minimize(fun=cost, x0=theta, args=(X, y), method='TNC', jac=gradient)
    res
    # help(opt.minimize) 
    # res.x  # final_theta
    
         fun: 0.2034977015894744
         jac: array([9.11457705e-09, 9.59621025e-08, 4.84073722e-07])
     message: 'Local minimum reached (|pg| ~= 0)'
        nfev: 36
         nit: 17
      status: 0
     success: True
           x: array([-25.16131867,   0.20623159,   0.20147149])
    
    cost(result[0], X, y)
    

    0.2034977015894744

    1.6 Evaluating logistic regression

    学习好了参数θ后,我们来用这个模型预测某个学生是否能被录取。

    接下来,我们需要编写一个函数,用我们所学的参数theta来为数据集X输出预测。然后,我们可以使用这个函数来给我们的分类器的训练精度打分。

    逻辑回归模型的假设函数:
    \[{{h}_{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}\]
    h θ {{h}_{\theta }} hθ大于等于0.5时,预测 y=1

    h θ {{h}_{\theta }} hθ小于0.5时,预测 y=0 。

    def predict(theta, X):
        probability = sigmoid(X@theta)
        return [1 if x >= 0.5 else 0 for x in probability]  # return a list
    
    final_theta = result[0]
    predictions = predict(final_theta, X)
    correct = [1 if a==b else 0 for (a, b) in zip(predictions, y)]
    accuracy = sum(correct) / len(X)
    accuracy
    

    0.89

    可以看到我们预测精度达到了89%,not bad.

    也可以用skearn中的方法来检验。

    from sklearn.metrics import classification_report
    print(classification_report(predictions, y))
    
                 precision    recall  f1-score   support
    
              0       0.85      0.87      0.86        39
              1       0.92      0.90      0.91        61
    
    avg / total       0.89      0.89      0.89       100
    

    1.7 Decision boundary(决策边界)

    X × θ = 0 X \times \theta = 0 X×θ=0 (this is the line)

    θ 0 + x 1 θ 1 + x 2 θ 2 = 0 \theta_0 + x_1\theta_1 + x_2\theta_2=0 θ0+x1θ1+x2θ2=0

    x1 = np.arange(130, step=0.1)
    x2 = -(final_theta[0] + x1*final_theta[1]) / final_theta[2]
    
    fig, ax = plt.subplots(figsize=(8,5))
    ax.scatter(positive['exam1'], positive['exam2'], c='b', label='Admitted')
    ax.scatter(negetive['exam1'], negetive['exam2'], s=50, c='r', marker='x', label='Not Admitted')
    ax.plot(x1, x2)
    ax.set_xlim(0, 130)
    ax.set_ylim(0, 130)
    ax.set_xlabel('x1')
    ax.set_ylabel('x2')
    ax.set_title('Decision Boundary')
    plt.show()
    

    output_43_0.png

    2 Regularized logistic regression

    在训练的第二部分,我们将要通过加入正则项提升逻辑回归算法。简而言之,正则化是成本函数中的一个术语,它使算法更倾向于“更简单”的模型(在这种情况下,模型将更小的系数)。这个理论助于减少过拟合,提高模型的泛化能力。这样,我们开始吧。

    设想你是工厂的生产主管,你有一些芯片在两次测试中的测试结果。对于这两次测试,你想决定是否芯片要被接受或抛弃。为了帮助你做出艰难的决定,你拥有过去芯片的测试数据集,从其中你可以构建一个逻辑回归模型。

    2.1 Visualizing the data

    data2 = pd.read_csv('ex2data2.txt', names=['Test 1', 'Test 2', 'Accepted'])
    data2.head()
    
    Test 1Test 2Accepted
    00.0512670.699561
    1-0.0927420.684941
    2-0.2137100.692251
    3-0.3750000.502191
    4-0.5132500.465641
    def plot_data():
        positive = data2[data2['Accepted'].isin([1])]
        negative = data2[data2['Accepted'].isin([0])]
    
        fig, ax = plt.subplots(figsize=(8,5))
        ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')
        ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')
        ax.legend()
        ax.set_xlabel('Test 1 Score')
        ax.set_ylabel('Test 2 Score')
        
    plot_data()	
    

    image.png

    注意到其中的正负两类数据并没有线性的决策界限。因此直接用logistic回归在这个数据集上并不能表现良好,因为它只能用来寻找一个线性的决策边界。

    所以接下会提到一个新的方法。

    2.2 Feature mapping

    一个拟合数据的更好的方法是从每个数据点创建更多的特征。

    我们将把这些特征映射到所有的x1和x2的多项式项上,直到第六次幂。

    https://www.zhihu.com/question/65020904

    for i in 0..power
          for p in 0..i:
            output x1^(i-p) * x2^p```
    

    m a p F e a t u r e ( x ) = [ 1 x 1 x 2 x 1 2 x 1 x 2 x 2 2 x 1 3 ⋮ x 1 x 2 5 x 2 6 ] {\rm{mapFeature}}(x)=\begin{bmatrix} {1}\\ {x_1}\\ {x_2}\\ {x_1^2}\\ {x1x2}\\ {x_2^2}\\ {x_1^3}\\ \vdots\\ {x_1x_2^5}\\ {x_2^6} \end{bmatrix} mapFeature(x)=1x1x2x12x1x2x22x13x1x25x26

    def feature_mapping(x1, x2, power):
        data = {}
        for i in np.arange(power + 1):
            for p in np.arange(i + 1):
                data["f{}{}".format(i - p, p)] = np.power(x1, i - p) * np.power(x2, p)
    
    #     data = {"f{}{}".format(i - p, p): np.power(x1, i - p) * np.power(x2, p)
    #                 for i in np.arange(power + 1)
    #                 for p in np.arange(i + 1)
    #             }
        return pd.DataFrame(data)
    
    x1 = data2['Test 1'].as_matrix()
    x2 = data2['Test 2'].as_matrix()
    
    _data2 = feature_mapping(x1, x2, power=6)
    _data2.head()
    
    f00f01f02f03f04f05f06f10f11f12...f30f31f32f33f40f41f42f50f51f60
    01.00.699560.4893840.3423540.2394970.1675420.1172060.0512670.0358640.025089...0.0001350.0000940.0000660.0000460.0000070.0000050.0000033.541519e-072.477505e-071.815630e-08
    11.00.684940.4691430.3213350.2200950.1507520.103256-0.092742-0.063523-0.043509...-0.000798-0.000546-0.000374-0.0002560.0000740.0000510.000035-6.860919e-06-4.699318e-066.362953e-07
    21.00.692250.4792100.3317330.2296420.1589700.110047-0.213710-0.147941-0.102412...-0.009761-0.006757-0.004677-0.0032380.0020860.0014440.001000-4.457837e-04-3.085938e-049.526844e-05
    31.00.502190.2521950.1266500.0636020.0319400.016040-0.375000-0.188321-0.094573...-0.052734-0.026483-0.013299-0.0066790.0197750.0099310.004987-7.415771e-03-3.724126e-032.780914e-03
    41.00.465640.2168210.1009600.0470110.0218900.010193-0.513250-0.238990-0.111283...-0.135203-0.062956-0.029315-0.0136500.0693930.0323120.015046-3.561597e-02-1.658422e-021.827990e-02

    5 rows × 28 columns

    经过映射,我们将有两个特征的向量转化成了一个28维的向量。

    在这个高维特征向量上训练的logistic回归分类器将会有一个更复杂的决策边界,当我们在二维图中绘制时,会出现非线性。

    虽然特征映射允许我们构建一个更有表现力的分类器,但它也更容易过拟合。在接下来的练习中,我们将实现正则化的logistic回归来拟合数据,并且可以看到正则化如何帮助解决过拟合的问题。

    2.3 Regularized Cost function

    J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − h θ ( x ( i ) ) ) ] + λ 2 m ∑ j = 1 n θ j 2 J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{[-{{y}^{(i)}}\log \left( {{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)-\left( 1-{{y}^{(i)}} \right)\log \left( 1-{{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)]}+\frac{\lambda }{2m}\sum\limits_{j=1}^{n}{\theta _{j}^{2}} J(θ)=m1i=1m[y(i)log(hθ(x(i)))(1y(i))log(1hθ(x(i)))]+2mλj=1nθj2

    注意:不惩罚第一项 θ 0 \theta_0 θ0

    先获取特征,标签以及参数theta,确保维度良好。

    # 这里因为做特征映射的时候已经添加了偏置项,所以不用手动添加了。
    X = _data2.as_matrix()  
    y = data2['Accepted'].as_matrix()
    theta = np.zeros(X.shape[1])
    X.shape, y.shape, theta.shape  # ((118, 28), (118,), (28,))
    
    def costReg(theta, X, y, l=1):
        # 不惩罚第一项
        _theta = theta[1: ]
        reg = (l / (2 * len(X))) *(_theta @ _theta)  # _theta@_theta == inner product
        
        return cost(theta, X, y) + reg
    
    costReg(theta, X, y, l=1)  #     0.6931471805599454
    

    2.4 Regularized gradient

    因为我们未对 θ 0 {{\theta }_{0}} θ0 进行正则化,所以梯度下降算法将分两种情形:

    在这里插入图片描述

    对上面的算法中 j=1,2,…,n 时的更新式子进行调整可得:

    θ j : = θ j ( 1 − a λ m ) − a 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) {{\theta }_{j}}:={{\theta }_{j}}(1-a\frac{\lambda }{m})-a\frac{1}{m}\sum\limits_{i=1}^{m}{({{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}})x_{j}^{(i)}} θj:=θj(1amλ)am1i=1m(hθ(x(i))y(i))xj(i)

    同样不惩罚第一个θ

    def gradientReg(theta, X, y, l=1):
        reg = (1 / len(X)) * theta
        reg[0] = 0  
        return gradient(theta, X, y) + reg
    
    gradientReg(theta, X, y, 1)
    
    array([8.47457627e-03, 8.47457627e-03, 7.77711864e-05, 3.76648474e-02,
           2.34764889e-02, 3.93028171e-02, 3.10079849e-02, 3.87936363e-02,
           1.87880932e-02, 1.15013308e-02, 8.19244468e-03, 3.09593720e-03,
           4.47629067e-03, 1.37646175e-03, 5.03446395e-02, 7.32393391e-03,
           1.28600503e-02, 5.83822078e-03, 7.26504316e-03, 1.83559872e-02,
           2.23923907e-03, 3.38643902e-03, 4.08503006e-04, 3.93486234e-02,
           4.32983232e-03, 6.31570797e-03, 1.99707467e-02, 1.09740238e-03])
    

    2.5 Learning parameters

    result2 = opt.fmin_tnc(func=costReg, x0=theta, fprime=gradientReg, args=(X, y, 2))
    result2
    
    (array([ 0.57761135,  0.47056293,  1.09213933, -0.93555548, -0.15107417,
            -0.96567576, -0.49622178, -0.87226365,  0.5986215 , -0.47857791,
            -0.19652206, -0.10212812, -0.1513566 , -0.03407832, -1.868297  ,
            -0.25062387, -0.49045048, -0.20293012, -0.26033467,  0.02385201,
            -0.0290203 , -0.0543879 ,  0.01131411, -1.39767636, -0.16559351,
            -0.24745221, -0.29518657,  0.00854288]), 57, 4)
    

    我们还可以使用高级Python库scikit-learn来解决这个问题。

    from sklearn import linear_model#调用sklearn的线性回归包
    model = linear_model.LogisticRegression(penalty='l2', C=1.0)
    model.fit(X, y.ravel())
    
    LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
              verbose=0, warm_start=False)
    
    model.score(X, y)  # 0.8305084745762712
    

    2.6 Evaluating logistic regression

    final_theta = result2[0]
    predictions = predict(final_theta, X)
    correct = [1 if a==b else 0 for (a, b) in zip(predictions, y)]
    accuracy = sum(correct) / len(correct)
    accuracy
    
    0.8135593220338984
    

    或者用skearn中的方法来评估结果。

    print(classification_report(y, predictions))
    
    '''
                     precision    recall  f1-score   support
    
                  0       0.87      0.75      0.80        60
                  1       0.77      0.88      0.82        58
        
        avg / total       0.82      0.81      0.81       118
     '''
    
    

    可以看到和skearn中的模型精确度差不多,这很不错。

    2.6 Decision boundary(决策边界)

    X × θ = 0 X \times \theta = 0 X×θ=0 (this is the line)

    x = np.linspace(-1, 1.5, 250)
    xx, yy = np.meshgrid(x, x)
    
    z = feature_mapping(xx.ravel(), yy.ravel(), 6).as_matrix()
    z = z @ final_theta
    z = z.reshape(xx.shape)
    
    plot_data()
    plt.contour(xx, yy, z, 0)
    plt.ylim(-.8, 1.2)
    

    image.png

    展开全文
  • 课程地址:...我直接从Octave的基础操作开始,因为前面的内容的课堂ppt都讲的很详细了 原文链接:Octave简要语法记录 Octave是一个科学计算及数...
  • 吴恩达课程给出来的数据因为是给优化跑的,普通的梯度下降跑不出来,除非初始值设[−100,1,1][-100,1,1][−100,1,1]这样的。 import numpy as np import pandas as pd import matplotlib.pyplot as plt # 获取数据...
  • 吴恩达深度学习课后编程题讲解(python

    万次阅读 多人点赞 2017-09-25 21:05:43
    小博极其喜欢这位人工智能领域大牛,非常膜拜,早在他出机器学习的课程的时候,就对机器学习产生了...吴恩达主要成就在机器学习人工智能领域,他是人工智能机器学习领域最权威的学者之一。 2010年,时任斯坦福大
  • 详细代码参考github多类分类 Multi-class Classificaition实例:建立逻辑回归模型识别手写数字(0-9)。1.可视化数据识别的手写数字图片为2020*像素,每个像素值表示...注意: Ocatave中的reshapenumpy中的reshape有...
  • 练习链接 编程练习4:神经网络学习 ....mat格式表示数据已保存为原生Octave / MATLAB矩阵格式,而不是像csv文件那样的文本(ASCII)格式。可以使用loadmat命令将这些矩阵直接读入程序。   ex4data1.mat中有5000个训.
  • 包含吴恩达机器学习线性回归练习题及答案,使用octave编写与课程一致,答案已经根据要求填充到相应的函数文件中。
  • 吴恩达机器学习作业Python实现(六):SVM支持向量机

    千次阅读 多人点赞 2018-05-26 22:59:21
    吴恩达机器学习系列作业目录 1 Support Vector Machines 1.1 Example Dataset 1 % matplotlib inline import numpy as np import pandas as pd import matplotlib . pyplot as plt import ...
  • mail processing import nltk, nltk.stem.porter #函数定义 def processEmail(email): """做除了Word StemmingRemoval of non-words的所有处理""" email = email.lower() email = re.sub('<[^]>', ' ', email) # ...
  • 吴恩达公开课机器学习课堂作业完整版代码,使用octave练习代码,已经做过,可靠。
  • [ 5.813503 2.633656 ] [ 7.119387 3.616684 ] data: (128, 128, 3) 总结: 1、画centroids形心的移动轨迹时按照octave的流程来画不太方便,所以增加了centroids_history 来保存每次迭代的形心坐标,画起来舒服些
  • 1.载入数据权重由于给出了权重的参数,即神经网络已经训练好了,我们直接拿权重对现有的图片进行预测。载入输入数据:参考代码:defloadData(self,path):self.data=scio.loadmat(path)self.x=self.data["X"]#(5000,...
  • 详细代码解释 (1)导入文档数据+画图 (2)对数据进行预处理 (3)求取最优的theta,并计算J(θ) (4)画图查看itersJ(θ)的关系 【4】正规方程 1.涉及知识点 2.详细代码解释 (1)定义正规方程函数 (2)求出最优...
  • 对于每一个训练样本,你有他们两次测试的评分最后是被录取的结果 数据可视化 import numpy as np import pandas as pd import matplotlib.pyplot as plt #读取数据 path = 'ex2data1.txt' da
  • models = [svm.SVC(C, kernel='linear') for C in [1, 100]] # 支持向量机模型 (kernel:核函数选项,这里是线性核函数 , C:权重,这里取1100) # 线性核函数画的决策边界就是直线 clfs = [model.fit(X, y.ravel()) ...
  • Octave/Matlab 教程(python/numpy 教程)前言一...《吴恩达机器学习》是在2014年发布的,那个时候机器学习的编程语言用octave较多,但是现在几乎都是python的天下,几乎所有的机器学习框架都在python上有很好的实现...
  • 吴恩达老师的机器学习视频一直以来备受广大学习机器学习同胞们的青睐h,也是很多学者的入门必学课程。在课程中老师使用的是Matlab/Octave编程,但如今Python已经成为了机器学习最主流的编程语言,因此我想将课程中的...
  • 推荐使用python,本节略。 转载于:https://www.cnblogs.com/ys99/p/9251205.html
  • 吴恩达老师的机器学习课程,可以说是机器学习入门的第一课最热门课程,我在github开源了吴恩达机器学习个人笔记,用python复现了课程作业,成为热门项目,star数达...
  • 吴恩达机器学习课程的作业代码以及学习笔记 学习资源可以在Coursera或者网页云课堂上找到,github上也有很多的资源。 在这里我将使用python语言完成所有的作业 我们开始做吧! 同步在CSDN上发布,作业详细的博客,
  • python+octave实现代码+实验参数,很基础的一个例子,传上感觉只对小小白有用python+octave实现代码+实验参数,很基础的一个例子,传上感觉只对小小白有用python+octave实现代码+实验参数,很基础的一个例子,传上...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 668
精华内容 267
关键字:

吴恩达octave和python

python 订阅
友情链接: jbs.rar