五节课从零起步(无需数学和Python基础)编码实现AI人工智能框架电子书V1_人工智能课程无数学基础

作者：小小林熬夜学编程 | 2024-05-23 06:50:36

踩

人工智能课程无数学基础

五节课从零起步
(无需数学和Python 基础)
编码实现AI 人工智能框架

王家林
2018/4/15

本电子书由段智华根据王家林大神 AI上课内容整理编写。
https://blog.csdn.net/duan_zhihua



下面是从零起步编写AI 深度学习框架运行效果，预测的准确度已经到达约99%，对于一
个五节课内开发出的Deep Learning框架而言，这已经是一种非常理想的运行效果：

获得达到上述运行效果的全部的五节课全部的视频、代码、资料等请加王老师的微信：


本电子文档包含两部分内容：
1， “从零起步（无需数学和 Python基础）从 30 个真实的商业案例代码中成为 AI 实
战专家：10大机器学习案例、13大深度学习案例、7大增强学习案例”课程介绍、
报名方式、课程大纲；
2， “5节课内从零起步(无需数学和Python基础)编码实现 AI框架”电子书全部的内
容(该部分内容超过 80 页，后续每周都会根据周日的内容进行版本更新，获得最新
内容请家王家林老师微信获取)；

其中“从零起步（无需数学和 Python基础）从30个真实的商业案例中成为AI实战专
家”：涵盖

16 个 Deternant Parts
51 个 Core Sections
324个 Key Points
10 大机器学习案例
13 大深度学习案例
7 大增强学习案例
共 100 个小时的视频直播

每周一到周六早上YY直播：

“30个真实商业案例代码中成为AI实战专家”报名费用和报名方式：
课程原价19800元，越早报名越多优惠.

个人优惠：
2018 年4月16-30 号：报名享“Early Bird”最优惠价格9980 元/人。
2018 年5月1-15 号：报名享最优惠价格12800元/人。
2018 年5月16-31 号：报名享最优惠价格15800 元/人。
2018 年6月1-15 号：报名享最优惠价格17800元/人。
2018 年6月16-30 号：报名费19800元/人。

团购优惠1：两个人进行团购报名：
2018 年4月16-30 号：报名享“Early Bird”最优惠价格5980 元/人。
2018 年5月1-15 号：报名享最优惠价格7980 元/人。
2018 年5月16-31 号：报名享最优惠价格9980元/人。
2018 年6月1-15 号：报名享最优惠价格11980元/人。

团购优惠 2：三人或三人以上进行团购报名：
2018年 4 月16-30号：报名享“Early Bird”最优惠价格 3980元/人。
2018年 5 月1-15 号：报名享最优惠价格 5980 元/人。
2018年 5 月16-31号：报名享最优惠价格 7980 元/人。
2018年 6 月1-15 号：报名享最优惠价格 9980 元/人。
所有已经报名的学员介绍朋友报名的，朋友和该学员将按照团购优惠方式及日期进行相应
费用计算，例如于 4 月 30 号前介绍一个朋友成功加入课程的，该朋友只需缴费 5980 元即
可加入学习，而该学员原来的报名费用的 9980 元中将会有 4000 元的学费返还，也就是该
学员也是按照5980元的报名费用加入。
报名请直接家王家林老师微信13928463918进行报名咨询和转账：

您也可以通过王家林老师的银行账号转账：
开户行:平安银行深圳五洲支行
账户名:王家林
帐号:6230583000010108167
整个“从零起步（无需数学和 Python基础）从30个真实的商业案例代码中成为 AI实战
专家：10大机器学习案例、13大深度学习案例、7大增强学习案例”课程基于真实世
界的“Case Study”驱动的方式，用案例贯穿所有的知识点，例如在深度学习
方面，我们用13大案例涵盖实战中的各种场景，对于 Deep Learning的每一个
核心算法我们均有至少 2个商业级实战案例：

部分实战案例介绍及代码截图如下：
真实实战项目之一：银行信用卡客户流失 AI管理系统
该案例服务于银行的信用卡客户，采用神经网络技术来分析预测银行信用卡用
户流失的因素及每个用户流失的可能。数据来源于银行的真实数据，该银行的
客户来自于全球，客户信息中包含 customer id, credit score, gender,
age, tenure, balance 等信息。通过Artificial Neural Network 对该数据的
成功分析，会有助于银行极大的减少信用卡用户的流失，从而通过 AI技术提供
给银行机构创造非常显著的价值。该项目来源真实案例，稍加修改就可以直接
作为解决方案提供给银行，部分数据和代码实现截图如下：



真实实战项目之二：图像（人脸）识别 AI系统
该项目使用CNN实现了识别任何类型的图像，特别适合用于做人脸识别、视频
检测、罪犯追踪等。同时该项目还可以应用于医疗行业中例如医疗诊断和智能
影像识别等，例如可以更高效和精准的识别出影像中的病症。项目实现代码片
段截图如下：

真实实战项目之三：股票价格预测 AI系统
该项目会实现一个及其强大的功能：预测股票价格。在项目中我们使用 Google
的过去多年的真实的股票数据进行训练、预测及测试。这个功能是非常强大
的，因为我们在这里使用的不是 RNN，而是LSTMs，这就使得我们的人工智能系
统成功的像人类一样拥有记忆！斯坦福大学也在加强这方面的研究，而通过该
项目的实战，你拥有了和斯坦福大学研究同类型的实战能力！部分代码片段如
下：
真实实战项目之四：信用卡申请反欺诈 AI系统
该项目在银行信用卡申请的反欺诈检测中有非常重大的应用价值。项目通过非
监督学习算法分析申请者填写的信用卡申请信息来在没有认为干扰的情况自动
化的侦查出潜在的信用卡申请的欺诈的申请者，这就一方面可以极大的减少信
用卡申请时候审核的工作量，另外一方面因为采用了非监督学习算法从而可以
检测出以前银行工作人员不知道的欺诈情况，创造性的阻止信用卡申请的欺诈
行为！部分数据和代码片段如下：


真实实战项目之五：AI深度学习推荐系统：Liked or Not Liked
该项目通过采用深度学习中的 Boltzmann Machines 来构建“Deep Belief
Networks”，从而服务于 Amazon、Google、Facebook、Netflix等类型的公
司。该项目的数据来源于工业界实际产生的数据，基于海量的用户和海量的商
品信息对用户喜好进行分析和预测，从而推荐用户喜欢的商品和服务。代码片
段如下所示：

真实实战项目之六：最强大的AI推荐系统：星级评价预测
该项目基于海量数据来预测商品和服务的评价星级：1-5星级。这是我个人最
为喜欢的项目之一，因为其价值意义非凡：通过不同星级的评价，我们的 AI系
统可以对即将推出的商品或者服务在用户还没有使用的情况下进行流行度评
测。这样一个强大的系统在投资人的投资、产品和服务的设计和研发、广告的
投放等领域有巨大的意义。在技术上我们基于 PyTorch平台自己手动实现了
AutoEncoders来实现该项目。从老师的角度而言，这个项目或许可以成就你的
一生我们的项目是基于业界的真实的数据的基础上进行实现，在推荐系统领
域，在项目几乎到处可以应用。部分代码截图如下所示：


2016年3 月，在超过2 亿人的关注下，AlphaGo击败了我们这个星球上曾经最为出色
的围棋选手，这是人工智能发展史上的里程碑式的进步和胜利；

2017年 3月 21号，凌晨 3点，在硅谷的源于天地之心的极度渴望中，在粉身碎骨的
对人工智能狂热的爱中，我顿悟了 AI技术的天机。我看见了、感受了、实践了一个 AI领域
的一个至大的秘密, 从纷繁复杂的技术幻相中进入了技术的实相！

2017 年 6 月 22 日，在这个至大秘密的指引下，成功在自己的 AI 深度学习框架的第一个
版本中实现了 ANN、RNN 和 Boltzmann Machines（详情请参考已经于 2018 年 4 月 15 号直播
完成的“5节课内从零起步(无需数学和Python基础)编码实现自己的 AI框架（类似于
TensorFlow） ”，视频下载https://pan.baidu.com/s/1euzFC3MxfQPRvPbnht1rng ）

（本课程文档课程大纲后面有段智华同学根据五节课课程内容编写的完整的电子书）

2017年 8月，在国务院印发的《新一代人工智能发展规划》中国家明确把人工智能定
位国家战略，属于二十一世纪三大尖端技术(基因工程、纳米科学、人工智能)之一，是未来
经济发展和产业转型的主要动力。并推出了中国新一代人工智能“三步走”发展战略：2020
年，人工智能产业成为新的重要经济增长点，人工智能技术应用成为改善民生的新途径；
2025年，人工智能成为我国产业升级和经济转型的主要动力；2030年，人工智能理论、技
术与应用总体达到世界领先水平，成为世界主要人工智能创新中心。

人工智能学习到底难不难？或许我们可以从现代人工智能的代表性技术Deep Learning
的核心难点“Back Propagation”来回答这个问题。什么是“Back Propagation”？一句话
来说就是从过去的行为中吸取失败(误差)的教训并改进系统的能力。目前所有的流行的人
工智能框架例如PyTorch、TensorFlow等都是基于这个核心点研发出来的，在具体实现上
会根据不同的问题场景采用 ReLU、Softmax、Entropy、Sigmoid等算法及其变形（任何 AI
框架都都会在框架内部实现这些算法，这也是框架带给开发者的核心福利）来驱动整个整
个技术框架的运行，而具体的AI的算法例如ANN、CNN、RNN、Boltzmann Machines、
AutoEncoders等都是在Back Propagation思想基础上演化出来的，是人们面临不同领域的
具体问题而发展出来的延伸算法。这种认知和行为进化的方式是人类最自然的行为方式，
所以说人工智能是人类最容易理解和掌握的技术之一！
(揭秘 AI 的全部精髓的一幅图)

遗憾的是，中国目前为止所有其它的人工智能AI课程中所推崇的先学习Python，然后
学习线性代数、微积分、概率统计等，然后再学习机器学习算法，然后在再学习Deep Learning
等的学习路径是完全错误的：第一， Python是一门极度重视用户使用直觉的编程语言，作
为一个IT开发者，你只需要在项目使用中去学习Python，完全不需要花几个月的时间去单
独学习现在的培训课程；第二，对一个正常的 IT 人员而言，可能需要花 3 年左右的时间学
习完人工智能所需要的全部的数学基础，你能够在在国内心无旁骛（辞掉工作？抛家离子？）
掌握完这些数学基础？第三，AI 算法的唯一学习正道是在案例中体会数据处理的每一个步
骤并基于该过程进行算法总结，自然而然的得出 AI 算法. 人工智能学习（习得）的精髓和
最大捷径在于从具体案例中体悟技术运行背后的初心与实相。
----王家林2018 年4月 7号于硅谷
(微信： 13928463918 QQ： 3120480359)


而基于王家林老师独创的人工智能“项目情景投射”学习法，任何 IT 人员皆可在
无需数学和Python 语言的基础上的情况下 3个月左右的时间成为 AI 技术实战高手:
1，五节课（分别在 4月9-13 号早上YY 视频直播）教你从零起步(无需Python 和数
学基础)开发出自己的AI深度学习框架，五节课的学习可能胜过你五年的自我摸索；
2，30 个真实商业案例代码中习得AI(从零起步到AI实战专家之路)：10 大机器学习
案例、13 大深度学习案例、7 大增强学习案例(本文档中有案例的详细介绍和案例实现
代码截图)；
3，100天的涅槃蜕变，平均每天学习 1个小时(周一到周六早上6:00-7:00YY 频道
68917580 视频直播)，周末复习每周的6 个小时的直播课程(报名学员均可获得所有的
直播视频、全部的商业案例完整代码、最具阅读价值的 AI 资料等)。

AI“项目情景投射”学习法-人人皆可学习的人工智能：

1，无缝平滑的学习过程：本课程的从最简单的常识出发来切入AI领域，每一个内容点
都是构建在前面知识点的基础上，尤其注重知识点之间的衔接，不跳过任何一个步
骤，打造无缝平滑的兴奋的学习体验。
2，不需要有数学基础：课程中用到的所有的数学内容都会从问题的视角出发，从
Intuition的角度让你感受“创造”数学的过程，而这种过程也正是牛顿、莱布尼茨、笛卡尔在开拓数学领域的过程（此时你可能会发现你以前学习了“假”的数学）；
3，不需要有机器学习或者 AI的基础：所有内容都会遵循人类最直觉的学习方式循序渐
进的讲授，并用 IT人员最易懂的语言-Code来实战所有内容；
4，不需要会 Python：课程中的每一行 Python 代码都会在实际问题场景中逐行编写和
解释，随着课程的进行，你会自然的成为一个实战级别的 Python编程高手；
5，完全可视化的学习方式：任何一个知识点的讲解都是：绘制原理图、编写代码、剖
析运行效果三步曲，精准的告诉你数据输入、加工运作、输出的全生命周期的每一
个细节。
6，提供全部的真实案例的解决方案代码和数据：课程会现场实现所有AI商业案例的代
码并提供完整的代码给给学员，学员日后在工作时候基本都是对这些代码的修改以
适应自己的企业需求而已。

整个课程遵循工匠精神，经过反复打磨，带领任何决心在人工智能领域有作为
的人掌握人工智能的核心实战技术，变革中国的人工智能教育。课程包含
Alphago 使用的三大核心：Machine Learning、Deep Learning、
Reinforcement Learning：


课程大纲如下：
-------------------- Part 1: Data Preprocessing -------------------

Section: 1 为什么说 AI 是未来 30年的核心
• 1. AI的 10大经典应用场景
• 2. AI在海量数据处理中不可被替代的原因
• 3. AI、机器学习、深度学习等之间的关系
• 4. 课程开发环境的安装和项目运行效果演示
Section: 2 机器学习数据的预处理

• 5. 为什么必须预处理 Machine Learning的数据？
• 6. 数据的获取及其分析
• 7. 使用第三方库来预处理数据：Numpy、Pandas、Matplotlib
• 8. 导入数据
• 9. 采用面向对象模块化的方式预处理数据
• 10. 实际生产环境中如何处理数据丢失的情况？
• 11. 如何处理 Categorical Data？
• 12. 把数据分为训练集和测试集
• 13. Feature Scaling的重大意义及具体方法
------------------------- Part 2: Regression --------------------
• 14. Regression解密及其分类 Section: 4 Simple Linear Regression
• 15. 从 Intuition 的角度透彻理解Simple Linear Regression
• 15. 案例的应用场景解析
• 16. 案例的数据分析及预处理
• 17. Simple Linear Regression 案例实战 - Part 1
• 18. Simple Linear Regression 案例实战 - Part 2
• 19. Simple Linear Regression 案例实战 - Part 3
• 20. Simple Linear Regression 案例实战 - Part 4
•
Section: 5 Multiple Linear Regression
• 21. 从 Intuition 的角度透彻理解Multiple Linear Regression
• 22. 案例的应用场景解析
• 23. 案例的数据分析及预处理
• 24. Multiple Linear Regression 案例实战 - Part 1
• 25. Multiple Linear Regression 案例实战 - Part 2
• 26. Multiple Linear Regression 案例实战 - Part 3
• 27. Multiple Linear Regression 中的Backward Elimination解密
Section: 6 Polynomial Regression
• 28. 从 Intuition 的角度透彻理解Polynomial Regression
• 29. 案例的应用场景解析
• 30. 案例的数据分析及预处理
• 31. Polynomial Regression 案例实战 - Part 1
• 32. Polynomial Regression 案例实战 - Part 2
• 33. Polynomial Regression 案例实战 - Part 3
• 34. Polynomial Regression 案例实战 - Part 4
Section: 7 Support Vector Regression (SVR)
• 35. 从 Intuition 的角度透彻理解SVR
• 36. 案例的应用场景解析及数据的预处理
• 37. SVR 案例实战
Section: 8 Decision Tree Regression
• 38. 从 Intuition 的角度透彻理解Decision Tree Regression • 39. 案例的应用场景解析及数据的预处理
• 40. Decision Tree Regression 案例实战
Section: 9 Random Forest Regression
• 41. 从 Intuition 的角度透彻理解Random Forest Regression
• 42. 案例的应用场景解析及数据的预处理
• 43. Random Forest Regression 案例实战
Section: 10 对于 Regression 模型的 Performance进行评估
• 44. 从 Intuition 的角度透彻理解R-Squared
• 45. 从 Intuition 的角度透彻理解Adjusted R-Squared Intuition
• 46. 对Regression 模型的 Performance 进行评估实战
• 47. 剖析 Linear Regression Coefficients
------------------------- Part 3: Classification --------------------
• 48. Classification的解密及其类型
Section: 11 Logistic Regression
• 49. 从 Intuition 的角度透彻理解 Logistic Regression
• 50. 案例的应用场景解析及数据的预处理
• 51. Logistic Regression 案例实战 - Part 1
• 52. Logistic Regression 案例实战 - Part 2
• 53. Logistic Regression 案例实战 - Part 3
• 54. Logistic Regression 案例实战 - Part 4
• 55. Logistic Regression 案例实战 - Part 5
Section: 12 K-Nearest Neighbors (K-NN)
• 56. 从 Intuition 的角度透彻理解 K-Nearest Neighbors
• 57. 案例的应用场景解析及数据的预处理
• 58. K-NN 案例实战
Section: 13 Support Vector Machine (SVM)
• 59. 从 Intuition 的角度透彻理解 SVM • 60. 案例的应用场景解析及数据的预处理
• 61. SVM 案例实战
Section: 14 Kernel SVM
• 62. 从 Intuition 的角度透彻理解 Kernel SVM
• 63. 进行高纬映射
• 64. Kernel的使用技巧
• 65. 不同类型的 Kernel 函数
• 66. 案例的应用场景解析及数据的预处理
• 67. Kernel SVM 案例实战
Section: 15 Naive Bayes
• 68. 从 Intuition 的角度透彻理解 Bayes
• 69. 从 Intuition 的角度透彻理解 Naive Bayes
• 70. 案例的应用场景解析及数据的预处理
• 71. Naive Bayes 案例实战
Section: 16 Decision Tree Classification
• 72. 从 Intuition 的角度透彻理解 Decision Tree Classification
• 73. 案例的应用场景解析及数据的预处理
• 74. Decision Tree Classification 案例实战
Section: 17 Random Forest Classification
• 75. 从 Intuition 的角度透彻理解 Random Forest Classification Intuition
• 76. 案例的应用场景解析及数据的预处理
• 77. Random Forest Classification 案例实战
Section: 18 对 Classification 进行 Performance 的评估
• 78. False Positives & False Negatives解析
• 79. Confusion Matrix解密
• 80. Accuracy Paradox解密
• 81. CAP Curve解密
-------------------- Part 4: Clustering --------------------
• 82. Clustering的解密及其类型
Section: 19 K-Means Clustering
• 83. 从 Intuition 的角度透彻理解 K-Means Clustering
• 84. K-Means Random 初始化陷阱
• 85. K-Means 中Clusters 数目选取技巧分享
• 86. 案例的应用场景解析及数据的预处理
• 87. K-Means Clustering 案例实战
Section: 20 Hierarchical Clustering
• 88. 从 Intuition 的角度透彻理解 Hierarchical Clustering
• 89. Hierarchical Clustering中的Dendrograms 工作机制解密
• 90. Dendrograms在Hierarchical Clustering的运用
• 91. 案例的应用场景解析及数据的预处理
• 92. HC 案例实战 - Part 1
• 93. HC 案例实战 - Part 2
• 94. HC 案例实战 - Part 3
• 95. HC 案例实战 - Part 4
• 96. HC 案例实战 - Part 5

