吴恩达 订阅
吴恩达(1976-,英文名:Andrew Ng),华裔美国人,是斯坦福大学计算机科学系和电子工程系副教授,人工智能实验室主任。吴恩达是人工智能和机器学习领域国际上最权威的学者之一。吴恩达也是在线教育平台Coursera的联合创始人(with Daphne Koller)。2014年5月16日,吴恩达加入百度,担任百度公司首席科学家,负责百度研究院的领导工作,尤其是Baidu Brain计划。 [1]  2017年10月,吴恩达将出任Woebot公司新任董事长,该公司拥有一款同名聊天机器人。 [2] 展开全文
吴恩达(1976-,英文名:Andrew Ng),华裔美国人,是斯坦福大学计算机科学系和电子工程系副教授,人工智能实验室主任。吴恩达是人工智能和机器学习领域国际上最权威的学者之一。吴恩达也是在线教育平台Coursera的联合创始人(with Daphne Koller)。2014年5月16日,吴恩达加入百度,担任百度公司首席科学家,负责百度研究院的领导工作,尤其是Baidu Brain计划。 [1]  2017年10月,吴恩达将出任Woebot公司新任董事长,该公司拥有一款同名聊天机器人。 [2]
信息
职    业
计算机科学家
主要成就
人工智能和机器学习领域国际最权威学者之一
毕业院校
University of California, Berkeley
国    籍
美国
出生地
英国伦敦
博士导师
Michael I. Jordan
中文名
吴恩达
外文名
Andrew Y. Ng
出生日期
1976年
吴恩达人物经历
吴恩达1976年出生于伦敦,父亲是一位香港医生 [3]  ,英文名叫Andrew Ng,吴恩达年轻时候在香港和新加坡度过。1992年吴恩达就读新加坡莱佛士书院,并于1997年获得了卡内基梅隆大学的计算机科学学士学位。之后他在1998年获得了麻省理工学院的硕士学位,并于2002年获得了加州大学伯克利分校的博士学位,并从这年开始在斯坦福大学工作。他(2002年)住在加利福尼亚州的帕洛阿尔托。吴恩达是斯坦福大学计算机科学系和电子工程系副教授,人工智能实验室主任。吴恩达主要成就在机器学习和人工智能领域,他是人工智能和机器学习领域最权威的学者之一。2010年,时任斯坦福大学教授的吴恩达加入谷歌开发团队XLab——这个团队已先后为谷歌开发无人驾驶汽车和谷歌眼镜两个知名项目。吴恩达与谷歌顶级工程师开始合作建立全球最大的“神经网络”,这个神经网络能以与人类大脑学习新事物相同的方式来学习现实生活。谷歌将这个项目命名为“谷歌大脑”。吴恩达最知名的是,所开发的人工神经网络通过观看一周YouTube视频,自主学会识别哪些是关于猫的视频。这个案例为人工智能领域翻开崭新一页。吴恩达表示,未来将会在谷歌无人驾驶汽车上使用该项技术,来识别车前面的动物或者小孩,从而及时躲避。2014年5月16日,百度宣布吴恩达加入百度,担任百度公司首席科学家,负责百度研究院的领导工作,尤其是Baidu Brain计划。 [1]  2014年5月19日,百度宣布任命吴恩达博士为百度首席科学家,全面负责百度研究院。这是中国互联网公司迄今为止引进的最重量级人物。消息一经公布,就成为国际科技界的关注话题。美国权威杂志《麻省理工科技评论》(MIT Technology Review)甚至用充满激情的笔调对未来给予展望:“百度将领导一个创新的软件技术时代,更加了解世界。” [4]  在2019世界人工智能大会期间, Landing AI创始人、著名科学家吴恩达接受新浪科技专访,谈到了对5G、深度学习、个人数据隐私等方面的看法。在谈到深度学习时,吴恩达表示,深度学习还有很大的潜力,是一项被证明有效的技术,我们需要继续加大投入。 [5] 
收起全文
精华内容
下载资源
问答
  • 【目录】【吴恩达课后作业目录】 吴恩达深度学习相关资源下载地址(蓝奏云) 课程 周数 名称 类型 语言 地址 课程1 - 神经网络和深度学习 第1周 深度学习简介 测验 中英 传送门 无编程作业 编程作业 —— —— 第2周...
    【目录】【吴恩达课后作业目录】
    吴恩达深度学习相关资源下载地址(蓝奏云)
    课程 周数 名称 类型 语言 地址
    课程1 - 神经网络和深度学习 第1周 深度学习简介 测验 中英 传送门
    无编程作业 编程作业 —— ——
    第2周 神经网络基础 测验 中英 传送门
    具有神经网络思维的Logistic回归 编程作业 中文 传送门
    第3周 浅层神经网络 测验 中英 传送门
    带有一个隐藏层的平面数据分类 编程作业 中文 传送门
    第4周 深度神经网络的关键概念 测验 中英 传送门
    一步步搭建多层神经网络以及应用(1 & 2) 编程作业 中文 传送门
    课程2 - 改善深层神经网络 第1周 深度学习的实践 测验 中英 传送门
    初始化、正则化、梯度校验(1 & 2 & 3) 编程作业 中文 传送门
    第2周 优化算法 测验 中英 传送门
    优化算法实战 编程作业 中文 传送门
    第3周 超参数调整,批量标准化,编程框架 测验 中英 传送门
    TensorFlow入门 编程作业 中文 传送门
    课程3 - 结构化机器学习项目 第1周 和平之城中的鸟类识别(案例研究) 测验 中英 传送门
    无编程作业 编程作业 —— ——
    第2周 自动驾驶(案例研究) 测验 中英 传送门
    无编程作业 编程作业 —— ——
    课程4 - 卷积神经网络 第1周 卷积神经网络的基本知识 测验 中英 传送门
    搭建卷积神经网络模型以及应用(1&2) 编程作业 中文 传送门
    第2周 深度卷积模型 测验 中英 传送门
    Keras入门与残差网络的搭建 编程作业 中文 传送门
    第3周 检测算法 测验 中英 传送门
    车辆识别 编程作业 中文 传送门
    第4周 特殊应用:人脸识别和神经风格转换 测验 中英 传送门
    人脸识别与神经风格转换 编程作业 中文 传送门
    课程5 - 序列模型 第1周 循环神经网络 测验 中英 传送门
    搭建循环神经网络及其应用 编程作业 中文 传送门
    第2周 自然语言处理与词嵌入 测验 中英 传送门
    词向量的运算与Emoji生成器 编程作业 中文 传送门
    第3周 序列模型与注意力机制 测验 中英 传送门
    机器翻译与触发词检测 编程作业 中文 传送门
    吴恩达深度学习相关资源下载地址(蓝奏云)
    展开全文
  • 吴恩达

    千次阅读 2018-01-31 15:24:47
    吴恩达第三锤:宣布成立AI基金AIFund 原创 2018年01月31日 12:24:01 标签:吴恩达 /人工智能 676 作者 | 谷磊 吴恩达的第三个创业项目正式公布了——AIFund ,顾名思义,是一只专注...

    1.75亿美元!吴恩达第三锤:宣布成立AI基金AIFund

    原创 2018年01月31日 12:24:01

    这里写图片描述

    作者 | 谷磊

    吴恩达的第三个创业项目正式公布了——AIFund ,顾名思义,是一只专注AI领域的投资基金。

    自离职百度后,吴恩达宣布要做的三个AI 项目已经一一亮相。

    现在我们简单回顾一下这三个项目,按照时间先后依次为:

    deeplearning.ai:致力于传播AI知识(培养人才) 
    Landing.ai:致力于帮助企业AI转型,已经从制造业开始(深入应用场景) 
    AIFund:AI基金(资金支持)

    其实,现在的人工智能创业,按照稀缺程度排序恰恰就是人才、应用场景、钱,不得不说,吴老师这个闭环玩儿的666.

    AIFund

    这里写图片描述

    正式公布这个消息的时间是在北京时间1月30日晚,吴恩达通过Twitter和Medium宣布了第三个创业项目AI Fund成立的消息。吴恩达称:

    “该基金已经募集到了1.75亿美元,接下来将启动多个利用人工智能来提高人们生活质量的新项目。我们也希望能够帮助大家走进AI,并在AI驱动的社会中做出重要的工作。”

    关于基金的资金来源和管理架构,吴恩达在在公开信中表示,AIFund的投资者包括NEA,红杉,Greylock Partners和软银集团等,他将作为普通合伙人(General Partner)领导该基金,Eva Wang担任合伙人兼首席运营官,Steven Syverud也在合伙人行列。Eva曾是Fenwick&West的合伙人,她将为AIFund带来运营和法律方面的专业支持,Steven曾担任Sycamore的首席执行官,领导了Coursera Specializations的开发,他将为团队提供重要的产品和业务发展知识。

    这里写图片描述 
    Eva Wang(左)、吴恩达(中)、Steven Syverud(右)

    关于成立该基金的目的,吴恩达认为,由于六个月的时间差距就能决定一个AI创业项目的生死,所以我们设立了这个基金,以保证它们能快速展开工作。也正是这个原因,目前AIFund正在开展的3个AI驱动的新方向还不能全部公布,Landing.ai是其中之一,其余的项目要等团队准备充分以后才能公布。

    在外媒Techcrunch的报道中,吴恩达表示,开公司这件事儿,速度是关键。同时人工智能企业不同于普通的创业公司,通常情况下你都会得到一个闭环的反馈,在此基础上,哪些可以成功哪些不会成功,其实是可以做出一个快速判断的。

    吴恩达强调,在百度带领AI团队的时候,他的一部分工作就是组建团队并探索新的方向,然后评估哪些具备继续投入资源的潜力。言下之意,吴老师对这种通过开发系统的、可重复的流程来寻找AI浪潮下机遇的投资创业模式充满了信心。

    下面,营长再和大家一起回忆一下吴恩达的其余两个AI项目:

    deeplearning.ai

    2017年3月,吴恩达从百度辞职。同年8月,其第一个创业项目 deeplearning.ai 正式浮出水面。吴恩达在Medium上发表的博文中称,他一直在进行3个新的AI项目,deeplearning.ai 是第一个公布的。它致力于传播 AI 知识,并联合 Coursera 平台推出了一系列深度学习课程。这些课程将帮助学员掌握深度学习,有效应用深度学习,并在AI领域成就一番事业。

    这里写图片描述

    在课程里,吴恩达表示,学员将学会深度学习的基础,弄懂如何搭建神经网络,并掌握如何组织起一个成功的机器学习项目。

    里面的知识点包含卷积网络、RNN、LSTM、Adam、Dropout、BatchNorm、Xavier/He initialization等;还包括深度学习在医疗、自动驾驶、手语识别、音乐生成、自然语言处理等领域的真实案例,并会同英伟达的深度学习研究院(Deep Learning Institute)在一些专门的深度学习高级课题上合作,为学生的编程作业提供工业级的GPU运算。

    此外,吴恩达还采访了 Geoffrey Hinton、Yoshua Bengio、Ian Goodfellow 等机器学习界的顶级专家,请他们为初学者提供学习建议,可以说诚意满满。

    关于这门深度学习课程更详细的介绍,请参见AI科技大本营曾经发布的《刚刚,我们详细对比了吴恩达和Udacity的深度学习课程,你们感受下…》。

    ▌Landing.ai

    2017年12月,吴恩达宣布创立Landing.ai,并出任公司首席执行官。这是他离开百度后创立的第二家公司。

    这里写图片描述

    Landing.ai 旨在助力企业进行人工智能转型,吴恩达在公开信中说,我们首先会关注制造业,通过和企业建立中长期的战略伙伴关系,为企业提供战略和技术,构建人工智能解决方案,帮助企业进行结构调整,并为员工提供技术培训等等。

    吴恩达认为,IT行业打造了人类的数字化虚拟环境, 而制造业则塑造了人类的物质环境,影响几乎涉及到社会的每一个角落。 通过制造,人类的创造力超越了显示器上的像素,成为具体的物理对象。 将人工智能引入制造业,既是对物质世界进行数字化转型。

    吴恩达觉得人工智能技术非常适合解决制造业面临的挑战,如不稳定的质量及良率,生产线设计缺乏灵活性,产能管理困难以及生产成本上升。 AI可以帮助解决这些问题,改善质检流程(请看自动质检解决方案案例),缩短设计周期,消除供应链瓶颈,减少材料和能源浪费,并且提高产量。

    据吴恩达透露,Landing.ai 已经与富士康达成战略合作,合作开发基于两家公司核心竞争力的AI技术及人才培训等项目。

    关于Landing.ai 的详细介绍,请参见AI科技大本营曾经发布的《重磅 | 吴恩达又一项目Landing.ai曝光,这一次,他是要给传统制造业狠狠开刀!》。

    展开全文
  • 吴恩达课后编程作业】Course 1 - 神经网络和深度学习 - 第二周作业 - 具有神经网络思维的Logistic回归 上一篇:【课程1 - 第二周测验】※※※※※ 【回到目录】※※※※※下一篇:【课程1 - 第三周测验】 ...

    【吴恩达课后编程作业】Course 1 - 神经网络和深度学习 - 第二周作业 - 具有神经网络思维的Logistic回归


    上一篇:【课程1 - 第二周测验】※※※※※ 【回到目录】※※※※※下一篇:【课程1 - 第三周测验】

    在开始之前,首先声明本文参考【Kulbear】的github上的文章,本文参考Logistic Regression with a Neural Network mindset,我基于他的文章加以自己的理解发表这篇博客,力求让大家以最轻松的姿态理解吴恩达的视频,如有不妥的地方欢迎大家指正。


    本文所使用的资料已上传到百度网盘【点击下载】,提取码:2u3w ,请在开始之前下载好所需资料,然后将文件解压到你的代码文件同一级目录下,请确保你的代码那里有lr_utils.py和datasets文件夹。


    【博主使用的python版本:3.6.2】


    我们要做的事是搭建一个能够**【识别猫】** 的简单的神经网络,你可以跟随我的步骤在Jupyter Notebook中一步步地把代码填进去,也可以直接复制完整代码,在完整代码在本文最底部。

    在开始之前,我们有需要引入的库:

    • numpy :是用Python进行科学计算的基本软件包。
    • h5py:是与H5文件中存储的数据集进行交互的常用软件包。
    • matplotlib:是一个著名的库,用于在Python中绘制图表。
    • lr_utils :在本文的资料包里,一个加载资料包里面的数据的简单功能的库。

    如果你没有以上的库,请自行安装。

    import numpy as np
    import matplotlib.pyplot as plt
    import h5py
    from lr_utils import load_dataset
    
    

    lr_utils.py代码如下,你也可以自行打开它查看:

    import numpy as np
    import h5py
        
        
    def load_dataset():
        train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
        train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
        train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels
    
        test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
        test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
        test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels
    
        classes = np.array(test_dataset["list_classes"][:]) # the list of classes
        
        train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
        test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
        
        return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
    

    解释以下上面的load_dataset() 返回的值的含义:

    • train_set_x_orig :保存的是训练集里面的图像数据(本训练集有209张64x64的图像)。
    • train_set_y_orig :保存的是训练集的图像对应的分类值(【0 | 1】,0表示不是猫,1表示是猫)。
    • test_set_x_orig :保存的是测试集里面的图像数据(本训练集有50张64x64的图像)。
    • test_set_y_orig : 保存的是测试集的图像对应的分类值(【0 | 1】,0表示不是猫,1表示是猫)。
    • classes : 保存的是以bytes类型保存的两个字符串数据,数据为:[b’non-cat’ b’cat’]。

    现在我们就要把这些数据加载到主程序里面:

    train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset()
    

    我们可以看一下我们加载的文件里面的图片都是些什么样子的,比如我就查看一下训练集里面的第26张图片,当然你也可以改变index的值查看一下其他的图片。

    index = 25
    plt.imshow(train_set_x_orig[index])
    #print("train_set_y=" + str(train_set_y)) #你也可以看一下训练集里面的标签是什么样的。
    

    运行结果如下:
    index_25

    现在我们可以结合一下训练集里面的数据来看一下我到底都加载了一些什么东西。

    #打印出当前的训练标签值
    #使用np.squeeze的目的是压缩维度,【未压缩】train_set_y[:,index]的值为[1] , 【压缩后】np.squeeze(train_set_y[:,index])的值为1
    #print("【使用np.squeeze:" + str(np.squeeze(train_set_y[:,index])) + ",不使用np.squeeze: " + str(train_set_y[:,index]) + "】")
    #只有压缩后的值才能进行解码操作
    print("y=" + str(train_set_y[:,index]) + ", it's a " + classes[np.squeeze(train_set_y[:,index])].decode("utf-8") + "' picture")
    

    打印出的结果是:y=[1], it's a cat' picture,我们进行下一步,我们查看一下我们加载的图像数据集具体情况,我对以下参数做出解释:

    • m_train :训练集里图片的数量。
    • m_test :测试集里图片的数量。
    • num_px : 训练、测试集里面的图片的宽度和高度(均为64x64)。

    请记住,train_set_x_orig 是一个维度为(m_​​train,num_px,num_px,3)的数组。

    m_train = train_set_y.shape[1] #训练集里图片的数量。
    m_test = test_set_y.shape[1] #测试集里图片的数量。
    num_px = train_set_x_orig.shape[1] #训练、测试集里面的图片的宽度和高度(均为64x64)。
    
    #现在看一看我们加载的东西的具体情况
    print ("训练集的数量: m_train = " + str(m_train))
    print ("测试集的数量 : m_test = " + str(m_test))
    print ("每张图片的宽/高 : num_px = " + str(num_px))
    print ("每张图片的大小 : (" + str(num_px) + ", " + str(num_px) + ", 3)")
    print ("训练集_图片的维数 : " + str(train_set_x_orig.shape))
    print ("训练集_标签的维数 : " + str(train_set_y.shape))
    print ("测试集_图片的维数: " + str(test_set_x_orig.shape))
    print ("测试集_标签的维数: " + str(test_set_y.shape))
    

    运行之后的结果:

    训练集的数量: m_train = 209
    测试集的数量 : m_test = 50
    每张图片的宽/: num_px = 64
    每张图片的大小 : (64, 64, 3)
    训练集_图片的维数 : (209, 64, 64, 3)
    训练集_标签的维数 : (1, 209)
    测试集_图片的维数: (50, 64, 64, 3)
    测试集_标签的维数: (1, 50)
    

    为了方便,我们要把维度为(64,64,3)的numpy数组重新构造为(64 x 64 x 3,1)的数组,要乘以3的原因是每张图片是由64x64像素构成的,而每个像素点由(R,G,B)三原色构成的,所以要乘以3。在此之后,我们的训练和测试数据集是一个numpy数组,【每列代表一个平坦的图像】 ,应该有m_train和m_test列。

    当你想将形状(a,b,c,d)的矩阵X平铺成形状(b * c * d,a)的矩阵X_flatten时,可以使用以下代码:

    #X_flatten = X.reshape(X.shape [0],-1).T #X.T是X的转置
    #将训练集的维度降低并转置。
    train_set_x_flatten  = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
    #将测试集的维度降低并转置。
    test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
    

    这一段意思是指把数组变为209行的矩阵(因为训练集里有209张图片),但是我懒得算列有多少,于是我就用-1告诉程序你帮我算,最后程序算出来时12288列,我再最后用一个T表示转置,这就变成了12288行,209列。测试集亦如此。

    然后我们看看降维之后的情况是怎么样的:

    print ("训练集降维最后的维度: " + str(train_set_x_flatten.shape))
    print ("训练集_标签的维数 : " + str(train_set_y.shape))
    print ("测试集降维之后的维度: " + str(test_set_x_flatten.shape))
    print ("测试集_标签的维数 : " + str(test_set_y.shape))
    

    执行之后的结果为:

    训练集降维最后的维度: (12288, 209)
    训练集_标签的维数 : (1, 209)
    测试集降维之后的维度: (12288, 50)
    测试集_标签的维数 : (1, 50)
    

    为了表示彩色图像,必须为每个像素指定红色,绿色和蓝色通道(RGB),因此像素值实际上是从0到255范围内的三个数字的向量。机器学习中一个常见的预处理步骤是对数据集进行居中和标准化,这意味着可以减去每个示例中整个numpy数组的平均值,然后将每个示例除以整个numpy数组的标准偏差。但对于图片数据集,它更简单,更方便,几乎可以将数据集的每一行除以255(像素通道的最大值),因为在RGB中不存在比255大的数据,所以我们可以放心的除以255,让标准化的数据位于[0,1]之间,现在标准化我们的数据集:

    train_set_x = train_set_x_flatten / 255
    test_set_x = test_set_x_flatten / 255
    

    flatten


    现在总算是把我们加载的数据弄完了,我们现在开始构建神经网络。

    以下是数学表达式,如果对数学公式不甚理解,请仔细看一下吴恩达的视频。

    对于 x(i)x^{(i)}: z(i)=wTx(i)+b(1)z^{(i)} = w^T x^{(i)} + b \tag{1}y^(i)=a(i)=sigmoid(z(i))(2)\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\tag{2}L(a(i),y(i))=y(i)log(a(i))(1y(i))log(1a(i))(3) \mathcal{L}(a^{(i)}, y^{(i)}) = - y^{(i)} \log(a^{(i)}) - (1-y^{(i)} ) \log(1-a^{(i)})\tag{3}

    然后通过对所有训练样例求和来计算成本: J=1mi=1mL(a(i),y(i))(4) J = \frac{1}{m} \sum_{i=1}^m \mathcal{L}(a^{(i)}, y^{(i)})\tag{4}

    建立神经网络的主要步骤是:

    1. 定义模型结构(例如输入特征的数量)

    2. 初始化模型的参数

    3. 循环:

      3.1 计算当前损失(正向传播)

      3.2 计算当前梯度(反向传播)

      3.3 更新参数(梯度下降)

    现在构建sigmoid(),需要使用 sigmoid(w ^ T x + b) 计算来做出预测。

    def sigmoid(z):
        """
        参数:
            z  - 任何大小的标量或numpy数组。
        
        返回:
            s  -  sigmoid(z)
        """
        s = 1 / (1 + np.exp(-z))
        return s
    

    我们可以测试一下sigmoid(),检查一下是否符合我们所需要的条件。

    #测试sigmoid()
    print("====================测试sigmoid====================")
    print ("sigmoid(0) = " + str(sigmoid(0)))
    print ("sigmoid(9.2) = " + str(sigmoid(9.2)))
    

    打印出的结果为:

    ====================测试sigmoid====================
    sigmoid(0) = 0.5
    sigmoid(9.2) = 0.999898970806
    

    既然sigmoid测试好了,我们现在就可以初始化我们需要的参数w和b了。

    def initialize_with_zeros(dim):
        """
            此函数为w创建一个维度为(dim,1)的0向量,并将b初始化为0。
            
            参数:
                dim  - 我们想要的w矢量的大小(或者这种情况下的参数数量)
            
            返回:
                w  - 维度为(dim,1)的初始化向量。
                b  - 初始化的标量(对应于偏差)
        """
        w = np.zeros(shape = (dim,1))
        b = 0
        #使用断言来确保我要的数据是正确的
        assert(w.shape == (dim, 1)) #w的维度是(dim,1)
        assert(isinstance(b, float) or isinstance(b, int)) #b的类型是float或者是int
        
        return (w , b)
    

    初始化参数的函数已经构建好了,现在就可以执行“前向”和“后向”传播步骤来学习参数。

    我们现在要实现一个计算成本函数及其渐变的函数propagate()。

    def propagate(w, b, X, Y):
    	"""
        实现前向和后向传播的成本函数及其梯度。
        参数:
            w  - 权重,大小不等的数组(num_px * num_px * 3,1)
            b  - 偏差,一个标量
            X  - 矩阵类型为(num_px * num_px * 3,训练数量)
            Y  - 真正的“标签”矢量(如果非猫则为0,如果是猫则为1),矩阵维度为(1,训练数据数量)
    
        返回:
            cost- 逻辑回归的负对数似然成本
            dw  - 相对于w的损失梯度,因此与w相同的形状
            db  - 相对于b的损失梯度,因此与b的形状相同
        """
    	m = X.shape[1]
        
        #正向传播
        A = sigmoid(np.dot(w.T,X) + b) #计算激活值,请参考公式2。
        cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) #计算成本,请参考公式3和4。
        
        #反向传播
        dw = (1 / m) * np.dot(X, (A - Y).T) #请参考视频中的偏导公式。
        db = (1 / m) * np.sum(A - Y) #请参考视频中的偏导公式。
    	
    	#使用断言确保我的数据是正确的
        assert(dw.shape == w.shape)
        assert(db.dtype == float)
        cost = np.squeeze(cost)
        assert(cost.shape == ())
        
        #创建一个字典,把dw和db保存起来。
        grads = {
                    "dw": dw,
                    "db": db
                 }
        return (grads , cost)
    

    写好之后我们来测试一下。

    #测试一下propagate
    print("====================测试propagate====================")
    #初始化一些参数
    w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])
    grads, cost = propagate(w, b, X, Y)
    print ("dw = " + str(grads["dw"]))
    print ("db = " + str(grads["db"]))
    print ("cost = " + str(cost))
    

    测试结果是:

    ====================测试propagate====================
    dw = [[ 0.99993216]
     [ 1.99980262]]
    db = 0.499935230625
    cost = 6.00006477319
    

    现在,我要使用渐变下降更新参数。

    目标是通过最小化成本函数 JJ 来学习 wwbb 。对于参数 θ\theta ,更新规则是 $ \theta = \theta - \alpha \text{ } d\theta$,其中 α\alpha 是学习率。

    def optimize(w , b , X , Y , num_iterations , learning_rate , print_cost = False):
        """
        此函数通过运行梯度下降算法来优化w和b
        
        参数:
            w  - 权重,大小不等的数组(num_px * num_px * 3,1)
            b  - 偏差,一个标量
            X  - 维度为(num_px * num_px * 3,训练数据的数量)的数组。
            Y  - 真正的“标签”矢量(如果非猫则为0,如果是猫则为1),矩阵维度为(1,训练数据的数量)
            num_iterations  - 优化循环的迭代次数
            learning_rate  - 梯度下降更新规则的学习率
            print_cost  - 每100步打印一次损失值
        
        返回:
            params  - 包含权重w和偏差b的字典
            grads  - 包含权重和偏差相对于成本函数的梯度的字典
            成本 - 优化期间计算的所有成本列表,将用于绘制学习曲线。
        
        提示:
        我们需要写下两个步骤并遍历它们:
            1)计算当前参数的成本和梯度,使用propagate()。
            2)使用w和b的梯度下降法则更新参数。
        """
        
        costs = []
        
        for i in range(num_iterations):
            
            grads, cost = propagate(w, b, X, Y)
            
            dw = grads["dw"]
            db = grads["db"]
            
            w = w - learning_rate * dw
            b = b - learning_rate * db
            
            #记录成本
            if i % 100 == 0:
                costs.append(cost)
            #打印成本数据
            if (print_cost) and (i % 100 == 0):
                print("迭代的次数: %i , 误差值: %f" % (i,cost))
            
        params  = {
                    "w" : w,
                    "b" : b }
        grads = {
                "dw": dw,
                "db": db } 
        return (params , grads , costs)
    

    现在就让我们来测试一下优化函数:

    #测试optimize
    print("====================测试optimize====================")
    w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])
    params , grads , costs = optimize(w , b , X , Y , num_iterations=100 , learning_rate = 0.009 , print_cost = False)
    print ("w = " + str(params["w"]))
    print ("b = " + str(params["b"]))
    print ("dw = " + str(grads["dw"]))
    print ("db = " + str(grads["db"]))
    

    测试结果为:

    ====================测试optimize====================
    w = [[ 0.1124579 ]
     [ 0.23106775]]
    b = 1.55930492484
    dw = [[ 0.90158428]
     [ 1.76250842]]
    db = 0.430462071679
    

    optimize函数会输出已学习的w和b的值,我们可以使用w和b来预测数据集X的标签。

    现在我们要实现预测函数predict()。计算预测有两个步骤:

    1. 计算 Y^=A=σ(wTX+b)\hat{Y} = A = \sigma(w^T X + b)

    2. 将a的值变为0(如果激活值<= 0.5)或者为1(如果激活值> 0.5),

    然后将预测值存储在向量Y_prediction中。

    def predict(w , b , X ):
        """
        使用学习逻辑回归参数logistic (w,b)预测标签是0还是1,
        
        参数:
            w  - 权重,大小不等的数组(num_px * num_px * 3,1)
            b  - 偏差,一个标量
            X  - 维度为(num_px * num_px * 3,训练数据的数量)的数据
        
        返回:
            Y_prediction  - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组(向量)
        
        """
        
        m  = X.shape[1] #图片的数量
        Y_prediction = np.zeros((1,m)) 
        w = w.reshape(X.shape[0],1)
        
        #计预测猫在图片中出现的概率
        A = sigmoid(np.dot(w.T , X) + b)
        for i in range(A.shape[1]):
            #将概率a [0,i]转换为实际预测p [0,i]
            Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0
        #使用断言
        assert(Y_prediction.shape == (1,m))
        
        return Y_prediction
    

    老规矩,测试一下。

    #测试predict
    print("====================测试predict====================")
    w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])
    print("predictions = " + str(predict(w, b, X)))
    

    就目前而言,我们基本上把所有的东西都做完了,现在我们要把这些函数统统整合到一个model()函数中,届时只需要调用一个model()就基本上完成所有的事了。

    def model(X_train , Y_train , X_test , Y_test , num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):
        """
        通过调用之前实现的函数来构建逻辑回归模型
        
        参数:
            X_train  - numpy的数组,维度为(num_px * num_px * 3,m_train)的训练集
            Y_train  - numpy的数组,维度为(1,m_train)(矢量)的训练标签集
            X_test   - numpy的数组,维度为(num_px * num_px * 3,m_test)的测试集
            Y_test   - numpy的数组,维度为(1,m_test)的(向量)的测试标签集
            num_iterations  - 表示用于优化参数的迭代次数的超参数
            learning_rate  - 表示optimize()更新规则中使用的学习速率的超参数
            print_cost  - 设置为true以每100次迭代打印成本
        
        返回:
            d  - 包含有关模型信息的字典。
        """
        w , b = initialize_with_zeros(X_train.shape[0])
        
        parameters , grads , costs = optimize(w , b , X_train , Y_train,num_iterations , learning_rate , print_cost)
        
        #从字典“参数”中检索参数w和b
        w , b = parameters["w"] , parameters["b"]
        
        #预测测试/训练集的例子
        Y_prediction_test = predict(w , b, X_test)
        Y_prediction_train = predict(w , b, X_train)
        
        #打印训练后的准确性
        print("训练集准确性:"  , format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100) ,"%")
        print("测试集准确性:"  , format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100) ,"%")
        
        d = {
                "costs" : costs,
                "Y_prediction_test" : Y_prediction_test,
                "Y_prediciton_train" : Y_prediction_train,
                "w" : w,
                "b" : b,
                "learning_rate" : learning_rate,
                "num_iterations" : num_iterations }
        return d
    

    把整个model构建好之后我们这就算是正式的实际测试了,我们这就来实际跑一下。

    print("====================测试model====================")     
    #这里加载的是真实的数据,请参见上面的代码部分。
    d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)
    

    执行后的数据:

    ====================测试model====================
    迭代的次数: 0 , 误差值: 0.693147
    迭代的次数: 100 , 误差值: 0.584508
    迭代的次数: 200 , 误差值: 0.466949
    迭代的次数: 300 , 误差值: 0.376007
    迭代的次数: 400 , 误差值: 0.331463
    迭代的次数: 500 , 误差值: 0.303273
    迭代的次数: 600 , 误差值: 0.279880
    迭代的次数: 700 , 误差值: 0.260042
    迭代的次数: 800 , 误差值: 0.242941
    迭代的次数: 900 , 误差值: 0.228004
    迭代的次数: 1000 , 误差值: 0.214820
    迭代的次数: 1100 , 误差值: 0.203078
    迭代的次数: 1200 , 误差值: 0.192544
    迭代的次数: 1300 , 误差值: 0.183033
    迭代的次数: 1400 , 误差值: 0.174399
    迭代的次数: 1500 , 误差值: 0.166521
    迭代的次数: 1600 , 误差值: 0.159305
    迭代的次数: 1700 , 误差值: 0.152667
    迭代的次数: 1800 , 误差值: 0.146542
    迭代的次数: 1900 , 误差值: 0.140872
    训练集准确性: 99.04306220095694 %
    测试集准确性: 70.0 %
    

    我们更改一下学习率和迭代次数,有可能会发现训练集的准确性可能会提高,但是测试集准确性会下降,这是由于过拟合造成的,但是我们并不需要担心,我们以后会使用更好的算法来解决这些问题的。


    到目前为止,我们的程序算是完成了,但是,我们可以在后面加一点东西,比如画点图什么的。

    #绘制图
    costs = np.squeeze(d['costs'])
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (per hundreds)')
    plt.title("Learning rate =" + str(d["learning_rate"]))
    plt.show()
    

    跑一波出来的效果图是这样的,可以看到成本下降,它显示参数正在被学习:
    pic

    让我们进一步分析一下,并研究学习率alpha的可能选择。为了让渐变下降起作用,我们必须明智地选择学习速率。学习率α\alpha 决定了我们更新参数的速度。如果学习率过高,我们可能会“超过”最优值。同样,如果它太小,我们将需要太多迭代才能收敛到最佳值。这就是为什么使用良好调整的学习率至关重要的原因。

    我们可以比较一下我们模型的学习曲线和几种学习速率的选择。也可以尝试使用不同于我们初始化的learning_rates变量包含的三个值,并看一下会发生什么。

    learning_rates = [0.01, 0.001, 0.0001]
    models = {}
    for i in learning_rates:
        print ("learning rate is: " + str(i))
        models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
        print ('\n' + "-------------------------------------------------------" + '\n')
    
    for i in learning_rates:
        plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))
    
    plt.ylabel('cost')
    plt.xlabel('iterations')
    
    legend = plt.legend(loc='upper center', shadow=True)
    frame = legend.get_frame()
    frame.set_facecolor('0.90')
    plt.show()
    

    跑一下打印出来的结果是:

    learning rate is: 0.01
    训练集准确性: 99.52153110047847 %
    测试集准确性: 68.0 %
    
    -------------------------------------------------------
    
    learning rate is: 0.001
    训练集准确性: 88.99521531100478 %
    测试集准确性: 64.0 %
    
    -------------------------------------------------------
    
    learning rate is: 0.0001
    训练集准确性: 68.42105263157895 %
    测试集准确性: 36.0 %
    
    -------------------------------------------------------
    

    pic2


    **【完整代码】: **

    # -*- coding: utf-8 -*-
    """
    Created on Wed Mar 21 17:25:30 2018
    
    博客地址 :http://blog.csdn.net/u013733326/article/details/79639509
    
    @author: Oscar
    """
    
    import numpy as np
    import matplotlib.pyplot as plt
    import h5py
    from lr_utils import load_dataset
    
    train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset()
    
    m_train = train_set_y.shape[1] #训练集里图片的数量。
    m_test = test_set_y.shape[1] #测试集里图片的数量。
    num_px = train_set_x_orig.shape[1] #训练、测试集里面的图片的宽度和高度(均为64x64)。
    
    #现在看一看我们加载的东西的具体情况
    print ("训练集的数量: m_train = " + str(m_train))
    print ("测试集的数量 : m_test = " + str(m_test))
    print ("每张图片的宽/高 : num_px = " + str(num_px))
    print ("每张图片的大小 : (" + str(num_px) + ", " + str(num_px) + ", 3)")
    print ("训练集_图片的维数 : " + str(train_set_x_orig.shape))
    print ("训练集_标签的维数 : " + str(train_set_y.shape))
    print ("测试集_图片的维数: " + str(test_set_x_orig.shape))
    print ("测试集_标签的维数: " + str(test_set_y.shape))
    
    #将训练集的维度降低并转置。
    train_set_x_flatten  = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
    #将测试集的维度降低并转置。
    test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
    
    print ("训练集降维最后的维度: " + str(train_set_x_flatten.shape))
    print ("训练集_标签的维数 : " + str(train_set_y.shape))
    print ("测试集降维之后的维度: " + str(test_set_x_flatten.shape))
    print ("测试集_标签的维数 : " + str(test_set_y.shape))
    
    train_set_x = train_set_x_flatten / 255
    test_set_x = test_set_x_flatten / 255
    
    def sigmoid(z):
        """
        参数:
            z  - 任何大小的标量或numpy数组。
    
        返回:
            s  -  sigmoid(z)
        """
        s = 1 / (1 + np.exp(-z))
        return s
    
    def initialize_with_zeros(dim):
        """
            此函数为w创建一个维度为(dim,1)的0向量,并将b初始化为0。
    
            参数:
                dim  - 我们想要的w矢量的大小(或者这种情况下的参数数量)
    
            返回:
                w  - 维度为(dim,1)的初始化向量。
                b  - 初始化的标量(对应于偏差)
        """
        w = np.zeros(shape = (dim,1))
        b = 0
        #使用断言来确保我要的数据是正确的
        assert(w.shape == (dim, 1)) #w的维度是(dim,1)
        assert(isinstance(b, float) or isinstance(b, int)) #b的类型是float或者是int
    
        return (w , b)
    
    def propagate(w, b, X, Y):
        """
        实现前向和后向传播的成本函数及其梯度。
        参数:
            w  - 权重,大小不等的数组(num_px * num_px * 3,1)
            b  - 偏差,一个标量
            X  - 矩阵类型为(num_px * num_px * 3,训练数量)
            Y  - 真正的“标签”矢量(如果非猫则为0,如果是猫则为1),矩阵维度为(1,训练数据数量)
    
        返回:
            cost- 逻辑回归的负对数似然成本
            dw  - 相对于w的损失梯度,因此与w相同的形状
            db  - 相对于b的损失梯度,因此与b的形状相同
        """
        m = X.shape[1]
    
        #正向传播
        A = sigmoid(np.dot(w.T,X) + b) #计算激活值,请参考公式2。
        cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) #计算成本,请参考公式3和4。
    
        #反向传播
        dw = (1 / m) * np.dot(X, (A - Y).T) #请参考视频中的偏导公式。
        db = (1 / m) * np.sum(A - Y) #请参考视频中的偏导公式。
    
        #使用断言确保我的数据是正确的
        assert(dw.shape == w.shape)
        assert(db.dtype == float)
        cost = np.squeeze(cost)
        assert(cost.shape == ())
    
        #创建一个字典,把dw和db保存起来。
        grads = {
                    "dw": dw,
                    "db": db
                 }
        return (grads , cost)
    
    def optimize(w , b , X , Y , num_iterations , learning_rate , print_cost = False):
        """
        此函数通过运行梯度下降算法来优化w和b
    
        参数:
            w  - 权重,大小不等的数组(num_px * num_px * 3,1)
            b  - 偏差,一个标量
            X  - 维度为(num_px * num_px * 3,训练数据的数量)的数组。
            Y  - 真正的“标签”矢量(如果非猫则为0,如果是猫则为1),矩阵维度为(1,训练数据的数量)
            num_iterations  - 优化循环的迭代次数
            learning_rate  - 梯度下降更新规则的学习率
            print_cost  - 每100步打印一次损失值
    
        返回:
            params  - 包含权重w和偏差b的字典
            grads  - 包含权重和偏差相对于成本函数的梯度的字典
            成本 - 优化期间计算的所有成本列表,将用于绘制学习曲线。
    
        提示:
        我们需要写下两个步骤并遍历它们:
            1)计算当前参数的成本和梯度,使用propagate()。
            2)使用w和b的梯度下降法则更新参数。
        """
    
        costs = []
    
        for i in range(num_iterations):
    
            grads, cost = propagate(w, b, X, Y)
    
            dw = grads["dw"]
            db = grads["db"]
    
            w = w - learning_rate * dw
            b = b - learning_rate * db
    
            #记录成本
            if i % 100 == 0:
                costs.append(cost)
            #打印成本数据
            if (print_cost) and (i % 100 == 0):
                print("迭代的次数: %i , 误差值: %f" % (i,cost))
    
        params  = {
                    "w" : w,
                    "b" : b }
        grads = {
                "dw": dw,
                "db": db } 
        return (params , grads , costs)
    
    def predict(w , b , X ):
        """
        使用学习逻辑回归参数logistic (w,b)预测标签是0还是1,
    
        参数:
            w  - 权重,大小不等的数组(num_px * num_px * 3,1)
            b  - 偏差,一个标量
            X  - 维度为(num_px * num_px * 3,训练数据的数量)的数据
    
        返回:
            Y_prediction  - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组(向量)
    
        """
    
        m  = X.shape[1] #图片的数量
        Y_prediction = np.zeros((1,m)) 
        w = w.reshape(X.shape[0],1)
    
        #计预测猫在图片中出现的概率
        A = sigmoid(np.dot(w.T , X) + b)
        for i in range(A.shape[1]):
            #将概率a [0,i]转换为实际预测p [0,i]
            Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0
        #使用断言
        assert(Y_prediction.shape == (1,m))
    
        return Y_prediction
    
    def model(X_train , Y_train , X_test , Y_test , num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):
        """
        通过调用之前实现的函数来构建逻辑回归模型
    
        参数:
            X_train  - numpy的数组,维度为(num_px * num_px * 3,m_train)的训练集
            Y_train  - numpy的数组,维度为(1,m_train)(矢量)的训练标签集
            X_test   - numpy的数组,维度为(num_px * num_px * 3,m_test)的测试集
            Y_test   - numpy的数组,维度为(1,m_test)的(向量)的测试标签集
            num_iterations  - 表示用于优化参数的迭代次数的超参数
            learning_rate  - 表示optimize()更新规则中使用的学习速率的超参数
            print_cost  - 设置为true以每100次迭代打印成本
    
        返回:
            d  - 包含有关模型信息的字典。
        """
        w , b = initialize_with_zeros(X_train.shape[0])
    
        parameters , grads , costs = optimize(w , b , X_train , Y_train,num_iterations , learning_rate , print_cost)
    
        #从字典“参数”中检索参数w和b
        w , b = parameters["w"] , parameters["b"]
    
        #预测测试/训练集的例子
        Y_prediction_test = predict(w , b, X_test)
        Y_prediction_train = predict(w , b, X_train)
    
        #打印训练后的准确性
        print("训练集准确性:"  , format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100) ,"%")
        print("测试集准确性:"  , format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100) ,"%")
    
        d = {
                "costs" : costs,
                "Y_prediction_test" : Y_prediction_test,
                "Y_prediciton_train" : Y_prediction_train,
                "w" : w,
                "b" : b,
                "learning_rate" : learning_rate,
                "num_iterations" : num_iterations }
        return d
    
    d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)
    
    #绘制图
    costs = np.squeeze(d['costs'])
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (per hundreds)')
    plt.title("Learning rate =" + str(d["learning_rate"]))
    plt.show()
    
    展开全文
  • 吴恩达 Coursera DeepLearning.ai《深度学习》系列课程笔记目录总集

    作者大树先生
    博客http://blog.csdn.net/koala_tree
    知乎https://www.zhihu.com/people/dashuxiansheng
    GitHubhttps://github.com/MrLeeTree
    2018 年 4 月 5 日


    本文发布在知乎的专栏中,为了方便习惯使用CSDN的用户,更改了下面文章的直链到CSDN中的笔记。
    同时,也欢迎大家关注我的知乎:大树先生,会不定期有新的干货更新。一起学习一起进步呀!_


    DeepLearning.ai简介

    deepLearning.ai 是由吴恩达在Coursera上推出的一个教授深度学习的专题系列课程。整个专题共包括五门课程:01.神经网络和深度学习;02.改善深层神经网络-超参数调试、正则化以及优化;03.结构化机器学习项目;04.卷积神经网络;05.序列模型。

    课程描述:

    请允许我引用官网的介绍:

    如果你想进入人工智能,这个课程专题将会给你带来帮助。深度学习是科技领域最受追捧的技能之一,我们将帮助你进行学习这些知识。
    在五门课程中,你将学习深度学习的基础知识,了解如何构建神经网络,并学习如何实践机器学习项目,学习卷积网络,RNN,LSTM,Adam,Dropout,BatchNorm,Xavier/He初始化等等。你将从事医疗,自动驾驶,手语阅读,音乐创作和自然语言处理的案例研究。届时,你不但会掌握深度学习的基础理论,还会看到它在工业中的应用。上面的这些想法都将在Python和TensorFlow的练习中所实现。另外,你还将听到许多深度学习的高层领导,他们将与你分享他们的个人故事,并为你提供职业建议。
    AI正在对各行各业产生着巨大的影响,在完成此专题的课程后,你可能会找到创造性的方法将其应用到你的工作中。我们将帮助你掌握深度学习,了解如何使用它,帮助你建立AI的职业生涯。

    课程内容:

    • Coursera:官方课程安排(英文字幕)。付费用户在课程作业中可以获得作业评分,每门课程修完可获得结课证书;不付费可以免费上课、做课后作业,但没有作业评分,结课无法获得课程证书。
    • 网易云课堂:网易引进的正版授权(中英文字幕)。课程完全免费,但没有课后作业,没有课程证书。

    推荐指数:

    4.5 星(个人意见)
    目前已有的深度学习课程中难得的好课程。

    个人提炼笔记及编程作业总集

    下面是个人在上课的过程中,从中提炼的要点笔记,以及自己完成的课后编程作业。课程为主,练习为辅,笔记做巩固。所以建议大家以这样的核心思想来进行这门课程的学习。废话不多说,上笔记!


    01. 神经网络和深度学习

    • 神经网络概论
    • 主要介绍:神经网络的概念、深度学习兴起的原因、课程内容等;
    • 笔记:介绍性课程,没有做相应的笔记。
    • 编程作业:无
    • 神经网络基础
    • 浅层神经网络
    • 深层神经网络

    02. 改善深层神经网络:超参数调试、正则化以及优化

    • 深度学习的实践方面
    • 优化算法
    • 超参数调试和Batch Norm及框架

    03. 结构化机器学习项目

    • 机器学习策略(1)
    • 机器学习策略(2)

    04. 卷积神经网络

    • 卷积神经网络基础
    • 卷积神经网络实例模型
    • 目标检测
    • 特殊应用:人脸识别和神经风格迁移

    05. 序列模型

    • 循环神经网络
    • 自然语言处理和词嵌入
    • 序列模型和注意力机制

    总结

    整个专题课程的学习跨度比较长,在上课的过程中不断地思考做笔记的过程也确实缓慢而辛苦,但一路下来确实有了很大的收获。期初只是为了做一个自己后期进行复习的笔记,但后来感觉记录的笔记还算整洁,所以就放到知乎上和大家一起分享,希望我的这些能够给更多有同样需求的同学和朋友们带来小小的帮助。

    最后

    笔记属于课程的提炼,虽然总体来说已经较为全面了,但限于个人的能力和精力,笔记中难免会出现遗漏或者错误的地方。如果大家在阅读笔记的时候,发现了错误的地方以及觉得比较重要但我没有记录的内容,那么欢迎大家在下方评论留言或者私信给我,我将会及时做更正和补充,感谢支持。

    最后,感谢每位点赞的知友。同时,也欢迎其他平台的转载和分享,一起进步呀_!

    展开全文
  • 吴恩达课后编程作业】Course 1 - 神经网络和深度学习 - 第三周作业 - 带有一个隐藏层的平面数据分类 上一篇:【 课程1 - 第三周测验】※※※※※ 【回到目录】※※※※※下一篇:【课程1 - 第四周测验】 ...
  • 吴恩达 machine learning

    2018-05-04 18:24:53
    吴恩达 machine learning 公开课讲义 吴恩达 machine learning 公开课讲义 吴恩达 machine learning 公开课讲义 吴恩达 machine learning 公开课讲义
  • 吴恩达机器学习课件

    2018-05-15 14:18:47
    吴恩达机器学习课件吴恩达机器学习课件吴恩达机器学习课件吴恩达机器学习课件吴恩达机器学习课件
  • 吴恩达机器学习资料

    2018-05-30 11:36:39
    吴恩达机器学习资料 吴恩达机器学习资料吴恩达机器学习资料吴恩达机器学习资料
  • 吴恩达机器学习讲义

    2017-09-25 22:06:13
    吴恩达机器学习讲义; 吴恩达机器学习讲义; 吴恩达机器学习讲义; 吴恩达机器学习讲义; 吴恩达机器学习讲义
  • 斯坦福大学吴恩达机器学习课程 完整学习笔记+原始版讲义 全是高清版的ppt该课件为中科院一位仁兄在学习斯坦福大学吴恩达机器学习课程时候所做的学习笔记,非常好,吴老师上课略过的一些内容笔记都详细给出,并且还做...
  • 吴恩达machine learning

    2019-03-06 20:33:40
    此文件为吴恩达机器学习8个实验的代码,matlab格式的。结合吴恩达机器学习课程视频使用更佳。
  • 吴恩达机器学习与深度学习作业目录 [图片已修复]

    万次阅读 多人点赞 2018-10-23 10:03:59
    吴恩达机器学习作业目录 1 吴恩达机器学习作业Python实现(一):线性回归 2 吴恩达机器学习作业Python实现(二):logistic回归 3 吴恩达机器学习作业Python实现(三):多类分类和前馈神经网络 4 吴恩达机器学习作业...
  • 吴恩达机器学习

    2017-11-15 14:07:48
    吴恩达 机器学习上课时的课件笔记,可以配合吴恩达的视频看
  • 吴恩达作业答案

    2018-03-09 17:48:24
    吴恩达主讲机器学习网易公开课内容吴恩达主讲机器学习部分第一讲Python编程部分答案共享
  • 吴恩达深度学习课程笔记;吴恩达深度学习课程笔记;吴恩达深度学习课程笔记;吴恩达深度学习课程笔记
  • 吴恩达NLP课程资料

    万次阅读 2020-12-08 14:16:10
    吴恩达老师在2020年6月份推出了NLP课程,Natural Language Processing Specialization  本人忙里偷闲将老师的视频和作业都完成了,后续会持续更新课程的资料和作业。目前NLP课程一共分为四门,每门课程会分为三...
  • 吴恩达机器学习编程作业,吴恩达机器学习编程作业,吴恩达机器学习编程作业,吴恩达机器学习编程作业。含有8个作业
  • 机器学习吴恩达视频mp4 机器学习吴恩达视频mp4 机器学习吴恩达视频mp4
  • 这几天把吴恩达机器学习的视频看了下,都是很基础的,很适合入门视频链接:网易云课堂-吴恩达机器学习配套讲解链接:第一节 第二节 第三节 第四节 第五节入门的话每天看一节就可以,用到的知识也都很基础(微...
  • 吴恩达深度学习课程概念(notation)对照表 吴恩达深度学习课程概念(notation)对照表 吴恩达深度学习课程概念(notation)对照表 吴恩达深度学习课程概念(notation)对照表 吴恩达深度学习课程概念(notation)对照表
  • 吴恩达UFLDL教程

    2019-01-06 17:00:02
    吴恩达的深度学习的入门资料,内容详实易懂,简单易学。
  • 吴恩达机器学习笔记

    2018-11-07 11:23:56
    吴恩达老师斯坦福cs231机器学习笔记详细整理,包含吴恩达老师课程详细讲解,是入门机器学习的必备资源
  • 吴恩达视频

    2019-07-17 10:07:47
    吴恩达视频
  • 吴恩达Deep Learning

    2018-09-04 21:07:26
    吴恩达深度学习课程的英文讲义,简单易懂,结合视频课程很方便

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,679
精华内容 11,071
关键字:

吴恩达