2021-09-07 23:27:05

docs/misc/AI学习路线.md

@@ -0,0 +1,660 @@
+# 基础知识
+![图片](https://uploader.shimo.im/f/bxR0xWoah6gf2gMo.png!thumbnail)
+## 1.数学
+数学是学不完的，也没有几个人能像博士一样扎实地学好数学基础，入门人工智能领域，其实只需要掌握必要的基础知识就好。AI的数学基础最主要是高等数学、线性代数、概率论与数理统计三门课程，这三门课程是本科必修的。这里整理了一个简易的数学入门文章。
+数学基础: 高等数学
+[https://zhuanlan.zhihu.com/p/36311622](https://zhuanlan.zhihu.com/p/36311622)
+数学基础: 线性代数
+[https://zhuanlan.zhihu.com/p/36584206](https://zhuanlan.zhihu.com/p/36584206)
+数学基础: 概率论与数理统计
+[https://zhuanlan.zhihu.com/p/36584335](https://zhuanlan.zhihu.com/p/36584335)
+
+机器学习的数学基础资料下载: 
+1.机器学习的数学基础.docx
+中文版，对高等数学、线性代数、概率论与数理统计三门课的公式做了总结
+2) 斯坦福大学机器学习的数学基础.pdf
+原版英文材料，非常全面，建议英语好的同学直接学习这个材料
+下载链接: [https://pan.baidu.com/s/1LaUlrJzy98CG1Wma9FgBtg](https://pan.baidu.com/s/1LaUlrJzy98CG1Wma9FgBtg) 提取码: hktx 
+
+推荐教材
+相比国内浙大版和同济版的数学教材，通俗易懂，便于初学者更好地奠定数学基础
+下载链接: [https://blog.csdn.net/Datawhale/article/details/81744961](https://blog.csdn.net/Datawhale/article/details/81744961)
+
+## 2.统计学
+* 入门教材: 
+
+深入浅出统计学
+* 进阶教材: 
+
+商务与经济统计
+* 视频
+
+可汗学院统计学: [http://open.163.com/special/Khan/khstatistics.html](http://open.163.com/special/Khan/khstatistics.html)
+
+## 3.编程
+入门人工智能领域，推荐Python这门编程语言。
+1) Python安装: 
+关于python安装包，我推荐下载Anaconda，Anaconda是一个用于科学计算的Python发行版，支持 Linux, Mac, Windows系统，提供了包管理与环境管理的功能，可以很方便地解决多版本Python并存、切换以及各种第三方包安装问题。
+下载地址: [https://www.](https://link.zhihu.com/?target=https%3A//www.anaconda.com/download/)[anaconda.com/download/](https://link.zhihu.com/?target=https%3A//www.anaconda.com/download/) 推荐选Anaconda （python 3.7版本）
+
+IDE: 推荐使用pycharm，社区版免费
+下载地址: [https://www.](https://link.zhihu.com/?target=https%3A//www.jetbrains.com/)[jetbrains.com/](https://link.zhihu.com/?target=https%3A//www.jetbrains.com/)
+
+安装教程: 
+Anaconda+Jupyter notebook+Pycharm: 
+[https://zhuanlan.zhihu.com/p/59027692](https://zhuanlan.zhihu.com/p/59027692)
+Ubuntu18.04深度学习环境配置(CUDA9+CUDNN7.4+TensorFlow1.8): 
+[https://zhuanlan.zhihu.com/p/50302396](https://zhuanlan.zhihu.com/p/50302396)
+
+
+2) python入门的资料推荐
+a.廖雪峰python学习笔记
+[https://blog.csdn.net/datawhale/article/category/7779959](https://blog.csdn.net/datawhale/article/category/7779959)
+
+b.python入门笔记
+作者李金，这个是jupyter notebook文件，把python的主要语法演示了一次，值得推荐。
+下载链接: [https://pan.baidu.com/s/1IPZI5rygbIh5R5OuTHajzA](https://pan.baidu.com/s/1IPZI5rygbIh5R5OuTHajzA) 提取码: 2bzh 
+
+
+c.南京大学python视频教程
+这个教程非常值得推荐，python主要语法和常用的库基本涵盖了。
+查看地址: [https://www.icourse163.org/course/0809NJU004-1001571005?from=study](https://www.icourse163.org/course/0809NJU004-1001571005?from=study)
+
+看完这三个资料，python基本入门了，可以使用scikit-learn等机器学习库来解决机器学习的
+问题了。
+
+3）补充
+代码规范: 
+[https://zhuanlan.zhihu.com/p/59763076](https://zhuanlan.zhihu.com/p/59763076)
+numpy练习题: 
+[https://zhuanlan.zhihu.com/p/57872490](https://zhuanlan.zhihu.com/p/57872490)
+pandas练习题: 
+[https://zhuanlan.zhihu.com/p/56644669](https://zhuanlan.zhihu.com/p/56644669)
+
+# 数据分析/挖掘
+![图片](https://uploader.shimo.im/f/G1qZ7iUeRrAhFK9u.png!thumbnail)
+## 1.数据分析的基础书籍: 
+《利用python进行数据分析》
+这本书含有大量的实践案例，你将学会如何利用各种Python库（包括NumPy，Pandas、Matplotlib以及IPython等）高效地解决各式各样的数据分析问题。如果把代码都运行一次，基本上就能解决数据分析的大部分问题了。
+## 2.特征工程: 
+[https://blog.csdn.net/Datawhale/article/details/83033869](https://blog.csdn.net/Datawhale/article/details/83033869)
+## 3.数据挖掘项目: 
+[https://blog.csdn.net/datawhale/article/details/80847662](https://blog.csdn.net/datawhale/article/details/80847662)
+# 机器学习
+![图片](https://uploader.shimo.im/f/udrFwkqrEeA6mjVe.png!thumbnail)
+## 1.公开课 - 吴恩达《Machine Learning》
+这绝对是机器学习入门的首选课程，没有之一！即便你没有扎实的机器学习所需的扎实的概率论、线性代数等数学基础，也能轻松上手这门机器学习入门课，并体会到机器学习的无穷趣味。
+
+课程主页
+[https://www.coursera.org/learn/machine-learning](https://www.coursera.org/learn/machine-learning)
+
+课程完整思维导图: 
+
+![图片](https://uploader.shimo.im/f/NZFYqVr4ghI09BnJ.png!thumbnail)
+
+下载链接: [https://pan.baidu.com/s/16065BpNAP7JEx_PpFHLSOw](https://pan.baidu.com/s/16065BpNAP7JEx_PpFHLSOw)[ ](https://pan.baidu.com/s/16065BpNAP7JEx_PpFHLSOw提取码)提取码: xcmi
+
+**中文视频**
+网易云课堂搬运了这门课，并由黄海广等人翻译了中文字幕。
+
+观看地址: [https://study.163.com/course/introduction.htm?courseId=1004570029&_trace_c_p_k2_=d107b2ac93794ae79c941899f93332a1](https://study.163.com/course/introduction.htm?courseId=1004570029&_trace_c_p_k2_=d107b2ac93794ae79c941899f93332a1)
+
+**中文笔记及作业代码**
+[https://github.com/fengdu78/Coursera-ML-AndrewNg-Notes](https://github.com/fengdu78/Coursera-ML-AndrewNg-Notes)
+
+
+## 2.公开课 - 吴恩达 CS229
+吴恩达在斯坦福教授的机器学习课程 CS229 与 吴恩达在 Coursera 上的《Machine Learning》相似，但是有更多的数学要求和公式的推导，难度稍难一些。该课程对机器学习和统计模式识别进行了广泛的介绍。主题包括: 监督学习（生成/鉴别学习、参数/非参数学习、神经网络、支持向量机）；无监督学习（聚类、降维、核方法）；学习理论（偏差/方差权衡；VC理论；大幅度利润）；强化学习和自适应控制。本课程还将讨论机器学习的最新应用，如机器人控制、数据挖掘、自主导航、生物信息学、语音识别以及文本和Web数据处理。
+### 课程主页: [http://cs229.stanford.edu/](http://cs229.stanford.edu/)
+### 中文视频
+[http://open.163.com/special/opencourse/machinelearning.html](http://open.163.com/special/opencourse/machinelearning.html)
+### 中文笔记
+[https://kivy-cn.github.io/Stanford-CS-229-CN/#/](https://kivy-cn.github.io/Stanford-CS-229-CN/#/)
+### 速查表
+这份给力的资源贡献者是一名斯坦福的毕业生 Shervine Amidi。作者关于 CS229 整理了一份超级详细的速查表
+[https://zhuanlan.zhihu.com/p/56534902](https://zhuanlan.zhihu.com/p/56534902)
+### 作业代码
+[https://github.com/Sierkinhane/CS229-ML-Implements](https://github.com/Sierkinhane/CS229-ML-Implements)
+## 3.公开课 - 林轩田《机器学习基石》
+### 课程介绍
+台湾大学林轩田老师的《机器学习基石》课程由浅入深、内容全面，基本涵盖了机器学习领域的很多方面。其作为机器学习的入门和进阶资料非常适合。而且林老师的教学风格也很幽默风趣，总让读者在轻松愉快的氛围中掌握知识。这门课比 Ng 的《Machine Learning》稍难一些，侧重于机器学习理论知识。
+### 中文视频
+[https://www.bilibili.com/video/av36731342](https://www.bilibili.com/video/av36731342)
+### 中文笔记
+[https://redstonewill.com/category/ai-notes/lin-ml-foundations/](https://redstonewill.com/category/ai-notes/lin-ml-foundations/)
+### 配套教材
+配套书籍为《Learning From Data》，在线书籍主页: [http://amlbook.com/](http://amlbook.com/)
+## 4.公开课 - 林轩田《机器学习技法》
+### 课程介绍
+《机器学习技法》课程是《机器学习基石》的进阶课程。主要介绍了机器学习领域经典的一些算法，包括支持向量机、决策树、随机森林、神经网络等等。难度要略高于《机器学习基石》，具有很强的实用性。
+### 中文视频
+[https://www.bilibili.com/video/av36760800](https://www.bilibili.com/video/av36760800)
+### 中文笔记
+[https://redstonewill.com/category/ai-notes/lin-ml-techniques/](https://redstonewill.com/category/ai-notes/lin-ml-techniques/)
+## 5.书籍 - 《机器学习》
+周志华的《机器学习》被大家亲切地称为“西瓜书”。这本书非常经典，讲述了机器学习核心数学理论和算法，适合有作为学校的教材或者中阶读者自学使用，入门时学习这本书籍难度稍微偏高了一些。
+![图片](https://uploader.shimo.im/f/P3AKvtlFmbIlJVrN.png!thumbnail)
+这本书配合《机器学习实战》这本书，效果很好！
+### 读书笔记
+[https://www.cnblogs.com/limitlessun/p/8505647.html#_label0](https://www.cnblogs.com/limitlessun/p/8505647.html#_label0)
+### 公式推导
+[https://datawhalechina.github.io/pumpkin-book/#/](https://datawhalechina.github.io/pumpkin-book/#/)
+### 课后习题
+[https://zhuanlan.zhihu.com/c_1013850291887845376](https://zhuanlan.zhihu.com/c_1013850291887845376)
+
+## 6.书籍 - 《统计学习方法》
+李航的这本《统计学习方法》堪称经典，包含更加完备和专业的机器学习理论知识，作为夯实理论非常不错。
+![图片](https://uploader.shimo.im/f/5n2sq6L07OkA1XJg.png!thumbnail)
+### 课讲 PPT
+[https://github.com/fengdu78/lihang-code/tree/master/ppt](https://github.com/fengdu78/lihang-code/tree/master/ppt)
+### 读书笔记
+[http://www.cnblogs.com/limitlessun/p/86111](http://www.cnblogs.com/limitlessun/p/8611103.html)[03.html](http://03.html
+参考笔记
+https://zhuanlan.zhihu.com/p/36378498
+代码实现
+)
+
+[https://github.com/SmirkCao/Lihang](https://github.com/SmirkCao/Lihang)
+### 参考笔记
+[https://zhuanlan.zhihu.com/p/36378498](http://03.html
+参考笔记
+https://zhuanlan.zhihu.com/p/36378498
+代码实现
+)
+### 代码实现
+[https://github.com/fengdu78/lihang-code/tree/master/code](https://github.com/fengdu78/lihang-code/tree/master/code)
+## 7.书籍 - 《Scikit-Learn 与 TensorFlow 机器学习实用指南》
+在经过前面的学习之后，这本《Scikit-Learn 与 TensorFlow 机器学习实用指南》非常适合提升你的机器学习实战编程能力。这本书分为两大部分，第一部分介绍机器学习基础算法，每章都配备 Scikit-Learn 实操项目；第二部分介绍神经网络与深度学习，每章配备 TensorFlow 实操项目。如果只是机器学习，可先看第一部分的内容。
+![图片](https://uploader.shimo.im/f/ARnTj6fm9UA67x7z.png!thumbnail)
+### 全书代码
+[https://github.com/ageron/handson-ml](https://github.com/ageron/handson-ml)
+## 8.实战 - Kaggle 比赛
+比赛是提升自己机器学习实战能力的最有效的方式，首选 Kaggle 比赛。
+### Kaggle 主页
+[https://www.kaggle.com/](https://www.kaggle.com/)
+### Kaggle 路线
+[https://github.com/apachecn/kaggle](https://github.com/apachecn/kaggle)
+## 9.工具 - Scikit-Learn 官方文档
+Scikit-Learn 作为机器学习一个非常全面的库，是一份不可多得的实战编程手册。
+### 官方文档
+[https://scikit-learn.org/stable/index.html](https://scikit-learn.org/stable/index.html)
+### 中文文档（0.19）
+[http://sklearn.apachecn.org/#/](http://sklearn.apachecn.org/#/)
+# 深度学习
+![图片](https://uploader.shimo.im/f/CWIQXBU0YksSqDOc.png!thumbnail)
+## 1.公开课 - 吴恩达《Deep Learning》
+在吴恩达开设了机器学习课程之后，发布的《Deep Learning》课程也备受好评，吴恩达老师的课程最大的特点就是将知识循序渐进的传授给你，是入门学习不可多得良好视频资料。整个专题共包括五门课程: 01.神经网络和深度学习；02.改善深层神经网络-超参数调试、正则化以及优化；03.结构化机器学习项目；04.卷积神经网络；05.序列模型。
+### 课程视频
+网易云课堂: [https://mooc.study.163.com/university/deeplearning_ai#/c](https://mooc.study.163.com/university/deeplearning_ai#/c)
+Coursera: [https://www.coursera.org/specializations/deep-learning](https://www.coursera.org/specializations/deep-learning)
+
+### 课程笔记
+之前编写过吴恩达老师机器学习个人笔记黄海广博士带领团队整理了中文笔记
+地址: [https://github.com/fengdu78/deeplearning_ai_books](https://github.com/fengdu78/deeplearning_ai_books)
+### 参考论文
+吴恩达老师在课程中提到了很多优秀论文，黄海广博士整理如下: 
+[https://github.com/fengdu78/deeplearning_ai_books/tree/master/%E5%8F%82%E8%80%83%E8%AE%BA%E6%96%87](https://github.com/fengdu78/deeplearning_ai_books/tree/master/%E5%8F%82%E8%80%83%E8%AE%BA%E6%96%87)
+
+### 课程PPT及课后作业
+吴恩达深度学习课程，包含课程的课件、课后作业和一些其他资料: 
+[https://github.com/stormstone/deeplearning.ai](https://github.com/stormstone/deeplearning.ai)
+
+## 2.公开课 - Fast.ai《程序员深度学习实战》
+说到深度学习的公开课，与吴恩达《Deep Learning》并驾齐驱的另一门公开课便是由Fast.ai出品的《程序员深度学习实战》。这门课最大的特点便是**“自上而下”**而不是**“自下而上”**,是绝佳的通过实战学习深度学习的课程。
+### 视频地址
+B站地址(英文字幕): 
+[https://www.bilibili.com/video/av18904696?from=search&seid=10813837536595120136](https://www.bilibili.com/video/av18904696?from=search&seid=10813837536595120136)
+CSDN地址(2017版中文字幕):
+[https://edu.csdn.net/course/detail/5192](https://edu.csdn.net/course/detail/5192)
+### 课程笔记
+英文笔记原文: 
+[https://medium.com/@hiromi_suenaga/deep-learning-2-part-1-lesson-1-602f73869197](https://medium.com/@hiromi_suenaga/deep-learning-2-part-1-lesson-1-602f73869197)
+由ApacheCN组织进行的中文翻译: 
+[https://github.com/apachecn/fastai-ml-dl-notes-zh](https://github.com/apachecn/fastai-ml-dl-notes-zh)
+
+## 3.公开课-CS230 Deep Learning
+### 课程介绍
+斯坦福的深度学习课程CS230在4月2日刚刚开课，对应的全套PPT也随之上线。从内容来看，今年的课程与去年的差别不大，涵盖了CNNs, RNNs, LSTM, Adam, Dropout, BatchNorm, Xavier/He initialization 等深度学习的基本模型，涉及医疗、自动驾驶、手语识别、音乐生成和自然语言处理等领域。
+
+Datawhale整理了该门课程的详细介绍及参考资料
+[https://mp.weixin.qq.com/s/kA-L8t5mGq6jExMBRjyg4g](https://mp.weixin.qq.com/s/kA-L8t5mGq6jExMBRjyg4g)
+### 
+## 4.书籍-复旦教授邱锡鹏《神经网络与深度学习》
+本书是入门深度学习领域的极佳教材，主要介绍了神经网络与深度学习中的基础知识、主要模型（前馈网络、卷积网络、循环网络等）以及在计算机视觉、自然语言处理等领域的应用。
+[https://mp.weixin.qq.com/s/-NaDpXsxvu4DpXqVNXIAvQ](https://mp.weixin.qq.com/s/-NaDpXsxvu4DpXqVNXIAvQ)
+
+## 5.书籍 -《深度学习》
+![图片](https://uploader.shimo.im/f/ExWrjEUvH1E0SakQ.png!thumbnail)
+完成以上学习后，想要更加系统的建立深度学习的知识体系，阅读《深度学习》准没错。该书从浅入深介绍了基础数学知识、机器学习经验以及现阶段深度学习的理论和发展，它能帮助人工智能技术爱好者和从业人员在三位专家学者的思维带领下全方位了解深度学习。
+### 书籍介绍
+《深度学习》通常又被称为花书，深度学习领域最经典的畅销书。由全球知名的三位专家IanGoodfellow、YoshuaBengio和AaronCourville撰写，是深度学习领域奠基性的经典教材。全书的内容包括3个部分: 第1部分介绍基本的数学工具和机器学习的概念，它们是深度学习的预备知识；第2部分系统深入地讲解现今已成熟的深度学习方法和技术；第3部分讨论某些具有前瞻性的方向和想法，它们被公认为是深度学习未来的研究重点。该书被大众尊称为“AI圣经”。
+
+### 在线阅读
+该书由众多网友众包翻译，电子版在以下地址获得: 
+[https://github.com/exacity/deeplearningbook-chinese](https://github.com/exacity/deeplearningbook-chinese)
+
+## 6.书籍 -《深度学习 500 问》
+当你看完了所有的视频，研习了AI圣经，一定充满了满脑子问号，此时不如来深度学习面试中常见的500个问题。
+### 书籍介绍
+DeepLearning-500-questions，作者是川大的一名优秀毕业生谈继勇。该项目以深度学习面试问答形式，收集了 500 个问题和答案。内容涉及了常用的概率知识、线性代数、机器学习、深度学习、计算机视觉等热点问题，该书目前尚未完结，却已经收获了Github 2.4w stars。
+### 项目地址
+[https://github.com/scutan90/DeepLearning-500-questions](https://github.com/scutan90/DeepLearning-500-questions)
+
+## 7.工具 - TensorFlow 官方文档
+进行深度学习怎么离得开TensorFlow
+### 官方文档
+[https://www.tensorflow.org/api_docs/python/tf](https://www.tensorflow.org/api_docs/python/tf)
+### 中文文档
+[https://github.com/jikexueyuanwiki/tensorflow-zh](https://github.com/jikexueyuanwiki/tensorflow-zh)
+
+## 7.工具 - PyTorch官方文档
+PyTorch是进行深度学习的另一个主流框架
+### 官方文档
+[https://pytorch.org/docs/stable/index.html](https://pytorch.org/docs/stable/index.html)
+### 中文文档(版本0.3)
+[https://github.com/apachecn/pytorch-doc-zh](https://github.com/apachecn/pytorch-doc-zh)
+# 强化学习
+![图片](https://uploader.shimo.im/f/E8K8fklpvKceOGQe.png!thumbnail)
+## 1.公开课 - David Silver《Reinforcement Learning》
+同吴恩达的课程对于机器学习和深度学习初学者的意义一样，David Silver的这门课程绝对是大多数人学习强化学习必选的课程。课程从浅到深，把强化学习的内容娓娓道来，极其详尽。不过由于强化学习本身的难度，听讲这门课还是有一定的门槛，建议还是在大致了解这个领域之后观看该视频学习效果更佳，更容易找到学习的重点。另外，由于强化学习领域飞速地发展，最前沿的知识（特别是与深度学习相关的）没有被涵盖在这个课程中，需要另外补充。
+### 课程介绍
+该课程对强化学习领域做了相当详尽的讲解，其主要内容有: 马尔可夫决策过程（强化学习的基础理论）、动态规划、免模型预测（蒙特卡洛学习、时序差分学习和λ时序差分强化学习）、免模型控制（On-policy Learning和Off-policy Learning）、价值函数的近似表示、策略梯度算法、集成学习与计划、探索与利用以及实例演示。
+
+### 视频地址
+B站地址(中文字幕): 
+[https://www.bilibili.com/video/av45357759?from=search&seid=9547815852611563503](https://www.bilibili.com/video/av45357759?from=search&seid=9547815852611563503)
+课程原地址: 
+[https://www.youtube.com/watch?v=2pWv7GOvuf0](https://www.youtube.com/watch?v=2pWv7GOvuf0)
+
+### 课程资料
+课程PPT: 
+[http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html](http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html)
+课程笔记: 
+[https://www.zhihu.com/people/qqiang00/posts](https://www.zhihu.com/people/qqiang00/posts)
+
+## 2.公开课 - 李宏毅《深度强化学习》
+David Silver的课程虽然内容详尽，但前沿的很多内容都没有被包括在内，这时，台大李宏毅的《深度强化学习》就是学习前沿动态的不二之选。李宏毅老师讲课非常幽默风趣，并且浅显易懂，而且对于大多数初学者来说，中文教学可谓是福音。当然，这门课程也有着没有对理论知识做太多详尽地展开、内容主要围绕着深度强化学习进行等缺陷，但这并不妨碍其成为初学者们的首选之一。
+### 课程介绍
+该课程上线于2018年，基本涵盖了当年的前沿技术，其主要内容有: 策略梯度算法（David Silver的课程中提到的算法大多都在这部分的内容中提到，但其主要是从神经网络的角度出发）、Q-learning（这部分涵盖了大量的Q-learning优化的讲解）、Actor-Critic、Sparse Reward 和 Imitation Learning。
+### 视频地址
+B站地址(中文字幕): 
+[https://www.bilibili.com/video/av24724071?from=search&seid=9547815852611563503](https://www.bilibili.com/video/av24724071?from=search&seid=9547815852611563503)
+课程原地址: 
+[https://www.youtube.com/watch?v=2pWv7GOvuf0](https://www.youtube.com/watch?v=2pWv7GOvuf0)
+
+### 课程资料
+课程PPT: 
+[http://speech.ee.ntu.edu.tw/~tlkagk/courses_MLDS18.html](http://speech.ee.ntu.edu.tw/~tlkagk/courses_MLDS18.html)
+课程笔记: 
+[https://blog.csdn.net/cindy_1102/article/details/87905272](https://blog.csdn.net/cindy_1102/article/details/87905272)
+
+
+# 前沿 Paper
+![图片](https://uploader.shimo.im/f/zViCOYrXGokl9Taa.png!thumbnail)
+## Arxiv
+### Arxiv Stats
+Arxiv 机器学习最新论文检索，主页地址: 
+[https://arxiv.or](https://arxiv.org/list/stat.ML/recent?ref=bestofml.com)[g/list/stat.ML](https://arxiv.org/list/stat.ML/recent?ref=bestofml.com)[/recent?ref=bestofml.com](https://arxiv.org/list/stat.ML/recent?ref=bestofml.com)
+### Arxiv Sanity Preserver
+Andrej Karpathy 开发了 Arxiv Sanity Preserver，帮助分类、搜索和过滤特征，主页地址: 
+[ht](http://www.arxiv-sanity.com/?ref=bestofml.com)[tp://www.arxiv-sanity.com/?ref=bestofml.co](http://www.arxiv-sanity.com/?ref=bestofml.com)[m](http://www.arxiv-sanity.com/?ref=bestofml.com)
+## Papers with Code
+### Papers with Code(Browse state-of-the-art)
+这个网站叫做 Browse state-of-the-art。它将 ArXiv 上的最新深度学习论文与 GitHub 上的开源代码联系起来。该项目目前包含了 651 个排行榜，1016 个深度学习任务，795 个数据集，以及重磅的 10257 个含复现代码的优秀论文。简直就是一个寻找论文和代码的利器。它将 1016 个深度学习任务分成了 16 大类，涉及了深度学习的各个方面。
+
+主页地址: 
+[https://paperswithcode.com/sota](https://paperswithcode.com/sota)
+
+举两个例子: 
+
+（1）CV: [https://paperswithcode.com/area/computer-vision](https://paperswithcode.com/area/computer-vision)
+（2）NLP: [https://paperswithcode.com/area/natural-language-processing](https://paperswithcode.com/area/natural-language-processing)
+
+介绍: [https://redstonewill.com/2039/](https://redstonewill.com/2039/)
+### Papers with Code(Sorted by stars)
+这份资源收集了 AI 领域从 2013 - 2018 年所有的论文，并按照在 GitHub 上的标星数量进行排序。GitHub 项目地址: 
+[https://github.com/zziz/pwc](https://github.com/zziz/pwc)
+## Deep Learning Papers(Reading Roadmap)
+如果你是深度学习领域的新手，你可能会遇到的第一个问题是“我应该从哪篇论文开始阅读？”下面是一个深入学习论文的阅读路线图！GitHub 项目地址: 
+[https://github.com/floodsung/Deep-Learning-Papers-Reading-Roadmap](https://github.com/floodsung/Deep-Learning-Papers-Reading-Roadmap)
+
+这份深度学习论文阅读路线分为三大块: 
+
+**1 Deep Learning History and Basics**
+**2 Deep Learning Method**
+**3 Applications**
+## Deep Learning Object Detection
+目标检测（Object Detection）是深度学习 CV 领域的一个核心研究领域和重要分支。纵观 2013 年到 2019 年，从最早的 R-CNN、Fast R-CNN 到后来的 YOLO v2、YOLO v3 再到今年的 M2Det，新模型层出不穷，性能也越来越好！本资源对目标检测近几年的发展和相关论文做出一份系统介绍，总结一份超全的文献 paper 列表。
+
+![图片](https://uploader.shimo.im/f/wIBvBV6ZPYYpL5GA.png!thumbnail)
+
+GitHub 项目地址: 
+[https://github.com/hoya012/deep_learning_object_detection](https://github.com/hoya012/deep_learning_object_detection)
+
+介绍: [https://redstonewill.com/1934/](https://redstonewill.com/1934/)
+## 知名会议
+**NeurIPS**: [https://nips.cc/](https://nips.cc/)
+**ICML**: [https://icml.cc/](https://icml.cc/)
+**ICLR**: [https://iclr.cc/](https://iclr.cc/)
+**AAAI**: [https://aaai.org/Conferences/AAAI-19/](https://aaai.org/Conferences/AAAI-19/)
+**IJCAI**: [https://www.ijcai.org/](https://www.ijcai.org/)
+**UAI**: [http://www.auai.org/uai2019/index.php](http://www.auai.org/uai2019/index.php)
+
+### 计算机视觉: 
+**CVPR**: [http://cvpr2019.thecvf.com/](http://cvpr2019.thecvf.com/)
+**ECCV**: [https://eccv2018.org/program/main-conference/](https://eccv2018.org/program/main-conference/)
+**ICCV**: [http://iccv2019.thecvf.com/](http://iccv2019.thecvf.com/)
+
+### 自然语言处理: 
+**ACL**: [http://www.aclcargo.com/](http://www.aclcargo.com/)
+**EMNLP**: [https://www.aclweb.org/portal/content/emnlp-2018](https://www.aclweb.org/portal/content/emnlp-2018)
+**NAACL**: [https://naacl2019.org/](https://naacl2019.org/)
+### 知名期刊
+**JAIR**: [https://www.jair.org/index.php/jair](https://www.jair.org/index.php/jair)
+**JMLR**: [http://www.jmlr.org/](http://www.jmlr.org/)
+### 其它
+机器人方面，有 CoRL（学习）、ICAPS（规划，包括但不限于机器人）、ICRA、IROS、RSS；对于更理论性的研究，有 AISTATS、COLT、KDD。
+# 理论应用
+![图片](https://uploader.shimo.im/f/O1TdCdH56vcst1dF.png!thumbnail)
+## 自然语言处理
+
+1. NLP是什么
+
+自然语言处理（NLP，Natural Language Processing）是研究计算机处理人类语言的一门技术，目的是弥补人类交流（自然语言）和计算机理解（机器语言）之间的差距。NLP包含句法语义分析、信息抽取、文本挖掘、机器翻译、信息检索、问答系统和对话系统等领域。
+
+1. 课程推荐
+
+① CS224n 斯坦福深度自然语言处理课
+17版中文字幕 [https://www.bilibili.com/video/av41393758/?p=1](https://www.bilibili.com/video/av41393758/?p=1)
+课程笔记: [http://www.hankcs.com/?s=CS224n%E7%AC%94%E8%AE%B0](http://www.hankcs.com/?s=CS224n%E7%AC%94%E8%AE%B0)
+2019版课程主页: [http://web.stanford.edu/class/cs224n/](http://web.stanford.edu/class/cs224n/) （需科学上网）
+② 自然语言处理 - Dan Jurafsky 和 Chris Manning
+B站英文字幕版: [https://www.bilibili.com/video/av35805262/](https://www.bilibili.com/video/av35805262/)
+学术激流网: [http://academictorrents.com/details/d2c8f8f1651740520b7dfab23438d89bc8c0c0ab](http://academictorrents.com/details/d2c8f8f1651740520b7dfab23438d89bc8c0c0ab)
+
+1. 书籍推荐
+
+① Python自然语言处理
+中英文版
+>入门读物，整本书不仅涉及了语料库的操作，也对传统的基于规则的方法有所涉及。全书包括了分词（tokenization）、词性标注（POS）、语块（Chunk）标注、句法剖析与语义剖析等方面，是nlp中不错的一本实用教程。
+
+② 自然语言处理综论
+中英文版
+>By Daniel Jurafsky和James H. Martin
+>权威性杠杠的！经典的NLP教科书，涵盖了经典自然语言处理、统计自然语言处理、语音识别和计算语言学等方面。
+
+③ 统计自然语言处理基础
+中英文版
+>By Chris Manning和HinrichSchütze
+>更高级的统计NLP方法，在统计基本部分和n元语法部分介绍地都很不错 
+
+1. 博客推荐
+
+我爱自然语言处理网站  [http://www.52nlp.cn/](http://www.52nlp.cn/)
+>TFIDF、文档相似度等等网站上都有通俗易懂的解释
+
+语言日志博客（Mark Liberman）[http://languagelog.ldc.upenn.edu/nll/](http://languagelog.ldc.upenn.edu/nll/)  
+natural language processing blog [https://nlpers.blogspot.com/](https://nlpers.blogspot.com/)
+>美国Hal Daumé III维护的一个natural language processing的博客，经常评论最新学术动态，值得关注。有关于ACL、NAACL等学术会议的参会感想和对论文的点评
+### 5.项目推荐
+基于LSTM的中文问答系统 [https://github.com/S-H-Y-GitHub/QA](https://github.com/S-H-Y-GitHub/QA)
+基于RNN的文本生成器 [https://github.com/karpathy/char-rnn](https://github.com/karpathy/char-rnn)
+基于char-rnn的汪峰歌词生成器 [https://github.com/phunterlau/wangfeng-rnn](https://github.com/phunterlau/wangfeng-rnn)
+用RNN生成手写数字 [https://github.com/skaae/lasagne-draw](https://github.com/skaae/lasagne-draw)
+1. 开源NLP工具包
+
+中文NLP相关:  [https://github.com/crownpku/Awesome-Chinese-NLP](https://github.com/crownpku/Awesome-Chinese-NLP)
+英文NLP相关: 
+>NLTK [http://www.nltk.org/](http://www.nltk.org/)
+>TextBlob: [http://textblob.readthedocs.org/en/dev/](http://textblob.readthedocs.org/en/dev/)
+>Gensim: [http://radimrehurek.com/gensim/](http://radimrehurek.com/gensim/)
+>Pattern: [http://www.clips.ua.ac.be/pattern](http://www.clips.ua.ac.be/pattern)
+>Spacy:: [http://spacy.io](http://spacy.io)
+>Orange: [http://orange.biolab.si/features/](http://orange.biolab.si/features/)
+>Pineapple: [https://github.com/proycon/pynlpl](https://github.com/proycon/pynlpl)
+1. 相关论文
+
+100 Must-Read NLP Papers [https://github.com/mhagiwara/100-nlp-papers](https://github.com/mhagiwara/100-nlp-papers)
+## **计算机视觉**
+1. 计算机视觉的应用
+| 计算机视觉的应用   | 无人驾驶   | 
+|:----:|:----:|:----:|:----:|
+|    | 无人安防   | 
+|    | 人脸识别   | 
+|    | 车辆车牌识别   | 
+|    | 以图搜图   | 
+|    | VR/AR   | 
+|    | 3D重构   | 
+|    | 无人机   | 
+|    | 医学图像分析   | 
+|    | 其他   | 
+
+### 2.课程推荐
+**Stanford CS223B** 
+比较适合基础，适合刚刚入门的同学，跟深度学习的结合相对来说会少一点，不会整门课讲深度学习，而是主要讲计算机视觉，方方面面都会讲到
+
+李飞飞: CS231n课程
+[https://mp.weixin.qq.com/s/-NaDpXsxvu4DpXqVNXIAvQ](https://mp.weixin.qq.com/s/-NaDpXsxvu4DpXqVNXIAvQ)
+### 3.书籍推荐
+1）入门学习: 《**Computer Vision: Models, Learning and Inference**》
+2）经典权威的参考资料: 《**Computer Vision: Algorithms and Applications**》
+3）理论实践: 《**OpenCV3编程入门**》
+## **推荐系统**
+### 1.推荐系统是什么
+推荐系统就是自动联系用户和物品的一种工具，它能够在信息过载的环境中帮助用户发现令他们感兴趣的信息，也能将信息推送给对它们感兴趣的用户。 推荐系统属于资讯过滤的一种应用。
+### 2.推荐课程
+推荐系统专项课程《[Recommender Systems Specialization](https://www.coursera.org/specializations/recommender-systems)》
+这个系列由4门子课程和1门毕业项目课程组成，包括推荐系统导论，最近邻协同过滤，推荐系统评价，矩阵分解和高级技术等。
+观看地址: [https://www.coursera.org/specializations/recommender-systems](https://www.coursera.org/specializations/recommender-systems)
+### 3.书籍推荐
+《推荐系统实践》（项亮 著）
+《推荐系统》（Dietmar Jannach等 著，蒋凡 译）
+《用户网络行为画像》（牛温佳等 著）
+《Recommender Systems Handbook》（Paul B·Kantor等 著）
+### 4.算法库
+**LibRec**
+LibRec是一个Java版本的覆盖了70余个各类型推荐算法的推荐系统开源算法库，由国内的推荐系统大牛郭贵冰创办，目前已更新到2.0版本，它有效地解决了评分预测和物品推荐两大关键的推荐问题。
+项目地址: [https://github.com/guoguibing/librec](https://github.com/guoguibing/librec)
+官网: [官网https://www.librec.net/](https://www.librec.net/)
+**LibMF**
+C++版本开源推荐系统，主要实现了基于矩阵分解的推荐系统。针对SGD（随即梯度下降）优化方法在并行计算中存在的 locking problem 和 memory discontinuity问题，提出了一种 矩阵分解的高效算法FPSGD（Fast Parallel SGD），根据计算节点的个数来划分评分矩阵block，并分配计算节点。
+项目地址: [http://www.csie.ntu.edu.tw/~cjlin/libmf/](http://www.csie.ntu.edu.tw/~cjlin/libmf/)
+**SurPRISE**
+一个Python版本的开源推荐系统，有多种经典推荐算法
+项目地址: [http://surpriselib.com/](http://surpriselib.com/)
+**Neural Collaborative Filtering**
+神经协同过滤推荐算法的Python实现
+项目地址: [https://github.com/hexiangnan/neural_collaborative_filtering](https://github.com/hexiangnan/neural_collaborative_filtering)
+**Crab**
+基于Python开发的开源推荐软件，其中实现有item和user的协同过滤
+项目地址: [http://muricoca.github.io/crab/](http://muricoca.github.io/crab/)
+
+### 5.常用数据集
+**MovieLen**
+地址: [https://grouplens.org/datasets/movielens/](https://grouplens.org/datasets/movielens/)
+MovieLens数据集中，用户对自己看过的电影进行评分，分值为1~5。MovieLens包括两个不同大小的库，适用于不同规模的算法。小规模的库是943个独立用户对1 682部电影作的10 000次评分的数据；大规模的库是6 040个独立用户对3 900部电影作的大约100万次评分。适用于传统的推荐任务
+**Douban**
+地址: [https://www.cse.cuhk.edu.hk/irwin.king.new/pub/data/douban](https://www.cse.cuhk.edu.hk/irwin.king.new/pub/data/douban)
+Douban是豆瓣的匿名数据集，它包含了12万用户和5万条电影数据，是用户对电影的评分信息和用户间的社交信息，适用于社会化推荐任务。
+**BookCrossing**
+地址: [http://www2.informatik.uni-freiburg.de/~cziegler/BX/](http://www2.informatik.uni-freiburg.de/~cziegler/BX/)
+这个数据集是网上的Book-Crossing图书社区的278858个用户对271379本书进行的评分，包括显式和隐式的评分。这些用户的年龄等人口统计学属性(demographic feature)都以匿名的形式保存并供分析。这个数据集是由Cai-Nicolas Ziegler使用爬虫程序在2004年从Book-Crossing图书社区上采集的。
+**Jester Joke**
+地址: [http://eigentaste.berkeley.edu/dataset/](http://eigentaste.berkeley.edu/dataset/)
+Jester Joke是一个网上推荐和分享笑话的网站。这个数据集有73496个用户对100个笑话作的410万次评分。评分范围是−10~10的连续实数。这些数据是由加州大学伯克利分校的Ken Goldberg公布的。
+**Netflix**
+[地址: http://academictorrents.com/details/9b13183dc4d60676b773c9e2cd6de5e5542cee9a](http://academictorrents.com/details/9b13183dc4d60676b773c9e2cd6de5e5542cee9a)
+这个数据集来自于电影租赁网址Netflix的数据库。Netflix于2005年底公布此数据集并设立百万美元的奖金(netflix prize)，征集能够使其推荐系统性能上升10%的推荐算法和架构。这个数据集包含了480 189个匿名用户对大约17 770部电影作的大约10亿次评分。
+Usenet Newsgroups(http://qwone.com/~jason/20Newsgroups/) 
+这个数据集包括20个新闻组的用户浏览数据。最新的应用是在KDD 2007上的论文。新闻组的内容和讨论的话题包括计算机技术、摩托车、篮球、政治等。用户们对这些话题进行评价和反馈。
+**UCI库**
+地址: [https://archive.ics.uci.edu/ml/datasets.html](https://archive.ics.uci.edu/ml/datasets.html)
+UCI库是Blake等人在1998年开放的一个用于机器学习和评测的数据库，其中存储大量用于模型训练的标注样本，可用于推荐系统的性能测试数据。
+### 6.推荐论文
+经典必读论文整理，包括综述文章、传统经典推荐文章、社会化推荐文章、基于深度学习的推荐系统文章、专门用于解决冷启动的文章、POI相关的论文、利用哈希技术来加速推荐的文章以及推荐系统中经典的探索与利用问题的相关文章等。
+项目地址: [https://github.com/hongleizhang/RSPapers](https://github.com/hongleizhang/RSPapers)
+### 7.推荐项目
+今日头条推荐系统机制介绍，面向内容创作者
+[分享人: 项亮，今日头条推荐算法架构师](https://v.qq.com/x/page/f0800qavik7.html?)
+[https://v.qq.com/x/page/f0800qavik7.html?](https://v.qq.com/x/page/f0800qavik7.html?)
+
+3分钟了解今日头条推荐系统原理
+[https://v.qq.com/x/page/g05349lb80j.html?](https://v.qq.com/x/page/g05349lb80j.html?)
+
+facebook是如何为十亿人推荐好友的
+[https://code.facebook.com/posts/861999383875667/recommending-items-to-more-than-a-billion-people/](https://code.facebook.com/posts/861999383875667/recommending-items-to-more-than-a-billion-people/)
+
+Netflix的个性化和推荐系统架构
+[http://techblog.netflix.com/2013/03/system-architectures-for.html](http://techblog.netflix.com/2013/03/system-architectures-for.html)
+
+## 风控模型（评分卡模型）
+### 1.评分卡模型简介
+ 评分卡模型时在银行、互金等公司与借贷相关业务中最常见也是最重要的模型之一。简而言之它的作用就是对客户进行打分，来对客户是否优质进行评判。根据评分卡模型应用的业务阶段不用，评分卡模型主要分为三大类: A卡（Application score card）申请评分卡、B卡（Behavior score card）行为评分卡、C卡（Collection score card）催收评分卡。其中申请评分卡用于贷前，行为评分卡用于贷中，催收评分卡用于贷后，这三种评分卡在我们的信贷业务的整个生命周期都至关重要。
+### 2.推荐书籍
+《信用风险评分卡研究——基于SAS的开发与实施》
+### 3.评分卡模型建模过程
+（1）样本选取: 确定训练样本、测试样本的观察窗（特征的时间跨度）与表现窗（标签的时间跨度），且样本的标签定义是什么？一般情况下风险评分卡的标签都是考虑客户某一段时间内的延滞情况。
+（2）特征准备: 原始特征、衍生变量
+（3）数据清洗: 根据业务需求对缺失值或异常值等进行处理
+（4）特征筛选: 根据特征的IV值（特征对模型的贡献度）、PSI（特征的稳定性）来进行特征筛选，IV值越大越好（但是一个特征的IV值超过一定阈值可能要考虑是否用到未来数据），PSI越小越好（一般建模时取特征的PSI小于等于0.01）
+（5）对特征进行WOE转换，即对特征进行分箱操作，注意在进行WOE转换时要注重特征的可解释性
+（6）建立模型，在建立模型过程中可根据模型和变量的统计量判断模型中包含和不包含每个变量时的模型质量来进行变量的二次筛选。
+（7）评分卡模型一般关注的指标是KS值（衡量的是好坏样本累计分部之间的差值）、模型的PSI(即模型整体的稳定性）、AUC值等。
+## **知识图谱**
+### 1.知识图谱是什么
+知识图谱是一种结构化数据的处理方法，它涉及知识的提取、表示、存储、检索等一系列技术。从渊源上讲，它是知识表示与推理、数据库、信息检索、自然语言处理等多种技术发展的融合。
+### 2.推荐资料
+[为什么需要知识图谱？什么是知识图谱？——KG的前世今生](https://zhuanlan.zhihu.com/p/31726910)
+[什么是知识图谱？](https://zhuanlan.zhihu.com/p/34393554)
+[智能搜索时代: 知识图谱有何价值？](https://zhuanlan.zhihu.com/p/35982177?from=1084395010&wm=9848_0009&weiboauthoruid=5249689143)
+[百度王海峰: 知识图谱是 AI 的基石](http://www.infoq.com/cn/news/2017/11/Knowledge-map-cornerstone-AI#0-tsina-1-5001-397232819ff9a47a7b7e80a40613cfe1)
+[译文|从知识抽取到RDF知识图谱可视化](http://rdc.hundsun.com/portal/article/907.html?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io)
+### **3.主要内容**
+1. **知识提取**
+
+构建kg首先需要解决的是数据，知识提取是要解决结构化数据生成的问题。我们可以用自然语言处理的方法，也可以利用规则。
+* 使用规则: 
+    * 正则表达式: 
+
+       正则表达式（Regular Expression， regex）是字符串处理的基本功。数据爬取、数据清洗、实体提取、关系提取，都离不开regex。
+推荐资料入门: 
+          * [精通正则表达式](https://book.douban.com/subject/2154713/)
+          * regexper 可视化:  [例 [a-z]*(\d{4}(\D+))](https://regexper.com/#%5Ba-z%5D*(%5Cd%7B4%7D(%5CD%2B)))
+          * pythex 在线测试正则表达式 [http://pythex.org/](http://pythex.org/)
+
+推荐资料进阶: 
+          * re2 一个更快的Cython实现 [https://pypi.python.org/pypi/re2/](https://pypi.python.org/pypi/re2/)
+          * Parsley 更人性化的正则表达语法 [http://parsley.readthedocs.io/en/latest/tutorial.html](http://parsley.readthedocs.io/en/latest/tutorial.html)
+
+    * 中文分词和词性标注
+
+        分词也是后续所有处理的基础，词性（Part of Speech, POS）就是中学大家学过的动词、名词、形容词等等的词的分类。一般的分词工具都会有词性标注的选项。 
+推荐资料入门: 
+          * jieba 中文分词包  [https://github.com/fxsjy/jieba](https://github.com/fxsjy/jieba)
+          * 中文词性标记集 [https://github.com/memect/kg-beijing/wiki/中文词性标记集](https://github.com/memect/kg-beijing/wiki/%E4%B8%AD%E6%96%87%E8%AF%8D%E6%80%A7%E6%A0%87%E8%AE%B0%E9%9B%86)
+
+ 推荐资料进阶: 
+          * genius 采用 CRF条件随机场算法 [https://github.com/duanhongyi/genius](https://github.com/duanhongyi/genius)
+          * Stanford CoreNLP分词  [https://blog.csdn.net/guolindonggld/article/details/72795022](https://blog.csdn.net/guolindonggld/article/details/72795022)
+
+    *  命名实体识别
+
+       命名实体识别（NER）是信息提取应用领域的重要基础工具，一般来说，命名实体识别的任务就是识别出待处理文本中三大类（实体类、时间类和数字类）、七小类（人名、机构名、地名、时间、日期、货币和百分比）命名实体。
+
+推荐资料: 
+          * Stanford CoreNLP 进行中文命名实体识别 [https://blog.csdn.net/guolindonggld/article/details/72795022](https://blog.csdn.net/guolindonggld/article/details/72795022)
+* 使用深度学习: 
+
+        使用自然语言处理的方法，一般是给定schema，从非结构化数据中抽取特定领域的三元组（spo），如最近[百度举办的比赛](http://lic2019.ccf.org.cn/kg)就是使用DL模型进行信息抽取。
+
+    * 序列标注
+
+       使用序列生出模型，主要是标记出三元组中subject及object的起始位置，从而抽取信息。
+推荐资料: 
+          * 序列标注问题 [https://www.cnblogs.com/jiangxinyang/p/9368482.html](https://www.cnblogs.com/jiangxinyang/p/9368482.html)
+
+
+    * seq2seq
+
+      使用seq2seq端到端的模型，主要借鉴文本摘要的思想，将三元组看成是非结构化文本的摘要，从而进行抽取，其中还涉及Attention机制。
+
+推荐资料: 
+          * seq2seq详解 [https://blog.csdn.net/irving_zhang/article/details/78889364](https://blog.csdn.net/irving_zhang/article/details/78889364)
+          * 详解从Seq2Seq模型到Attention模型  [https://caicai.science/2018/10/06/attention%E6%80%BB%E8%A7%88/](https://caicai.science/2018/10/06/attention%E6%80%BB%E8%A7%88/)
+
+1. **知识表示**
+
+     知识表示（Knowledge Representation，KR，也译为知识表现）是研究如何将结构化数据组织，以便于机器处理和人的理解的方法。
+
+需要熟悉下面内容: 
+* JSON和YAML
+  * json库 [https://docs.python.org/2/library/json.html](https://docs.python.org/2/library/json.html)
+  * PyYAML是Python里的Yaml处理库 [http://pyyaml.org/wiki/PyYAML](http://pyyaml.org/wiki/PyYAML)
+* RDF和OWL
+  * RDF和OWL语义 [http://blog.memect.cn/?p=871](http://blog.memect.cn/?p=871) 
+* JSON-LD
+  * JSON-LD主页 [http://json-ld.org/](http://json-ld.org/)
+
+1. **知识存储**
+
+需要熟悉常见的图数据库
+* 知识链接的方式: 字符串、外键、URI
+* PostgreSQL及其JSON扩展
+  * Psycopg包操作PostgreSQL [http://initd.org/psycopg/docs/](http://initd.org/psycopg/docs/)
+* 图数据库 Neo4j和OrientDB
+  * Neo4j的Python接口 [https://neo4j.com/developer/python/](https://neo4j.com/developer/python/)
+  * OrientDB: [http://orientdb.com/orientdb/](http://orientdb.com/orientdb/)
+* RDF数据库Stardog
+  * Stardog官网: [http://stardog.com/](http://stardog.com/)
+
+1. **知识检索**
+
+需要熟悉常见的检索技术
+* ElasticSearch
+
+ES教程:  [http://joelabrahamsson.com/elasticsearch-101/](http://joelabrahamsson.com/elasticsearch-101/)
+
+1. 相关术语及技术路线
+* [本体](https://www.zhihu.com/question/19558514)
+* [RDF](https://www.w3.org/RDF/)
+* [Apache Jena](https://jena.apache.org/)
+* [D2RQ](http://d2rq.org/getting-started)
+  * Protege构建本体系列
+* [protege](https://protege.stanford.edu/)
+* [protege使用](https://zhuanlan.zhihu.com/p/32389370)
+  * 开发语言
+* python或java
+  * 图数据库技术
+* [Neo4j](https://neo4j.com/)
+* [AllegroGraph](https://franz.com/agraph/allegrograph/)
+  * 可视化技术
+* [d3.js](https://d3js.org/)
+* [Cytoscape.js](http://js.cytoscape.org/)
+  * 分词技术
+* [jieba](https://github.com/fxsjy/jieba)
+* [hanlp](https://github.com/hankcs/HanLP)
+### 5.项目实战
+* [基于知识图谱的问答](https://github.com/kangzhun/KnowledgeGraph-QA-Service)
+* [Agriculture_KnowledgeGraph](https://github.com/qq547276542/Agriculture_KnowledgeGraph)
+# 贡献平台
+由知名开源平台，AI技术平台以及领域专家: ApacheCN，Datawhale，AI有道和黄海广博士联合整理贡献。
+参与名单: 
+ApacheCN: 片刻，李翔宇，飞龙，王翔
+Datawhale: 范晶晶，马晶敏，李碧涵，李福，光城，居居，康兵兵，郑家豪
+AI有道: 红色石头
+# 平台介绍
+* **Datawhale**: 一个专注于AI领域的开源组织，上海交通大学国家级孵化项目，目前有7个独立团队，聚集了一群有开源精神和探索精神的团队成员，汇聚了来自各个高校和企业的优秀学习者，致力于构建纯粹的学习圈子和优质的开源项目，提供的组队学习涵盖了数据分析，数据挖掘，机器学习，深度学习，编程等16个内容领域。
+
+![图片](https://uploader.shimo.im/f/zZmdWtiX9iop46uo.png!thumbnail)
+* **AI有道**: 一个专注于 AI 领域的技术公众号。公众号主要涉及人工智能领域 Python、ML 、CV、NLP 等前沿知识、干货笔记和优质资源！我们致力于为广大人工智能爱好者提供优质的 AI 资源和切实可行的 AI 学习路线。
+
+![图片](https://uploader.shimo.im/f/SFZ8X6UVSCQom4Ek.png!thumbnail)
+* **黄博（机器学习初学者）**: 机器学习课程在国内还不够普及，大部分初学者还是很迷茫，走了很多弯路，黄海广博士希望能尽自己的微薄之力，为机器学习初学者提供一个学习交流的平台。
+
+![图片](https://uploader.shimo.im/f/FUax8CI2ZTYyvYcF.png!thumbnail)
+* **ApacheCN**: 一个致力于提供优质开源项目的开源组织，致力于AI文档翻译，Kaggle比赛交流、LeetCode算法刷题、大数据交流等项目。我们希望做出广大 AI 爱好者真正需要的东西，打造真正有价值的长尾作品。官方网址: [http://www.apachecn.org/](http://www.apachecn.org/)，点击阅读原文即可查看。
+
+## 
+
+
+

docs/misc/CNN原理.md

@@ -0,0 +1,673 @@
+# CNN原理
+
+> 建议: 看懂原理就行
+
+# [【深度学习系列】卷积神经网络CNN原理详解(一)——基本原理](https://www.cnblogs.com/charlotte77/p/7759802.html)
+
+　　上篇文章我们给出了用paddlepaddle来做手写数字识别的示例，并对网络结构进行到了调整，提高了识别的精度。有的同学表示不是很理解原理，为什么传统的机器学习算法，简单的神经网络(如多层感知机)都可以识别手写数字，我们要采用卷积神经网络CNN来进行别呢？CNN到底是怎么识别的？用CNN有哪些优势呢？我们下面就来简单分析一下。在讲CNN之前，为避免完全零基础的人看不懂后面的讲解，我们先简单回顾一下传统的神经网络的基本知识。
+
+* * *
+
+　　**神经网络的预备知识**
+
+**     为什么要用神经网络？**
+
+* 特征提取的高效性。
+
+大家可能会疑惑，对于同一个分类任务，我们可以用机器学习的算法来做，为什么要用神经网络呢？大家回顾一下，一个分类任务，我们在用机器学习算法来做时，首先要明确feature和label，然后把这个数据"灌"到算法里去训练，最后保存模型，再来预测分类的准确性。但是这就有个问题，即我们需要实现确定好特征，每一个特征即为一个维度，特征数目过少，我们可能无法精确的分类出来，即我们所说的欠拟合，如果特征数目过多，可能会导致我们在分类过程中过于注重某个特征导致分类错误，即过拟合。
+
+　　举个简单的例子，现在有一堆数据集，让我们分类出西瓜和冬瓜，如果只有两个特征: 形状和颜色，可能没法分区来；如果特征的维度有: 形状、颜色、瓜瓤颜色、瓜皮的花纹等等，可能很容易分类出来；如果我们的特征是: 形状、颜色、瓜瓤颜色、瓜皮花纹、瓜蒂、瓜籽的数量，瓜籽的颜色、瓜籽的大小、瓜籽的分布情况、瓜籽的XXX等等，很有可能会过拟合，譬如有的冬瓜的瓜籽数量和西瓜的类似，模型训练后这类特征的权重较高，就很容易分错。这就导致我们在特征工程上需要花很多时间和精力，才能使模型训练得到一个好的效果。然而神经网络的出现使我们不需要做大量的特征工程，譬如提前设计好特征的内容或者说特征的数量等等，我们可以直接把数据灌进去，让它自己训练，自我“修正”，即可得到一个较好的效果。
+
+* 数据格式的简易性
+
+　　在一个传统的机器学习分类问题中，我们“灌”进去的数据是不能直接灌进去的，需要对数据进行一些处理，譬如量纲的归一化，格式的转化等等，不过在神经网络里我们不需要额外的对数据做过多的处理，具体原因可以看后面的详细推导。
+
+* 参数数目的少量性
+
+　　在面对一个分类问题时，如果用SVM来做，我们需要调整的参数需要调整核函数，惩罚因子，松弛变量等等，不同的参数组合对于模型的效果也不一样，想要迅速而又准确的调到最适合模型的参数需要对背后理论知识的深入了解(当然，如果你说全部都试一遍也是可以的，但是花的时间可能会更多),对于一个基本的三层神经网络来说(输入-隐含-输出)，我们只需要初始化时给每一个神经元上随机的赋予一个权重w和偏置项b，在训练过程中，这两个参数会不断的修正，调整到最优质，使模型的误差最小。所以从这个角度来看，我们对于调参的背后理论知识并不需要过于精通(只不过做多了之后可能会有一些经验，在初始值时赋予的值更科学，收敛的更快罢了)
+
+**   有哪些应用？**
+
+　　应用非常广，不过大家注意一点，我们现在所说的神经网络，并不能称之为深度学习，神经网络很早就出现了，只不过现在因为不断的加深了网络层，复杂化了网络结构，才成为深度学习，并在图像识别、图像检测、语音识别等等方面取得了不错的效果。
+
+    **基本网络结构**
+
+　　一个神经网络最简单的结构包括输入层、隐含层和输出层，每一层网络有多个神经元，上一层的神经元通过激活函数映射到下一层神经元，每个神经元之间有相对应的权值，输出即为我们的分类类别。
+
+**　详细数学推导**
+
+　　去年中旬我参考吴恩达的UFLDL和mattmazur的博客写了篇文章详细讲解了一个最简单的神经网络从前向传播到反向传播的直观推导，大家可以先看看这篇文章--[一文弄懂神经网络中的反向传播法--BackPropagation](http://www.cnblogs.com/charlotte77/p/5629865.html)。
+
+**　优缺点**
+
+　　前面说了很多优点，这里就不多说了，简单说说缺点吧。我们试想一下如果加深我们的网络层，每一个网络层增加神经元的数量，那么参数的个数将是M*N（m为网络层数，N为每层神经元个数），所需的参数会非常多，参数一多，模型就复杂了，越是复杂的模型就越不好调参，也越容易过拟合。此外我们从神经网络的反向传播的过程来看，梯度在反向传播时，不断的迭代会导致梯度越来越小，即梯度消失的情况，梯度一旦趋于0，那么权值就无法更新，这个神经元相当于是不起作用了，也就很难导致收敛。尤其是在图像领域，用最基本的神经网络，是不太合适的。后面我们会详细讲讲为啥不合适。
+
+* * *
+
+　　**为什么要用卷积神经网络？**
+
+**　  传统神经网络的劣势**
+
+　　前面说到在图像领域，用传统的神经网络并不合适。我们知道，图像是由一个个像素点构成，每个像素点有三个通道，分别代表RGB颜色，那么，如果一个图像的尺寸是（28，28，1），即代表这个图像的是一个长宽均为28，channel为1的图像（channel也叫depth,此处1代表灰色图像）。如果使用全连接的网络结构，即，网络中的神经与与相邻层上的每个神经元均连接，那就意味着我们的网络有 `28 * 28 =784` 个神经元，hidden层采用了15个神经元，那么简单计算一下，我们需要的参数个数(w和b)就有:  `784*15*10+15+10=117625` 个，这个参数太多了，随便进行一次反向传播计算量都是巨大的，从计算资源和调参的角度都不建议用传统的神经网络。(评论中有同学对这个参数计算不太理解，我简单说一下: 图片是由像素点组成的，用矩阵表示的， `28*28` 的矩阵，肯定是没法直接放到神经元里的，我们得把它“拍平”，变成一个`28*28=784` 的一列向量，这一列向量和隐含层的15个神经元连接，就有 `784*15=11760` 个权重w，隐含层和最后的输出层的10个神经元连接，就有 `11760*10=117600` 个权重w，再加上隐含层的偏置项15个和输出层的偏置项10个，就是: 117625个参数了)
+
+![](img/CNN原理/853467-20171031123650574-11330636.png)
+
+　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图1 三层神经网络识别手写数字
+
+**　　卷积神经网络是什么？**
+
+**　　三个基本层**
+
+*  **卷积层（Convolutional Layer）**
+
+　　上文提到我们用传统的三层神经网络需要大量的参数，原因在于每个神经元都和相邻层的神经元相连接，但是思考一下，这种连接方式是必须的吗？全连接层的方式对于图像数据来说似乎显得不这么友好，因为图像本身具有“二维空间特征”，通俗点说就是局部特性。譬如我们看一张猫的图片，可能看到猫的眼镜或者嘴巴就知道这是张猫片，而不需要说每个部分都看完了才知道，啊，原来这个是猫啊。所以如果我们可以用某种方式对一张图片的某个典型特征识别，那么这张图片的类别也就知道了。这个时候就产生了卷积的概念。举个例子，现在有一个4*4的图像，我们设计两个卷积核，看看运用卷积核后图片会变成什么样。
+
+![](img/CNN原理/853467-20171104142033154-1330878114.png)
+
+ 图2　4*4 image与两个2*2的卷积核操作结果
+
+　　由上图可以看到，原始图片是一张灰度图片,每个位置表示的是像素值，0表示白色，1表示黑色，（0，1）区间的数值表示灰色。对于这个4*4的图像，我们采用两个2*2的卷积核来计算。设定步长为1，即每次以2*2的固定窗口往右滑动一个单位。以第一个卷积核filter1为例，计算过程如下: 
+
+```python
+feature_map1(1,1) = 1*1 + 0*(-1) + 1*1 + 1*(-1) = 1 
+feature_map1(1,2) = 0*1 + 1*(-1) + 1*1 + 1*(-1) = -1 
+...
+feature_map1(3,3) = 1*1 + 0*(-1) + 1*1 + 0*(-1) = 2
+```
+
+　　可以看到这就是最简单的内积公式。feature_map1(1,1)表示在通过第一个卷积核计算完后得到的feature_map的第一行第一列的值，随着卷积核的窗口不断的滑动，我们可以计算出一个3\*3的feature_map1;同理可以计算通过第二个卷积核进行卷积运算后的feature_map2，那么这一层卷积操作就完成了。feature_map尺寸计算公式: [ (原图片尺寸 -卷积核尺寸)/ 步长 ] + 1。这一层我们设定了两个2\*2的卷积核，在paddlepaddle里是这样定义的: 
+
+
+```python
+conv_pool_1 = paddle.networks.simple_img_conv_pool(
+        input=img,
+        filter_size=3,
+        num_filters=2,
+        num_channel=1,
+        pool_stride=1,
+        act=paddle.activation.Relu())
+```
+
+
+　　这里调用了networks里simple_img_conv_pool函数，激活函数是Relu(修正线性单元)，我们来看一看源码里外层接口是如何定义的: 
+
+
+```python
+def simple_img_conv_pool(input,
+                         filter_size,
+                         num_filters,
+                         pool_size,
+                         name=None,
+                         pool_type=None,
+                         act=None,
+                         groups=1,
+                         conv_stride=1,
+                         conv_padding=0,
+                         bias_attr=None,
+                         num_channel=None,
+                         param_attr=None,
+                         shared_bias=True,
+                         conv_layer_attr=None,
+                         pool_stride=1,
+                         pool_padding=0,
+                         pool_layer_attr=None):
+    """
+    Simple image convolution and pooling group.
+    Img input => Conv => Pooling => Output.
+    :param name: group name.
+    :type name: basestring
+    :param input: input layer.
+    :type input: LayerOutput
+    :param filter_size: see img_conv_layer for details.
+    :type filter_size: int
+    :param num_filters: see img_conv_layer for details.
+    :type num_filters: int
+    :param pool_size: see img_pool_layer for details.
+    :type pool_size: int
+    :param pool_type: see img_pool_layer for details.
+    :type pool_type: BasePoolingType
+    :param act: see img_conv_layer for details.
+    :type act: BaseActivation
+    :param groups: see img_conv_layer for details.
+    :type groups: int
+    :param conv_stride: see img_conv_layer for details.
+    :type conv_stride: int
+    :param conv_padding: see img_conv_layer for details.
+    :type conv_padding: int
+    :param bias_attr: see img_conv_layer for details.
+    :type bias_attr: ParameterAttribute
+    :param num_channel: see img_conv_layer for details.
+    :type num_channel: int
+    :param param_attr: see img_conv_layer for details.
+    :type param_attr: ParameterAttribute
+    :param shared_bias: see img_conv_layer for details.
+    :type shared_bias: bool
+    :param conv_layer_attr: see img_conv_layer for details.
+    :type conv_layer_attr: ExtraLayerAttribute
+    :param pool_stride: see img_pool_layer for details.
+    :type pool_stride: int
+    :param pool_padding: see img_pool_layer for details.
+    :type pool_padding: int
+    :param pool_layer_attr: see img_pool_layer for details.
+    :type pool_layer_attr: ExtraLayerAttribute
+    :return: layer's output
+    :rtype: LayerOutput
+    """
+    _conv_ = img_conv_layer(
+        name="%s_conv" % name,
+        input=input,
+        filter_size=filter_size,
+        num_filters=num_filters,
+        num_channels=num_channel,
+        act=act,
+        groups=groups,
+        stride=conv_stride,
+        padding=conv_padding,
+        bias_attr=bias_attr,
+        param_attr=param_attr,
+        shared_biases=shared_bias,
+        layer_attr=conv_layer_attr)
+    return img_pool_layer(
+        name="%s_pool" % name,
+        input=_conv_,
+        pool_size=pool_size,
+        pool_type=pool_type,
+        stride=pool_stride,
+        padding=pool_padding,
+        layer_attr=pool_layer_attr)
+```
+
+我们在 [Paddle/python/paddle/v2/framework/nets.py](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/nets.py) 里可以看到simple_img_conv_pool这个函数的定义: 
+
+```python
+def simple_img_conv_pool(input,
+                         num_filters,
+                         filter_size,
+                         pool_size,
+                         pool_stride,
+                         act,
+                         pool_type='max',
+                         main_program=None,
+                         startup_program=None):
+    conv_out = layers.conv2d(
+        input=input,
+        num_filters=num_filters,
+        filter_size=filter_size,
+        act=act,
+        main_program=main_program,
+        startup_program=startup_program)
+
+    pool_out = layers.pool2d(
+        input=conv_out,
+        pool_size=pool_size,
+        pool_type=pool_type,
+        pool_stride=pool_stride,
+        main_program=main_program,
+        startup_program=startup_program)
+    return pool_out
+```
+
+　　可以看到这里面有两个输出，conv_out是卷积输出值，pool_out是池化输出值，最后只返回池化输出的值。conv_out和pool_out分别又调用了layers.py的conv2d和pool2d，去layers.py里我们可以看到conv2d和pool2d是如何实现的: 
+
+　　conv2d:
+
+```python
+def conv2d(input,
+           num_filters,
+           name=None,
+           filter_size=[1, 1],
+           act=None,
+           groups=None,
+           stride=[1, 1],
+           padding=None,
+           bias_attr=None,
+           param_attr=None,
+           main_program=None,
+           startup_program=None):
+    helper = LayerHelper('conv2d', **locals())
+    dtype = helper.input_dtype()
+
+    num_channels = input.shape[1]
+    if groups is None:
+        num_filter_channels = num_channels
+    else:
+        if num_channels % groups is not 0:
+            raise ValueError("num_channels must be divisible by groups.")
+        num_filter_channels = num_channels / groups
+
+    if isinstance(filter_size, int):
+        filter_size = [filter_size, filter_size]
+    if isinstance(stride, int):
+        stride = [stride, stride]
+    if isinstance(padding, int):
+        padding = [padding, padding]
+
+    input_shape = input.shape
+    filter_shape = [num_filters, num_filter_channels] + filter_size
+
+    std = (2.0 / (filter_size[0]**2 * num_channels))**0.5
+    filter = helper.create_parameter(
+        attr=helper.param_attr,
+        shape=filter_shape,
+        dtype=dtype,
+        initializer=NormalInitializer(0.0, std, 0))
+    pre_bias = helper.create_tmp_variable(dtype)
+
+    helper.append_op(
+        type='conv2d',
+        inputs={
+            'Input': input,
+            'Filter': filter,
+        },
+        outputs={"Output": pre_bias},
+        attrs={'strides': stride,
+               'paddings': padding,
+               'groups': groups})
+
+    pre_act = helper.append_bias_op(pre_bias, 1)
+
+    return helper.append_activation(pre_act)
+```
+
+　　pool2d:
+
+```python
+def pool2d(input,
+           pool_size,
+           pool_type,
+           pool_stride=[1, 1],
+           pool_padding=[0, 0],
+           global_pooling=False,
+           main_program=None,
+           startup_program=None):
+    if pool_type not in ["max", "avg"]:
+        raise ValueError(
+            "Unknown pool_type: '%s'. It can only be 'max' or 'avg'.",
+            str(pool_type))
+    if isinstance(pool_size, int):
+        pool_size = [pool_size, pool_size]
+    if isinstance(pool_stride, int):
+        pool_stride = [pool_stride, pool_stride]
+    if isinstance(pool_padding, int):
+        pool_padding = [pool_padding, pool_padding]
+
+    helper = LayerHelper('pool2d', **locals())
+    dtype = helper.input_dtype()
+    pool_out = helper.create_tmp_variable(dtype)
+
+    helper.append_op(
+        type="pool2d",
+        inputs={"X": input},
+        outputs={"Out": pool_out},
+        attrs={
+            "poolingType": pool_type,
+            "ksize": pool_size,
+            "globalPooling": global_pooling,
+            "strides": pool_stride,
+            "paddings": pool_padding
+        })
+
+    return pool_out
+```
+
+　　大家可以看到，具体的实现方式还调用了[layers_helper.py](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/v2/framework/layer_helper.py):
+
+```python
+import copy
+import itertools
+
+from paddle.v2.framework.framework import Variable, g_main_program, \
+    g_startup_program, unique_name, Program
+from paddle.v2.framework.initializer import ConstantInitializer, \
+    UniformInitializer
+
+
+class LayerHelper(object):
+    def __init__(self, layer_type, **kwargs):
+        self.kwargs = kwargs
+        self.layer_type = layer_type
+        name = self.kwargs.get('name', None)
+        if name is None:
+            self.kwargs['name'] = unique_name(self.layer_type)
+
+    @property
+    def name(self):
+        return self.kwargs['name']
+
+    @property
+    def main_program(self):
+        prog = self.kwargs.get('main_program', None)
+        if prog is None:
+            return g_main_program
+        else:
+            return prog
+
+    @property
+    def startup_program(self):
+        prog = self.kwargs.get('startup_program', None)
+        if prog is None:
+            return g_startup_program
+        else:
+            return prog
+
+    def append_op(self, *args, **kwargs):
+        return self.main_program.current_block().append_op(*args, **kwargs)
+
+    def multiple_input(self, input_param_name='input'):
+        inputs = self.kwargs.get(input_param_name, [])
+        type_error = TypeError(
+            "Input of {0} layer should be Variable or sequence of Variable".
+            format(self.layer_type))
+        if isinstance(inputs, Variable):
+            inputs = [inputs]
+        elif not isinstance(inputs, list) and not isinstance(inputs, tuple):
+            raise type_error
+        else:
+            for each in inputs:
+                if not isinstance(each, Variable):
+                    raise type_error
+        return inputs
+
+    def input(self, input_param_name='input'):
+        inputs = self.multiple_input(input_param_name)
+        if len(inputs) != 1:
+            raise "{0} layer only takes one input".format(self.layer_type)
+        return inputs[0]
+
+    @property
+    def param_attr(self):
+        default = {'name': None, 'initializer': UniformInitializer()}
+        actual = self.kwargs.get('param_attr', None)
+        if actual is None:
+            actual = default
+        for default_field in default.keys():
+            if default_field not in actual:
+                actual[default_field] = default[default_field]
+        return actual
+
+    def bias_attr(self):
+        default = {'name': None, 'initializer': ConstantInitializer()}
+        bias_attr = self.kwargs.get('bias_attr', None)
+        if bias_attr is True:
+            bias_attr = default
+
+        if isinstance(bias_attr, dict):
+            for default_field in default.keys():
+                if default_field not in bias_attr:
+                    bias_attr[default_field] = default[default_field]
+        return bias_attr
+
+    def multiple_param_attr(self, length):
+        param_attr = self.param_attr
+        if isinstance(param_attr, dict):
+            param_attr = [param_attr]
+
+        if len(param_attr) != 1 and len(param_attr) != length:
+            raise ValueError("parameter number mismatch")
+        elif len(param_attr) == 1 and length != 1:
+            tmp = [None] * length
+            for i in xrange(length):
+                tmp[i] = copy.deepcopy(param_attr[0])
+            param_attr = tmp
+        return param_attr
+
+    def iter_inputs_and_params(self, input_param_name='input'):
+        inputs = self.multiple_input(input_param_name)
+        param_attrs = self.multiple_param_attr(len(inputs))
+        for ipt, param_attr in itertools.izip(inputs, param_attrs):
+            yield ipt, param_attr
+
+    def input_dtype(self, input_param_name='input'):
+        inputs = self.multiple_input(input_param_name)
+        dtype = None
+        for each in inputs:
+            if dtype is None:
+                dtype = each.data_type
+            elif dtype != each.data_type:
+                raise ValueError("Data Type mismatch")
+        return dtype
+
+    def create_parameter(self, attr, shape, dtype, suffix='w',
+                         initializer=None):
+        # Deepcopy the attr so that parameters can be shared in program
+        attr_copy = copy.deepcopy(attr)
+        if initializer is not None:
+            attr_copy['initializer'] = initializer
+        if attr_copy['name'] is None:
+            attr_copy['name'] = unique_name(".".join([self.name, suffix]))
+        self.startup_program.global_block().create_parameter(
+            dtype=dtype, shape=shape, **attr_copy)
+        return self.main_program.global_block().create_parameter(
+            name=attr_copy['name'], dtype=dtype, shape=shape)
+
+    def create_tmp_variable(self, dtype):
+        return self.main_program.current_block().create_var(
+            name=unique_name(".".join([self.name, 'tmp'])),
+            dtype=dtype,
+            persistable=False)
+
+    def create_variable(self, *args, **kwargs):
+        return self.main_program.current_block().create_var(*args, **kwargs)
+
+    def create_global_variable(self, persistable=False, *args, **kwargs):
+        return self.main_program.global_block().create_var(
+            *args, persistable=persistable, **kwargs)
+
+    def set_variable_initializer(self, var, initializer):
+        assert isinstance(var, Variable)
+        self.startup_program.global_block().create_var(
+            name=var.name,
+            type=var.type,
+            dtype=var.data_type,
+            shape=var.shape,
+            persistable=True,
+            initializer=initializer)
+
+    def append_bias_op(self, input_var, num_flatten_dims=None):
+        """
+        Append bias operator and return its output. If the user does not set 
+        bias_attr, append_bias_op will return input_var
+         
+        :param input_var: the input variable. The len(input_var.shape) is larger
+        or equal than 2.
+        :param num_flatten_dims: The input tensor will be flatten as a matrix 
+        when adding bias.
+        `matrix.shape = product(input_var.shape[0:num_flatten_dims]), product(
+                input_var.shape[num_flatten_dims:])`
+        """
+        if num_flatten_dims is None:
+            num_flatten_dims = self.kwargs.get('num_flatten_dims', None)
+            if num_flatten_dims is None:
+                num_flatten_dims = 1
+
+        size = list(input_var.shape[num_flatten_dims:])
+        bias_attr = self.bias_attr()
+        if not bias_attr:
+            return input_var
+
+        b = self.create_parameter(
+            attr=bias_attr, shape=size, dtype=input_var.data_type, suffix='b')
+        tmp = self.create_tmp_variable(dtype=input_var.data_type)
+        self.append_op(
+            type='elementwise_add',
+            inputs={'X': [input_var],
+                    'Y': [b]},
+            outputs={'Out': [tmp]})
+        return tmp
+
+    def append_activation(self, input_var):
+        act = self.kwargs.get('act', None)
+        if act is None:
+            return input_var
+        if isinstance(act, basestring):
+            act = {'type': act}
+        tmp = self.create_tmp_variable(dtype=input_var.data_type)
+        act_type = act.pop('type')
+        self.append_op(
+            type=act_type,
+            inputs={"X": [input_var]},
+            outputs={"Y": [tmp]},
+            attrs=act)
+        return tmp
+```
+
+　　详细的源码细节我们下一节会讲这里指写一下实现的方式和调用的函数。
+
+　　所以这个卷积过程就完成了。从上文的计算中我们可以看到，同一层的神经元可以共享卷积核，那么对于高位数据的处理将会变得非常简单。并且使用卷积核后图片的尺寸变小，方便后续计算，并且我们不需要手动去选取特征，只用设计好卷积核的尺寸，数量和滑动的步长就可以让它自己去训练了，省时又省力啊。
+
+　　**为什么卷积核有效？**
+
+　　那么问题来了，虽然我们知道了卷积核是如何计算的，但是为什么使用卷积核计算后分类效果要由于普通的神经网络呢？我们仔细来看一下上面计算的结果。通过第一个卷积核计算后的feature_map是一个三维数据，在第三列的绝对值最大，说明原始图片上对应的地方有一条垂直方向的特征，即像素数值变化较大；而通过第二个卷积核计算后，第三列的数值为0，第二行的数值绝对值最大，说明原始图片上对应的地方有一条水平方向的特征。
+
+　　仔细思考一下，这个时候，我们设计的两个卷积核分别能够提取，或者说检测出原始图片的特定的特征。此时我们其实就可以把卷积核就理解为特征提取器啊！现在就明白了，为什么我们只需要把图片数据灌进去，设计好卷积核的尺寸、数量和滑动的步长就可以让自动提取出图片的某些特征，从而达到分类的效果啊！
+
+　　**注**: 1.此处的卷积运算是两个卷积核大小的矩阵的内积运算，不是矩阵乘法。即相同位置的数字相乘再相加求和。不要弄混淆了。
+
+　　　　2.卷积核的公式有很多，这只是最简单的一种。我们所说的卷积核在数字信号处理里也叫滤波器，那滤波器的种类就多了，均值滤波器，高斯滤波器，拉普拉斯滤波器等等，不过，不管是什么滤波器，都只是一种数学运算，无非就是计算更复杂一点。
+
+            3.每一层的卷积核大小和个数可以自己定义，不过一般情况下，根据实验得到的经验来看，会在越靠近输入层的卷积层设定少量的卷积核，越往后，卷积层设定的卷积核数目就越多。具体原因大家可以先思考一下，小结里会解释原因。
+
+* **池化层（Pooling Layer）**
+
+　　通过上一层2*2的卷积核操作后，我们将原始图像由4*4的尺寸变为了3*3的一个新的图片。池化层的主要目的是通过降采样的方式，在不影响图像质量的情况下，压缩图片，减少参数。简单来说，假设现在设定池化层采用MaxPooling，大小为2*2，步长为1，取每个窗口最大的数值重新，那么图片的尺寸就会由3*3变为2*2: (3-2)+1=2。从上例来看，会有如下变换: 
+
+
+![](img/CNN原理/853467-20171104142056685-2048616836.png)
+
+ 　　　　　　图3 Max Pooling结果
+
+     通常来说，池化方法一般有一下两种: 
+
+* MaxPooling: 取滑动窗口里最大的值
+* AveragePooling: 取滑动窗口内所有值的平均值
+
+　 为什么采用Max Pooling？
+
+　　从计算方式来看，算是最简单的一种了，取max即可，但是这也引发一个思考，为什么需要Max Pooling，意义在哪里？如果我们只取最大值，那其他的值被舍弃难道就没有影响吗？不会损失这部分信息吗？如果认为这些信息是可损失的，那么是否意味着我们在进行卷积操作后仍然产生了一些不必要的冗余信息呢？
+
+　　其实从上文分析卷积核为什么有效的原因来看，每一个卷积核可以看做一个特征提取器，不同的卷积核负责提取不同的特征，我们例子中设计的第一个卷积核能够提取出“垂直”方向的特征，第二个卷积核能够提取出“水平”方向的特征，那么我们对其进行Max Pooling操作后，提取出的是真正能够识别特征的数值，其余被舍弃的数值，对于我提取特定的特征并没有特别大的帮助。那么在进行后续计算使，减小了feature map的尺寸，从而减少参数，达到减小计算量，缺不损失效果的情况。
+
+　　不过并不是所有情况Max Pooling的效果都很好，有时候有些周边信息也会对某个特定特征的识别产生一定效果，那么这个时候舍弃这部分“不重要”的信息，就不划算了。所以具体情况得具体分析，如果加了Max Pooling后效果反而变差了，不如把卷积后不加Max Pooling的结果与卷积后加了Max Pooling的结果输出对比一下，看看Max Pooling是否对卷积核提取特征起了反效果。
+
+     Zero Padding
+
+      所以到现在为止，我们的图片由4*4，通过卷积层变为3*3，再通过池化层变化2*2，如果我们再添加层，那么图片岂不是会越变越小？这个时候我们就会引出“Zero Padding”（补零），它可以帮助我们保证每次经过卷积或池化输出后图片的大小不变，如，上述例子我们如果加入Zero Padding，再采用3*3的卷积核，那么变换后的图片尺寸与原图片尺寸相同，如下图所示: 
+
+![](img/CNN原理/853467-20171031215017701-495180034.png)
+
+　　图4 zero padding结果
+
+ 　　通常情况下，我们希望图片做完卷积操作后保持图片大小不变，所以我们一般会选择尺寸为3*3的卷积核和1的zero padding，或者5*5的卷积核与2的zero padding，这样通过计算后，可以保留图片的原始尺寸。那么加入zero padding后的feature_map尺寸 =( width + 2 * padding_size - filter_size )/stride + 1
+
+　　注: 这里的width也可换成height，此处是默认正方形的卷积核，weight = height，如果两者不相等，可以分开计算，分别补零。
+
+* **Flatten层 & Fully Connected Layer**
+
+到这一步，其实我们的一个完整的“卷积部分”就算完成了，如果想要叠加层数，一般也是叠加“Conv-MaxPooing",通过不断的设计卷积核的尺寸，数量，提取更多的特征，最后识别不同类别的物体。做完Max Pooling后，我们就会把这些数据“拍平”，丢到Flatten层，然后把Flatten层的output放到full connected Layer里，采用softmax对其进行分类。
+
+![](img/CNN原理/853467-20171104142200763-1912037434.png)
+
+　　　　图5 Flatten过程
+
+　　
+
+* **小结**
+
+　　这一节我们介绍了最基本的卷积神经网络的基本层的定义，计算方式和起的作用。有几个小问题可以供大家思考一下: 　
+
+1.卷积核的尺寸必须为正方形吗？可以为长方形吗？如果是长方形应该怎么计算？
+
+2.卷积核的个数如何确定？每一层的卷积核的个数都是相同的吗？ 
+
+3.步长的向右和向下移动的幅度必须是一样的吗？
+
+　　如果对上面的讲解真的弄懂了的话，其实这几个问题并不难回答。下面给出我的想法，可以作为参考: 
+
+　　1.卷积核的尺寸不一定非得为正方形。长方形也可以，只不过通常情况下为正方形。如果要设置为长方形，那么首先得保证这层的输出形状是整数，不能是小数。如果你的图像是边长为 28 的正方形。那么卷积层的输出就满足 [ (28 - kernel_size)/ stride ] + 1 ，这个数值得是整数才行，否则没有物理意义。譬如，你算得一个边长为 3.6 的 feature map 是没有物理意义的。 pooling 层同理。FC 层的输出形状总是满足整数，其唯一的要求就是整个训练过程中 FC 层的输入得是定长的。如果你的图像不是正方形。那么在制作数据时，可以缩放到统一大小（非正方形），再使用非正方形的 kernel_size 来使得卷积层的输出依然是整数。总之，撇开网络结果设定的好坏不谈，其本质上就是在做算术应用题: 如何使得各层的输出是整数。
+
+
+　　2.由经验确定。通常情况下，靠近输入的卷积层，譬如第一层卷积层，会找出一些共性的特征，如手写数字识别中第一层我们设定卷积核个数为5个，一般是找出诸如"横线"、“竖线”、“斜线”等共性特征，我们称之为basic feature，经过max pooling后，在第二层卷积层，设定卷积核个数为20个，可以找出一些相对复杂的特征，如“横折”、“左半圆”、“右半圆”等特征，越往后，卷积核设定的数目越多，越能体现label的特征就越细致，就越容易分类出来，打个比方，如果你想分类出“0”的数字，你看到![](img/CNN原理/853467-20171031231438107-1902818098.png)这个特征，能推测是什么数字呢？只有越往后，检测识别的特征越多，试过能识别![](img/CNN原理/853467-20171101085737623-1572944193.png)这几个特征，那么我就能够确定这个数字是“0”。
+
+
+　　3.有stride_w和stride_h，后者表示的就是上下步长。如果用stride，则表示stride_h=stride_w=stride。
+
+* * *
+
+*　　***手写数字识别的CNN网络结构**
+
+　　上面我们了解了卷积神经网络的基本结构后，现在来具体看一下在实际数据---手写数字识别中是如何操作的。上文中我定义了一个最基本的CNN网络。如下(代码详见[github](https://github.com/huxiaoman7/PaddlePaddle_code))
+
+
+```python
+def convolutional_neural_network_org(img):
+    # first conv layer
+    conv_pool_1 = paddle.networks.simple_img_conv_pool(
+        input=img,
+        filter_size=3,
+        num_filters=20,
+        num_channel=1,
+        pool_size=2,
+        pool_stride=2,
+        act=paddle.activation.Relu())
+    # second conv layer
+    conv_pool_2 = paddle.networks.simple_img_conv_pool(
+        input=conv_pool_1,
+        filter_size=5,
+        num_filters=50,
+        num_channel=20,
+        pool_size=2,
+        pool_stride=2,
+        act=paddle.activation.Relu())
+    # fully-connected layer
+    predict = paddle.layer.fc(
+        input=conv_pool_2, size=10, act=paddle.activation.Softmax())
+    return predict
+```
+
+　　那么它的网络结构是: 
+
+　　conv1----> conv2---->fully Connected layer
+
+　　非常简单的网络结构。第一层我们采取的是 `3*3` 的正方形卷积核，个数为20个，深度为1，stride为2，pooling尺寸为 `2*2`，激活函数采取的为RELU；第二层只对卷积核的尺寸、个数和深度做了些变化，分别为 `5*5` ，50个和20；最后链接一层全连接，设定10个label作为输出，采用Softmax函数作为分类器，输出每个label的概率。
+
+　　那么这个时候我考虑的问题是，既然上面我们已经了解了卷积核，改变卷积核的大小是否会对我的结果造成影响？增多卷积核的数目能够提高准确率？于是我做了个实验: 
+
+![](img/CNN原理/853467-20171031232805748-157396975.png)
+
+* 第一次改进: 仅改变第一层与第二层的卷积核数目的大小，其他保持不变。可以看到结果提升了0.06%
+* 　第二次改进: 保持3*3的卷积核大小，仅改变第二层的卷积核数目，其他保持不变，可以看到结果相较于原始参数提升了0.08%
+
+　　由以上结果可以看出，改变卷积核的大小与卷积核的数目会对结果产生一定影响，在目前手写数字识别的项目中，缩小卷积核尺寸，增加卷积核数目都会提高准确率。不过以上实验只是一个小测试，有兴趣的同学可以多做几次实验，看看参数带来的具体影响，下篇文章我们会着重分析参数的影响。
+
+　　这篇文章主要介绍了神经网络的预备知识，卷积神经网络的常见的层及基本的计算过程，看完后希望大家明白以下几个知识点: 
+
+> * 为什么卷积神经网络更适合于图像分类？相比于传统的神经网络优势在哪里？
+> * 卷积层中的卷积过程是如何计算的？为什么卷积核是有效的？
+> * 卷积核的个数如何确定？应该选择多大的卷积核对于模型来说才是有效的？尺寸必须为正方形吗？如果是长方形因该怎么做？
+> * 步长的大小会对模型的效果产生什么样的影响？垂直方向和水平方向的步长是否得设定为相同的？
+> * 为什么要采用池化层，Max Pooling有什么好处？
+> * Zero Padding有什么作用？如果已知一个feature map的尺寸，如何确定zero padding的数目？
+
+    上面的问题，有些在文章中已经详细讲过，有些大家可以根据文章的内容多思考一下。最后给大家留几个问题思考一下: 
+
+> * 为什么改变卷积核的大小能够提高结果的准确率？卷积核大小对于分类结果是如何影响的？
+> * 卷积核的参数是怎么求的？一开始随机定义一个，那么后来是如何训练才能使这个卷积核识别某些特定的特征呢？
+> * 1*1的卷积核有意义吗？为什么有些网络层结构里会采用1*1的卷积核？
+
+　　
+
+　　下篇文章我们会着重讲解以下几点: 
+
+> * 卷积核的参数如何确定？随机初始化一个数值后，是如何训练得到一个能够识别某些特征的卷积核的？
+> * CNN是如何进行反向传播的？
+> * 如何调整CNN里的参数？
+> * 如何设计最适合的CNN网络结构？
+> * 能够不用调用框架的api，手写一个CNN，并和paddlepaddle里的实现过程做对比，看看有哪些可以改进的？
+
+ps: 本篇文章是基于个人对CNN的理解来写的，本人能力有限，有些地方可能写的不是很严谨，如有错误或疏漏之处，请留言给我，我一定会仔细核实并修改的^_^！不接受无脑喷哦~此外，文中的图表结构均为自己所做，希望不要被人随意抄袭，可以进行非商业性质的转载，需要转载留言或发邮件即可，希望能够尊重劳动成果，谢谢！有不懂的也请留言给我，我会尽力解答的哈~
+
+---
+
+* 作者: Charlotte77 
+* 出处: http://www.cnblogs.com/charlotte77/ 
+* 本文以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，非商业用途！ 

docs/misc/LSTM原理.md

@@ -0,0 +1,61 @@
+# LSTM原理
+
+# 长短期记忆网络（Long Short-Term Memory，LSTM）及其变体双向LSTM和GRU
+
+**LSTM**（Long Short-Term Memory）长短期记忆网络，是一种时间递归神经网络，**适合于处理和预测时间序列中间隔和延迟相对较长的重要事件**。LSTM是解决循环神经网络RNN结构中存在的“梯度消失”问题而提出的，是一种特殊的循环神经网络。最常见的一个例子就是: 当我们要预测“the clouds are in the (...)"的时候, 这种情况下，相关的信息和预测的词位置之间的间隔很小，RNN会使用先前的信息预测出词是”sky“。但是如果想要预测”I grew up in France ... I speak fluent (...)”，语言模型推测下一个词可能是一种语言的名字，但是具体是什么语言，需要用到间隔很长的前文中France，在这种情况下，RNN因为“梯度消失”的问题，并不能利用间隔很长的信息，然而，LSTM在设计上明确避免了长期依赖的问题，这主要归功于LSTM精心设计的“门”结构(输入门、遗忘门和输出门)消除或者增加信息到细胞状态的能力，使得LSTM能够记住长期的信息。
+
+![](img/LSTM原理/20180704173253439.jpg)  vs   ![](img/LSTM原理/20180704173230785.jpg)  
+
+标准的RNN结构都具有一种重复神经网络模块的链式形式，一般是一个tanh层进行重复的学习（如上图左边图），而在LSTM中（上图右边图），重复的模块中有四个特殊的结构。**贯穿在图上方的水平线为细胞状态（cell），黄色的矩阵是学习得到的神经网络层，粉色的圆圈表示运算操作，黑色的箭头表示向量的传输**，整体看来，不仅仅是h在随着时间流动，细胞状态c也在随着时间流动，细胞状态c代表着长期记忆。
+
+上面我们提到LSTM之所以能够记住长期的信息，在于设计的“门”结构，“门”结构是一种让信息选择式通过的方法，包括一个sigmoid神经网络层和一个pointwise乘法操作，如下图所示结构。复习一下sigmoid函数，![](img/LSTM原理/20180705153027598.jpg)，sigmoid输出为0到1之间的数组，一般用在二分类问题，输出值接近0代表“不允许通过”，趋向1代表“允许通过”。
+
+![](img/LSTM原理/20180705152515679.jpg)
+
+
+**在LSTM中，第一阶段是遗忘门，遗忘层决定哪些信息需要从细胞状态中被遗忘，下一阶段是输入门，输入门确定哪些新信息能够被存放到细胞状态中，最后一个阶段是输出门，输出门确定输出什么值**。下面我们把LSTM就着各个门的子结构和数学表达式进行分析。
+
+* 遗忘门: 遗忘门是以上一层的输出![](img/LSTM原理/20180705154943659.jpg)和本层要输入的序列数据![](img/LSTM原理/20180705155022656.jpg)作为输入，通过一个激活函数sigmoid，得到输出为![](img/LSTM原理/201807051551130.jpg)。![](img/LSTM原理/20180705155135748.jpg)的输出取值在[0,1]区间，表示上一层细胞状态被遗忘的概率，1是“完全保留”，0是“完全舍弃”
+
+![](img/LSTM原理/20180705154117297.jpg)
+
+
+* 输入门: 输入门包含两个部分，第一部分使用sigmoid激活函数，输出为![](img/LSTM原理/20180705160829424.jpg)，第二部分使用tanh激活函数，输出为![](img/LSTM原理/20180705161911316.jpg)。**【个人通俗理解: ![](img/LSTM原理/20180705162106120.jpg)在RNN网络中就是本层的输出，![](img/LSTM原理/20180705162239540.jpg)是在[0,1]区间取值，表示![](img/LSTM原理/20180705162835994.jpg)中的信息被保留的程度，![](img/LSTM原理/20180705162518689.jpg)表示该层被保留的新信息】**
+
+![](img/LSTM原理/20180705154140100.jpg)
+
+
+到目前为止，![](img/LSTM原理/20180705162951402.jpg)是遗忘门的输出，控制着上一层细胞状态![](img/LSTM原理/20180705163019968.jpg)被遗忘的程度，![](img/LSTM原理/20180705163047274.jpg)为输入门的两个输出乘法运算，表示有多少新信息被保留，基于此，我们就可以把新信息更新这一层的细胞状态![](img/LSTM原理/20180705163146715.jpg)。
+
+![](img/LSTM原理/20180705154157781.jpg)
+
+
+* 输出门: 输出门用来控制该层的细胞状态有多少被过滤。首先使用sigmoid激活函数得到一个[0,1]区间取值的![](img/LSTM原理/20180705163549770.jpg)，接着将细胞状态![](img/LSTM原理/20180705164009353.jpg)通过tanh激活函数处理后与![](img/LSTM原理/20180705164029948.jpg)相乘，即是本层的输出![](img/LSTM原理/20180705164102617.jpg)。
+
+![](img/LSTM原理/20180705154210768.jpg)
+
+
+至此，终于将LSTM的结构理解了，现在有很多LSTM结构的变形，只要把这个母体结构理解了，再去理解变形的结构应该不会再有多麻烦了。
+
+**双向LSTM**
+
+双向RNN由两个普通的RNN所组成，一个正向的RNN，利用过去的信息，一个逆序的RNN，利用未来的信息，这样在时刻t，既能够使用t-1时刻的信息，又能够利用到t+1时刻的信息。一般来说，由于双向LSTM能够同时利用过去时刻和未来时刻的信息，会比单向LSTM最终的预测更加准确。下图为双向LSTM的结构。
+
+![](img/LSTM原理/20180713200802779.jpg)
+
+
+* ![](img/LSTM原理/20180713204707320.jpg)为正向的RNN，参与正向计算，t时刻的输入为t时刻的序列数据![](img/LSTM原理/20180713204850377.jpg)和t-1时刻的输出![](img/LSTM原理/20180713204838867.jpg)
+* ![](img/LSTM原理/20180713204802532.jpg)为逆向的RNN，参与反向计算，t时刻的输入为t时刻的序列数据![](img/LSTM原理/20180713204852425.jpg)和t+1时刻的输出![](img/LSTM原理/20180713204825347.jpg)
+* t时刻的最终输出值取决于![](img/LSTM原理/20180713204838867.jpg)和![](img/LSTM原理/20180713204913638.jpg)
+
+**GRU（Gated Recurrent Unit）**是LSTM最流行的一个变体，比LSTM模型要简单
+
+![](img/LSTM原理/20180713200829571.jpg)
+
+
+GRU包括两个门，一个重置门![](img/LSTM原理/20180713205653854.jpg)和更新门![](img/LSTM原理/20180713205710503.jpg)。这两个门的激活函数为sigmoid函数，在[0,1]区间取值。
+
+候选隐含状态![](img/LSTM原理/20180713210203944.jpg)使用重置门![](img/LSTM原理/20180713205653854.jpg)来控制t-1时刻信息的输入，如果![](img/LSTM原理/20180713205653854.jpg)结果为0，那么上一个隐含状态的输出信息![](img/LSTM原理/20180713211322965.jpg)将被丢弃。也就是说，**重置门决定过去有多少信息被遗忘，有助于捕捉时序数据中短期的依赖关系**。
+
+
+隐含状态使用更新门![](img/LSTM原理/20180713205710503.jpg)对上一时刻隐含状态![](img/LSTM原理/20180713210738834.jpg)和候选隐含状态![](img/LSTM原理/20180713210203944.jpg)进行更新。更新门控制过去的隐含状态在当前时刻的重要性，**如果更新门一直趋近于1，t时刻之前的隐含状态将一直保存下来并全传递到t时刻，****更新门有助于捕捉时序数据中中长期的依赖关系**。

docs/misc/RNN原理.md

@@ -0,0 +1,144 @@
+# RNN原理
+
+# 循环神经网络（RNN）原理通俗解释
+
+## 1.RNN怎么来的？
+
+循环神经网络的应用场景比较多，比如暂时能写论文，写程序，写诗，但是，（总是会有但是的），但是他们现在还不能正常使用，学习出来的东西没有逻辑，所以要想真正让它更有用，路还很远。
+
+这是一般的神经网络应该有的结构:  
+![这里写图片描述](img/RNN原理/20171119130251741.jpg)
+
+既然我们已经有了人工神经网络和卷积神经网络，为什么还要循环神经网络？ 
+原因很简单，无论是卷积神经网络，还是人工神经网络，他们的前提假设都是: 元素之间是相互独立的，**输入与输出也是独立的**，比如猫和狗。 
+但现实世界中，很多元素都是相互连接的，比如股票随时间的变化，一个人说了: 我喜欢旅游，其中最喜欢的地方是云南，以后有机会一定要去___这里填空，人应该都知道是填“云南“。因为我们是根据上下文的内容推断出来的，但机会要做到这一步就相当得难了。因此，就有了现在的循环神经网络，他的本质是**: 像人一样拥有记忆的能力。**因此，他的输出就依赖于当前的输入和记忆。
+
+## 2.RNN的网络结构及原理
+
+它的网络结构如下:  
+![这里写图片描述](img/RNN原理/20171129184524844.jpg)
+其中每个圆圈可以看作是一个单元，而且每个单元做的事情也是一样的，因此可以折叠呈左半图的样子。用一句话解释RNN，就是**一个单元结构重复使用**。
+
+RNN是一个序列到序列的模型，假设![-w88](img/RNN原理/15570321772488.jpg)是一个输入: “我是中国“，那么![-w54](img/RNN原理/15570322195709.jpg)就应该对应”是”，”中国”这两个，预测下一个词最有可能是什么？就是![-w31](img/RNN原理/15570322451341.jpg)应该是”人”的概率比较大。
+
+因此，我们可以做这样的定义: 
+
+![-w416](img/RNN原理/15570322822857.jpg)
+
+。因为我们当前时刻的输出是由记忆和当前时刻的输入决定的，就像你现在大四，你的知识是由大四学到的知识（当前输入）和大三以及大三以前学到的东西的（记忆）的结合，RNN在这点上也类似，神经网络最擅长做的就是通过一系列参数把很多内容整合到一起，然后学习这个参数，因此就定义了RNN的基础: 
+
+![-w200](img/RNN原理/15570322981095.jpg)
+
+大家可能会很好奇，为什么还要加一个f()函数，其实这个函数是神经网络中的激活函数，但为什么要加上它呢？ 
+举个例子，假如你在大学学了非常好的解题方法，那你初中那时候的解题方法还要用吗？显然是不用了的。RNN的想法也一样，既然我能记忆了，那我当然是只记重要的信息啦，其他不重要的，就肯定会忘记，是吧。但是在神经网络中什么最适合过滤信息呀？肯定是激活函数嘛，因此在这里就套用一个激活函数，来做一个非线性映射，来过滤信息，这个激活函数可能为tanh，也可为其他。
+
+假设你大四快毕业了，要参加考研，请问你参加考研是不是先记住你学过的内容然后去考研，还是直接带几本书去参加考研呢？很显然嘛，那RNN的想法就是预测的时候带着当前时刻的记忆
+去预测。假如你要预测“我是中国“的下一个词出现的概率，这里已经很显然了，运用softmax来预测每个词出现的概率再合适不过了，但预测不能直接带用一个矩阵来预测呀，所有预测的时候还要带一个权重矩阵V,用公式表示为:
+
+![-w160](img/RNN原理/15570323546017.jpg)
+
+
+其中![-w21](img/RNN原理/15570323768890.jpg)就表示时刻t的输出。
+
+RNN中的结构细节:  
+1.可以把St当作隐状态，捕捉了之前时间点上的信息。就像你去考研一样，考的时候记住了你能记住的所有信息。 
+2.Ot是由当前时间以及之前所有的记忆得到的。就是你考研之后做的考试卷子，是用你的记忆得到的。 
+3.很可惜的是，St并不能捕捉之前所有时间点的信息。就像你考研不能记住所有的英语单词一样。 
+4.和卷积神经网络一样，这里的网络中每个cell都共享了一组参数（U，V，W）,这样就能极大的降低计算量了。 
+5.Ot在很多情况下都是不存在的，因为很多任务，比如文本情感分析，都是只关注最后的结果的。就像考研之后选择学校，学校不会管你到底怎么努力，怎么心酸的准备考研，而只关注你最后考了多少分。
+
+## 3.RNN的改进1: 双向RNN
+
+在有些情况，比如有一部电视剧，在第三集的时候才出现的人物，现在让预测一下在第三集中出现的人物名字，你用前面两集的内容是预测不出来的，所以你需要用到第四，第五集的内容来预测第三集的内容，这就是双向RNN的想法。如图是双向RNN的图解:  
+![这里写图片描述](img/RNN原理/bi-directional-rnn.png) 
+![-w347](img/RNN原理/15570324711246.jpg)
+
+这里的![-w50](img/RNN原理/15570324937386.jpg)做的是一个拼接，如果他们都是1000x1维的，拼接在一起就是1000x2维的了。
+
+双向RNN需要的内存是单向RNN的两倍，因为在同一时间点，双向RNN需要保存两个方向上的权重参数，在分类的时候，需要同时输入两个隐藏层输出的信息。
+
+## 4.RNN的改进2: 深层双向RNN
+
+深层双向RNN 与双向RNN相比，多了几个隐藏层，因为他的想法是很多信息记一次记不下来，比如你去考研，复习考研英语的时候，背英语单词一定不会就看一次就记住了所有要考的考研单词吧，你应该也是带着先前几次背过的单词，然后选择那些背过，但不熟的内容，或者没背过的单词来背吧。
+
+深层双向RNN就是基于这么一个想法，他的输入有两方面，第一就是前一时刻的隐藏层传过来的信息![-w41](img/RNN原理/15570325271812.jpg)，和当前时刻上一隐藏层传过来的信息![-w167](img/RNN原理/15570325458791.jpg)，包括前向和后向的。 
+![这里写图片描述](img/RNN原理/deep-bi-directional-rnn.png)
+
+我们用公式来表示是这样的: 
+![这里写图片描述](img/RNN原理/deep-bi-directional-rnn-hidden-layer.png) 
+然后再利用最后一层来进行分类，分类公式如下:  
+![这里写图片描述](img/RNN原理/deep-bi-directional-rnn-classification.png)
+
+### 4.1 Pyramidal RNN
+
+其他类似的网络还有Pyramidal RNN:  
+![这里写图片描述](img/RNN原理/20171221152506461.jpg)
+我们现在有一个很长的输入序列，可以看到这是一个双向的RNN，上图是谷歌的W.Chan做的一个测试，它原先要做的是语音识别，他要用序列到序列的模型做语音识别，序列到序列就是说，输入一个序列然后就输出一个序列。
+
+由图我们发现，上一层的两个输出，作为当前层的输入，如果是非常长的序列的话，这样做的话，每一层的序列都比上一层要短，但当前层的输入f(x)也会随之增多，貌似看一起相互抵消，运算量并没有什么改进。
+
+但我们知道，对于一层来说，它是从前往后转的，比如要预测一个股市的变化，以天为单位，假如要预测明天的股市变化，你就要用今天，以及今天之前的所有数据，我们暂时无法只用昨天的数据，不用今天的数据，预测明天的数据，也即是说，预测必须具有连续性。 
+但每一层的f运算是可以并行的，从这个角度来看，运算量还是可以接受的，特别是在原始输入序列较短的时候还是有优势的。
+
+## 5.RNN的训练-BPTT
+
+如前面我们讲的，如果要预测t时刻的输出，我们必须先利用上一时刻（t-1）的记忆和当前时刻的输入，得到t时刻的记忆: 
+
+![-w202](img/RNN原理/15570325921406.jpg)
+
+然后利用当前时刻的记忆，通过softmax分类器输出每个词出现的概率: 
+
+![-w144](img/RNN原理/15570326059642.jpg)
+
+为了找出模型最好的参数，U，W，V，我们就要知道当前参数得到的结果怎么样，因此就要定义我们的损失函数，用交叉熵损失函数: 
+
+![-w252](img/RNN原理/15570326336949.jpg)
+
+其中![-w14](img/RNN原理/15570326853547.jpg)
+ t时刻的标准答案，是一个只有一个是1，其他都是0的向量； ![-w19](img/RNN原理/15570326727679.jpg)是我们预测出来的结果，与![-w14](img/RNN原理/15570327422935.jpg)
+的维度一样，但它是一个概率向量，里面是每个词出现的概率。因为对结果的影响，肯定不止一个时刻，因此需要把所有时刻的造成的损失都加起来: 
+
+![-w300](img/RNN原理/15570327570018.jpg)
+
+![](img/RNN原理/20171130091040277.jpg)
+
+如图所示，你会发现每个cell都会有一个损失，我们已经定义好了损失函数，接下来就是熟悉的一步了，那就是根据损失函数利用SGD来求解最优参数，在CNN中使用反向传播BP算法来求解最优参数，但在RNN就要用到BPTT，它和BP算法的本质区别，也是CNN和RNN的本质区别: CNN没有记忆功能，它的输出仅依赖与输入，但RNN有记忆功能，它的输出不仅依赖与当前输入，还依赖与当前的记忆。这个记忆是序列到序列的，也就是当前时刻收到上一时刻的影响，比如股市的变化。
+
+因此，在对参数求偏导的时候，对当前时刻求偏导，一定会涉及前一时刻，我们用例子看一下: 
+
+![](img/RNN原理/20171130091956686.jpg)
+
+假设我们对E3的W求偏导: 它的损失首先来源于预测的输出![-w19](img/RNN原理/15570327881131.jpg)
+，预测的输出又是来源于当前时刻的记忆s3,当前的记忆又是来源于当前的输出和截止到上一时刻的记忆: ![-w170](img/RNN原理/15570328132196.jpg)
+因此，根据链式法则可以有:
+![-w172](img/RNN原理/15570328255432.jpg)
+
+但是，你会发现，![-w145](img/RNN原理/15570328436386.jpg)
+，也就是s2里面的函数还包含了W，因此，这个链式法则还没到底，就像图上画的那样，所以真正的链式法则是这样的:  
+![这里写图片描述](img/RNN原理/20171130094236429.jpg) 
+我们要把当前时刻造成的损失，和以往每个时刻造成的损失加起来，因为我们每一个时刻都用到了权重参数W。和以往的网络不同，一般的网络，比如人工神经网络，参数是不同享的，但在循环神经网络，和CNN一样，设立了参数共享机制，来降低模型的计算量。
+
+## 6.RNN与CNN的结合应用: 看图说话
+
+在图像处理中，目前做的最好的是CNN，而自然语言处理中，表现比较好的是RNN，因此，我们能否把他们结合起来，一起用呢？那就是看图说话了，这个原理也比较简单，举个小栗子: 假设我们有CNN的模型训练了一个网络结构，比如是这个
+
+![](img/RNN原理/20171129213601819.jpg)
+
+最后我们不是要分类嘛，那在分类前，是不是已经拿到了图像的特征呀，那我们能不能把图像的特征拿出来，放到RNN的输入里，让他学习呢？
+
+之前的RNN是这样的: 
+
+![-w238](img/RNN原理/15570328705596.jpg)
+
+我们把图像的特征加在里面，可以得到: 
+
+![-w266](img/RNN原理/15570328817086.jpg)
+
+其中的X就是图像的特征。如果用的是上面的CNN网络，X应该是一个4096X1的向量。
+
+注: 这个公式只在第一步做，后面每次更新就没有V了，因为给RNN数据只在第一次迭代的时候给。
+
+## 7.RNN项目练手
+
+RNN可以写歌词，写诗等，这有个项目可以玩玩，还不错。 
+[Tensorflow实现RNN](https://github.com/hzy46/Char-RNN-TensorFlow)