----------- Part 5: Association Rule Learning ----------
• 97. Association Rule Learning的解密及其类型
Section: 21 Apriori
• 98. 从 Intuition 的角度透彻理解 Apriori
• 99. 案例的应用场景解析及数据的预处理
• 100. Apriori 案例实战 - Part 1
• 101. Apriori 案例实战 - Part 2
• 102. Apriori 案例实战 - Part 3
Section: 22 Eclat • 103. 从 Intuition 的角度透彻理解 Eclat
• 104. 案例的应用场景解析及数据的预处理
• 105. Eclat 案例实战
------------Part 6: Natural Language Processing---------
Section: 23 Natural Language Processing
• 106. 从 Intuition 的角度透彻理解 Natural Language Processing
• 107. 案例的应用场景解析及数据的预处理
• 108. Natural Language Processing 案例实战 - Part 1
• 109. Natural Language Processing 案例实战 - Part 2
• 110. Natural Language Processing 案例实战 - Part 3
• 111. Natural Language Processing 案例实战 - Part 4
• 112. Natural Language Processing 案例实战 - Part 5
• 113. Natural Language Processing 案例实战 - Part 6
• 114. Natural Language Processing 案例实战 - Part 7
• 115. Natural Language Processing 案例实战 - Part 8
• 116. Natural Language Processing 案例实战 - Part 9
• 117. Natural Language Processing 案例实战 - Part 10
---------- Part 7: Dimensionality Reduction -----------
• 118. Dimensionality Reduction解密及其类型
Section: 24 Principal Component Analysis (PCA)
• 119. 从 Intuition 的角度透彻理解 PCA
• 120. 案例的应用场景解析及数据的预处理
• 121. PCA 案例实战 - Part 1
• 122. PCA 案例实战 - Part 2
• 123. PCA 案例实战 - Part 3
Section: 25 Linear Discriminant Analysis (LDA)
• 124. 从 Intuition 的角度透彻理解 LDA
• 125. 案例的应用场景解析及数据的预处理
• 126. LDA案例实战
Section: 360 / 3 Section: 26 Kernel PCA
• 127. 从 Intuition 的角度透彻理解 Kernel PCA
• 128. 案例的应用场景解析及数据的预处理
• 129. Kernel PCA 案例实战
------------ Part 8: Model Selection & Boosting ---------
• 130. Model Selection & Boosting透彻剖析
Section: 27 Model Selection
• 131. 数据源分析
• 132. k-Fold Cross Validation 透彻剖析与实战
• 133. Grid Search 案例实战 - Part 1
• 134. Grid Search 案例实战 - Part 2
Section: 28 XGBoost
• 135. 数据源分析
• 136. XGBoost 案例实战 - Part 1
• 137. XGBoost 案例实战 - Part 2

------------- Part 9 - Artificial Neural Networks -----------
Section: 29 从Intuition 的角度透彻理解 ANN
• 138. 从 Intuition 的角度透彻理解 Neuron
• 139. 从 Intuition 的角度透彻理解 Activation Function
• 140. 从 Intuition 的角度透彻理解 Neural Networks工作机制
• 141. 从 Intuition 的角度透彻理解 Neural Networks 能够学习的内幕
• 142. 从 Intuition 的角度透彻理解 Gradient Descent
• 143. 从 Intuition 的角度透彻理解 Stochastic Gradient Descent
• 144. 从 Intuition 的角度透彻理解 Backpropagation
Section: 30 ANN真实商业案例实战
• 145. 案例的应用场景解析及数据的预处理 • 146. 动手构建 ANN真实商业案例实战 - Step 1
• 147. 动手构建 ANN真实商业案例实战 - Step 2
• 148. 动手构建 ANN真实商业案例实战 - Step 3
• 149. 动手构建 ANN真实商业案例实战 - Step 4
• 150. 动手构建 ANN真实商业案例实战 - Step 5
• 151. 动手构建 ANN真实商业案例实战 - Step 6
• 152. 动手构建 ANN真实商业案例实战 - Step 7
• 153. 动手构建 ANN真实商业案例实战 - Step 8
• 154. 动手构建 ANN真实商业案例实战 - Step 9
• 155. 动手构建 ANN真实商业案例实战 - Step 10
• 156. Evaluating ANN真实商业案例实战
• 157. Improving ANN真实商业案例实战
• 158. Tuning ANN真实商业案例实战
------ Part 10 - Convolutional Neural Networks ------
Section: 31 从Intuition的角度透彻理解 CNN
• 159. 到底什么是 CNN
• 160. 从 Intuition 的角度透彻理解 Convolution Operation
• 161. 从 Intuition 的角度透彻理解 ReLU Layer
• 162. 从 Intuition 的角度透彻理解 Pooling
• 163. 从 Intuition 的角度透彻理解 Flattening
• 164. 从 Intuition 的角度透彻理解 Full Connection
• 165. Softmax & Cross-Entropy解密
Section: 32 CNN真实商业案例实战
• 166. 案例的应用场景解析及数据的预处理
• 167. 动手构建 CNN真实商业案例实战 - Step 1
• 168. 动手构建 CNN真实商业案例实战 - Step 2
• 169. 动手构建 CNN真实商业案例实战 - Step 3
• 170. 动手构建 CNN真实商业案例实战 - Step 4
• 171. 动手构建 CNN真实商业案例实战 - Step 5
• 172. 动手构建 CNN真实商业案例实战 - Step 6
• 173. 动手构建 CNN真实商业案例实战 - Step 7
• 174. 动手构建 CNN真实商业案例实战 - Step 8
• 175. 动手构建 CNN真实商业案例实战 - Step 9
• 176. 动手构建 CNN真实商业案例实战 - Step 10
• 177. Evaluating CNN真实商业案例实战
• 178. Improving CNN真实商业案例实战
• 179. Tuning CNN真实商业案例实战、
--------- Part 11 - Recurrent Neural Networks -----------
Section: 33 从Intuition的角度透彻理解 RNN
• 180. Recurrent Neural Networks背后的设计思想解密
• 181. Vanishing Gradient 带来的问题和困境
• 182. 从 Intuition 的角度透彻理解 LSTMs
• 183. LSTM的变种
Section: 34 RNN真实商业案例实战
• 184. 案例的应用场景解析及数据的预处理
• 185. 动手构建 RNN真实商业案例实战 - Step 1
• 186. 动手构建 RNN真实商业案例实战 - Step 2
• 187. 动手构建 RNN真实商业案例实战 - Step 3
• 188. 动手构建 RNN真实商业案例实战 - Step 4
• 189. 动手构建 RNN真实商业案例实战 - Step 5
• 190. 动手构建 RNN真实商业案例实战 - Step 6
• 191. 动手构建 RNN真实商业案例实战 - Step 7
• 192. 动手构建 RNN真实商业案例实战 - Step 8
• 193. 动手构建 RNN真实商业案例实战 - Step 9
• 194. 动手构建 RNN真实商业案例实战 - Step 10
• 195. 动手构建 RNN真实商业案例实战 - Step 11
• 196. 动手构建 RNN真实商业案例实战 - Step 12
• 197. 动手构建 RNN真实商业案例实战 - Step 13
• 198. 动手构建 RNN真实商业案例实战 - Step 14
• 199. 动手构建 RNN真实商业案例实战 - Step 15
• 200. Evaluating RNN真实商业案例实战
• 201. Improving RNN真实商业案例实战
• 202. Tuning RNN真实商业案例实战
---------------- Part 12 - Self Organizing Maps ---------------
Section: 35 从Intuition的角度透彻理解 SOMs
• 203. Self-Organizing Maps 具体工作机制内幕详解
• 204. Self-Organizing Maps Learn具体机制内幕详解 (Part 1)
• 205. Self-Organizing Maps Learn具体机制详解(Part 2)
• 206. Live SOM 现实案例分析
Section: 36 SOM真实商业案例实战
• 207. 案例的应用场景解析及数据的预处理
• 208. 动手构建 SOM真实商业案例实战 - Step 1
• 209. 动手构建 SOM真实商业案例实战 - Step 2
• 210. 动手构建 SOM真实商业案例实战 - Step 3
• 211. 动手构建 SOM真实商业案例实战 - Step 4
• 211. 动手构建 SOM真实商业案例实战 - Step 5
• 212. Mega Case Study - Step 1
• 213. Mega Case Study - Step 2
• 214. Mega Case Study - Step 3
• 215. Mega Case Study - Step 4
------------------- Part 13- Boltzmann Machines ---------------
Section: 37 从 Intuition 的角度透彻理解 Boltzmann Machine Intuition
• 216. Boltzmann Machine产生的内幕历史及其带来的启发
• 217. Energy-Based Models (EBM)透彻解析
• 218. Restricted Boltzmann Machine透彻解析
• 219. Contrastive Divergence原理和工作机制
• 220. Deep Belief Networks工作机制和价值
• 221. Deep Boltzmann Machines工作机制和价值
Section: 38 Boltzmann Machines真实商业案例实战
• 222. 案例的应用场景解析
• 223. 在 Ubuntu 上安装 PyTorch
• 224. 数据预处理
• 225. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 1
• 226. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 2
• 227. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 3
• 228. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 4
• 229. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 5
• 230. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 6
• 231. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 7
• 232. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 8
• 233. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 9
• 234. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 10
• 235. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 11
• 236. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 12 • 237. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 13
• 238. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 14
• 239. 动手构建 BOLTZMANN MACHINE 真实商业案例实战 - Step 15
• 240. Evaluating BOLTZMANN MACHINE真实商业案例实战

----------------------- Part 14 - AutoEncoders -----------------------
Section: 39 从 Intuition 的角度透彻理解 AutoEncoders
• 241. Auto Encoders解析
• 242. Biases解析
• 243. 如何训练 Auto Encoder？
• 244. Overcomplete hidden layers解析
• 245. Sparse Autoencoders解密
• 246. Denoising Autoencoders解密
• 247. Contractive Autoencoders解密
• 248. Stacked Autoencoders解密
• 249. Deep Autoencoders解密
Section: 40 AutoEncoders 真实商业案例实战
• 222. 案例的应用场景解析
• 223. 在 Ubuntu 上安装 PyTorch
• 224. 数据预处理
• 225. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 1
• 226. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 2
• 227. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 3
• 228. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 4
• 229. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 5
• 230. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 6
• 231. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 7
• 232. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 8
• 233. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 9
• 234. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 10
• 235. 动手构建 AUTOENCODERS 真实商业案例实战 - Step 11

------------- Part 15 – Reinforcement Learning ------------
Section: 41 从 Intuition 的角度透彻理解 Reinforcement Learning
• 236. 到底什么 Reinforcement Learning？
• 237. Reinforcement Learning在现实中的经典应用
• 238. Reinforcement Learning的终极潜力是什么？
• 239. Problem Setup and The Explore-Exploit Dilemma详解
• 240. Epsilon-Greedy详解
• 241. 更新 Sample Mean
• 242. 对比不同的 Epsilons
• 243. Optimistic Initial Values详解
• 244. UCB详解
• 245. Bayesian / Thompson Sampling详解
• 246. Thompson Sampling vs. Epsilon-Greedy vs. Optimistic Initial Values vs. UCB
详解
• 247. Nonstationary Bandits解析
Section: 42 实战构建 Intelligent Tic-Tac-Toe Agent
• 248. Naive Solution to Tic-Tac-Toe
• 249. Components of a Reinforcement Learning System
• 250. Notes on Assigning Rewards
• 251. The Value Function and Your First Reinforcement Learning Algorithm
• 252. Tic Tac Toe Code: Outline
• 253. Tic Tac Toe Code: Representing States
• 254. Tic Tac Toe Code: Enumerating States Recursively
• 255. Tic Tac Toe Code: The Environment
• 256. Tic Tac Toe Code: The Agent
• 257. Tic Tac Toe Code: Main Loop and Demo
• 258. Tic Tac Toe案例总结及启示
Section: 43 Markov Decision Proccesses 解密及案例实战
• 259. Gridworld解密
• 260. Markov Property详解
• 261. Defining and Formalizing the MDP实战
• 262. Future Rewards解密
• 263. Value Function解析和实战
• 265. Bellman 案例实战
• 266. Optimal Policy and Optimal Value Function解密和实战
• 267. MDP 案例总结及启示 Section: 44 Dynamic Programming 解密及案例实战
• 268. Dynamic Programming and Iterative Policy Evaluation解密
• 269. Gridworld代码实战
• 270. Iterative Policy Evaluation案例实战
• 271. Policy Improvement案例实战
• 272. Policy Iteration案例实战
• 274. Policy Iteration in Windy Gridworld案例实战
• 275. Value Iteration案例实战
• 277. Dynamic Programming 案例实战总结及启示
Section: 45 Monte Carlo 解密及案例实战
• 278. Monte Carlo内幕解析
• 279. Monte Carlo Policy Evaluation解析及案例实战
• 280. Policy Evaluation in Windy Gridworld实战
• 281. Monte Carlo Control解密及案例实战
• 282. Monte Carlo Control without Exploring Starts解密及案例实战
• 283. Monte Carlo案例实战总结及启示
Section: 46 Temporal Difference Learning 解密及案例实战
• 284. Temporal Difference内幕解析
• 285. TD(0) Prediction解析及案例实战
• 286. SARSA解析及案例实战
• 287. Q Learning解析及案例实战
• 288. TD案例实战总结及启示
Section: 47 Approximation Methods 解密及案例实战
• 289. Approximation内幕解析
• 290. Linear Models for Reinforcement Learning解密
• 291. Features解密
• 292. Monte Carlo Prediction with Approximation解析及案例实战
• 293. TD(0) Semi-Gradient Prediction解析
• 294. Semi-Gradient SARSA3:08解析及案例实战

----- Part 16 – Advanced Reinforcement Learning -----
Section: 48 OpenAI Gym解密及案例实战
• 295. OpenAI Gym解密
• 296. Random Search解密
• 297. CartPole with Bins解密及案例实战
• 298. RBF Neural Networks解密
• 299. RBF Networks with Mountain Car案例实战
• 300. RBF Networks with CartPole解密及案例实战
• 301. Reinforcement Learning和Neural Network深度整合
• 302. OpenAI Gym 案例实战总结及启发
Section: 49 TD Lambda 解密及案例实战
• 303. N-Step Methods解析及案例实战
• 304. TD Lambda解密及案例实战
• 305. TD Lambda案例实战总结及启发
Section: 50 Policy Gradients 解密及案例实战
• 306. Policy Gradient Methods解密
• 307. Policy Gradient in TensorFlow for CartPole实战
• 308. Policy Gradient in Theano for CartPole实战
• 309. Continuous Action Spaces解密
• 310. Mountain Car Continuous Specifics解密
• 311. Mountain Car Continuous Theano实战 – Part1
• 312. Mountain Car Continuous Theano 实战 – Part2
• 313. Mountain Car Continuous Tensorflow实战 – Part1
• 314. Mountain Car Continuous Tensorflow 实战 – Part2
• 315. Policy Gradient 案例实战总结及启发
Section: 51 Deep Q-Learning 解密及案例实战
• 316. Deep Q-Learning解密
• 317. Deep Q-Learning Techniques解密
• 318. Deep Q-Learning in Tensorflow for CartPole实战
• 319. Deep Q-Learning in Theano for CartPole实战
• 320. Additional Implementation Details for Atari实战
• 321. Deep Q-Learning in Tensorflow for Breakout实战 • 322. Deep Q-Learning in Theano for Breakout实战
• 323. Partially Observable MDPs解密
• 324. Deep Q-Learning Section案例实战总结及启发



五节课从零起步
(无需数学和Python 基础)
编码实现AI 人工智能框架

(V1)

王家林
2018/4/15

本电子书由段智华根据王家林大神 AI上课内容整理编写。
https://blog.csdn.net/duan_zhihua

王家林
《Spark 大数据商业实战三部曲》作者，人工智能 PyTorch 全球布道师。目前自己独立
研发的AI框架“盘古”已实现 Deep Learning的六大核心算法。

1、导论：为什么人工智能是必然的未来
非常高兴在美国硅谷通过网络和大家分享人工智能的内容，本课分享三个方面的内容：
1、为什么一定需要AI? 2、AI为何如此强大？ 3、学习 AI的唯一正道是什么？国内的很多
朋友在学习AI的时候遇见各种麻烦和数学的问题：例如，项目案例的问题，想理解TensorFlow
或流行的人工智能框架内幕运行原理的问题，总是不得法门。在这章节中我们将逐步进行解
析。前三章节的目标：将带领大家手动开发出自己的深度学习框架！不需要数学基础，不需
要 Python 语言基础，一行一行的写代码，一行一行的测试，自己写深度学习框架、进行
TensorFlow 的深度学习，以及学习在业界突然崛起的、最流行的深度学习框架 PyTorch，
PyTorch来自Facebook，在科研界， PyTorch的流行度及被认可度已经远远超过了TensorFlow，
虽然在工业界或商业界，主要使用的还是TensorFlow。我们自己写的深度学习框架的内核机
制原理和TensorFlow、PyTorch是一致的。
1) 我们先谈第一个问题：为什么一定需要 AI？
最伟大的科学家、物理学家之一的斯蒂芬·威廉·霍金（Stephen William Hawking），被
认为是人类历史上继爱因斯坦之后最伟大的科学家，他在 2014 年曾发表一句名言：The
development of full artificial intelligence could spell the end of the human race。（人工智能的发
展可能会终结人类），或者说人工智能是人类最后要做的一件事情。
2015 年，霍金、特斯拉公司CEO埃隆·马斯克（Elon Musk）和苹果联合创始人史蒂夫·沃
兹尼亚克（Steve Wozniak）与其他上百位专业人士共同签署了一封公开信，号召禁止人工智
能武器。
2016 年 3 月，人工智能业界发生了一件震惊世界的事件，阿尔法狗击败了我们这个星
球上最出色的围棋选手，最特殊的地方在于阿尔法狗下围棋的时候使用了一种设计人员没有
想到的围棋策略，这是人类人工智能里程碑式的进步和胜利，也是人类智慧里程碑式的进步
和胜利。
2017 年3月，霍金在接受英国《泰晤士报》采访时再次发出警告，“强大的AI是整个人
类体验的最美好的或者是最坏的事情。人工智能进一步发展可能会通过核战争或生物战争摧
毁人类”。
2017 年7月，国务院正式发布《新一代人工智能发展规划》，明确把人工智能发展作为
国家战略。作为二十一世纪的三大尖端技术之一（基因工程、纳米工程、人工智能），人工
智能是高、精、尖的技术。国务院人工智能三步走的规划：第一步，到2020 年人工智能总
体技术和应用与世界先进水平同步，人工智能产业成为新的重要经济增长点，人工智能技术
应用成为改善民生的新途径，有力支撑进入创新型国家行列和实现全面建成小康社会的奋斗
目标。第二步，到2025 年人工智能基础理论实现重大突破，部分技术与应用达到世界领先
水平，人工智能成为带动我国产业升级和经济转型的主要动力，智能社会建设取得积极进展。
第三步，到2030 年人工智能理论、技术与应用总体达到世界领先水平，成为世界主要人工
智能创新中心，智能经济、智能社会取得明显成效，为跻身创新型国家前列和经济强国奠定
重要基础。
2018 年4月，业界发生轰动媒体的新闻，超过50 名的人工智能专家和科学家共同抵制
韩国科学技术院的一项研究计划，这项计划使用 AI 研究人工智能武器，在现场抵制的包括
人工智能领域的一些大神，人工智能领域做出突出贡献的核心科学家如图 1-1 所示，其中2000 年度及2010年度的科学家中很多人参与了抵制运动。
2018 年 4 月，谷歌 3000 多名员工联名上书谷歌管理人员，抵制谷歌和美国政府的合
作，合作的核心是通过谷歌领先的人工智能技术和军事科技进行合作，研发军事方面的人工
智能武器。为什么人工智能武器这么可怕？核心是深度学习加上增强学习。

图 1- 1 人工智能领域科学家

从技术的角度，为什么一定要使用 AI 人工智能？图 1-2 是显示人类进步的曲线图，反
映了从公元 2005 年以前的进步曲线，即从人类诞生开始到 2005 年的进步曲线，X 轴是时
间，Y轴是人类的进步，人类进步曲线非常平缓。

图 1- 2 人类进步曲线图

如图1-3 所示，在2005 年前后，人类进步曲线突然垂直上升，从人类诞生到2005年有
个很长的时间跨度，对比整个 2005 年以前的历史和现在 2005 年以后人类进步曲线垂直上
升的比较，反映出 2005 年到 2010 年、2010 年到 2020 年，2020 年到 2030 年，2030 年到
2050 年演进的方式。你处在人类文明空前大爆发的阶段，人工智能 5 年的时间相当于过去
五千年人类进步的时光。
图 1- 3 2005 年前后人类进步曲线图

如图 1-4 所示，从数据的角度观察数据的核裂变式增长，2005 年以前人类历史上总共
拥有的数据（书籍、音频、视频等）是 130EB，2010 年从 130EB 上升到 1200EB，增长了约
10 倍；到了2015 年，从 1200EB 增长到 7900EB，增长了约 7 倍；预计到 2020 年，将到达
40900EB，从2015年到2020年增长了5倍。而 2020 年与从人类诞生到2005年以前的数据
比较，增长了约300 倍以上。

图 1- 4 数据的核裂变式增长

如图1-5 所示，面对数据的核裂变式增长，我们怎么办？数据收集、存储、管理都有成
本，FaceBook、谷歌、Amazon 等公司将用户数据收集起来，是否就为了做大数据？一开始
的时候他们可能为了做大数据，但数据足够大的时候，为了提升单位数据的价值，必须求助
人工智能。这里谈一下大数据，机器学习是大数据的核心之一，大数据也包括SQL、流处理、
图计算等，但在真正人工智能的深度学习和增强学习面前，以前了解的机器学习和图计算只
是开胃菜。

图 1- 5 数据的核裂变式增长

如图 1-6 所示，面对数据海量式的、核裂变式增长，数据科学家们使用 Hive、数据库、
或者使用 Python、R 语言进行处理，从 2020 年来看，数据科学家们能处理的数据大约是数
据总量的10%，如果想依赖数据科学家来处理爆炸式增长的数据是远远不够的。

图 1- 6 传统的数据处理方式无法适应数据的增长

在数据科学家们使用传统的方法（Hive、数据库）解决问题的基础上，图1-7 中所示的
机器上的方法是使用 Hadoop、Spark 进行处理，从大数据的视角，Spark 是大数据处理的计
算引擎；但从人工智能的视角，使用大数据进行的处理依旧不能满足数据爆发式的增长，这
里大约处理15%-20%的数据。

图 1- 7 机器处理数据的方法

如图1-8 所示，使用机器学习（包括 Spark机器学习本身，处理15%-20%的数据）的基
础上，进行人工智能处理。 AI的处理能力由低到高分别为：机器学习、深度学习、增强学习。
这里除了机器学习，还有一个向上的箭头，可以认为下面的三分之一为机器学习算法本身
（线性回归、逻辑回归、K-means等），中间的三分之一是深度学习，上面的三分之一是增强
学习。此时得出一个结论：人工智能的核心杀伤力是以深度学习为基础的增强学习。真正的
人工智能就是深度学习、增强学习。要想体验、驾驭人工智能时代，核心是增强学习方向。
但现在人工智能业界运用最普遍的是机器学习，原因在于：第一点，因为很多企业的数
据规模没那么大，也没那么迫切的需求提取数据的价值，第二点，没有足够的人才进行人工
智能处理。

图 1- 8 人工智能方法
FaceBook、谷歌、Amazon 业界最领先的人工智能公司，他们的所有产品都在全面的深
度学习化，一开始是机器学习和大数据公司，在全面的转向深度学习。在2020 年以前，人
工智能学习的核心是深度学习，深度学习是目前商业界最有价值和潜力的，深度学习应用于
自动驾驶和演示人工智能武器等，在2020年以后可以增强学习为核心。
增强学习的核心是实时的与环境进行交互，交互的能力可从环境交互中不断提升自己的
能力，但其致命性的弱点是增强学习的数据不够多，因为是实时的交互。而深度学习最擅长
的就是海量的数据处理，增强学习和深度学习的联合体，将使增强学习爆发出终极的潜力，
也使深度学习的价值最大化。因此，2020年前要以深度学习为核心。

2) 人工智能为什么这么强大？就像《狮子王》中谈到的：the past can hurt. you can either run from it or learn from it（过
去的经历可能会造成伤害，你可以不管这些东西，或者从中学到一些东西）。过去以前的编
程和人工智能的编程有什么区别？机器学习、深度学习、增强学习以前的编程是不关心机器
的经验的，以前的编程是根据你的经验和代码，无法根据现有的数据或发生的事件改变你的
程序，流程各方面已经确定，无法从已有的数据或个体的数据进行学习，第一行代码，第二
行代码，第三行代码......；而人工智能的核心，能从每次发生的事件中进行学习，并不断改
进优化，然后用不断优化应对现在和未来的变化。科研界认为PyTorch比谷歌的TensorFlow
好很多，因为PyTorch有个动态图的核心特性，可以随时修改图；TensorFlow是业界最核心
主流的人工智能框架，TensorFlow 是静态的，静态图根据已有的数据学习完成以后就不能再
修改，而PyTorch学习完成以后可以动态改变，PyTorch 是业界最先进的人工智能框架。
人工智能从每次的经历进行学习，用于下一次的行为改进。深度学习基于海量的数据完
成这个过程，增强学习是实时的与环境进行交互，来完成这个过程。机器学习、深度学习、
增强学习的算法如果不是从这个角度考虑的，那一定是错的。

如图1-9 所示，TensorFlow网站（http://playground.tensorflow.org/）是 TensorFlow 公司
提供给人工智能学习者从可视化图的角度看人工智能的神经网络到底是怎么运行的示意图。

图 1- 9 TensorFlow 可视化运行图

Data是数据，从数据里面提取特征（FEATURES），类似大脑的加工处理过程，对特征进
行加工处理，如果想成为人工智能发展史上大神级别的人物，必须熟练操作微积分、线性代
数、概率论、数理统计的数学知识，但是 TensorFlow、PyTorch 人工智能框架已经将一些深
奥的内容实现了，通过Python、c、c++等编程实现，不需要具体对每一步进行数学推导，我
们只需知道每一步的数据是怎么流动的，数据的处理过程，具体怎么做的，直接拿过来就可
以使用。图中右边是输出，将数据进行逻辑分类，分成两种颜色的点，例如：哪些是垃圾邮
件，哪些是垃圾短信，哪些是垃圾电话。点左上角的运行按钮，结果在output中进行显示，
图上方的曲线是种子曲线，种子越小，精确度越高。运行一段时间以后，曲线不变动了。
再次运行，可以看到开始的精确度（Test loss）大于 50%，例如预测是否是垃圾邮件，
一个是对的，一个是错的，这个太糟糕了，我们的要求是 1万分钟最多只有1 个出错，谷歌
就做到了。点击运行以后，立即查看损失曲线，及数据流动的过程，原先的Test loss是 50%，现在Test loss可能变成了0.6%，训练的时候Training loss可能是0.2%。这是一个非常不错的
结果，意味着1 千封的垃圾邮件识别中可能有几封是错的，大部分预测是正确的。
运行的时候中间有一些隐藏的网络层，其中有个 Activation特别重要，国内将其翻译为
激活函数，人工智能为什么能够学习？是由于动力的驱动，人工智能深度学习领域称之为激
活函数，激活函数是深度学习的精髓，怎么提供动力也是人工智能科学家几十年来研究的内
容。这里的激活函数包括：ReLU、Tanh、Sigmoid、Linear，这是人工智能深度学习本身最大
的难点，人工智能框架的核心就在这里。为什么从这一步学到下一步，从下一步又学到下一
步，为什么能改进下一次的行动，就是由于激活函数的作用，激活函数也会配合损失函数，
核心就是Activation激活函数导致的。

3) 学习AI的唯一正道是什么？
学习AI的唯一正道就是实际的商业案例学习，通过机器学习案例、深度学习案例、增
强学习案例学习人工智能。不需要数学基础，不需要 Python 语言基础，只有在真实场景中
的学习才是最有效的学习。其中AutoEncoders、Boltzmann_machines是深度学习推荐系统中
两个最核心的算法，这里不是指普通机器学习的推荐系统，而是指深度学习的推荐系统，深
度学习的推荐系统肯定比普通机器学习的推荐系统更强大。推荐包括两个类型：第一个类型，
用户会不会喜欢这个商品；第二个类型，对于商品，用户会打几星级评价，例如，对于一个
产品，用户是给一星级评价、二星级评价，还是五星级评价。假设推一个电影，推荐系统能
计算出电影的流行度等内容，这个对于投资人很重要。Self_Organizing_Maps 算法可统计全
国上班的统计图、消费的统计图、打车的统计图、流量的统计图等。其他包括 Mountaincar
算法等。
为什么说不需要数学基础，不需要 Python 语言基础，直接就可以学习人工智能深度学
习、增强学习的内容？原因很简单，例如牛顿、莱布尼茨等科学家是在解决实际问题的过程
中，自然而然的得出一个数学公式，如果我们回到基于数据的真实场景，清晰看见数据每一
步的处理，每一步的流动，就能自然而然的得到牛顿、莱布尼茨、笛卡尔等科学家得出的公
式或算法，在人工智能中的学习过程中，重新“发明”了一门数学。
Python 不需要学，Python 是一门面向对象的函数式编程的语言，是一门编程者体验的
语言，通过一两个案例达到熟练操作的地步，30 个人工智能的案例通过Python编写，可达
到Python开发高手的级别。

2、第一节课：从零起步编码实现多层次神经网络
非常高兴在美国硅谷通过网络和大家分享人工智能的内容，2017年3 月21 日，王家林
老师受到启发，感知系统实相以后，在硅谷通过三个月的时间，于2017 年6月 22日实现了
自己的人工智能框架，在框架中实现了基本的 ANN (Artificial Neural Network),CNN
（Convolutional Neural Network），但那时还没实现RNN(Recurrent neural Network)，但是实现
了另外两个特别重要的算法，一个是自动编码 AutoEncoders、还有一个非监督学习
Boltzmann_machines，这两个都跟推荐系统相关。如果必须掌握，最大化掌握深度学习中的
算法，神经网络算法是必须掌握的，CNN、RNN 等都是基于它的基础延伸出来的，包括非监
督学习中的 AutoEncoders，也是基于神经网络的算法延伸出来的。AutoEncoders、
Boltzmann_machines在实际运用中可用于推荐系统，在 FaceBook、谷歌、Amazon各种场合
都可以看见推荐系统的身影，深度学习的图片识别、声音识别可能暂时不那么重要，从2017
年6 月至今，将近10 个月的时间，王家林老师在自己开发的人工智能框架中试验了很多论
文的人工智能算法。如何去实现论文中的算法，这是做人工智能研究的核心能力之一。研究 TensorFlow、PyTorch 的时候会发现，TensorFlow、PyTorch 和我们自己开发的人工
智能框架的思想是一样的，但在实现上有所不同。自己开发的人工智能框架满足了基本的人
工智能框架神经网络的需要，如果要像 TensorFlow、PyTorch 这么强大，需要迭代研发很多
版本。我们从将最基础的一个版本，在无需数学基础，无需 Python 语言的基础之上，再改
进几个版本，通过版本的迭代，迭代到自研的人工智能框架内核和 TensorFlow、PyTorch 的
内核是一致的程度。
从零起步编码实现多层次神经网络，这里神经网络是指它的骨架，如图1-10 所示， Input
Layer 是神经网络的输入层，Output Layer 是神经网络的输出层，中间的 Hidden Layers 是是
神经网络的的隐藏层，相当于一个程序，有输入、输出，中间有处理过程。

图 1- 10 神经网络骨架

我们仍然打开TensorFlow网站（http://playground.tensorflow.org/）的可视化平台，如图
1- 9 TensorFlow 可视化运行图，最左侧是数据的输入，最右侧 Output是数据的输出，中间
就是处理的过程，有线条连接输入层、隐藏层、输出层，就是数据处理的过程，这样一种处
理的思路和写一个Java语言的“Hello World”，使用一个 Main入口，打印一行“Hello Java”语
句，在代码编写上没有任何区别，只不过神经网络把代码分成了几个步骤，而且循环迭代。
首先是数据输入，这是第一步，做任何一个程序都有数据输入的过程；第二步进行初步的处
理；第三步进行进一步的处理，然后会得出一个中间结果，注意是中间结果，然后开始循环
遍历中间处理的过程，每一步都会对自己的处理进行一点改进。重复的次数越多，理论上处
理的效果就越好。在网站运行一下，右侧是输出的效果，代表训练的误差和测试的误差，可
以看到值的变化，最后会达到变化不太明显的状态。网页左上方有个 Epoch，Epoch 是指都
所有的数据处理了一遍，一次就是一个Epoch，不断的重复数据的处理过程，最大化的减少
误差。误差越来越小，然后变化基本不动了，基本不动或者变化非常缓慢的时候，可能停止
了训练，需要进行优化。数据有流动，从左侧流动到右侧，不断的变化，不断的变化，这里
的变化是一个循环，循环处理三个步骤，不断的循环这三个步骤，关键在于什么地方呢？关
键在于每个步骤处理完以后，下一个步重复这个步骤的时候能改进上一个步骤的表现，这是
人工智能的核心，也是和传统编程不同的地方。所以，自研神经网络首先要实现这样的一个
结构，第一层、第二层、第三层、第四层，中间的两层就相当于隐藏层，隐藏层是深度学习
比普通的机器学习强大的地方。
要想实现从左侧到右侧的功能，然后又有循环，首先要有一个结构体或者一个对象，去
实现循环。所谓的结构体或者对象就是输入层、隐藏层、输出层，这个过程和人类学习的过
程是一样的，人类永远是从错误中学习的。人类感知系统如图 1-11 所示。人有各种感知系统，类似于人工智能的数据输入，人所感知的疼痛就类似于人工智能的激活函数，得出一定
的结论供下一步去处理。人工智能的认知过程和人的认知过程是一样的。

图 1- 11 Human Nervous System 人的感知系统

如图1-12所示，Input是输入层，Output是输出层，中间有个处理的过程。神经网络对
外界的感知并做决定，很多时候需考虑不同的因素，并且不同的因素的重要性优先级不同。
权衡的因素从神经网络的角度讲是特征（Features），从数学语言的角度讲是维度（Dimension）。
例如：预测一下读者会不会喜欢这本书？书有很多特征：出版的时间、价格、作者、出版社
等等都是权衡的因素Features， CNN、 RNN之所以强大，就在于其可以自动的提取Features，
而普通的机器学习提取Features是一个非常麻烦的过程。

图 1- 12 Neural Cell

如图1-13所示，不同的特征有不同的权重，如 x1、x2、x3、x4、x5....等权重，例如是否
需要深厚的数学基础及编程语言基础是人工智能课程学习的一个权重，如果你选择了如需要
这些基础就放弃，说明这个权重对你影响很大，所以权重系数很大，权重可能为 0.9 或者
0.85；外一个因素是上课时间，可能上课时间无所谓，权重可能就为 0.1；课程中是否有足
够的项目案例，这个特别重要，这个权重可能是0.99。特征Features是衡量的因素，权重是
每个因素的重要性。要构建一个神经网络有几个点：输入层、输出层、中间的隐藏层，前面
的层对于后面的层次都有特征及权重。
图 1- 13 Constructing Nodes of Nueral Network
不同的权重可能还会加一个偏爱因子，例如项目案例非常重要，在项目权重 0.99 的基
础上，可能加一个所谓的 Bias 因子，Bias 是额外增加的一个权重。Bias 和 Weight 不一样，
Bias称之为偏爱因子。
图1-14是阿尔法狗的训练过程，人类下围棋的专家形成了一些数据，阿尔法狗通过
监督学习的算法进行一定程度的学习，这个学习就是神经网络的深度学习，学到一定程度
以后进行增强学习。

图 1- 14 阿尔法狗的学习

接下来从零起步进行自研人工智能框架代码实战。
同学们可以自行安装 Anaconda 的开发环境（https://www.anaconda.com/download/）。
进入Anaconda的控制台，启动 Spyder，Anaconda Spyder是本书机器学习和人工智能学习的
集成开发环境。如图1-15所示。
图 1- 15 Anaconda 的控制台

进入 Spyder 的 File explorer ，创建自定义的神经网络项目的文件夹目录
Artificial_Intelligence_From_Scratch。

图 1- 16 创建目录

选择 Artificial_Intelligence_From_Scratch 目录，单击齿轮图标，然后单击“Set console
working directory” ，设置成为工作目录。这步很重要，后续的所有代码将放在这个目录中，
工作目录包括了上下文信息。

图 1- 17 设置工作目录
作为自研人工智能框架的第一步，我们要写什么？从零起步编码实现多层次神经网络，
要实现四个步骤：
1) 代码实现神经网络的 Node Structure。
2) 代码实现神经网络 Layers之间Nodes的连接。
3) 如何初始化神经网络的 Weight及 AI论文阅读经验分享。神经网络的权重对于初学
者是个难点。要实现的论文中的算法，这里研究的论文是《Improving the learning
speed of 2-layer neural networks by choosing initial values of the adaptive weights》。
4) 实现多个Hidden Layer。
我们要实现的自研人工智能框架和 TensorFlow类似，可以调整增加减少neurons。第一
步我们要实现神经网络的节点结构。节点结构从面向 Java的角度讲，就是JavabBean。
我们先在 Artificial_Intelligence_From_Scratch 工作目录中建立一个子目录 entity，entity
是实体的含义。

图 1- 18 创建 entity 子目录
在 entity 的目录下创建一个节点文件 Node.py。

图 1- 19 创建 Node.py 文件

接下来我们通过代码实现多层次神经网络功能。
(1) 代码实现神经网络的 Node Structure。通过代码实现神经网络的节点结构功能：
 第一步：设置和访问 Neuron在全局所处的 Layer 层
 第二步：设置和访问 Neuron全局唯一的 ID
 第三步：设置和访问 Neuron的 Label名称
 第四步：判断当前的 Neuron是否是一个 Bias
Node.py 源代码：
1. # -*- coding: utf-8 -*-
2.
3. class Node:
4.
5. #第一步：设置和访问 Neuron 在全局所处的 Layer 层
6.
7. #设置 Neuron 在整个神经网络中唯一的 Layer 层
8. def set_level(self, level):
9. self._level = level
10.
11. #获得 Neuron 在整个神经网络中唯一的 Layer 层
12. def get_level(self):
13. return self._level
14.
15. #第二步：设置和访问 Neuron 全局唯一的ID
16.
17. #设置 Neuron 在整个神经网络中唯一的 ID
18. def set_index(self, index):
19. self._index = index
20.
21. #获得 Neuron 在整个神经网络中唯一的 ID
22. def get_index(self):
23. return self._index
24.
25. #第三步：设置和访问 Neuron的 Label 名称
26.
27.
28. #设置 Neuron 在整个神经网络 Label 名称
29. def set_label(self, label):
30. self._label = label
31.
32. #获得 Neuron 在整个神经网络 Label 名称
33. def get_label(self):
34. return self._label
35.
36.
37. #第四步：判断当前的 Neuron 是否是一个 Bias
38. 39.
40. #设置 Neuron 在整个神经网络中是否是一个 Bias
41. def set_is_bias_unit(self, is_bias_unit):
42. self._is_bias_unit = is_bias_unit
43.
44. #获得 Neuron 在整个神经网络中是否是一个 Bias
45. def get_is_bias_unit(self):
46. return self._is_bias_unit
47.
48. #获得上一个 Layer 中所有和自己有 Weight 关系的 Neuron的 Value
49. #设置给当前的 Neuron
50. def set_input_value(self,input_value):
51. self._input_value=input_value
52.
53.
54. #获得上一个 Layer 中所有和自己有 Weight 关系的 Neuron 的Value
55. def get_input_value(self):
56. return self._input_value
57.
58. #当前的 Neuron 对接收到的输入源的所有数据进行 Non-Linearity的处理后会产生
59. #具体的结果。接下来使用 getter setter 把该结果来存储和访问该非线性计算结果。
60. def set_value(self,value):
61. self._value=value
62.
63. def get_value(self):
64. return self._value
65.

(2) 代码实现神经网络 Layers之间Nodes的连接。
Weight代表了神经网络中前后层次之间的联系，循环遍历所有的节点，建立不同节
点之间的关联关系（节点不能是Bias成员），返回 weights
NetworkConnection.py代码：
1. # -*- coding: utf-8 -*-
2. from entity.Weight import Weight
3. import math
4. import random
5.
6. class NetworkConnection:
7.
8. #Weight 代表了神经网络中前后层次之间的联系
9. def create_Weights(nodes, num_of_features, hidden_layers):
10. weights = []
11. 12. #整个 Neural Network的层数= Input layers + Hidden layers + Output layers
13. total_layers = 1 + len(hidden_layers) + 1
14.
15. #记录 Weight 的 ID
16. weight_index = 0
17.
18. #Weight 发生于前后两个 Layers 之间，所以要从总的 Layer 数量中减去 1
19. for i in range(total_layers - 1):
20. #循环遍历所有的节点
21.
22. for j in range(len(nodes)):
23. #判断当前节点所在的具体的 Layer
24.
25.
26.
27. if nodes[j].get_level() == i:
28. #再次循环遍历所有的节点，核心目的在判断不同节点之间的
Layer 的先后关系
29. for k in range(len(nodes)):
30.
31. #构成 Weight 的前提条件是有前后相邻的 Layer 关系
32. if nodes[k].get_level() == i + 1:
33. #比较的 Node 之间不能是 Bias 成员
34. #当我们的设置hidden_layers = [4,2]的时候 ID 为 0、
3、8 的 Node为 Bias
35. if nodes[k].get_is_bias_unit() == False:
36. if nodes[j].get_is_bias_unit() == False:
37. #节点所在的 Layer 的 ID 越小，就越在前面，
nodes[j]在第i 层，而nodes[k]在第 i+1 层
38. #从nodes[j]触发到 nodes[k]之间创建 Weight
39. weight = Weight()
40. weight.set_weight_index(weight_index)
41. weight.set_from_index(nodes[j].get_index())
42. weight.set_to_index(nodes[k].get_index())
43.
44. #下面是5 节课内从零起步(无需数学和Python
基础)编码实现 AI 框架
45. #第一节课：从零起步编码实现多层次神经网
络的最大难点
46. # 创建 Weight 的之 Value，此时请再次运行
http://playground.tensorflow.org/
47. # 会发现 AI 运行所有的故事都是在更新
Weight 的值
48. 49. #具体算法实现请参考本课程群内部的文件
50. range_min = 0
51. range_max = 1
52.
53. init_epsion = math.sqrt(6) /
(math.sqrt(num_of_features) + 1)
54.
55. rand = range_min + (range_max - range_min) *
random.random()
56. rand = rand * (2 * init_epsion) -init_epsion
57.
58. weight.set_value(rand)
59.
60.
61. weights.append(weight) #加入到 weights 集合中
62.
63. weight_index = weight_index + 1
64. print("The weight from " +
str(nodes[j].get_index()) + " to "+ str(nodes[k].get_index()) + " : " + str(rand))
65.
66.
67.
68.
69. return weights
70.

(3) 如何初始化神经网络的 Weight及 AI论文阅读经验分享。神经网络的权重对于初学
者是个难点。
 第一步：设置和访问 Weight的的 ID
 第二步：设置和访问 Weight的来源节点
 第三步：设置和访问 Weight的目标节点
 第四步：设置和访问 Weight的值
Weight.py 的源代码：
1. # -*- coding: utf-8 -*-
2.
3. class Weight:
4.
5.
6. #第一步：设置和访问 Weight 的的 ID
7. def set_weight_index(self, weight_index):
8. self._weight_index = weight_index
9.
10. def get_weight_index(self):
11. return self._weight_index 12.
13. #第二步：设置和访问 Weight 的来源节点
14. def set_from_index(self, from_node_index):
15. self._from_index = from_node_index
16.
17. def get_from_index(self):
18. return self._from_index
19.
20.
21. #第三步：设置和访问 Weight 的目标节点
22. def set_to_index(self, to_node_index):
23. self._to_node_index = to_node_index
24.
25. def get_to_index(self):
26. return self._to_index
27.
28. #第四步：设置和访问 Weight 的值
29. def set_value(self, value):
30. self._value = value
31.
32. def get_value(self):
33. return self._value
34.

(4) 实现多个Hidden Layer。
创建整个神经网络的所有节点。
NetworkStructure.py 源代码：
1. # -*- coding: utf-8 -*-
2.
3. #导入要使用的 Node 类
4. from entity.Node import Node
5. class NetworkStructure:
6.
7. #创建整个神经网络的所有节点
8. def create_nodes(num_of_features, hidden_layers):
9. nodes = []
10.
11. nodeIndex = 0 #Neuron 的 ID
12.
13. #Input layer
14.
15. #Bias Unit
16. 17. node = Node()
18. node.set_level(0)
19. node.set_index(nodeIndex)
20. node.set_label("+1")
21. node.set_is_bias_unit(True)
22. nodes.append(node)
23. nodeIndex = nodeIndex + 1
24.
25. print(node.get_label(), "\t", end = '')
26.
27.
28. for i in range(num_of_features):
29. print("V" + str(i+1) + "\t", end = '')
30. node = Node()
31. node.set_level(0)
32. node.set_index(nodeIndex)
33. node.set_label("+1")
34. node.set_is_bias_unit(False)
35. nodes.append(node)
36. nodeIndex = nodeIndex + 1
37.
38. print("")
39.
40. #Hidden layer
41. for i in range(len(hidden_layers)):
42. print("Hidden layer creation: ", end = '')
43.
44. #Bias Unit
45.
46. node = Node()
47. node.set_level(i+1)
48. node.set_index(nodeIndex)
49. node.set_label(i+1)
50. node.set_is_bias_unit(True)
51. nodes.append(node)
52. nodeIndex = nodeIndex + 1
53.
54. print(node.get_label(), "\t", end = '')
55.
56. #创建该 layer 的 Neurons
57. for j in range(hidden_layers[i]):
58. #创建该 layer 内部的 Neuron
59. node = Node()
60. node.set_level(i+1) 61. node.set_index(nodeIndex)
62. node.set_label("N[" + str(i+1) + "][" + str(j + 1) + "]")
63. node.set_is_bias_unit(False)
64. nodes.append(node)
65. nodeIndex = nodeIndex + 1
66.
67. print(node.get_label(), "\t", end = '')
68.
69.
70. print("")
71.
72. #Output layer
73. node = Node()
74. node.set_level(1 + len(hidden_layers))
75. node.set_index(nodeIndex)
76. node.set_label("Output")
77. node.set_is_bias_unit(False)
78. nodes.append(node)
79. nodeIndex = nodeIndex + 1
80. print("Output layer: ", node.get_label())
81.
82. return nodes
83.
84.

(5) 整个AI人工智能框架的入口类是Neuron_Network_Entry.py，我们创建实例instances、
神经元节点、隐藏层等变量，然后创建相互之间的权重连接关系。
Neuron_Network_Entry.py
1. # -*- coding: utf-8 -*-
2. from service.NetworkStructure import NetworkStructure
3. from service.NetworkConnection import NetworkConnection
4. #from entity.Node import Node
5. #Exclusive OR: 只有第一个元素和第二个元素不同的时候，结果才是 1，否则为 0
6. instances = [[0,0,0],
7. [0,1,1],
8. [1,0,1],
9. [1,1,0]]
10.
11. num_of_features = len(instances[0]) - 1 #在这里是只有第一列和第二列是 features，第三列
是根据某种关系而得出的结果
12.
13. hidden_layers = [4,2] #这里 hardcode 为两个 Hidden layer，第一个 Hidden Layer 有 4 个
Neuron，第二个 Hidden Layer 有连个 Neuron
14. #hidden_layers = [8,4,2] 15. nodes = NetworkStructure.create_nodes(num_of_features,hidden_layers)
16.
17. #ID 为 0、3、8 的 Node 为 Bias
18. #for i in range(len(nodes)):
19. # print("This is a bias:" + str(nodes[i].get_is_bias_unit()))
20.
21. weights = NetworkConnection.create_Weights(nodes,num_of_features, hidden_layers)
22.
23.

Neuron_Network_Entry.py 的运行结果如下：
1. +1 V1 V2
2. Hidden layer creation: 1 N[1][1] N[1][2] N[1][3]
N[1][4] Hidden layer creation: 2 N[2][1] N[2][2]
3. Output layer: Output
4. The weight from 1 to 4 : 0.13435033348808822
5. The weight from 1 to 5 : -0.8746277847113736
6. The weight from 1 to 6 : -0.8013636576296298
7. The weight from 1 to 7 : -0.20116942166494012
8. The weight from 2 to 4 : -0.19491319773895655
9. The weight from 2 to 5 : -0.9890612748469597
10. The weight from 2 to 6 : -0.9366153095486941
11. The weight from 2 to 7 : 0.19916644350391421
12. The weight from 4 to 9 : -0.3796380006519604
13. The weight from 4 to 10 : -0.604548306776146
14. The weight from 5 to 9 : 0.8551829387383982
15. The weight from 5 to 10 : 0.4617959177774711
16. The weight from 6 to 9 : -0.8052493675763375
17. The weight from 6 to 10 : 0.914614435777299
18. The weight from 7 to 9 : -0.5682949753457094
19. The weight from 7 to 10 : -0.8842628312130644
20. The weight from 9 to 11 : 0.20155741846708497
21. The weight from 10 to 11 : 0.0771101729511281

这里是hidden_layers = [4,2] 为两个Hidden layer，第一个Hidden Layer有4个Neuron，
第二个Hidden Layer有2个Neuron。整个神经元网络有12 个节点，其中ID为 0、3、8
的 Node 为Bias节点，ID为 1，2 的是输入层，分别关联到 4、5、6、7节点，然后4、
5、6、7节点分别关联到下一个隐藏层的节点9，10 节点；9，10节点最后输出到输出
层节点ID 11 ，打印出各权重的结果。

本节课的作业： Python 中的方法带self、与不带self的区别？
(1) 带self，例如：
class Node: def set_index(self,index):
self._index = index

要创建一个实例来调用方法。
node = Node()
node.set_index(nodeIndex)

(2) 不带self，直接调用这个方法。
例如：
class NetworkStructure:
def create_nodes(num_of_features,hidden_nodes):
可以直接调用：
nodes = NetworkStructure.create_nodes(num_of_features,hidden_nodes)

3、第二节课：从零起步在框架中编码实现 Feed Propagation
功能
非常高兴在硅谷通过网络和大家分享人工智能的系列内容，这节课是我们完全从零起步
编码实现自己的或自定义框架的第二节课，如果大家遵循我们第一节课、第二节课、第三节
课直至第五节课的内容，你不需要任何数学基础，也不需要任何 Python 基础，你就可以开
发出人工智能框架！而开发人工智能框架的思想和业界商业界最成功应用的TensorFlow、突
然崛起的最先进的Pytorch的思想是类似的。
我们的课程属于接下来的两个课程的前置课程：
1，每周一到周六早上 6:00-7:00：30 个真实商业案例代码中习得 AI：10 大机器学习案
例、13大深度学习案例、7 大增强学习案例。
2，每周日上午10:30-12:00：AI的上帝视角：从零起步开发自己的AI人工智能框架（同
类型的框架例如TensorFlow 和 PyTorch等）
我们的 30 个商业案例全是真实的商业案例，到时现场直播的时候大家就会发现这是非
常非常有意义的！掌握了这 30 个商业案例，如果你不是想自己开发一个人工智能框架，或
者带领一个团队开发一个人工智能框架，要与Google、 FaceBook在技术领域竞争或者交流，
那么我们的 30 个真实的商业案例基本上满足了你以后 30 年在人工智能领域的工作了，以
后的工作基本上就是修修改改，满足你各类型的业务需求！
在这里我回答一个问题：为什么一开始我们就讲人工智能框架的开发？
我们讲30个真实商业案例是基于框架的，例如：TensorFlow 和PyTorch、增强学习使用
公益组织提供的一个增强学习的平台，测试各种增强学习的效果。之所以这么做，我们不借
助其他的框架，也不借助 Python 的机器学习框架，我们从零起步开发人工智能框架，核心
目的有以下三点：
1) 让大家真正理解人工智能框架，这里指深度学习框架，其内部工作机制是怎么运作
的。通过自己写代码懂得了框架怎么运行的，写代码进行了实现，再学习TensorFlow
就易如反掌，再开发任何级别的人工智能的应用程序就非常简单，你就能居高临下。
这是我们的第一个目的。
2) 第二个目的：如果你自己开发，即使不加入我们的周日课程，你用5 节课开发一个
最基本的人工智能框架，那你做商业应用程序的时候内心会很淡定很从容，就能知
道 TensorFlow 内部大致是怎么回事情，这和你听听别人讲解，而不是自己写的代
码，那完全是两回事。 3) 家林老师这几年在硅谷，5 到 10 年的时间也会将硅谷，硅谷是大数据，也是人工
智能的核心发源地，为了追求心中技术的梦想一直会在硅谷，很希望在国内培养一
批人工智能方面的领军人物。

无论你是学习 30 个真实商业案例的课程，还是从零起步开发自己的人工智能框架，我
们都希望大家有个很好的基础，希望大家成为自己所在公司的人工智能的精神领袖和实战专
家！ 30 个真实商业案例从 4月9 日开始做一个铺垫，会有100天左右的直播；从零起步开
发人工智能框架，将实现类似 Pytorch 的动态图的非常先进的功能，不亚于 TensorFlow、
Pytorch，每周日上午10:30-12:00 的课程会一直持续到 2020年9 月27 日。

本节课是 5 节课内从零起步(无需数学和 Python 基础)编码实现 AI 框架之第二节课：从
零起步在框架中编码实现 Feed Propagation 功能。本节课从零起步在框架中编码实现 Feed
Propagation功能：
1) 在每个Node 上增加数据的输入和计算结果 Getter和Setter
2) 实现 Forward Propagation算法
3) 使用sigmoid函数作为 Activation函数
4) 测试并分析计算结果

(1) 在每个Node 上增加数据的输入和计算结果 Getter和Setter。
在第一节课的基础上，我们在 Node.py 文件中增加数据的输入和计算结果 Getter 和
Setter。
 通过get_input_value 、set_input_value 方法获得上一个 Layer中所有和自己有权重
（Weight）关系的 Neron的值 Values，并设置给当前的Neuron。
 通过 get_value、set_value 方法获得经过非线性计算后的结果，并设置给当前的
Neuron。
Node.py源代码如下：
1. …….
2. #获得上一个 Layer 中所有和自己有 Weight 关系的 Neron的 Values 并设置给当然的
3. Neuron
4. def set_input_value(self, input_value):
5. self._input_value = input_value
6.
7. #获得当前 Neuron 中接收到的上一个 Layer 中所有和自己有 Weight 关系的 Neron
的 Values
8. def get_input_value(self):
9. return self._input_value
10.
11. #当前的 Neuron 多接受到的输入源的所有数据进行 Non-Linearity的处理后会产生
具体的结果
12. #接下来使用 setter 和 getter 把来存储和访问该非线性计算结果
13.
14. #获得经过非线性计算后的结果并设置给当前的 Neuron
15. def set_value(self, value):
16. self._value = value 17.
18. #获得当前 Neuron 的Value
19. def get_value(self):
20. return self._value
21.

(2) 实现 Forward Propagation算法
本节课的核心内容是实现前向传播（Forward Propagation）算法。如下图：例如假
设上一层结点 i,j,k,…等一些结点与本层的结点 w 有连接，那么结点 w 的值怎么算呢？
通过上一层的 i,j,k 等结点以及对应的连接权值进行加权和运算，（本节这里前向传播算
法过滤掉Bias因子节点），再通过一个非线性函数（即激活函数如sigmoid函数）计算，
最后得到的结果就是本层结点w 的输出。
图中前向传播算法的计算：
 先进行节点值及权重系数乘积的求和计算：（1*3+0*8+1*4）-1 =6。
 激活函数进行归一化处理，将6 转换为输出结果1。

ForwardPropagation.py 的源代码如下：
1. # -*- coding: utf-8 -*-
2. #完成从 Input Layer,经过若干层的 Hidden Layers,最后得出 Output Layer 的值
3. import math
4. class ForwardPropagation:
5.
6. def applyForwardPropagation(nodes, weights, instance):
7. for i in range(len(nodes)):
8. if nodes[i].get_is_bias_unit() == True:
9. nodes[i].set_neuron_value = 1
10.
11.
12. # 把数据输入到 Input Layer
13. #例如说处理 instance = [0,1,1]
14.
15. for j in range(len(instance) - 1): #训练的时候只需要 features
16. value_of_feature = instance[j] #获得该条数据中每个 Feature 具体的值
17.
18.
19. for k in range(len(nodes)):
20. 21. if j + 1 == nodes[k].get_index(): #索引为0 的节点为 Bias，所以从索引
为 1 的 Node 开始
22. nodes[k].set_value(value_of_feature)
23.
24.
25. #Hidden Layer 的处理
26. for j in range(len(nodes)):
27. if nodes[j].get_is_bias_unit() == False and nodes[j].get_level() > 0 :
28.
29. target_neuron_input = 0 #接受上一个 Layer 中所有的和自己相关的
Neurons 和 Weights 的乘积之和
30. target_neuron_output = 0 #经过 Non-Linearity后的输出，我们这里使
用 Sigmoid
31. #获得当前 Neuron的 ID
32. target_index = nodes[j].get_index()
33.
34. for k in range(len(weights)):
35. #获得和当前的 Neuron 关联的 Weight
36. if target_index == weights[k].get_to_index():
37. #获得该 Weight 的 Value
38. weight_value = weights[k].get_value()
39. #获得该 Weight 的来源的 Neuron的 ID
40. from_index = weights[k].get_from_index()
41.
42. #获得该来源 Neuron 的Value
43. for m in range(len(nodes)):
44. #获得该 ID的 Neuron
45. if from_index == nodes[m].get_index():
46. #获得该 Neuron 的具体的 Value
47. value_from_neuron = nodes[m].get_value()
48.
49. #把 Weight 和相应的 Value 相乘，然后累加
50. target_neuron_input = target_neuron_input +
(weight_value * value_from_neuron)
51.
52. #一个 Weight 只连接一个上一个 Layer 的 Neuron，
所以不需要继续循环真个神经网络的其它 Neurons'
53. break
54.
55. #从和 Break对其出发，一共按了 4 次后退键，因为接下来是要应用
Sigmoid 多当前的 Neuron 的所有的输入累计后的值进行操作
56. target_neuron_output = 1 / (1 + math.exp(- target_neuron_input))
57. 58. #接下来把输入值和当然 Neuron 采用 Sigmoid Activation 计算后的值
设置进当前的 Neuron
59. nodes[j].set_input_value(target_neuron_input)
60. nodes[j].set_value(target_neuron_output)

(3) 使用sigmoid函数作为 Activation激活函数。
Sigmoid 函数是一个在生物学中常见的 S 型的函数，也称为 S 型生长曲线。在信息科学
中，由于其单增以及反函数单增等性质，Sigmoid 函数常被用作神经网络的阈值函数，
将变量映射到0,1 之间。实现归一化处理。
本节案例我们使用简单的指数函数进行归一化处理。即通过 Sigmoid 将当前的 Neuron
的所有的输入累计后的值进行操作，target_neuron_input 通过 1 / (1 + math.exp(-
target_neuron_input))，计算结果作为输出值target_neuron_output。

ForwardPropagation.py 源代码实现如下：
1. …..
2. #从和 Break对其出发，一共按了 4 次后退键，因为接下来是要应用 Sigmoid 多当前的
Neuron 的所有的输入累计后的值进行操作
3. target_neuron_output = 1 / (1 + math.exp(- target_neuron_input))
4. ……

(4) 测试并分析计算结果。
在 Neuron_Network_Entry.py 文件中修改代码，从 Input Layer触发，经过所有的 Hidden
Layers的处理，最终得出Output Layer的结果。
Neuron_Network_Entry.py源代码如下：
1. …….
2. #从 Input Layer 触发，经过所有的 Hidden Layers 的处理，最终得出 Output Layer 的结
果。
3.
4. for i in range(len(instances)):
5. instance = instances[i]
6.
7. ForwardPropagation.applyForwardPropagation(nodes, weights, instance)
8.
9. #得出此次 Forward Propagation 的输出结果
10. print("Prediction: " + str(nodes[len(nodes) - 1].get_value()))
11.

Neuron_Network_Entry.py的运行结果如下：
1. +1 V1 V2
2. Hidden layer creation: 1 N[1][1] N[1][2] N[1][3]
N[1][4] N[1][5] N[1][6] N[1][7] N[1][8]
3. Hidden layer creation: 2 N[2][1] N[2][2] N[2][3]
N[2][4]
4. Hidden layer creation: 3 N[3][1] N[3][2]
5.
6. Output layer: Output
7. The weight from 1 at layers[0] to 4 at layers[1] : 0.682010054426426
8. The weight from 1 at layers[0] to 5 at layers[1] : 0.4462749257618013
9. The weight from 1 at layers[0] to 6 at layers[1] : 0.16160202385864175
10. The weight from 1 at layers[0] to 7 at layers[1] : -0.8293483877977663
11. The weight from 1 at layers[0] to 8 at layers[1] : 0.8425783956944617
12. The weight from 1 at layers[0] to 9 at layers[1] : -0.09707734276349977
13. The weight from 1 at layers[0] to 10 at layers[1] : 0.19246729112981065
14. The weight from 1 at layers[0] to 11 at layers[1] : -0.07144351444843577
15. The weight from 2 at layers[0] to 4 at layers[1] : 0.9655120959373438
16. The weight from 2 at layers[0] to 5 at layers[1] : 0.412297300185698
17. The weight from 2 at layers[0] to 6 at layers[1] : -0.47246534784877203
18. The weight from 2 at layers[0] to 7 at layers[1] : -0.12471427081208997
19. The weight from 2 at layers[0] to 8 at layers[1] : -0.6382557927597117
20. The weight from 2 at layers[0] to 9 at layers[1] : 0.10738693446830583
21. The weight from 2 at layers[0] to 10 at layers[1] : -0.025251306294619247
22. The weight from 2 at layers[0] to 11 at layers[1] : 0.08577583858433924
23. The weight from 4 at layers[1] to 13 at layers[2] : 0.4205437000804866
24. The weight from 4 at layers[1] to 14 at layers[2] : 0.6714193541057805
25. The weight from 4 at layers[1] to 15 at layers[2] : 0.978499088182812
26. The weight from 4 at layers[1] to 16 at layers[2] : 0.40008688442906704
27. The weight from 5 at layers[1] to 13 at layers[2] : 0.9060350693349206
28. The weight from 5 at layers[1] to 14 at layers[2] : -0.954780134506903
29. The weight from 5 at layers[1] to 15 at layers[2] : 0.2002488166002787
30. The weight from 5 at layers[1] to 16 at layers[2] : -0.6783558210922017
31. The weight from 6 at layers[1] to 13 at layers[2] : -0.5080667016535712
32. The weight from 6 at layers[1] to 14 at layers[2] : -0.5164272805019525
33. The weight from 6 at layers[1] to 15 at layers[2] : -0.15325930283914424
34. The weight from 6 at layers[1] to 16 at layers[2] : -0.3511553702447253
35. The weight from 7 at layers[1] to 13 at layers[2] : 0.8839918451858777
36. The weight from 7 at layers[1] to 14 at layers[2] : -0.6242276041022798
37. The weight from 7 at layers[1] to 15 at layers[2] : -0.8719713647888472
38. The weight from 7 at layers[1] to 16 at layers[2] : 0.5821146360823584
39. The weight from 8 at layers[1] to 13 at layers[2] : -0.14909760993973764
40. The weight from 8 at layers[1] to 14 at layers[2] : -0.3889436600158289 41. The weight from 8 at layers[1] to 15 at layers[2] : -0.9584174395773749
42. The weight from 8 at layers[1] to 16 at layers[2] : 0.5349114755539881
43. The weight from 9 at layers[1] to 13 at layers[2] : -0.8054789129243652
44. The weight from 9 at layers[1] to 14 at layers[2] : -0.1624957942951466
45. The weight from 9 at layers[1] to 15 at layers[2] : -0.3449863660814254
46. The weight from 9 at layers[1] to 16 at layers[2] : -0.040445297924280865
47. The weight from 10 at layers[1] to 13 at layers[2] : -0.5636343487353018
48. The weight from 10 at layers[1] to 14 at layers[2] : -0.6331043052233007
49. The weight from 10 at layers[1] to 15 at layers[2] : 0.9258612666017985
50. The weight from 10 at layers[1] to 16 at layers[2] : 0.07836601506397933
51. The weight from 11 at layers[1] to 13 at layers[2] : -0.9801755029220328
52. The weight from 11 at layers[1] to 14 at layers[2] : 0.8581871213959458
53. The weight from 11 at layers[1] to 15 at layers[2] : -0.03585909343817084
54. The weight from 11 at layers[1] to 16 at layers[2] : -0.8362853166389556
55. The weight from 13 at layers[2] to 18 at layers[3] : 0.9352117750168787
56. The weight from 13 at layers[2] to 19 at layers[3] : 0.3384623166221661
57. The weight from 14 at layers[2] to 18 at layers[3] : -0.1925801474485741
58. The weight from 14 at layers[2] to 19 at layers[3] : 0.6629615274975045
59. The weight from 15 at layers[2] to 18 at layers[3] : -0.5156626918145072
60. The weight from 15 at layers[2] to 19 at layers[3] : -0.7717488675712948
61. The weight from 16 at layers[2] to 18 at layers[3] : -0.04612918490370388
62. The weight from 16 at layers[2] to 19 at layers[3] : 0.9760033825108967
63. The weight from 18 at layers[3] to 20 at layers[4] : -0.64341229565003
64. The weight from 19 at layers[3] to 20 at layers[4] : 0.6741240645845519
65. Prediction: 0.5190028617090506
66. Prediction: 0.5177101237343301
67. Prediction: 0.5185081918463893
68. Prediction: 0.5172200931191119

对于 instances 数据，矩阵的第一列、第二列是输入数据的特征值，第三列是异或
结果，在instances数据中，只有第一个元素和第二个元素不同的时候，结果才是1，否
则为0。
1. instances = [[0,0,0],
2. [0,1,1],
3. [1,0,1],
4. [1,1,0]]

本节我们使用神经网络进行计算，预测 instances的第一行数据（0，0）的结果值
是 0.5190028617090506，预计结果应为 0，第 2 行数据（0，1）的结果值是
0.5177101237343301预计结果应为1，第3行数据（1， 0）的结果值是0.5185081918463893，
预计结果应为1，第4 行数据（1，1）的结果值是0.5172200931191119，预计结果应为
0。因为这里只进行了1 次迭代计算，也类似TensorFlow 开始运行时损失曲线50%，后
续将进行版本迭代优化。
1. Prediction: 0.5190028617090506 2. Prediction: 0.5177101237343301
3. Prediction: 0.5185081918463893
4. Prediction: 0.5172200931191119

4、第三节课：从零起步在框架中编码实现 Back Propagation
功能
非常高兴在美国硅谷通过网络和大家分享人工智能的内容，这里分享的是人工智能最开
始的 5 节课的内容，这 5 节课的内容告诉大家如何在没有 Python、数学基础的情况下能够
开发出自己的 AI 框架，我们这节课是第三课。前面第一节课完成的是深度学习的骨架、网
络结构；第二节课分享的是 Forward Propagation实现，这节课实现的是Back Propagation。
Forward propagation 和Back Propagation 一来一回，形成了深度学习的神经网络能够学习最
重要的过程，输入端到输出端运行的时候往往有误差，需要我们回顾过去，分析哪些因子导
致了这些误差。

我们的直播课程在完成这5 节课程以后，将带领大家每周一到周六早上6:00-7:00 讲30
个项目案例，每周日上午 10:30-12:00 从零起步开发自己的 AI 人工智能框架，讲 2 年多时
间，从2018 年 4 月9 日开始，2020 年 9 月 27 日结束。为什么讲 2 年，老师将带领周日上
课的同学开发出类似 TensorFlow、Pytorch 的人工智能框架，家林老师在 2017 年 6 月 22 日
已开发出自己的人工智能框架，周六只讲真实案例的实战，所以不需要数学基础，不需要
Python 语言基础，围绕项目实战！如果想成为解决问题的高手，上周一至周六的课程就够
了。
周一到周六30个项目案例的报名价格是19800元。
周日的框架开发将在报名的学员中家林老师将亲自筛选 10 名，周六（2018 年 4 月 14
日）发布标准开始筛选，筛选需一周的时间，下周日的时候给大家最终的结果，周日的课程
除了选定10 的名学员以外，从第 11名开始按年收费，每个星期只上1次课程，按年收费每
年30万人民币。

本节课内容：
1) DeepLearning是具体是如何学习的？
2) 实现Back Propagation算法
3) 测试并分析计算结果

ForwardPropagation.py源代码中增加返回值：
1. …….
2. return nodes

BackPropagation.py的源代码：
1. # -*- coding: utf-8 -*-
2. from service.ForwardPropagation import ForwardPropagation
3.
4. #完成 Deep Learning Framework 中最为核心的功能：Back Propagation:
5. #第一步：从误差的结果出发，从最右侧到最左侧（不包含 Input Layer）遍历整个
Neuron Network 构成的 Chain； 6. #第二步：在遍历的时候计算每个 Neuron 对误差结果应该负的责任；
7. #第三步：进行 Derivative 计算；
8. #第四步：通过 Gradient Desendent 来调整 Weights 的值以减少预测的误差
9. class BackPropagation:
10.
11. def applyBackPragation(instances, nodes, weights, learning_rate):
12.
13. num_of_features = len(instances[0]) - 1 #记录输入的 Features 的个数，instance 的
最后一列是 Real Result
14.
15. #循环遍历所有的 Training Dataset 完成一个 Epoch 并进行每个节点所负责的
Error 的记录
16. for i in range(len(instances)):
17.
18. #使用 Forward Propagation 从 Input Layer 出发，经过 Hidden Layers,最后获
得 Output
19. nodes = ForwardPropagation.applyForwardPropagation(nodes, weights,
instances[i])
20. predicted_value = nodes[len(nodes) - 1].get_value() #记录该次 Forward
Propagation 最终的误差
21.
22.
23. actual_value = instances[i][num_of_features] #获得当前 instance 的 Real
Value
24.
25. minor_error = predicted_value - actual_value #计算预测值和真实值之间的误
差
26.
27. nodes[len(nodes)-1].set_minor_error(minor_error) #把该误差值设置进 Output
Layer 中的输出节点中
28.
29. #因为输出节点已经计算完误差，所以会减掉 2；
30. #因为 Input Layer 不参与计算，所以 range 的三个参数中的第二个参数是
num_of_features
31. #该循环遍历是从 Output Layer 的前面的一个 Hidden Layer 开始的，或者
说是从最后一个 Hidden Layer 开始的
32. for j in range(len(nodes)-2, num_of_features, -1):
33. target_index = nodes[j].get_index() #从最后一个 Hidden Layer 的最后一
个 Neuron 开始计算，然后依次向前
34.
35. sum_minor_error = 0 #存储当前 Neuron 应该为误差所要负的责任
36.
37. #循环遍历所有的 Weights 以获得以 target_index为出发点的所有
Weights 38. for k in range(len(weights)):
39. #如果当前的 Weight 是以 target_index所在的 Neuron 为出发节
点，则说明该 Weight 需要多结果负(直接)责任
40. if weights[k].get_from_index() == target_index:
41.
42. affecting_theta = weights[k].get_value() #获得当前 Weight 的
Value
43.
44. affected_minor_error = 1 #初始化当前 Neuron 对结果影响的
Value
45.
46. target_minor_error_index = weights[k].get_to_index() #计算当
前 Neuron 所影响的下一个 Layer 中具体的 Neuron 的 ID
47.
48. for m in range(len(nodes)):
49. if nodes[m].get_index() == target_minor_error_index:
50. affected_minor_error = nodes[m].get_minor_error()
51.
52. #获得当前 Weight 的触发 Neuron 对结果负责任的具体的值
53. updated_minor_error = affecting_theta * affected_minor_error
54.
55. #把对下一个 Layer 中具体误差负责任的所有误差都累加到
当前 Neuron 并保存到当前的 Neuron 中
56. sum_minor_error = sum_minor_error + updated_minor_error
57. #保存当前的 Neuron 对下一个 Layer 的所有的 Neurons 所造成的 Loss
影响的总和
58. nodes[j].set_minor_error(sum_minor_error)
59.
60. #这里是对我们在 ForwardPropagation 使用的是 Sigmoid Activation，所以这里
是对 Sigmoid 进行求导
61. # 然后更新
Weights！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
！！！
62. for j in range(len(weights)):
63. weight_from_node_value = 0
64. weight_to_node_value = 0
65. weight_to_node_error = 0
66.
67. for k in range(len(nodes)):
68.
69. if nodes[k].get_index() == weights[j].get_from_index():
70. weight_from_node_value = nodes[k].get_value()
71.
72. if nodes[k].get_index() == weights[k].get_to_index(): 73. weight_to_node_value = nodes[k].get_value()
74. weight_to_node_error = nodes[k].get_minor_error()
75.
76.
77. #进行求导，因为我们在 ForwardPropagation 使用的是 Sigmoid
Activation，所以这里是对 Sigmoid 进行求导
78. # Forward Propagation 中的 Sigmoid 代码：target_neuron_output = 1 / (1 +
math.exp(- target_neuron_input))
79.
80. derivative = weight_to_node_error * (weight_to_node_value * (1 -
weight_to_node_value
81. )) *
weight_from_node_value
82.
83. #更新 Weight，这是下次计算的时候能够更加准确的关键，因为把上面的
计算成果运用在了调整 Neuron Network的 Weights 上
84. weights[j].set_value(weights[j].get_value() - derivative * learning_rate)
85.
86.
87. return nodes, weights
88.

Neuron_Network_Entry.py
1. ……
2. epoch = 100000
3. learning_rate=0.1
4.
5. for i in range(epoch):
6. nodes,weights=
BackPropagation.applyBackPragation(instances,nodes,weights,learning_rate)

运行结果如下：
1. +1 V1 V2
2. Hidden layer creation: 1 N[1][1] N[1][2] N[1][3]
N[1][4] N[1][5] N[1][6] N[1][7] N[1][8]
3. Hidden layer creation: 2 N[2][1] N[2][2] N[2][3]
N[2][4]
4. Hidden layer creation: 3 N[3][1] N[3][2]
5.
6. Output layer: Output
7. The weight from 1 at layers[0] to 4 at layers[1] : 0.014754395461041403
8. The weight from 1 at layers[0] to 5 at layers[1] : 0.4852675953091179
9. The weight from 1 at layers[0] to 6 at layers[1] : -0.04730302732915692
10. The weight from 1 at layers[0] to 7 at layers[1] : 0.8328414197074481 11. The weight from 1 at layers[0] to 8 at layers[1] : -0.292038833157093
12. The weight from 1 at layers[0] to 9 at layers[1] : 0.36985194298359403
13. The weight from 1 at layers[0] to 10 at layers[1] : 0.5863269939947326
14. The weight from 1 at layers[0] to 11 at layers[1] : -0.058199463488485925
15. The weight from 2 at layers[0] to 4 at layers[1] : -0.06391839587513704
16. The weight from 2 at layers[0] to 5 at layers[1] : 0.7155263421232831
17. The weight from 2 at layers[0] to 6 at layers[1] : 0.7929838794184614
18. The weight from 2 at layers[0] to 7 at layers[1] : -0.7692820599673437
19. The weight from 2 at layers[0] to 8 at layers[1] : 0.6461702707507939
20. The weight from 2 at layers[0] to 9 at layers[1] : -0.7691783670361847
21. The weight from 2 at layers[0] to 10 at layers[1] : 0.1427196162091069
22. The weight from 2 at layers[0] to 11 at layers[1] : 0.23743848194973216
23. The weight from 4 at layers[1] to 13 at layers[2] : 0.6052229799647102
24. The weight from 4 at layers[1] to 14 at layers[2] : -0.176208412308542
25. The weight from 4 at layers[1] to 15 at layers[2] : -0.0971505490245631
26. The weight from 4 at layers[1] to 16 at layers[2] : -0.7851333794894211
27. The weight from 5 at layers[1] to 13 at layers[2] : 0.8340699603325874
28. The weight from 5 at layers[1] to 14 at layers[2] : -0.4953866016439531
29. The weight from 5 at layers[1] to 15 at layers[2] : 0.300134717197019
30. The weight from 5 at layers[1] to 16 at layers[2] : -0.3410805860986401
31. The weight from 6 at layers[1] to 13 at layers[2] : -0.05099358623099992
32. The weight from 6 at layers[1] to 14 at layers[2] : 0.6770340678151971
33. The weight from 6 at layers[1] to 15 at layers[2] : -0.3399588934067035
34. The weight from 6 at layers[1] to 16 at layers[2] : -0.36481726753031773
35. The weight from 7 at layers[1] to 13 at layers[2] : -0.3557995724109385
36. The weight from 7 at layers[1] to 14 at layers[2] : -0.21130922293946441
37. The weight from 7 at layers[1] to 15 at layers[2] : -0.3503562853274226
38. The weight from 7 at layers[1] to 16 at layers[2] : -0.58603113217164
39. The weight from 8 at layers[1] to 13 at layers[2] : 0.6620007049827901
40. The weight from 8 at layers[1] to 14 at layers[2] : 0.5428075846795659
41. The weight from 8 at layers[1] to 15 at layers[2] : -0.6968294407883738
42. The weight from 8 at layers[1] to 16 at layers[2] : -0.6477770513493042
43. The weight from 9 at layers[1] to 13 at layers[2] : -0.8814785316164266
44. The weight from 9 at layers[1] to 14 at layers[2] : -0.5402344713592881
45. The weight from 9 at layers[1] to 15 at layers[2] : -0.21791220078736018
46. The weight from 9 at layers[1] to 16 at layers[2] : -0.5927862722093897
47. The weight from 10 at layers[1] to 13 at layers[2] : -0.5857985964431403
48. The weight from 10 at layers[1] to 14 at layers[2] : 0.5621070507473107
49. The weight from 10 at layers[1] to 15 at layers[2] : -0.32785236322128597
50. The weight from 10 at layers[1] to 16 at layers[2] : 0.5168866366231784
51. The weight from 11 at layers[1] to 13 at layers[2] : 0.2653645801268325
52. The weight from 11 at layers[1] to 14 at layers[2] : -0.8283554568707727
53. The weight from 11 at layers[1] to 15 at layers[2] : -0.34734329416660203
54. The weight from 11 at layers[1] to 16 at layers[2] : 0.02855335929143199 55. The weight from 13 at layers[2] to 18 at layers[3] : 0.7571692716017584
56. The weight from 13 at layers[2] to 19 at layers[3] : 0.38199702838698024
57. The weight from 14 at layers[2] to 18 at layers[3] : 0.48899162049930633
58. The weight from 14 at layers[2] to 19 at layers[3] : 0.3846848263168843
59. The weight from 15 at layers[2] to 18 at layers[3] : 0.6777881462245301
60. The weight from 15 at layers[2] to 19 at layers[3] : 0.04792435974248255
61. The weight from 16 at layers[2] to 18 at layers[3] : -0.47975304566677224
62. The weight from 16 at layers[2] to 19 at layers[3] : -0.39110771186712434
63. The weight from 18 at layers[3] to 20 at layers[4] : -0.7800338665855491
64. The weight from 19 at layers[3] to 20 at layers[4] : -0.762021553391644
65. Prediction: 0.27563657064323516
66. Prediction: 0.2699850961962282
67. Prediction: 0.2780605556964589
68. Prediction: 0.27220177815008695

本节课作业：根据今天的视频自己手动写代码实现Back Propagation并画出Back
Propagation工作流程图

Back Propagation工作流程图：
这里致谢网友提供的三层神经网络的后向传播算法实现过程图，清楚的阐述了 Back
Propagation的算法过程：
每个神经元有两个单元组成。一个是权重和输入信号。另一个是非线性单元，叫做激
励函数。信号e 是激励信号。y = f(e) 是非线性单元的输出，即是神经元的输出。

为了训练神经网络，我们需要训练数据。训练数据由输入信号(x1 and x2 )和期望输出 z
组成。网络的训练过程是一个迭代处理的过程。训练数据集用来在每次迭代过程中更新神
经元的权重。每次学习过程由来自训练数据的输入信号开始。我们可以得出每一层的输
出。下图说明信号在神经网络的传输路线。w(xm)n 是神经元 xm 在第 n层输入的连接权
重。 yn 表示神经元n的输出。



隐层的信号传播路线如下图所示： wmn 代表输出神经元 m和输入神经元n的连接权
重。

输出层的信号传导：

在接下来的计算过程中，输出信号y 同训练数据集中的期望输出结果z 做对比。他们
之间的差异用d 表示。

由于这些神经元的输出不知道，所以直接计算损失信号不太可能。很多年前训练多层
感知器的有效方法已经被发现了。仅仅后向传播算法被广泛应用。其主要思想是计算损失信
号d反向传播所有神经元。


权重系数wmn 用来计算损失信号。神经网络的所有层都按照此过程计算。



当计算每个神经元的损失信号的时候。每个神经元的输入节点权重系数被修改。公
式df(e)/de代表每隔神经元激励函数的梯度。







系数 h 决定了学习的速率。有一些选择参数的方法。第一种方法是选择较大的值开始
网络训练。然而，当权重系数确定之后，参数值急剧减小。第二种方法比较复杂，参数值从
较小开始。在学习的过程中，参数值增加，然后在最后阶段再一次减小参数值。用小参数值
训练网络能够决定权重系数。

5、第四节课：从零起步在框架中编码实现损失度 Loss 的计
算及其可视化
非常高兴在硅谷通过网络和大家分享人工智能的内容，这是我们整个人工智能课程的前
置课程的前 5 节课，这 5 节课在你没有 Python、数学基础的情况下，从零起步开发出自己
的AI框架，就像编码实现TensorFlow和 PyTorch，前面我们上了三节课，非常感谢大家在线
上的支持！这节课是第四节课，将从零起步在框架中编码实现损失度 Loss 的计算及其可视
化。
本期内容：
(1) Loss：所有AI框架终身的魔咒。
(2) 编码实现Loss实现并进行测试。
(3) 可视化Loss在 Epoch中的效果。
大家可以加入Spark+AI 免费试听课程：群②： 437123764 群③ ： 418110145（群中
包含最全面的试听课程的视频、代码和资料等）。Spark+AI 内部 VIP 课程群是我们内部缴费
的学员群。

本节课中人工智能神经网络损失度Loss的计算方法：
(1) Loss 的计算方法一：最简单的 Loss 的计算方式是把每个 Instance 计算的 Predicted 的结
果减去Real Value然后累计，完毕后除以所有的 Instances的个数
方法一的优点：方便理解；
方法一的缺点：不具有实用价值，没有真实的AI框架采用这种算法；

(2) Loss的计算的方法二：把每个Instance计算的Predicted 的结果减去Real Value后进行
绝对值求值，然后累计，完毕后除以所有的Instances的个数
方法二的优点：真实反馈出预测值和真实值的差异
方法二的缺点：可能获得很慢的 Converge 的过程

(3) Loss的计算的方法三：把每个Instance计算的Predicted 的结果减去Real Value后进行
平方的求值，然后累计，完毕后除以所有的Instances的个数
方法三的缺点：当数据量很大的时候，会导致很大的计算量；并且有些计算是不必要
的；

(4) 方法四：采用样本方差的计算，该方法适合数据量比较大的时候。

LossComputation.py的源代码：
1. class LossComputation:
2.
3. def compute_loss(instances, nodes, weights):
4.
5.
6. total_loss = 0 #记录累加的误差
7.
8. for i in range(len(instances)):
9. 10. instance = instances[i]
11.
12. nodes = ForwardPropagation.applyForwardPropagation(nodes, weights,
instance)
13.
14. predicted_value = nodes[len(nodes) - 1].get_value();
15. real_value = instance[len(instance) - 1]
16.
17. squared_error = (predicted_value - real_value) * (predicted_value - real_value)
18.
19. total_loss = total_loss + squared_error
20.
21. total_losss = total_loss / len(instances)
22.
23. return total_losss

Neuron_Network_Entry.py的源代码：
1. ……
2. hidden_layers = [4]
3. ……
4. earning_rate = 0.1
5. loss_log = [] #把 Loss记录进来进行绘图
6.
7. for i in range(epoch):
8.
9. nodes, weights = BackPropagation.applyBackPragation(instances, nodes, weights,
learning_rate)
10. loss = LossComputation.compute_loss(instances, nodes, weights)
11.
12. if i % 100 == 0:
13. print("Epoch " + str(i), "\t", loss)
14. loss_log.append(loss)
15.
16. print("Congratulations! All Epoch is completed!!!")
17.
18.
19. print("Visualize the graduation of Loss in the traning process: ")
20. plt.plot(loss_log) #传进要进行可视化的数据集
21. plt.show() #显示可视化结果
22. …….

Neuron_Network_Entry.py的运行结果如下：
1. +1 V1 V2 2. Hidden layer creation: 1 N[1][1] N[1][2] N[1][3]
N[1][4]
3.
4. Output layer: Output
5. The weight from 1 at layers[0] to 4 at layers[1] : 0.6372396008442125
6. The weight from 1 at layers[0] to 5 at layers[1] : -0.25774890480736024
7. The weight from 1 at layers[0] to 6 at layers[1] : -0.093484210526798
8. The weight from 1 at layers[0] to 7 at layers[1] : -0.5610128941481678
9. The weight from 2 at layers[0] to 4 at layers[1] : -0.2975351873594848
10. The weight from 2 at layers[0] to 5 at layers[1] : 0.7627958841311253
11. The weight from 2 at layers[0] to 6 at layers[1] : 0.7315122071714462
12. The weight from 2 at layers[0] to 7 at layers[1] : 0.0773782068422375
13. The weight from 4 at layers[1] to 8 at layers[2] : 0.8256449925142169
14. The weight from 5 at layers[1] to 8 at layers[2] : 0.8446448665914241
15. The weight from 6 at layers[1] to 8 at layers[2] : 0.7451799815942421
16. The weight from 7 at layers[1] to 8 at layers[2] : 0.626508490023028
17. Epoch 0 0.36105398730168314
18. Epoch 1 0.3591621806974654
19. Epoch 2 0.35724586319550755
20. Epoch 3 0.35530660172668954
21. Epoch 4 0.3533461307449452
22. Epoch 5 0.3513663516320754
23. Epoch 6 0.3493693301190364
24. Epoch 7 0.347357291575456
25. Epoch 8 0.3453326140544699
26. Epoch 9 0.34329781902328566
27. Epoch 10 0.34125555976041216
28. Epoch 11 0.3392086074570395
29. Epoch 12 0.3371598351208648
30. Epoch 13 0.3351121994436341
31. Epoch 14 0.3330687208562735
32. Epoch 15 0.3310324620550032
33. Epoch 16 0.32900650533545006
34. Epoch 17 0.32699392911678177
35. Epoch 18 0.3249977840718683
36. Epoch 19 0.3230210693004515
37. Epoch 20 0.32106670898895046
38. Epoch 21 0.31913752999221
39. Epoch 22 0.3172362407494107
40. Epoch 23 0.31536541190945044
41. Epoch 24 0.3135274589920951
42. Epoch 25 0.31172462735236917
43. Epoch 26 0.30995897964981467
44. Epoch 27 0.30823238595437397 45. Epoch 28 0.3065465165498824
46. Epoch 29 0.3049028374274015
47. Epoch 30 0.3033026083965654
48. Epoch 31 0.30174688368593544
49. Epoch 32 0.30023651485474667
50. Epoch 33 0.2987721557994711
51. Epoch 34 0.2973542696098433
52. Epoch 35 0.2959831370103753
53. Epoch 36 0.2946588661144268
54. Epoch 37 0.29338140321776807
55. Epoch 38 0.2921505443661015
56. Epoch 39 0.29096594744492404
57. Epoch 40 0.28982714455901026
58. Epoch 41 0.288733554491316
59. Epoch 42 0.28768449505594534
60. Epoch 43 0.2866791951858167
61. Epoch 44 0.28571680662178867
62. Epoch 45 0.28479641509544373
63. Epoch 46 0.2839170509217971
64. Epoch 47 0.28307769894043866
65. Epoch 48 0.2822773077636871
66. Epoch 49 0.2815147983080598
67. Epoch 50 0.28078907160068023
68. Epoch 51 0.28009901586515995
69. Epoch 52 0.279443512902148
70. Epoch 53 0.2788214437882415
71. Epoch 54 0.27823169392353275
72. Epoch 55 0.2776731574629075
73. Epoch 56 0.2771447411695396
74. Epoch 57 0.2766453677310644
75. Epoch 58 0.2761739785798521
76. Epoch 59 0.27572953625885327
77. Epoch 60 0.27531102637381155
78. Epoch 61 0.274917459171402
79. Epoch 62 0.27454787078118625
80. Epoch 63 0.2742013241573057
81. Epoch 64 0.2738769097536523
82. Epoch 65 0.27357374596395356
83. Epoch 66 0.27329097935584945
84. Epoch 67 0.2730277847256819
85. Epoch 68 0.2727833649983973
86. Epoch 69 0.2725569509947258
87. Epoch 70 0.27234780108565404
88. Epoch 71 0.27215520075218463 89. Epoch 72 0.2719784620664747
90. Epoch 73 0.2718169231086768
91. Epoch 74 0.2716699473321727
92. Epoch 75 0.2715369228883909
93. Epoch 76 0.27141726192102644
94. Epoch 77 0.2713103998382387
95. Epoch 78 0.2712157945702738
96. Epoch 79 0.2711329258189469
97. Epoch 80 0.2710612943045067
98. Epoch 81 0.27100042101459454
99. Epoch 82 0.2709498464592841
100. Epoch 83 0.2709091299355482
101. Epoch 84 0.27087784880393173
102. Epoch 85 0.27085559777970886
103. Epoch 86 0.27084198824036676
104. Epoch 87 0.27083664755087583
105. Epoch 88 0.27083921840786795
106. Epoch 89 0.2708493582035629
107. Epoch 90 0.2708667384100274
108. Epoch 91 0.27089104398413993
109. Epoch 92 0.27092197279344976
110. Epoch 93 0.27095923506296443
111. Epoch 94 0.27100255284276575
112. Epoch 95 0.27105165949624804
113. Epoch 96 0.27110629920867774
114. Epoch 97 0.27116622651569855
115. Epoch 98 0.27123120585134863
116. Epoch 99 0.27130101111510363
117. Congratulations! All Epoch is completed!!!
118. Visualize the graduation of Loss in the traning process:

这里，家林老师布置了一个作业：在代码BackPropagation.py代码留了一个不是技
术问题的Bug, 是现场直播时老师写的，代码发布时老师改成了 Bug的版本，运行的时
候会发现损失率不会变化，结果图是一条直线，同学们要将这个 Bug查出来。

 代码优化：将代码 BackPropagation.py 中 weight_to_node_value ==
nodes[k].get_value() 改成weight_to_node_value = nodes[k].get_value()就可以了。修
改以后，重新运行，损失度曲线图如下：

 代码优化：计算方法优化，根据下图的公式修改均方误差值(mean-square error, MSE)，
MSE 反映估计量与被估计量之间差异程度的一种度量。可以将LossComputation.py
中的代码 total_loss = total_loss + squared_error 修改为：total_loss = total_loss +
squared_error/2 。

6、第五节课：从零起步通过 Adaptive Learning 和 Feature
Normalization 优化自己编写的 AI框架

非常高兴在人工智能、大数据、区块链等技术的发源地美国硅谷和大家分享人工智能的
内容，本节课是 5 节课内从零起步 (无需数学和 Python Python 基础 )编码实现 AI 框架的
第五节课：从零起步通过 Adaptive Learning 和 Feature Normalization 优化自己编写的 AI 框
架。
这节课讲解的内容是如何优化自己编写的AI框架。人工智能的框架优化及人工智能应
用程序的优化，会有很多技术，优化的技术多达几百种，今天分享的是其中的2种： Adaptive
Learning优化和Feature Normalization 优化。
具体内容：
(1) 自己编写的AI框架性能测试及问题剖析
(2) 采用Adaptive Learning进行性能优化编码
(3) 使用Feature Normalization

Feature Normalization特征归一化处理，在instances = [[0,0,0], [0,1,1], [1,0,1], [1,1,0]]
中第一列和第二列是features，即定义域在[0,1] ; 第三列是根据某种关系而得出的结果，即
值域是[0,1]

我们使用的是 Sigmoid 函数，从图中可以看出 Sigmoid 函数变化最明显的范围 X 轴在[-
4,4]之间，Y 轴范围从[0,1]。因此，我们要做的归一化优化，是将在instances = [[0,0,0], [0,1,1],
[1,0,1], [1,1,0]]的第一列和第二列 features的范围进行调整，即定义域从[0,1]调整为[-4,4] ; 第
三列是根据某种关系而得出的结果，仍是异或操作的结果（相同值为0，不同值为1），因此，
这里的值域范围仍是[0,1]。 FeatureNormalization.py源代码：
1. # -*- coding: utf-8 -*-
2. class FeatureNormalization:
3.
4.
5. def normalize(instances):
6. num_of_elements = len(instances[0])
7.
8. max_items = []
9. min_items = []
10.
11. #求出每一个 Feature（在这里也包含了对结果的正则化操作，这样才能保证误
差的真实性）的最大值和最小值
12. for j in range(num_of_elements):
13.
14. temp_max = instances[0][j]
15. temp_min = instances[0][j]
16.
17. #进行正则化的时候是针对 Input Source 的每一列数据进行的操作
18. for i in range(len(instances)):
19. instance = instances[i][j]
20.
21. if instance > temp_max:
22. temp_max = instance
23.
24. if instance < temp_min:
25. temp_min = instance
26.
27. max_items.append(temp_max)
28. min_items.append(temp_min)
29.
30. #初始化状态必须是数据源里面的数据
31. temp_max = instances[0][j]
32. temp_min = instances[0][j]
33.
34. #The process of normalization
35. for i in range(len(instances)):
36. for j in range(num_of_elements):
37. value = instances[i][j]
38.
39. #获取当前行的元素所在的列的最大值和最小值
40. maxItem = max_items[j]
41. minItem = min_items[j]
42. 43. #正则化到符合 Sigmoid 函数的定义域[-4,-4]和值域[0,1]
44. if j == num_of_elements - 1:
45. newMax = 1
46. newMin = 0
47.
48. else:
49. newMax = 4
50. newMin = -4
51.
52. value = ((newMax - newMin)*((value - minItem) /(maxItem - minItem)))
+ newMin
53.
54. instances[i][j] = value
55.
56. return instances
57.

Adaptive Learning性能优化：动态调整learning_rate，进行自适应调整。
1. previous_cost = 0
2.
3. for i in range(epoch):
4. nodes, initial_weights = BackPropagation.applyBackPragation(instances, nodes,
initial_weights, learning_rate)
5. loss = LossComputation.compute_loss(instances, nodes, initial_weights)
6.
7. if loss < previous_cost:
8. learning_rate = learning_rate + 0.1
9. else:
10. learning_rate = learning_rate - 0.5 * learning_rate
11.
12. previous_cost = loss

Neuron_Network_Entry.py代码调整如下：
1. # -*- coding: utf-8 -*-
2. from service.NetworkStructure import NetworkStructure
3. from service.NetworkConnection import NetworkConnection
4. from service.ForwardPropagation import ForwardPropagation
5. from service.BackPropagation import BackPropagation
6. from service.LossComputation import LossComputation
7. from service.FeatureNormalization import FeatureNormalization
8. import matplotlib.pyplot as plt
9. import copy
10. #from entity.Node import Node
11. #Exclusive OR: 只有第一个元素和第二个元素不同的时候，结果才是 1，否则为 0 12. instances = [[0,0,0],
13. [0,1,1],
14. [1,0,1],
15. [1,1,0]]
16.
17. instances = FeatureNormalization.normalize(instances)
18. print("Normalized Data: ", instances)
19.
20. num_of_features = len(instances[0]) - 1 #在这里是只有第一列和第二列是 features，第三列
是根据某种关系而得出的结果
21.
22. #hidden_layers = [4,2] #这里hardcode 为两个 Hidden layer，第一个 Hidden Layer 有 4 个
Neuron，第二个 Hidden Layer 有连个 Neuron
23. hidden_layers = [4]
24.
25. nodes = NetworkStructure.create_nodes(num_of_features,hidden_layers)
26.
27. #ID 为 0、3、8 的 Node 为 Bias
28. #for i in range(len(nodes)):
29. # print("This is a bias:" + str(nodes[i].get_is_bias_unit()))
30.
31. weights = NetworkConnection.create_Weights(nodes,num_of_features, hidden_layers)
32.
33. #记录 Neuron Network 最初始的 Weights
34. initial_weights = copy.deepcopy(weights)
35.
36. #对所有训练的数据集重复运行 1 万次
37. epoch = 1000
38.
39. learning_rate = 0.1
40. loss_log = [] #把 Loss记录进来进行绘图
41.
42. for i in range(epoch):
43.
44. nodes, weights = BackPropagation.applyBackPragation(instances, nodes, weights,
learning_rate)
45. loss = LossComputation.compute_loss(instances, nodes, weights)
46.
47. if i % 100 == 0:
48. print("Epoch " + str(i), "\t", loss)
49. loss_log.append(loss)
50.
51. print("Congratulations! All Epoch is completed!!!")
52. 53.
54. print("Visualize the graduation of Loss in the traning process: ")
55. plt.plot(loss_log, label = "Normal Gradient Descent Process:") #传进要进行可视化的数据集
56. plt.legend(bbox_to_anchor = (1,1), bbox_transform=plt.gcf().transFigure)
57.
58. adaptive_loss_log = []
59. previous_cost = 0
60.
61. for i in range(epoch):
62. nodes, initial_weights = BackPropagation.applyBackPragation(instances, nodes,
initial_weights, learning_rate)
63. loss = LossComputation.compute_loss(instances, nodes, initial_weights)
64.
65. if loss < previous_cost:
66. learning_rate = learning_rate + 0.1
67. else:
68. learning_rate = learning_rate - 0.5 * learning_rate
69.
70. previous_cost = loss
71.
72. if i % 100 == 0:
73. print("Epoch " + str(i), "\t", loss)
74. adaptive_loss_log.append(loss)
75. plt.plot(adaptive_loss_log, label = "Adaptive Loss Log:") #传进要进行可视化的数据集
76. plt.legend(bbox_to_anchor = (1,1), bbox_transform=plt.gcf().transFigure)
77.
78. plt.show() #显示可视化结果
79.
80.
81.
82. #从 Input Layer 触发，经过所有的 Hidden Layers 的处理，最终得出 Output Layer 的结
果。
83.
84. for i in range(len(instances)):
85. instance = instances[i]
86.
87. ForwardPropagation.applyForwardPropagation(nodes, initial_weights, instance)
88.
89. #得出此次 Forward Propagation 的输出结果
90. print("Prediction: " + str(nodes[len(nodes) - 1].get_value()) +
91. " while real value is: " + str(instance[num_of_features]))
92.
93.
Neuron_Network_Entry.py运行结果如下：
1. Normalized Data: [[-4.0, -4.0, 0.0], [-4.0, 4.0, 1.0], [4.0, -4.0, 1.0], [4.0, 4.0, 0.0]]
2. +1 V1 V2
3. Hidden layer creation: 1 N[1][1] N[1][2] N[1][3]
N[1][4]
4.
5. Output layer: Output
6. The weight from 1 at layers[0] to 4 at layers[1] : -0.09097987409054176
7. The weight from 1 at layers[0] to 5 at layers[1] : 0.12596202869325857
8. The weight from 1 at layers[0] to 6 at layers[1] : 0.18747316454705976
9. The weight from 1 at layers[0] to 7 at layers[1] : 0.7101983449275802
10. The weight from 2 at layers[0] to 4 at layers[1] : -0.33850429583008546
11. The weight from 2 at layers[0] to 5 at layers[1] : 0.9292932753987098
12. The weight from 2 at layers[0] to 6 at layers[1] : -0.8462086675776888
13. The weight from 2 at layers[0] to 7 at layers[1] : 0.15632986195554888
14. The weight from 4 at layers[1] to 8 at layers[2] : 0.227545678436061
15. The weight from 5 at layers[1] to 8 at layers[2] : -0.9953303232305183
16. The weight from 6 at layers[1] to 8 at layers[2] : 0.9660853800316864
17. The weight from 7 at layers[1] to 8 at layers[2] : 0.5423415324020104
18. Epoch 0 0.1558439528727816
19. Epoch 100 0.1492628731545601
20. Epoch 200 0.14926287315456024
21. Epoch 300 0.14926287315456024
22. Epoch 400 0.14926287315456024
23. Epoch 500 0.14926287315456024
24. Epoch 600 0.14926287315456024
25. Epoch 700 0.1492628731545596
26. Epoch 800 0.1492628731545596
27. Epoch 900 0.1492628731545596
28. Congratulations! All Epoch is completed!!!
29. Visualize the graduation of Loss in the traning process:
30. Epoch 0 0.1558439528727816
31. Epoch 100 0.1562943146608136
32. Epoch 200 0.14890751824738235
33. Epoch 300 0.14890751824738235
34. Epoch 400 0.14890751824738235
35. Epoch 500 0.14890751824738235
36. Epoch 600 0.14890751824738235
37. Epoch 700 0.14890751824738235
38. Epoch 800 0.14890751824738235
39. Epoch 900 0.14890751824738235
40.

本节课我们进行了两个优化：
1，正则化优化
2， Adaptive Learning优化
但从优化的效果来看，优化还不明显，损失度曲线在 0.15 左右，而期望的优化效果是
提升上百万倍，即结果如是 0，预测值可能需达到0.0000000001；结果如是1，预测值可能
需达到0.9999999 等。

本节课家林老师布置的作业：修改代码，提升精确度，调优代码以后，将会有上百万倍
的精确度的提升，要达到如下家林老师优化运行的效果。


7、总结：5 节课内从零起步(无需数学和 Python 基础)编码
实现类似于 TensorFlow的 AI框架大总结

非常高兴在大数据、人工智能技术的发源地美国硅谷和大家分享人工智能的内容，本节
课是在前面5 节课的基础上进行总结和思考。前面5 节课带领大家从零起步，在没有数学
和Python基础的情况下，开发出我们自己的 AI框架。
在我们自己的 AI 框架中，首先在第一节课实现了我们深度学习的结构；然后在第二节
课从零起步写代码实现了 Forward Propagation 算法；在第三节课带领大家实现了神经网络
最最重要的精髓Back Propagation， Back Propagation算法是1986年正式发布的， TensorFlow、
PyTorch 等人工智能框架深度学习基本上都是使用 Back Propagation 思想实现的；在第四节
课实现了误差或损失度的计算；第五节课进行了代码优化，实现了正则归一优化和自适应优
化。
在这节课中，我们看一下改动以后的代码，如何提升上百倍或上万倍的优化。具体内容：
1自己从零起步编写的AI框架性能测试
2 Neuron Network实现及和TensorFlow的对比
3 Forward Propagation实现及其和TensorFlow对比
4 Back Propagation实现及其和TensorFlow对比
5 Loss计算实现及其和 TensorFlow 对比

TensorFlow（http://playground.tensorflow.org）的运行示意图如下：

接下来展示我们自己的 AI 人工智能框架在 3 个隐藏层，2 个隐藏层及 1 个隐藏层的运
行情况。

(1) 3 个隐藏层的运行结果：

(2) 2 个隐藏层的运行结果：

(3) 1 个隐藏层的运行结果：

运行结果显示我们自己开发的人工智能框架预测非常不错，我们输入的数据是二维数组，
在二维数组中：
instances = [[0,0,0],
[0,1,1],
[1,0,1],
[1,1,0]]
二维数组有四行的元素，每行的元素有3 列。第一列和第二列输入的是features，第三
列是生成的结果。在训练的时候，我们将第一列、第二列作为数据的输入，然后预测第 3列
的结果。
提升性能万倍以上的AI框架代码完整代码实现（请于 Spark +AI VIP内部学员群内下载）

接下来我们进行Tensorflow 的安装部署及Tensorflow 使用初体验。
附：tensorflow初体验：
Anaconda中安装tensorflow
1. (g:\ProgramData\Anaconda3) C:\Users\lenovo>pip install --upgrade --ignore-installed
tensorflow
2. Collecting tensorflow
3. Downloading tensorflow-1.7.0-cp36-cp36m-win_amd64.whl (33.1MB)
4. 100% |████████████████████████████████| 33.1MB 96kB/s
5. Collecting six>=1.10.0 (from tensorflow)
6. Using cached six-1.11.0-py2.py3-none-any.whl
7. Collecting termcolor>=1.1.0 (from tensorflow)
8. Downloading termcolor-1.1.0.tar.gz
9. Collecting tensorboard<1.8.0,>=1.7.0 (from tensorflow)
10. Downloading tensorboard-1.7.0-py3-none-any.whl (3.1MB)
11. 100% |████████████████████████████████| 3.1MB 145kB/s
12. Collecting gast>=0.2.0 (from tensorflow)
13. Downloading gast-0.2.0.tar.gz
14. Collecting grpcio>=1.8.6 (from tensorflow)
15. Downloading grpcio-1.11.0-cp36-cp36m-win_amd64.whl (1.4MB)
16. 100% |████████████████████████████████| 1.4MB 112kB/s
17. Collecting astor>=0.6.0 (from tensorflow)
18. Downloading astor-0.6.2-py2.py3-none-any.whl
19. Collecting absl-py>=0.1.6 (from tensorflow)
20. Downloading absl-py-0.1.13.tar.gz (80kB)
21. 100% |████████████████████████████████| 81kB 178kB/s
22. Collecting numpy>=1.13.3 (from tensorflow)
23. Using cached numpy-1.14.2-cp36-none-win_amd64.whl
24. Collecting wheel>=0.26 (from tensorflow)
25. Downloading wheel-0.31.0-py2.py3-none-any.whl (41kB)
26. 100% |████████████████████████████████| 51kB 146kB/s
27. Collecting protobuf>=3.4.0 (from tensorflow)
28. Downloading protobuf-3.5.2.post1-cp36-cp36m-win_amd64.whl (958kB)
29. 100% |████████████████████████████████| 962kB 311kB/s
30. Collecting werkzeug>=0.11.10 (from tensorboard<1.8.0,>=1.7.0->tensorflow)
31. Downloading Werkzeug-0.14.1-py2.py3-none-any.whl (322kB)
32. 100% |████████████████████████████████| 327kB 331kB/s
33. Collecting bleach==1.5.0 (from tensorboard<1.8.0,>=1.7.0->tensorflow)
34. Downloading bleach-1.5.0-py2.py3-none-any.whl
35. Collecting markdown>=2.6.8 (from tensorboard<1.8.0,>=1.7.0->tensorflow)
36. Downloading Markdown-2.6.11-py2.py3-none-any.whl (78kB)
37. 100% |████████████████████████████████| 81kB 379kB/s 38. Collecting html5lib==0.9999999 (from tensorboard<1.8.0,>=1.7.0->tensorflow)
39. Downloading html5lib-0.9999999.tar.gz (889kB)
40. 100% |████████████████████████████████| 890kB 420kB/s
41. Collecting setuptools (from protobuf>=3.4.0->tensorflow)
42. Using cached setuptools-39.0.1-py2.py3-none-any.whl
43. Building wheels for collected packages: termcolor, gast, absl-py, html5lib
44. Running setup.py bdist_wheel for termcolor ... done
45. Stored in directory:
C:\Users\lenovo\AppData\Local\pip\Cache\wheels\de\f7\bf\1bcac7bf30549e6a4957382e2ecab
04c88e513117207067b03
46. Running setup.py bdist_wheel for gast ... done
47. Stored in directory:
C:\Users\lenovo\AppData\Local\pip\Cache\wheels\8e\fa\d6\77dd17d18ea23fd7b860e02623d2
7c1be451521af40dd4a13e
48. Running setup.py bdist_wheel for absl-py ... done
49. Stored in directory:
C:\Users\lenovo\AppData\Local\pip\Cache\wheels\76\f7\0c\88796d7212af59bb2f496b12267e
0605f205170781e9b86479
50. Running setup.py bdist_wheel for html5lib ... done
51. Stored in directory:
C:\Users\lenovo\AppData\Local\pip\Cache\wheels\6f\85\6c\56b8e1292c6214c4eb73b9dda50f
53e8e977bf65989373c962
52. Successfully built termcolor gast absl-py html5lib
53. notebook 5.4.0 requires ipykernel, which is not installed.
54. jupyter 1.0.0 requires ipykernel, which is not installed.
55. jupyter-console 5.2.0 requires ipykernel, which is not installed.
56. ipywidgets 7.1.1 requires ipykernel>=4.5.1, which is not installed.
57. Installing collected packages: six, termcolor, werkzeug, html5lib, bleach, wheel, markdown,
numpy, setuptools, protobuf, tensorboard, gast, grpcio, astor, absl-py, tensorflow
58.
59.
60. (g:\ProgramData\Anaconda3) C:\Users\lenovo>

TensorFlow.py 测试代码：
1. # -*- coding: utf-8 -*-
2.
3. import tensorflow as tf
4. import numpy as np
5.
6. # 使用 NumPy 生成假数据(phony data), 总共 100 个点.
7. x_data = np.float32(np.random.rand(2, 100)) # 随机输入
8. y_data = np.dot([0.100, 0.200], x_data) + 0.300
9.
10. # 构造一个线性模型 11. #
12. b = tf.Variable(tf.zeros([1]))
13. W = tf.Variable(tf.random_uniform([1, 2], -1.0, 1.0))
14. y = tf.matmul(W, x_data) + b
15.
16. # 最小化方差
17. loss = tf.reduce_mean(tf.square(y - y_data))
18. optimizer = tf.train.GradientDescentOptimizer(0.5)
19. train = optimizer.minimize(loss)
20.
21. # 初始化变量
22. init = tf.initialize_all_variables()
23.
24. # 启动图 (graph)
25. sess = tf.Session()
26. sess.run(init)
27.
28. # 拟合平面
29. for step in range(0, 201):
30. sess.run(train)
31. if step % 20 == 0:
32. print (step,sess.run(W), sess.run(b))
33.
34. # 得到最佳拟合结果 W: [[0.100 0.200]], b: [0.300]
35.

TensorFlow.py 测试代码的运行结果如下：
1. WARNING:tensorflow:From g:\ProgramData\Anaconda3\lib\site-
packages\tensorflow\python\util\tf_should_use.py:170: initialize_all_variables (from
tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.
2. Instructions for updating:
3. Use `tf.global_variables_initializer` instead.
4. 0 [[ 0.2849133 -0.06556708]] [0.85631585]
5. 20 [[0.07855916 0.09892854]] [0.36725342]
6. 40 [[0.0892528 0.17571881]] [0.31930056]
7. 60 [[0.0959838 0.19390662]] [0.30558503]
8. 80 [[0.09865399 0.19840951]] [0.30162516]
9. 100 [[0.09957236 0.199571 ]] [0.30047464]
10. 120 [[0.09986809 0.19988129]] [0.30013898]
11. 140 [[0.09996004 0.19996653]] [0.30004075]
12. 160 [[0.09998804 0.19999044]] [0.30001196]
13. 180 [[0.09999643 0.1999972 ]] [0.30000353]
14. 200 [[0.09999893 0.19999918]] [0.30000106]
TensorFlow 下载与安装(以下内容来自网络资料)
你可以使用我们提供的 Pip, Docker, Virtualenv, Anaconda 或源码编译的方法安装
TensorFlow.
Pip 安装
Pip 是一个 Python 的软件包安装与管理工具.
在安装 TensorFlow 过程中要涉及安装或升级的包详见列表
首先安装 pip (或 Python3 的 pip3 ):
# Ubuntu/Linux 64-bit
$ sudo apt-get install python-pip python-dev

# Mac OS X
$ sudo easy_install pip
安装 TensorFlow :
# Ubuntu/Linux 64-bit, CPU only, Python 2.7:
$ sudo pip install --upgrade https://storage.googleapis.com/tensorflow/l
inux/cpu/tensorflow-0.8.0-cp27-none-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 2.7. Requires CUDA toolkit 7.
5 and CuDNN v4.
# For other versions, see "Install from sources" below.
$ sudo pip install --upgrade https://storage.googleapis.com/tensorflow/l
inux/gpu/tensorflow-0.8.0-cp27-none-linux_x86_64.whl

# Mac OS X, CPU only:
$ sudo easy_install --upgrade six
$ sudo pip install --upgrade https://storage.googleapis.com/tensorflow/m
ac/tensorflow-0.8.0-py2-none-any.whl
如果是 Python3 :
# Ubuntu/Linux 64-bit, CPU only, Python 3.4:
$ sudo pip3 install --upgrade https://storage.googleapis.com/tensorflow/
linux/cpu/tensorflow-0.8.0-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.4. Requires CUDA toolkit 7.
5 and CuDNN v4.
# For other versions, see "Install from sources" below. $ sudo pip3 install --upgrade https://storage.googleapis.com/tensorflow/
linux/gpu/tensorflow-0.8.0-cp34-cp34m-linux_x86_64.whl

# Mac OS X, CPU only:
$ sudo easy_install --upgrade six
$ sudo pip3 install --upgrade https://storage.googleapis.com/tensorflow/
mac/tensorflow-0.8.0-py3-none-any.whl
备注：如果之前安装过 TensorFlow < 0.7.1 的版本,应该先使用 pip uninstall 卸载
TensorFlow 和 protobuf ,保证获取的是一个最新 protobuf 依赖下的安装包.
之后可以测试一下.
基于 Docker 的安装
我们也支持通过 Docker 运行 TensorFlow. 该方式的优点是不用操心软件依赖问题.
首先, 安装 Docker. 一旦 Docker 已经启动运行, 可以通过命令启动一个容器:
$ docker run -it b.gcr.io/tensorflow/tensorflow
该命令将启动一个已经安装好 TensorFlow 及相关依赖的容器.
其它镜像
默认的 Docker 镜像只包含启动和运行 TensorFlow 所需依赖库的一个最小集. 我们额
外提供了下面的容器, 该容器同样可以通过上述 docker run 命令安装:
• b.gcr.io/tensorflow/tensorflow-full: 镜像中的 TensorFlow 是从源代码完整安装
的, 包含了编译和运行 TensorFlow 所需的全部工具. 在该镜像上, 可以直接使用源
代码进行实验, 而不需要再安装上述的任何依赖.
基于 VirtualEnv 的安装
我们推荐使用 virtualenv 创建一个隔离的容器, 来安装 TensorFlow. 这是可选的, 但是
这样做能使排查安装问题变得更容易.
首先, 安装所有必备工具:
# 在 Linux 上:
$ sudo apt-get install python-pip python-dev python-virtualenv

# 在 Mac 上:
$ sudo easy_install pip # 如果还没有安装 pip
$ sudo pip install --upgrade virtualenv 接下来, 建立一个全新的 virtualenv 环境. 为了将环境建在 ~/tensorflow 目录下, 执
行:
$ virtualenv --system-site-packages ~/tensorflow
$ cd ~/tensorflow
然后, 激活 virtualenv:
$ source bin/activate # 如果使用 bash
$ source bin/activate.csh # 如果使用 csh
(tensorflow)$ # 终端提示符应该发生变化
在 virtualenv 内, 安装 TensorFlow:
(tensorflow)$ pip install --upgrade <$url_to_binary.whl>
接下来, 使用类似命令运行 TensorFlow 程序:
(tensorflow)$ cd tensorflow/models/image/mnist
(tensorflow)$ python convolutional.py

# 当使用完 TensorFlow
(tensorflow)$ deactivate # 停用 virtualenv

$ # 你的命令提示符会恢复原样
基于 Anaconda 的安装
Anaconda 是一个集成许多第三方科学计算库的 Python 科学计算环境,Anaconda 使用
conda 作为自己的包管理工具,同时具有自己的计算环境,类似 Virtualenv.
和 Virtualenv 一样,不同 Python 工程需要的依赖包,conda 将他们存储在不同的地
方。 TensorFlow 上安装的 Anaconda 不会对之前安装的 Python 包进行覆盖.
• 安装 Anaconda
• 建立一个 conda 计算环境
• 激活环境,使用 conda 安装 TensorFlow
• 安装成功后,每次使用 TensorFlow 的时候需要激活 conda 环境
安装 Anaconda :
参考 Anaconda 的下载页面的指导
建立一个 conda 计算环境名字叫 tensorflow:
# Python 2.7
$ conda create -n tensorflow python=2.7
# Python 3.4
$ conda create -n tensorflow python=3.4
激活tensorflow环境,然后使用其中的 pip 安装 TensorFlow. 当使用easy_install使
用--ignore-installed标记防止错误的产生。
$ source activate tensorflow
(tensorflow)$ # Your prompt should change

# Ubuntu/Linux 64-bit, CPU only, Python 2.7:
(tensorflow)$ pip install --ignore-installed --upgrade https://storage.g
oogleapis.com/tensorflow/linux/cpu/tensorflow-0.8.0rc0-cp27-none-linux_
x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 2.7. Requires CUDA toolkit 7.
5 and CuDNN v4.
# For other versions, see "Install from sources" below.
(tensorflow)$ pip install --ignore-installed --upgrade https://storage.g
oogleapis.com/tensorflow/linux/gpu/tensorflow-0.8.0rc0-cp27-none-linux_
x86_64.whl

# Mac OS X, CPU only:
(tensorflow)$ pip install --ignore-installed --upgrade https://storage.g
oogleapis.com/tensorflow/mac/tensorflow-0.8.0rc0-py2-none-any.whl
对于 Python 3.x :
$ source activate tensorflow
(tensorflow)$ # Your prompt should change

# Ubuntu/Linux 64-bit, CPU only, Python 3.4:
(tensorflow)$ pip install --ignore-installed --upgrade https://storage.g
oogleapis.com/tensorflow/linux/cpu/tensorflow-0.8.0rc0-cp34-cp34m-linux
_x86_64.whl

# Ubuntu/Linux 64-bit, GPU enabled, Python 3.4. Requires CUDA toolkit 7.
5 and CuDNN v4.
# For other versions, see "Install from sources" below.
(tensorflow)$ pip install --ignore-installed --upgrade https://storage.g
oogleapis.com/tensorflow/linux/gpu/tensorflow-0.8.0rc0-cp34-cp34m-linux
_x86_64.whl

# Mac OS X, CPU only:
(tensorflow)$ pip install --ignore-installed --upgrade https://storage.g
oogleapis.com/tensorflow/mac/tensorflow-0.8.0rc0-py3-none-any.whl conda 环境激活后,你可以测试
当你不用 TensorFlow 的时候,关闭环境:
(tensorflow)$ source deactivate

$ # Your prompt should change back
再次使用的时候再激活 :-)
$ source activate tensorflow
(tensorflow)$ # Your prompt should change.
# Run Python programs that use TensorFlow.
...
# When you are done using TensorFlow, deactivate the environment.
(tensorflow)$ source deactivate
尝试你的第一个 TensorFlow 程序
(可选) 启用 GPU 支持
如果你使用 pip 二进制包安装了开启 GPU 支持的 TensorFlow, 你必须确保系统里安
装了正确的 CUDA sdk 和 CUDNN 版本. 请参间 CUDA 安装教程
你还需要设置 LD_LIBRARY_PATH 和 CUDA_HOME 环境变量. 可以考虑将下面的命令添加
到 ~/.bash_profile 文件中, 这样每次登陆后自动生效. 注意, 下面的命令假定 CUDA
安装目录为 /usr/local/cuda:
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64"
export CUDA_HOME=/usr/local/cuda
运行 TensorFlow
打开一个 python 终端:
$ python

>>> import tensorflow as tf
>>> hello = tf.constant('Hello, TensorFlow!')
>>> sess = tf.Session()
>>> print sess.run(hello)
Hello, TensorFlow! >>> a = tf.constant(10)
>>> b = tf.constant(32)
>>> print sess.run(a+b)
42
>>>
从源码安装
克隆 TensorFlow 仓库
$ git clone --recurse-submodules https://github.com/tensorflow/tensorflo
w
--recurse-submodules 参数是必须得, 用于获取 TesorFlow 依赖的 protobuf 库.
Linux 安装
安装 Bazel
首先依照教程安装 Bazel 的依赖. 然后在链接中下载适合你的操作系统的最新稳定版,
最后按照下面脚本执行：
$ chmod +x PATH_TO_INSTALL.SH
$ ./PATH_TO_INSTALL.SH --user
注意把 PATH_TO_INSTALL.SH 替换为你下载的安装包的文件路径.
将执行路径 output/bazel 添加到 $PATH 环境变量中.
安装其他依赖
# For Python 2.7:
$ sudo apt-get install python-numpy swig python-dev python-wheel
# For Python 3.x:
$ sudo apt-get install python3-numpy swig python3-dev python3-wheel
可选: 安装 CUDA (在 Linux 上开启 GPU 支持)
为了编译并运行能够使用 GPU 的 TensorFlow, 需要先安装 NVIDIA 提供的 Cuda
Toolkit 7.0 和 CUDNN 6.5 V2.
TensorFlow 的 GPU 特性只支持 NVidia Compute Capability >= 3.5 的显卡. 被支
持的显卡包括但不限于: • NVidia Titan
• NVidia Titan X
• NVidia K20
• NVidia K40
下载并安装 Cuda Toolkit 7.0
下载地址
将工具安装到诸如 /usr/local/cuda 之类的路径.
下载并安装 CUDNN Toolkit 6.5
下载地址
解压并拷贝 CUDNN 文件到 Cuda Toolkit 7.0 安装路径下. 假设 Cuda Toolkit 7.0
安装在 /usr/local/cuda, 执行以下命令:
tar xvzf cudnn-6.5-linux-x64-v2.tgz
sudo cp cudnn-6.5-linux-x64-v2/cudnn.h /usr/local/cuda/include
sudo cp cudnn-6.5-linux-x64-v2/libcudnn* /usr/local/cuda/lib64
配置 TensorFlow 的 Cuda 选项
从源码树的根路径执行:
$ ./configure
Do you wish to bulid TensorFlow with GPU support? [y/n] y
GPU support will be enabled for TensorFlow

Please specify the location where CUDA 7.0 toolkit is installed. Refer t
o
README.md for more details. [default is: /usr/local/cuda]: /usr/local/cu
da

Please specify the location where CUDNN 6.5 V2 library is installed. Ref
er to
README.md for more details. [default is: /usr/local/cuda]: /usr/local/cu
da

Setting up Cuda include
Setting up Cuda lib64
Setting up Cuda bin
Setting up Cuda nvvm
Configuration finished
这些配置将建立到系统 Cuda 库的符号链接. 每当 Cuda 库的路径发生变更时, 必须重
新执行上述步骤, 否则无法调用 bazel 编译命令. 编译目标程序, 开启 GPU 支持
从源码树的根路径执行:
$ bazel build -c opt --config=cuda //tensorflow/cc:tutorials_example_tra
iner

$ bazel-bin/tensorflow/cc/tutorials_example_trainer --use_gpu
# 大量的输出信息. 这个例子用 GPU 迭代计算一个 2x2 矩阵的主特征值 (major eigen
value).
# 最后几行输出和下面的信息类似.
000009/000005 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -
0.894427]
000006/000001 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -
0.894427]
000009/000009 lambda = 2.000000 x = [0.894427 -0.447214] y = [1.788854 -
0.894427]
注意, GPU 支持需通过编译选项 "--config=cuda" 开启.
已知问题
• 尽管可以在同一个源码树下编译开启 Cuda 支持和禁用 Cuda 支持的版本, 我们还是
推荐在在切换这两种不同的编译配置时, 使用 "bazel clean" 清理环境.
• 在执行 bazel 编译前必须先运行 configure, 否则编译会失败并提示错误信息. 未来,
我们可能考虑将 configure 步骤包含在编译过程中, 以简化整个过程, 前提是 bazel
能够提供新的特性支持这样.
Mac OS X 安装
Mac 和 Linux 需要的软件依赖完全一样, 但是安装过程区别很大. 以下链接用于帮助你
在 Mac OS X 上安装这些依赖:
Bazel
参见本网页的 Mac OS X 安装指南.
SWIG
Mac OS X 安装教程.
注意: 你需要安装PCRE, 而不是 PCRE2.
Numpy
参见安装教程. 创建 pip 包并安装
$ bazel build -c opt //tensorflow/tools/pip_package:build_pip_package

$ bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorfl
ow_pkg

# .whl 文件的实际名字与你所使用的平台有关
$ pip install /tmp/tensorflow_pkg/tensorflow-0.5.0-cp27-none-linux_x86_6
4.whl
训练你的第一个 TensorFlow 神经网络模型
从源代码树的根路径执行:
$ cd tensorflow/models/image/mnist
$ python convolutional.py
Succesfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Succesfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Succesfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Succesfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting data/train-images-idx3-ubyte.gz
Extracting data/train-labels-idx1-ubyte.gz
Extracting data/t10k-images-idx3-ubyte.gz
Extracting data/t10k-labels-idx1-ubyte.gz
Initialized!
Epoch 0.00
Minibatch loss: 12.054, learning rate: 0.010000
Minibatch error: 90.6%
Validation error: 84.6%
Epoch 0.12
Minibatch loss: 3.285, learning rate: 0.010000
Minibatch error: 6.2%
Validation error: 7.0%
...
...
常见问题
GPU 相关问题如果在尝试运行一个 TensorFlow 程序时出现以下错误:
ImportError: libcudart.so.7.0: cannot open shared object file: No such f
ile or directory
请确认你正确安装了 GPU 支持, 参见相关章节.
在 Linux 上
如果出现错误:
...
"__add__", "__radd__",
^
SyntaxError: invalid syntax
解决方案: 确认正在使用的 Python 版本为 Python 2.7.
在 Mac OS X 上
如果出现错误:
import six.moves.copyreg as copyreg

ImportError: No module named copyreg
解决方案: TensorFlow 使用的 protobuf 依赖 six-1.10.0. 但是, Apple 的默认
python 环境已经安装了 six-1.4.1, 该版本可能很难升级. 这里提供几种方法来解决该
问题:
1. 升级全系统的 six:
sudo easy_install -U six
2. 通过 homebrew 安装一个隔离的 python 副本:
brew install python
3. 在 virtualenv 内编译或使用 TensorFlow.
如果出现错误:
>>> import tensorflow as tf
Traceback (most recent call last):
File "<stdin>", line 1, in <module> File "/usr/local/lib/python2.7/site-packages/tensorflow/__init__.py",
line 4, in <module>
from tensorflow.python import *
File "/usr/local/lib/python2.7/site-packages/tensorflow/python/__init_
_.py", line 13, in <module>
from tensorflow.core.framework.graph_pb2 import *
...
File "/usr/local/lib/python2.7/site-packages/tensorflow/core/framework
/tensor_shape_pb2.py", line 22, in <module>
serialized_pb=_b('\n,tensorflow/core/framework/tensor_shape.proto\x1
2\ntensorflow\"d\n\x10TensorShapeProto\x12-\n\x03\x64im\x18\x02 \x03(\x0
b\x32 .tensorflow.TensorShapeProto.Dim\x1a!\n\x03\x44im\x12\x0c\n\x04siz
e\x18\x01 \x01(\x03\x12\x0c\n\x04name\x18\x02 \x01(\tb\x06proto3')
TypeError: __init__() got an unexpected keyword argument 'syntax'
这是由于安装了冲突的 protobuf 版本引起的, TensorFlow 需要的是 protobuf 3.0.0.
当前最好的解决方案是确保没有安装旧版本的 protobuf, 可以使用以下命令重新安装
protobuf 来解决冲突:
brew reinstall --devel protobuf

8、课程信息：




















本电子书的完成非常感谢家林大神，家林大神倾其所能，将人工智能及大数据领域先进
的前沿技术传授给同学们，现场一行一行编写代码，5 节课内从零起步(无需数学和 Python
基础)编码实现AI人工智能框架，带领同学们创造了自己开发AI人工智能框架的奇迹！

其次要感谢我的家人的理解和支持，在这里特别要感谢一下我的岳母，这几年帮我带孩
子，让我没有后顾之忧，使我能坚持下来静心写书，一路前行，实现梦想！

2018/4/15 段智华于上海

“30个真实商业案例代码中成为AI实战专家”报名费用和报名方式：
课程原价19800元，越早报名越多优惠.

个人优惠：
2018 年4月16-30 号：报名享“Early Bird”最优惠价格9980 元/人。
2018 年5月1-15 号：报名享最优惠价格12800元/人。
2018 年5月16-31 号：报名享最优惠价格15800 元/人。
2018 年6月1-15 号：报名享最优惠价格17800元/人。
2018 年6月16-30 号：报名费19800元/人。

团购优惠1：两个人进行团购报名：
2018 年4月16-30 号：报名享“Early Bird”最优惠价格5980 元/人。
2018 年5月1-15 号：报名享最优惠价格7980 元/人。
2018 年5月16-31 号：报名享最优惠价格9980元/人。
2018 年6月1-15 号：报名享最优惠价格11980元/人。

团购优惠 2：三人或三人以上进行团购报名：
2018年 4 月16-30号：报名享“Early Bird”最优惠价格 3980元/人。
2018年 5 月1-15 号：报名享最优惠价格 5980 元/人。
2018年 5 月16-31号：报名享最优惠价格 7980 元/人。
2018年 6 月1-15 号：报名享最优惠价格 9980 元/人。
所有已经报名的学员介绍朋友报名的，朋友和该学员将按照团购优惠方式及日期进行费用
计算，例如于 4 月 30 号前介绍一个朋友成功加入课程的，该朋友只需缴费 5980 元即可加
入学习，而该学员原来的报名费用的 9980 元中将会有 4000 元的学费返还，也就是该学员
也是按照5980元的报名费用加入。
报名请直接家王家林老师微信13928463918进行报名咨询和转账：

您也可以通过王家林老师的银行账号转账：
开户行:平安银行深圳五洲支行
账户名:王家林
帐号:6230583000010108167

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/611763