修改中文符号为英文
This commit is contained in:
jiangzhonglian
parent
1a1ac08133
commit
294b3c2a5d
|
|
@ -0,0 +1,35 @@
|
|||
language: node_js # 构建所需的语言环境
|
||||
node_js:
|
||||
- "v10.16.0" # 对应的版本
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master # 构建的分支
|
||||
|
||||
cache:
|
||||
directories:
|
||||
- node_modules # 依赖缓存的目录
|
||||
|
||||
install:
|
||||
- npm install -g gitbook-cli # 安装编译工具
|
||||
- gitbook fetch 3.2.3 # 安装 Gitbook 子版本
|
||||
|
||||
script:
|
||||
- sh run_website.sh
|
||||
|
||||
after_script:
|
||||
- cd _book
|
||||
- git init
|
||||
- git config user.name ${GH_UN}
|
||||
- git config user.email ${GH_EMAIL}
|
||||
- git add -A
|
||||
- git commit -am "$(date "+%Y-%m-%d %H:%M:%S")"
|
||||
- git push "https://${GH_TOKEN}@github.com/${GH_USER}/${GH_REPO}.git" master:${GH_BRANCH} -f
|
||||
|
||||
env:
|
||||
global:
|
||||
- GH_UN=jiangzhonglian
|
||||
- GH_EMAIL=jiang-s@163.com
|
||||
- GH_USER=apachecn
|
||||
- GH_REPO=pytorch-doc-zh
|
||||
- GH_BRANCH=gh-pages
|
||||
44
README.md
44
README.md
|
|
@ -16,7 +16,7 @@
|
|||
* **我们不是 Apache 的官方组织/机构/团体，只是 Apache 技术栈（以及 AI）的爱好者！**
|
||||
* **ApacheCN - 学习群【724187166】<a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=51040bbd0bf7d0efbfa7256a0331d912a2055a906c324d52b02371d06f3c9878"><img border="0" src="http://data.apachecn.org/img/logo/ApacheCN-group.png" alt="ApacheCN - 学习机器学习群[724187166]" title="ApacheCN - 学习机器学习群[724187166]"></a>**
|
||||
|
||||
> **欢迎任何人参与和完善：一个人可以走的很快，但是一群人却可以走的更远**
|
||||
> **欢迎任何人参与和完善: 一个人可以走的很快，但是一群人却可以走的更远**
|
||||
|
||||
# 路线图
|
||||
|
||||
|
|
@ -33,7 +33,7 @@
|
|||
* 机器学习下载地址: <https://github.com/apachecn/data/tree/master/机器学习>
|
||||
* 深度学习数据地址: <https://github.com/apachecn/data/tree/master/深度学习>
|
||||
* 推荐系统数据地址: <https://github.com/apachecn/data/tree/master/推荐系统>
|
||||
* 视频网站：优酷 ／bilibili / Acfun / 网易云课堂，可直接在线播放。（最下方有相应链接）
|
||||
* 视频网站: 优酷 ／bilibili / Acfun / 网易云课堂，可直接在线播放。（最下方有相应链接）
|
||||
* -- 推荐 [红色石头](https://github.com/RedstoneWill): [台湾大学林轩田机器学习笔记](https://github.com/apachecn/ntu-hsuantienlin-ml)
|
||||
* -- 推荐 [机器学习笔记](https://feisky.xyz/machine-learning): https://feisky.xyz/machine-learning
|
||||
|
||||
|
|
@ -175,11 +175,11 @@
|
|||
|
||||
当然我知道，第一句就会被吐槽，因为科班出身的人，不屑的吐了一口唾沫，说傻X，还评论 Andrew Ng 的视频。。
|
||||
|
||||
我还知道还有一部分人，看 Andrew Ng 的视频就是看不懂，那神秘的数学推导，那迷之微笑的英文版的教学，我何尝又不是这样走过来的？？ 我的心可能比你们都痛，因为我在网上收藏过上10部《机器学习》相关视频，外加国内本土风格的教程：7月+小象 等等，我都很难去听懂，直到有一天，被一个百度的高级算法分析师推荐说：《机器学习实战》还不错，通俗易懂，你去试试？？
|
||||
我还知道还有一部分人，看 Andrew Ng 的视频就是看不懂，那神秘的数学推导，那迷之微笑的英文版的教学，我何尝又不是这样走过来的？？ 我的心可能比你们都痛，因为我在网上收藏过上10部《机器学习》相关视频，外加国内本土风格的教程: 7月+小象 等等，我都很难去听懂，直到有一天，被一个百度的高级算法分析师推荐说: 《机器学习实战》还不错，通俗易懂，你去试试？？
|
||||
|
||||
我试了试，还好我的Python基础和调试能力还不错，基本上代码都调试过一遍，很多高大上的 "理论+推导"，在我眼中变成了几个 "加减乘除+循环"，我想这不就是像我这样的程序员想要的入门教程么？
|
||||
|
||||
很多程序员说机器学习 TM 太难学了，是的，真 TM 难学，我想最难的是：没有一本像《机器学习实战》那样的作者愿意以程序员 Coding 角度去给大家讲解！！
|
||||
很多程序员说机器学习 TM 太难学了，是的，真 TM 难学，我想最难的是: 没有一本像《机器学习实战》那样的作者愿意以程序员 Coding 角度去给大家讲解！！
|
||||
|
||||
最近几天，GitHub 涨了 300颗 star，加群的200人， 现在还在不断的增加++，我想大家可能都是感同身受吧！
|
||||
|
||||
|
|
@ -265,15 +265,15 @@ WordNet可以被看作是一个同义词词典
|
|||
```python
|
||||
自从学习NLP以后，才发现国内与国外的典型区别:
|
||||
1. 对资源的态度是完全相反的:
|
||||
1) 国内：就好像为了名气，举办工作装逼的会议，就是没有干货，全部都是象征性的PPT介绍，不是针对在做的各位
|
||||
2）国外：就好像是为了推动nlp进步一样，分享者各种干货资料和具体的实现。（特别是: python自然语言处理）
|
||||
2. 论文的实现：
|
||||
1) 国内: 就好像为了名气，举办工作装逼的会议，就是没有干货，全部都是象征性的PPT介绍，不是针对在做的各位
|
||||
2）国外: 就好像是为了推动nlp进步一样，分享者各种干货资料和具体的实现。（特别是: python自然语言处理）
|
||||
2. 论文的实现:
|
||||
1) 各种高大上的论文实现，却还是没看到一个像样的GitHub项目！（可能我的搜索能力差了点，一直没找到）
|
||||
2）国外就不举例了，我看不懂！
|
||||
3. 开源的框架
|
||||
1）国外的开源框架： tensorflow/pytorch 文档+教程+视频（官方提供）
|
||||
1）国外的开源框架: tensorflow/pytorch 文档+教程+视频（官方提供）
|
||||
2) 国内的开源框架: 额额，还真举例不出来！但是牛逼吹得不比国外差！（MXNet虽然有众多国人参与开发，但不能算是国内开源框架。基于MXNet的动手学深度学习(http://zh.d2l.ai & https://discuss.gluon.ai/t/topic/753)中文教程,已经由沐神(李沐)以及阿斯顿·张讲授录制，公开发布(文档+第一季教程+视频）。)
|
||||
每一次深入都要去翻墙，每一次深入都要Google，每一次看着国内的说：哈工大、讯飞、中科大、百度、阿里多牛逼，但是资料还是得国外去找！
|
||||
每一次深入都要去翻墙，每一次深入都要Google，每一次看着国内的说: 哈工大、讯飞、中科大、百度、阿里多牛逼，但是资料还是得国外去找！
|
||||
有时候真的挺恨的！真的有点瞧不起自己国内的技术环境！
|
||||
|
||||
当然谢谢国内很多博客大佬，特别是一些入门的Demo和基本概念。【深入的水平有限，没看懂】
|
||||
|
|
@ -318,7 +318,7 @@ WordNet可以被看作是一个同义词词典
|
|||
|
||||
### 应用领域
|
||||
|
||||
#### 中文分词：
|
||||
#### 中文分词:
|
||||
|
||||
* 构建DAG图
|
||||
* 动态规划查找，综合正反向（正向加权反向输出）求得DAG最大概率路径
|
||||
|
|
@ -334,19 +334,19 @@ WordNet可以被看作是一个同义词词典
|
|||
2. [IMDB电影评论情感分类（斯坦福）](http://ai.stanford.edu/~amaas/data/sentiment)。来自网站imdb.com的一系列电影评论及其积极或消极的情绪。
|
||||
3. [新闻组电影评论情感分类（康奈尔）](http://www.cs.cornell.edu/people/pabo/movie-review-data/)。来自网站imdb.com的一系列电影评论及其积极或消极的情绪。
|
||||
|
||||
有关更多信息，请参阅帖子：
|
||||
有关更多信息，请参阅帖子:
|
||||
[单标签文本分类的数据集](http://ana.cachopo.org/datasets-for-single-label-text-categorization)。
|
||||
|
||||
> 情感分析
|
||||
|
||||
比赛地址: https://www.kaggle.com/c/word2vec-nlp-tutorial
|
||||
|
||||
* 方案一(0.86)：WordCount + 朴素 Bayes
|
||||
* 方案二(0.94)：LDA + 分类模型（knn/决策树/逻辑回归/svm/xgboost/随机森林）
|
||||
* 方案一(0.86): WordCount + 朴素 Bayes
|
||||
* 方案二(0.94): LDA + 分类模型（knn/决策树/逻辑回归/svm/xgboost/随机森林）
|
||||
* a) 决策树效果不是很好，这种连续特征不太适合的
|
||||
* b) 通过参数调整 200 个topic，信息量保存效果较优（计算主题）
|
||||
* 方案三(0.72)：word2vec + CNN
|
||||
* 说实话：没有一个好的机器，是调不出来一个好的结果 (: 逃
|
||||
* 方案三(0.72): word2vec + CNN
|
||||
* 说实话: 没有一个好的机器，是调不出来一个好的结果 (: 逃
|
||||
|
||||
**通过AUC 来评估模型的效果**
|
||||
|
||||
|
|
@ -359,7 +359,7 @@ WordNet可以被看作是一个同义词词典
|
|||
下面是一些很好的初学者语言建模数据集。
|
||||
|
||||
1. [古腾堡项目](https://www.gutenberg.org/)，一系列免费书籍，可以用纯文本检索各种语言。
|
||||
2. 还有更多正式的语料库得到了很好的研究; 例如：
|
||||
2. 还有更多正式的语料库得到了很好的研究; 例如:
|
||||
[布朗大学现代美国英语标准语料库](https://en.wikipedia.org/wiki/Brown_Corpus)。大量英语单词样本。
|
||||
[谷歌10亿字语料库](https://github.com/ciprian-chelba/1-billion-word-language-modeling-benchmark)。
|
||||
|
||||
|
|
@ -387,7 +387,7 @@ mage字幕是为给定图像生成文本描述的任务。
|
|||
1. [上下文中的公共对象（COCO）](http://mscoco.org/dataset/#overview)。包含超过12万张带描述的图像的集合
|
||||
2. [Flickr 8K](http://nlp.cs.illinois.edu/HockenmaierGroup/8k-pictures.html)。从flickr.com获取的8千个描述图像的集合。
|
||||
3. [Flickr 30K](http://shannon.cs.illinois.edu/DenotationGraph/)。从flickr.com获取的3万个描述图像的集合。
|
||||
欲了解更多，请看帖子：
|
||||
欲了解更多，请看帖子:
|
||||
|
||||
[探索图像字幕数据集，2016年](http://sidgan.me/technical/2016/01/09/Exploring-Datasets)
|
||||
|
||||
|
|
@ -399,7 +399,7 @@ mage字幕是为给定图像生成文本描述的任务。
|
|||
|
||||
1. [加拿大第36届议会的协调国会议员](https://www.isi.edu/natural-language/download/hansard/)。成对的英语和法语句子。
|
||||
2. [欧洲议会诉讼平行语料库1996-2011](http://www.statmt.org/europarl/)。句子对一套欧洲语言。
|
||||
有大量标准数据集用于年度机器翻译挑战; 看到：
|
||||
有大量标准数据集用于年度机器翻译挑战; 看到:
|
||||
|
||||
[统计机器翻译](http://www.statmt.org/)
|
||||
|
||||
|
|
@ -417,9 +417,9 @@ mage字幕是为给定图像生成文本描述的任务。
|
|||
1. [斯坦福问题回答数据集（SQuAD）](https://rajpurkar.github.io/SQuAD-explorer/)。回答有关维基百科文章的问题。
|
||||
2. [Deepmind问题回答语料库](https://github.com/deepmind/rc-data)。从每日邮报回答有关新闻文章的问题。
|
||||
3. [亚马逊问答数据](http://jmcauley.ucsd.edu/data/amazon/qa/)。回答有关亚马逊产品的问题。
|
||||
有关更多信息，请参阅帖子：
|
||||
有关更多信息，请参阅帖子:
|
||||
|
||||
[数据集：我如何获得问答网站的语料库，如Quora或Yahoo Answers或Stack Overflow来分析答案质量？](https://www.quora.com/Datasets-How-can-I-get-corpus-of-a-question-answering-website-like-Quora-or-Yahoo-Answers-or-Stack-Overflow-for-analyzing-answer-quality)
|
||||
[数据集: 我如何获得问答网站的语料库，如Quora或Yahoo Answers或Stack Overflow来分析答案质量？](https://www.quora.com/Datasets-How-can-I-get-corpus-of-a-question-answering-website-like-Quora-or-Yahoo-Answers-or-Stack-Overflow-for-analyzing-answer-quality)
|
||||
|
||||
#### 6.语音识别（Speech Recognition）
|
||||
|
||||
|
|
@ -440,7 +440,7 @@ mage字幕是为给定图像生成文本描述的任务。
|
|||
1. [法律案例报告数据集](https://archive.ics.uci.edu/ml/datasets/Legal+Case+Reports)。收集了4000份法律案件及其摘要。
|
||||
2. [TIPSTER文本摘要评估会议语料库](http://www-nlpir.nist.gov/related_projects/tipster_summac/cmp_lg.html)。收集了近200份文件及其摘要。
|
||||
3. [英语新闻文本的AQUAINT语料库](https://catalog.ldc.upenn.edu/LDC2002T31)。不是免费的，而是广泛使用的。新闻文章的语料库。
|
||||
欲了解更多信息：
|
||||
欲了解更多信息:
|
||||
|
||||
[文档理解会议（DUC）任务](http://www-nlpir.nist.gov/projects/duc/data.html)。
|
||||
[在哪里可以找到用于文本摘要的良好数据集？](https://www.quora.com/Where-can-I-find-good-data-sets-for-text-summarization)
|
||||
|
|
@ -474,7 +474,7 @@ mage字幕是为给定图像生成文本描述的任务。
|
|||
如果您希望更深入，本节提供了其他数据集列表。
|
||||
|
||||
1. [维基百科研究中使用的文本数据集](https://en.wikipedia.org/wiki/List_of_datasets_for_machine_learning_research#Text_data)
|
||||
2. [数据集：计算语言学家和自然语言处理研究人员使用的主要文本语料库是什么？](https://www.quora.com/Datasets-What-are-the-major-text-corpora-used-by-computational-linguists-and-natural-language-processing-researchers-and-what-are-the-characteristics-biases-of-each-corpus)
|
||||
2. [数据集: 计算语言学家和自然语言处理研究人员使用的主要文本语料库是什么？](https://www.quora.com/Datasets-What-are-the-major-text-corpora-used-by-computational-linguists-and-natural-language-processing-researchers-and-what-are-the-characteristics-biases-of-each-corpus)
|
||||
3. [斯坦福统计自然语言处理语料库](https://nlp.stanford.edu/links/statnlp.html#Corpora)
|
||||
4. [按字母顺序排列的NLP数据集列表](https://github.com/niderhoff/nlp-datasets)
|
||||
5. [该机构NLTK](http://www.nltk.org/nltk_data/)
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
+ [第7章_集成方法](docs/ml/7.集成方法-随机森林和AdaBoost.md)
|
||||
+ [第8章_回归](docs/ml/8.回归.md)
|
||||
+ [第9章_树回归](docs/ml/9.树回归.md)
|
||||
+ [第10章_KMeans聚类](docs/ml/10.k-means聚类.md)
|
||||
+ [第10章_KMeans聚类](docs/ml/10.KMeans聚类.md)
|
||||
+ [第11章_Apriori算法](docs/ml/11.使用Apriori算法进行关联分析.md)
|
||||
+ [第12章_FP-growth算法](docs/ml/12.使用FP-growth算法来高效发现频繁项集.md)
|
||||
+ [第13章_PCA降维](docs/ml/13.利用PCA来简化数据.md)
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
google.com, pub-3565452474788507, DIRECT, f08c47fec0942fa0
|
||||
|
|
@ -0,0 +1,176 @@
|
|||
{
|
||||
"title" : "Pytorch 中文文档",
|
||||
"author" : "ApacheCN",
|
||||
"description" : "Pytorch 中文文档: 教程和文档",
|
||||
"language" : "zh-hans",
|
||||
"plugins": [
|
||||
"github",
|
||||
"github-buttons",
|
||||
"-sharing",
|
||||
"insert-logo",
|
||||
"sharing-plus",
|
||||
"back-to-top-button",
|
||||
"code",
|
||||
"copy-code-button",
|
||||
"katex",
|
||||
"pageview-count",
|
||||
"edit-link",
|
||||
"emphasize",
|
||||
"alerts",
|
||||
"auto-scroll-table",
|
||||
"popup",
|
||||
"hide-element",
|
||||
"page-toc-button",
|
||||
"tbfed-pagefooter",
|
||||
"sitemap",
|
||||
"advanced-emoji",
|
||||
"expandable-chapters",
|
||||
"splitter",
|
||||
"search-pro"
|
||||
],
|
||||
"pluginsConfig": {
|
||||
"github": {
|
||||
"url": "https://github.com/apachecn/pytorch-doc-zh"
|
||||
},
|
||||
"github-buttons": {
|
||||
"buttons": [
|
||||
{
|
||||
"user": "apachecn",
|
||||
"repo": "pytorch-doc-zh",
|
||||
"type": "star",
|
||||
"count": true,
|
||||
"size": "small"
|
||||
}
|
||||
]
|
||||
},
|
||||
"insert-logo": {
|
||||
"url": "http://data.apachecn.org/img/logo.jpg",
|
||||
"style": "background: none; max-height: 150px; min-height: 150px"
|
||||
},
|
||||
"hide-element": {
|
||||
"elements": [".gitbook-link"]
|
||||
},
|
||||
"edit-link": {
|
||||
"base": "https://github.com/apachecn/pytorch-doc-zh/blob/master",
|
||||
"label": "编辑本页"
|
||||
},
|
||||
"sharing": {
|
||||
"qzone": true,
|
||||
"weibo": true,
|
||||
"twitter": false,
|
||||
"facebook": false,
|
||||
"google": false,
|
||||
"qq": false,
|
||||
"line": false,
|
||||
"whatsapp": false,
|
||||
"douban": false,
|
||||
"all": [
|
||||
"qq", "douban", "facebook", "google", "linkedin", "twitter", "weibo", "whatsapp"
|
||||
]
|
||||
},
|
||||
"page-toc-button": {
|
||||
"maxTocDepth": 4,
|
||||
"minTocSize": 4
|
||||
},
|
||||
"tbfed-pagefooter": {
|
||||
"copyright":"Copyright © ibooker.org.cn 2019",
|
||||
"modify_label": "该文件修订时间: ",
|
||||
"modify_format": "YYYY-MM-DD HH:mm:ss"
|
||||
},
|
||||
"sitemap": {
|
||||
"hostname": "http://pytorch.apachecn.org"
|
||||
}
|
||||
},
|
||||
"my_links" : {
|
||||
"sidebar" : {
|
||||
"Home" : "https://www.baidu.com"
|
||||
}
|
||||
},
|
||||
"my_plugins": [
|
||||
"donate",
|
||||
"todo",
|
||||
"-lunr",
|
||||
"-search",
|
||||
"expandable-chapters-small",
|
||||
"chapter-fold",
|
||||
"expandable-chapters",
|
||||
"expandable-chapters-small",
|
||||
"back-to-top-button",
|
||||
"ga",
|
||||
"baidu",
|
||||
"sitemap",
|
||||
"tbfed-pagefooter",
|
||||
"advanced-emoji",
|
||||
"sectionx",
|
||||
"page-treeview",
|
||||
"simple-page-toc",
|
||||
"ancre-navigation",
|
||||
"theme-apachecn@git+https://github.com/apachecn/theme-apachecn#HEAD",
|
||||
"pagefooter-apachecn@git+https://github.com/apachecn/gitbook-plugin-pagefooter-apachecn#HEAD"
|
||||
],
|
||||
"my_pluginsConfig": {
|
||||
"github-buttons": {
|
||||
"buttons": [
|
||||
{
|
||||
"user": "apachecn",
|
||||
"repo": "pytorch-doc-zh",
|
||||
"type": "star",
|
||||
"count": true,
|
||||
"size": "small"
|
||||
},
|
||||
{
|
||||
"user": "apachecn",
|
||||
"width": "160",
|
||||
"type": "follow",
|
||||
"count": true,
|
||||
"size": "small"
|
||||
}
|
||||
]
|
||||
},
|
||||
"ignores": ["node_modules"],
|
||||
"simple-page-toc": {
|
||||
"maxDepth": 3,
|
||||
"skipFirstH1": true
|
||||
},
|
||||
"page-toc-button": {
|
||||
"maxTocDepth": 2,
|
||||
"minTocSize": 2
|
||||
},
|
||||
"page-treeview": {
|
||||
"copyright": "Copyright © aleen42",
|
||||
"minHeaderCount": "2",
|
||||
"minHeaderDeep": "2"
|
||||
},
|
||||
"donate": {
|
||||
"wechat": "微信收款的二维码URL",
|
||||
"alipay": "支付宝收款的二维码URL",
|
||||
"title": "",
|
||||
"button": "赏",
|
||||
"alipayText": "支付宝打赏",
|
||||
"wechatText": "微信打赏"
|
||||
},
|
||||
"page-copyright": {
|
||||
"description": "modified at",
|
||||
"signature": "你的签名",
|
||||
"wisdom": "Designer, Frontend Developer & overall web enthusiast",
|
||||
"format": "YYYY-MM-dd hh:mm:ss",
|
||||
"copyright": "Copyright © 你的名字",
|
||||
"timeColor": "#666",
|
||||
"copyrightColor": "#666",
|
||||
"utcOffset": "8",
|
||||
"style": "normal",
|
||||
"noPowered": false
|
||||
},
|
||||
"ga": {
|
||||
"token": "UA-102475051-10"
|
||||
},
|
||||
"baidu": {
|
||||
"token": "75439e2cbd22bdd813226000e9dcc12f"
|
||||
},
|
||||
"pagefooter-apachecn": {
|
||||
"copyright":"Copyright © ibooker.org.cn 2019",
|
||||
"modify_label": "该文件修订时间: ",
|
||||
"modify_format": "YYYY-MM-DD HH:mm:ss"
|
||||
}
|
||||
}
|
||||
}
|
||||
262
docs/AI学习路线.md
262
docs/AI学习路线.md
|
|
@ -2,14 +2,14 @@
|
|||
|
||||
## 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
|
||||
|
|
@ -18,32 +18,32 @@
|
|||
|
||||
推荐教材
|
||||
相比国内浙大版和同济版的数学教材，通俗易懂，便于初学者更好地奠定数学基础
|
||||
下载链接：[https://blog.csdn.net/Datawhale/article/details/81744961](https://blog.csdn.net/Datawhale/article/details/81744961)
|
||||
下载链接: [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)
|
||||
可汗学院统计学: [http://open.163.com/special/Khan/khstatistics.html](http://open.163.com/special/Khan/khstatistics.html)
|
||||
|
||||
## 3.编程
|
||||
入门人工智能领域，推荐Python这门编程语言。
|
||||
1) 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版本）
|
||||
下载地址: [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/)
|
||||
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：
|
||||
安装教程:
|
||||
Anaconda+Jupyter notebook+Pycharm:
|
||||
[https://zhuanlan.zhihu.com/p/59027692](https://zhuanlan.zhihu.com/p/59027692)
|
||||
Ubuntu18.04深度学习环境配置(CUDA9+CUDNN7.4+TensorFlow1.8)：
|
||||
Ubuntu18.04深度学习环境配置(CUDA9+CUDNN7.4+TensorFlow1.8):
|
||||
[https://zhuanlan.zhihu.com/p/50302396](https://zhuanlan.zhihu.com/p/50302396)
|
||||
|
||||
|
||||
|
|
@ -58,27 +58,27 @@ b.python入门笔记
|
|||
|
||||
c.南京大学python视频教程
|
||||
这个教程非常值得推荐，python主要语法和常用的库基本涵盖了。
|
||||
查看地址：[https://www.icourse163.org/course/0809NJU004-1001571005?from=study](https://www.icourse163.org/course/0809NJU004-1001571005?from=study)
|
||||
查看地址: [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练习题：
|
||||
numpy练习题:
|
||||
[https://zhuanlan.zhihu.com/p/57872490](https://zhuanlan.zhihu.com/p/57872490)
|
||||
pandas练习题：
|
||||
pandas练习题:
|
||||
[https://zhuanlan.zhihu.com/p/56644669](https://zhuanlan.zhihu.com/p/56644669)
|
||||
|
||||
# 数据分析/挖掘
|
||||
|
||||
## 1.数据分析的基础书籍：
|
||||
## 1.数据分析的基础书籍:
|
||||
《利用python进行数据分析》
|
||||
这本书含有大量的实践案例，你将学会如何利用各种Python库（包括NumPy，Pandas、Matplotlib以及IPython等）高效地解决各式各样的数据分析问题。如果把代码都运行一次，基本上就能解决数据分析的大部分问题了。
|
||||
## 2.特征工程：
|
||||
## 2.特征工程:
|
||||
[https://blog.csdn.net/Datawhale/article/details/83033869](https://blog.csdn.net/Datawhale/article/details/83033869)
|
||||
## 3.数据挖掘项目：
|
||||
## 3.数据挖掘项目:
|
||||
[https://blog.csdn.net/datawhale/article/details/80847662](https://blog.csdn.net/datawhale/article/details/80847662)
|
||||
# 机器学习
|
||||
|
||||
|
|
@ -88,24 +88,24 @@ pandas练习题：
|
|||
课程主页
|
||||
[https://www.coursera.org/learn/machine-learning](https://www.coursera.org/learn/machine-learning)
|
||||
|
||||
课程完整思维导图：
|
||||
课程完整思维导图:
|
||||
|
||||
|
||||
|
||||
下载链接：[https://pan.baidu.com/s/16065BpNAP7JEx_PpFHLSOw](https://pan.baidu.com/s/16065BpNAP7JEx_PpFHLSOw)[ ](https://pan.baidu.com/s/16065BpNAP7JEx_PpFHLSOw提取码)提取码：xcmi
|
||||
下载链接: [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://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/)
|
||||
吴恩达在斯坦福教授的机器学习课程 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)
|
||||
### 中文笔记
|
||||
|
|
@ -123,7 +123,7 @@ pandas练习题：
|
|||
### 中文笔记
|
||||
[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/)
|
||||
配套书籍为《Learning From Data》，在线书籍主页: [http://amlbook.com/](http://amlbook.com/)
|
||||
## 4.公开课 - 林轩田《机器学习技法》
|
||||
### 课程介绍
|
||||
《机器学习技法》课程是《机器学习基石》的进阶课程。主要介绍了机器学习领域经典的一些算法，包括支持向量机、决策树、随机森林、神经网络等等。难度要略高于《机器学习基石》，具有很强的实用性。
|
||||
|
|
@ -183,33 +183,33 @@ Scikit-Learn 作为机器学习一个非常全面的库，是一份不可多得
|
|||
# 深度学习
|
||||
|
||||
## 1.公开课 - 吴恩达《Deep Learning》
|
||||
在吴恩达开设了机器学习课程之后，发布的《Deep Learning》课程也备受好评，吴恩达老师的课程最大的特点就是将知识循序渐进的传授给你，是入门学习不可多得良好视频资料。整个专题共包括五门课程：01.神经网络和深度学习；02.改善深层神经网络-超参数调试、正则化以及优化；03.结构化机器学习项目；04.卷积神经网络；05.序列模型。
|
||||
在吴恩达开设了机器学习课程之后，发布的《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)
|
||||
网易云课堂: [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](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站地址(英文字幕)：
|
||||
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组织进行的中文翻译：
|
||||
由ApacheCN组织进行的中文翻译:
|
||||
[https://github.com/apachecn/fastai-ml-dl-notes-zh](https://github.com/apachecn/fastai-ml-dl-notes-zh)
|
||||
|
||||
## 3.公开课-CS230 Deep Learning
|
||||
|
|
@ -227,10 +227,10 @@ Datawhale整理了该门课程的详细介绍及参考资料
|
|||
|
||||
完成以上学习后，想要更加系统的建立深度学习的知识体系，阅读《深度学习》准没错。该书从浅入深介绍了基础数学知识、机器学习经验以及现阶段深度学习的理论和发展，它能帮助人工智能技术爱好者和从业人员在三位专家学者的思维带领下全方位了解深度学习。
|
||||
### 书籍介绍
|
||||
《深度学习》通常又被称为花书，深度学习领域最经典的畅销书。由全球知名的三位专家IanGoodfellow、YoshuaBengio和AaronCourville撰写，是深度学习领域奠基性的经典教材。全书的内容包括3个部分：第1部分介绍基本的数学工具和机器学习的概念，它们是深度学习的预备知识；第2部分系统深入地讲解现今已成熟的深度学习方法和技术；第3部分讨论某些具有前瞻性的方向和想法，它们被公认为是深度学习未来的研究重点。该书被大众尊称为“AI圣经”。
|
||||
《深度学习》通常又被称为花书，深度学习领域最经典的畅销书。由全球知名的三位专家IanGoodfellow、YoshuaBengio和AaronCourville撰写，是深度学习领域奠基性的经典教材。全书的内容包括3个部分: 第1部分介绍基本的数学工具和机器学习的概念，它们是深度学习的预备知识；第2部分系统深入地讲解现今已成熟的深度学习方法和技术；第3部分讨论某些具有前瞻性的方向和想法，它们被公认为是深度学习未来的研究重点。该书被大众尊称为“AI圣经”。
|
||||
|
||||
### 在线阅读
|
||||
该书由众多网友众包翻译，电子版在以下地址获得：
|
||||
该书由众多网友众包翻译，电子版在以下地址获得:
|
||||
[https://github.com/exacity/deeplearningbook-chinese](https://github.com/exacity/deeplearningbook-chinese)
|
||||
|
||||
## 6.书籍 -《深度学习 500 问》
|
||||
|
|
@ -258,34 +258,34 @@ PyTorch是进行深度学习的另一个主流框架
|
|||
## 1.公开课 - David Silver《Reinforcement Learning》
|
||||
同吴恩达的课程对于机器学习和深度学习初学者的意义一样，David Silver的这门课程绝对是大多数人学习强化学习必选的课程。课程从浅到深，把强化学习的内容娓娓道来，极其详尽。不过由于强化学习本身的难度，听讲这门课还是有一定的门槛，建议还是在大致了解这个领域之后观看该视频学习效果更佳，更容易找到学习的重点。另外，由于强化学习领域飞速地发展，最前沿的知识（特别是与深度学习相关的）没有被涵盖在这个课程中，需要另外补充。
|
||||
### 课程介绍
|
||||
该课程对强化学习领域做了相当详尽的讲解，其主要内容有：马尔可夫决策过程（强化学习的基础理论）、动态规划、免模型预测（蒙特卡洛学习、时序差分学习和λ时序差分强化学习）、免模型控制（On-policy Learning和Off-policy Learning）、价值函数的近似表示、策略梯度算法、集成学习与计划、探索与利用以及实例演示。
|
||||
该课程对强化学习领域做了相当详尽的讲解，其主要内容有: 马尔可夫决策过程（强化学习的基础理论）、动态规划、免模型预测（蒙特卡洛学习、时序差分学习和λ时序差分强化学习）、免模型控制（On-policy Learning和Off-policy Learning）、价值函数的近似表示、策略梯度算法、集成学习与计划、探索与利用以及实例演示。
|
||||
|
||||
### 视频地址
|
||||
B站地址(中文字幕)：
|
||||
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：
|
||||
课程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。
|
||||
该课程上线于2018年，基本涵盖了当年的前沿技术，其主要内容有: 策略梯度算法（David Silver的课程中提到的算法大多都在这部分的内容中提到，但其主要是从神经网络的角度出发）、Q-learning（这部分涵盖了大量的Q-learning优化的讲解）、Actor-Critic、Sparse Reward 和 Imitation Learning。
|
||||
### 视频地址
|
||||
B站地址(中文字幕)：
|
||||
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：
|
||||
课程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)
|
||||
|
||||
|
||||
|
|
@ -293,32 +293,32 @@ B站地址(中文字幕)：
|
|||
|
||||
## Arxiv
|
||||
### Arxiv Stats
|
||||
Arxiv 机器学习最新论文检索，主页地址：
|
||||
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，帮助分类、搜索和过滤特征，主页地址：
|
||||
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)
|
||||
（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/)
|
||||
介绍: [https://redstonewill.com/2039/](https://redstonewill.com/2039/)
|
||||
### Papers with Code(Sorted by stars)
|
||||
这份资源收集了 AI 领域从 2013 - 2018 年所有的论文，并按照在 GitHub 上的标星数量进行排序。GitHub 项目地址：
|
||||
这份资源收集了 AI 领域从 2013 - 2018 年所有的论文，并按照在 GitHub 上的标星数量进行排序。GitHub 项目地址:
|
||||
[https://github.com/zziz/pwc](https://github.com/zziz/pwc)
|
||||
## Deep Learning Papers(Reading Roadmap)
|
||||
如果你是深度学习领域的新手，你可能会遇到的第一个问题是“我应该从哪篇论文开始阅读？”下面是一个深入学习论文的阅读路线图！GitHub 项目地址：
|
||||
如果你是深度学习领域的新手，你可能会遇到的第一个问题是“我应该从哪篇论文开始阅读？”下面是一个深入学习论文的阅读路线图！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**
|
||||
|
|
@ -328,30 +328,30 @@ Andrej Karpathy 开发了 Arxiv Sanity Preserver，帮助分类、搜索和过
|
|||
|
||||
|
||||
|
||||
GitHub 项目地址：
|
||||
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/)
|
||||
介绍: [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)
|
||||
**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/)
|
||||
### 计算机视觉:
|
||||
**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/)
|
||||
### 自然语言处理:
|
||||
**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/)
|
||||
**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。
|
||||
# 理论应用
|
||||
|
|
@ -366,11 +366,11 @@ GitHub 项目地址：
|
|||
|
||||
① 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/) （需科学上网）
|
||||
课程笔记: [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)
|
||||
B站英文字幕版: [https://www.bilibili.com/video/av35805262/](https://www.bilibili.com/video/av35805262/)
|
||||
学术激流网: [http://academictorrents.com/details/d2c8f8f1651740520b7dfab23438d89bc8c0c0ab](http://academictorrents.com/details/d2c8f8f1651740520b7dfab23438d89bc8c0c0ab)
|
||||
|
||||
1. 书籍推荐
|
||||
|
||||
|
|
@ -403,8 +403,8 @@ natural language processing blog [https://nlpers.blogspot.com/](https://nlpers.b
|
|||
用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相关：
|
||||
中文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/)
|
||||
|
|
@ -433,19 +433,19 @@ natural language processing blog [https://nlpers.blogspot.com/](https://nlpers.b
|
|||
**Stanford CS223B**
|
||||
比较适合基础，适合刚刚入门的同学，跟深度学习的结合相对来说会少一点，不会整门课讲深度学习，而是主要讲计算机视觉，方方面面都会讲到
|
||||
|
||||
李飞飞：CS231n课程
|
||||
李飞飞: 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）入门学习: 《**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)
|
||||
观看地址: [https://www.coursera.org/specializations/recommender-systems](https://www.coursera.org/specializations/recommender-systems)
|
||||
### 3.书籍推荐
|
||||
《推荐系统实践》（项亮 著）
|
||||
《推荐系统》（Dietmar Jannach等 著，蒋凡 译）
|
||||
|
|
@ -455,47 +455,47 @@ natural language processing blog [https://nlpers.blogspot.com/](https://nlpers.b
|
|||
**LibRec**
|
||||
LibRec是一个Java版本的覆盖了70余个各类型推荐算法的推荐系统开源算法库，由国内的推荐系统大牛郭贵冰创办，目前已更新到2.0版本，它有效地解决了评分预测和物品推荐两大关键的推荐问题。
|
||||
项目地址: [https://github.com/guoguibing/librec](https://github.com/guoguibing/librec)
|
||||
官网：[官网https://www.librec.net/](https://www.librec.net/)
|
||||
官网: [官网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/)
|
||||
项目地址: [http://www.csie.ntu.edu.tw/~cjlin/libmf/](http://www.csie.ntu.edu.tw/~cjlin/libmf/)
|
||||
**SurPRISE**
|
||||
一个Python版本的开源推荐系统，有多种经典推荐算法
|
||||
项目地址：[http://surpriselib.com/](http://surpriselib.com/)
|
||||
项目地址: [http://surpriselib.com/](http://surpriselib.com/)
|
||||
**Neural Collaborative Filtering**
|
||||
神经协同过滤推荐算法的Python实现
|
||||
项目地址：[https://github.com/hexiangnan/neural_collaborative_filtering](https://github.com/hexiangnan/neural_collaborative_filtering)
|
||||
项目地址: [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/)
|
||||
项目地址: [http://muricoca.github.io/crab/](http://muricoca.github.io/crab/)
|
||||
|
||||
### 5.常用数据集
|
||||
**MovieLen**
|
||||
地址：[https://grouplens.org/datasets/movielens/](https://grouplens.org/datasets/movielens/)
|
||||
地址: [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)
|
||||
地址: [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/)
|
||||
地址: [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/)
|
||||
地址: [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)
|
||||
[地址: 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)
|
||||
地址: [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?](https://v.qq.com/x/page/f0800qavik7.html?)
|
||||
|
||||
3分钟了解今日头条推荐系统原理
|
||||
|
|
@ -509,14 +509,14 @@ Netflix的个性化和推荐系统架构
|
|||
|
||||
## 风控模型（评分卡模型）
|
||||
### 1.评分卡模型简介
|
||||
评分卡模型时在银行、互金等公司与借贷相关业务中最常见也是最重要的模型之一。简而言之它的作用就是对客户进行打分，来对客户是否优质进行评判。根据评分卡模型应用的业务阶段不用，评分卡模型主要分为三大类：A卡（Application score card）申请评分卡、B卡（Behavior score card）行为评分卡、C卡（Collection score card）催收评分卡。其中申请评分卡用于贷前，行为评分卡用于贷中，催收评分卡用于贷后，这三种评分卡在我们的信贷业务的整个生命周期都至关重要。
|
||||
评分卡模型时在银行、互金等公司与借贷相关业务中最常见也是最重要的模型之一。简而言之它的作用就是对客户进行打分，来对客户是否优质进行评判。根据评分卡模型应用的业务阶段不用，评分卡模型主要分为三大类: 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）
|
||||
（1）样本选取: 确定训练样本、测试样本的观察窗（特征的时间跨度）与表现窗（标签的时间跨度），且样本的标签定义是什么？一般情况下风险评分卡的标签都是考虑客户某一段时间内的延滞情况。
|
||||
（2）特征准备: 原始特征、衍生变量
|
||||
（3）数据清洗: 根据业务需求对缺失值或异常值等进行处理
|
||||
（4）特征筛选: 根据特征的IV值（特征对模型的贡献度）、PSI（特征的稳定性）来进行特征筛选，IV值越大越好（但是一个特征的IV值超过一定阈值可能要考虑是否用到未来数据），PSI越小越好（一般建模时取特征的PSI小于等于0.01）
|
||||
（5）对特征进行WOE转换，即对特征进行分箱操作，注意在进行WOE转换时要注重特征的可解释性
|
||||
（6）建立模型，在建立模型过程中可根据模型和变量的统计量判断模型中包含和不包含每个变量时的模型质量来进行变量的二次筛选。
|
||||
（7）评分卡模型一般关注的指标是KS值（衡量的是好坏样本累计分部之间的差值）、模型的PSI(即模型整体的稳定性）、AUC值等。
|
||||
|
|
@ -526,34 +526,34 @@ Netflix的个性化和推荐系统架构
|
|||
### 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)
|
||||
[智能搜索时代: 知识图谱有何价值？](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)))
|
||||
* 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)
|
||||
|
||||
|
|
@ -561,16 +561,16 @@ Netflix的个性化和推荐系统架构
|
|||
|
||||
命名实体识别（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)
|
||||
|
||||
|
||||
|
|
@ -578,7 +578,7 @@ Netflix的个性化和推荐系统架构
|
|||
|
||||
使用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/)
|
||||
|
||||
|
|
@ -586,7 +586,7 @@ Netflix的个性化和推荐系统架构
|
|||
|
||||
知识表示（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)
|
||||
|
|
@ -598,21 +598,21 @@ Netflix的个性化和推荐系统架构
|
|||
1. **知识存储**
|
||||
|
||||
需要熟悉常见的图数据库
|
||||
* 知识链接的方式：字符串、外键、URI
|
||||
* 知识链接的方式: 字符串、外键、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/)
|
||||
* OrientDB: [http://orientdb.com/orientdb/](http://orientdb.com/orientdb/)
|
||||
* RDF数据库Stardog
|
||||
* Stardog官网：[http://stardog.com/](http://stardog.com/)
|
||||
* Stardog官网: [http://stardog.com/](http://stardog.com/)
|
||||
|
||||
1. **知识检索**
|
||||
|
||||
需要熟悉常见的检索技术
|
||||
* ElasticSearch
|
||||
|
||||
ES教程： [http://joelabrahamsson.com/elasticsearch-101/](http://joelabrahamsson.com/elasticsearch-101/)
|
||||
ES教程: [http://joelabrahamsson.com/elasticsearch-101/](http://joelabrahamsson.com/elasticsearch-101/)
|
||||
|
||||
1. 相关术语及技术路线
|
||||
* [本体](https://www.zhihu.com/question/19558514)
|
||||
|
|
@ -637,22 +637,22 @@ ES教程： [http://joelabrahamsson.com/elasticsearch-101/](http://joelabrahamss
|
|||
* [基于知识图谱的问答](https://github.com/kangzhun/KnowledgeGraph-QA-Service)
|
||||
* [Agriculture_KnowledgeGraph](https://github.com/qq547276542/Agriculture_KnowledgeGraph)
|
||||
# 贡献平台
|
||||
由知名开源平台，AI技术平台以及领域专家：ApacheCN，Datawhale，AI有道和黄海广博士联合整理贡献。
|
||||
参与名单：
|
||||
ApacheCN：片刻，李翔宇，飞龙，王翔
|
||||
Datawhale：范晶晶，马晶敏，李碧涵，李福，光城，居居，康兵兵，郑家豪
|
||||
AI有道：红色石头
|
||||
由知名开源平台，AI技术平台以及领域专家: ApacheCN，Datawhale，AI有道和黄海广博士联合整理贡献。
|
||||
参与名单:
|
||||
ApacheCN: 片刻，李翔宇，飞龙，王翔
|
||||
Datawhale: 范晶晶，马晶敏，李碧涵，李福，光城，居居，康兵兵，郑家豪
|
||||
AI有道: 红色石头
|
||||
# 平台介绍
|
||||
* **Datawhale**：一个专注于AI领域的开源组织，上海交通大学国家级孵化项目，目前有7个独立团队，聚集了一群有开源精神和探索精神的团队成员，汇聚了来自各个高校和企业的优秀学习者，致力于构建纯粹的学习圈子和优质的开源项目，提供的组队学习涵盖了数据分析，数据挖掘，机器学习，深度学习，编程等16个内容领域。
|
||||
* **Datawhale**: 一个专注于AI领域的开源组织，上海交通大学国家级孵化项目，目前有7个独立团队，聚集了一群有开源精神和探索精神的团队成员，汇聚了来自各个高校和企业的优秀学习者，致力于构建纯粹的学习圈子和优质的开源项目，提供的组队学习涵盖了数据分析，数据挖掘，机器学习，深度学习，编程等16个内容领域。
|
||||
|
||||
|
||||
* **AI有道**：一个专注于 AI 领域的技术公众号。公众号主要涉及人工智能领域 Python、ML 、CV、NLP 等前沿知识、干货笔记和优质资源！我们致力于为广大人工智能爱好者提供优质的 AI 资源和切实可行的 AI 学习路线。
|
||||
* **AI有道**: 一个专注于 AI 领域的技术公众号。公众号主要涉及人工智能领域 Python、ML 、CV、NLP 等前沿知识、干货笔记和优质资源！我们致力于为广大人工智能爱好者提供优质的 AI 资源和切实可行的 AI 学习路线。
|
||||
|
||||
|
||||
* **黄博（机器学习初学者）**：机器学习课程在国内还不够普及，大部分初学者还是很迷茫，走了很多弯路，黄海广博士希望能尽自己的微薄之力，为机器学习初学者提供一个学习交流的平台。
|
||||
* **黄博（机器学习初学者）**: 机器学习课程在国内还不够普及，大部分初学者还是很迷茫，走了很多弯路，黄海广博士希望能尽自己的微薄之力，为机器学习初学者提供一个学习交流的平台。
|
||||
|
||||
|
||||
* **ApacheCN**：一个致力于提供优质开源项目的开源组织，致力于AI文档翻译，Kaggle比赛交流、LeetCode算法刷题、大数据交流等项目。我们希望做出广大 AI 爱好者真正需要的东西，打造真正有价值的长尾作品。官方网址：[http://www.apachecn.org/](http://www.apachecn.org/)，点击阅读原文即可查看。
|
||||
* **ApacheCN**: 一个致力于提供优质开源项目的开源组织，致力于AI文档翻译，Kaggle比赛交流、LeetCode算法刷题、大数据交流等项目。我们希望做出广大 AI 爱好者真正需要的东西，打造真正有价值的长尾作品。官方网址: [http://www.apachecn.org/](http://www.apachecn.org/)，点击阅读原文即可查看。
|
||||
|
||||
##
|
||||
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ model = Sequential()
|
|||
# 其输出数组的尺寸为 (*, 32)
|
||||
model.add(Dense(32, input_shape=(16,)))
|
||||
|
||||
# 在第一层之后，你就不再需要指定输入的尺寸了：
|
||||
# 在第一层之后，你就不再需要指定输入的尺寸了:
|
||||
model.add(Dense(32))
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -6,13 +6,13 @@
|
|||
|
||||
> 硬件要求
|
||||
|
||||
支持以下启用GPU的设备：
|
||||
支持以下启用GPU的设备:
|
||||
|
||||
* 具有CUDA®Compute Capability 3.5或更高版本的NVIDIA®GPU卡。请参阅[支持CUDA的GPU卡](https://developer.nvidia.com/cuda-gpus)列表 。
|
||||
|
||||
> 软件需求
|
||||
|
||||
您的系统上必须安装以下NVIDIA®软件：
|
||||
您的系统上必须安装以下NVIDIA®软件:
|
||||
|
||||
* NVIDIA®GPU [驱动程序](https://www.nvidia.com/drivers) CUDA 10.0需要410.x或更高版本。
|
||||
* [CUDA®工具包](https://developer.nvidia.com/cuda-toolkit-archive) - TensorFlow支持CUDA 10.0（TensorFlow> = 1.13.0）
|
||||
|
|
@ -48,15 +48,15 @@ $ sudo apt-get install --no-install-recommends nvidia-430 -y
|
|||
正在读取软件包列表... 完成
|
||||
正在分析软件包的依赖关系树
|
||||
正在读取状态信息... 完成
|
||||
将会同时安装下列软件：
|
||||
将会同时安装下列软件:
|
||||
lib32gcc1 libc-dev-bin libc6 libc6-dbg libc6-dev libc6-i386
|
||||
建议安装：
|
||||
建议安装:
|
||||
glibc-doc
|
||||
推荐安装：
|
||||
推荐安装:
|
||||
libcuda1-430 nvidia-opencl-icd-430
|
||||
下列【新】软件包将被安装：
|
||||
下列【新】软件包将被安装:
|
||||
lib32gcc1 libc6-i386 nvidia-430
|
||||
下列软件包将被升级：
|
||||
下列软件包将被升级:
|
||||
libc-dev-bin libc6 libc6-dbg libc6-dev
|
||||
升级了 4 个软件包，新安装了 3 个软件包，要卸载 0 个软件包，有 260 个软件包未被升级。
|
||||
需要下载 99.7 MB/111 MB 的归档。
|
||||
|
|
@ -85,19 +85,19 @@ update-initramfs: Generating /boot/initrd.img-4.10.0-28-generic
|
|||
$ sudo nvidia-smi
|
||||
```
|
||||
|
||||
这里面大家需要注意的是： 采用在终端输入 `ubuntu-drivers devices` 会提示推荐你用什么版本，我的设备显示不出来，所以安装的是418.43这个型号的驱动。（目前最新版本）
|
||||
这里面大家需要注意的是: 采用在终端输入 `ubuntu-drivers devices` 会提示推荐你用什么版本，我的设备显示不出来，所以安装的是418.43这个型号的驱动。（目前最新版本）
|
||||
|
||||
注意事项一：官网下载地址
|
||||
推荐网址：(https://www.geforce.cn/drivers)只有这个GeForce型号的，别的型号推荐去其对应的网址查询。
|
||||
注意事项一: 官网下载地址
|
||||
推荐网址: (https://www.geforce.cn/drivers)只有这个GeForce型号的，别的型号推荐去其对应的网址查询。
|
||||
|
||||
注意事项二：不要在下面这个网址下载，不是不能，最直接的官网，对应的东西最新，也最详细
|
||||
注意事项二: 不要在下面这个网址下载，不是不能，最直接的官网，对应的东西最新，也最详细
|
||||
网址如下(https://www.nvidia.com/Download/index.aspx?lang=cn)
|
||||
|
||||
理由：
|
||||
理由:
|
||||
* （1）上面的网址，选择驱动型号，点进去可以看到许多详细的信息，尤其是它支持什么样的显卡，都有，特别详细。
|
||||
* （2）这个网址在我写博客（2019.3.6）为止，还没有GTX1660Ti的Ubuntu驱动
|
||||
|
||||
注意事项三：具体操作见网上别人写好的。
|
||||
注意事项三: 具体操作见网上别人写好的。
|
||||
|
||||
## 2.安装 CUDA 1.0 + cuDNN 7
|
||||
|
||||
|
|
@ -105,16 +105,16 @@ $ sudo nvidia-smi
|
|||
|
||||
下面这个网址是tensorflow各环境参数对应版本图(https://tensorflow.google.cn/install/source)可供参考。cuda和cudnn对应关系应该没问题，但是tensorflow版本不能过高，否则会出错。
|
||||
|
||||
注意事项一：下载地址
|
||||
cuda下载网址为：(https://developer.nvidia.com/)，右上角搜索“CUDA Toolkit Archive”，点击第一个（最新的）的进去，里面有许多版本可供选择，切记！切记!切记！目前网友的说法是：tensorflow只能支持cuda9.0及以下版本。
|
||||
注意事项一: 下载地址
|
||||
cuda下载网址为: (https://developer.nvidia.com/)，右上角搜索“CUDA Toolkit Archive”，点击第一个（最新的）的进去，里面有许多版本可供选择，切记！切记!切记！目前网友的说法是: tensorflow只能支持cuda9.0及以下版本。
|
||||
|
||||
注意事项二：选择run下载，而不选择del
|
||||
注意事项二: 选择run下载，而不选择del
|
||||
这个具体是什么原因，没搞明白，网友也强烈推荐run,我之前试过del的，失败了，所以大家尽量采用run这种方法。可能有人没明白说明意思，你在选择的时候多留个心眼就注意到了。
|
||||
|
||||
> cuDNN
|
||||
|
||||
官网网址如下
|
||||
网址：<https://developer.nvidia.com/cudnn>
|
||||
网址: <https://developer.nvidia.com/cudnn>
|
||||
需要注册，我是从别人那直接过来的，就没注册，大家需要的自己去，这个安装相对简单。
|
||||
|
||||
同样有验证的过程，这个相对来说是简单的，没什么需要太注意的，跟着网上的走就好了。
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ print(tf.__version__)
|
|||
|
||||
IMDB 数据集已经打包在 Tensorflow 中。该数据集已经经过预处理，评论（单词序列）已经被转换为整数序列，其中每个整数表示字典中的特定单词。
|
||||
|
||||
以下代码将下载 IMDB 数据集到您的机器上（如果您已经下载过将从缓存中复制）：
|
||||
以下代码将下载 IMDB 数据集到您的机器上（如果您已经下载过将从缓存中复制）:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -46,14 +46,14 @@ imdb = keras.datasets.imdb
|
|||
|
||||
## 探索数据
|
||||
|
||||
让我们花一点时间来了解数据格式。该数据集是经过预处理的：每个样本都是一个表示影评中词汇的整数数组。每个标签都是一个值为 0 或 1 的整数值，其中 0 代表消极评论，1 代表积极评论。
|
||||
让我们花一点时间来了解数据格式。该数据集是经过预处理的: 每个样本都是一个表示影评中词汇的整数数组。每个标签都是一个值为 0 或 1 的整数值，其中 0 代表消极评论，1 代表积极评论。
|
||||
|
||||
|
||||
```python
|
||||
print("Training entries: {}, labels: {}".format(len(train_data), len(train_labels)))
|
||||
```
|
||||
|
||||
评论文本被转换为整数值，其中每个整数代表词典中的一个单词。首条评论是这样的：
|
||||
评论文本被转换为整数值，其中每个整数代表词典中的一个单词。首条评论是这样的:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -74,7 +74,7 @@ len(train_data[0]), len(train_data[1])
|
|||
|
||||
### 将整数转换回单词
|
||||
|
||||
了解如何将整数转换回文本对您可能是有帮助的。这里我们将创建一个辅助函数来查询一个包含了整数到字符串映射的字典对象：
|
||||
了解如何将整数转换回文本对您可能是有帮助的。这里我们将创建一个辅助函数来查询一个包含了整数到字符串映射的字典对象:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -94,7 +94,7 @@ def decode_review(text):
|
|||
return ' '.join([reverse_word_index.get(i, '?') for i in text])
|
||||
```
|
||||
|
||||
现在我们可以使用 `decode_review` 函数来显示首条评论的文本：
|
||||
现在我们可以使用 `decode_review` 函数来显示首条评论的文本:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -103,7 +103,7 @@ decode_review(train_data[0])
|
|||
|
||||
## 准备数据
|
||||
|
||||
影评——即整数数组必须在输入神经网络之前转换为张量。这种转换可以通过以下两种方式来完成：
|
||||
影评——即整数数组必须在输入神经网络之前转换为张量。这种转换可以通过以下两种方式来完成:
|
||||
|
||||
* 将数组转换为表示单词出现与否的由 0 和 1 组成的向量，类似于 one-hot 编码。例如，序列[3, 5]将转换为一个 10,000 维的向量，该向量除了索引为 3 和 5 的位置是 1 以外，其他都为 0。然后，将其作为网络的首层——一个可以处理浮点型向量数据的稠密层。不过，这种方法需要大量的内存，需要一个大小为 `num_words * num_reviews` 的矩阵。
|
||||
|
||||
|
|
@ -111,7 +111,7 @@ decode_review(train_data[0])
|
|||
|
||||
在本教程中，我们将使用第二种方法。
|
||||
|
||||
由于电影评论长度必须相同，我们将使用 [pad_sequences](https://tensorflow.google.cn/api_docs/python/tf/keras/preprocessing/sequence/pad_sequences) 函数来使长度标准化：
|
||||
由于电影评论长度必须相同，我们将使用 [pad_sequences](https://tensorflow.google.cn/api_docs/python/tf/keras/preprocessing/sequence/pad_sequences) 函数来使长度标准化:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -126,14 +126,14 @@ test_data = keras.preprocessing.sequence.pad_sequences(test_data,
|
|||
maxlen=256)
|
||||
```
|
||||
|
||||
现在让我们看下样本的长度：
|
||||
现在让我们看下样本的长度:
|
||||
|
||||
|
||||
```python
|
||||
len(train_data[0]), len(train_data[1])
|
||||
```
|
||||
|
||||
并检查一下首条评论（当前已经填充）：
|
||||
并检查一下首条评论（当前已经填充）:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -142,12 +142,12 @@ print(train_data[0])
|
|||
|
||||
## 构建模型
|
||||
|
||||
神经网络由堆叠的层来构建，这需要从两个主要方面来进行体系结构决策：
|
||||
神经网络由堆叠的层来构建，这需要从两个主要方面来进行体系结构决策:
|
||||
|
||||
* 模型里有多少层？
|
||||
* 每个层里有多少*隐层单元（hidden units）*？
|
||||
|
||||
在此样本中，输入数据包含一个单词索引的数组。要预测的标签为 0 或 1。让我们来为该问题构建一个模型：
|
||||
在此样本中，输入数据包含一个单词索引的数组。要预测的标签为 0 或 1。让我们来为该问题构建一个模型:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -163,9 +163,9 @@ model.add(keras.layers.Dense(1, activation='sigmoid'))
|
|||
model.summary()
|
||||
```
|
||||
|
||||
层按顺序堆叠以构建分类器：
|
||||
层按顺序堆叠以构建分类器:
|
||||
|
||||
1. 第一层是`嵌入（Embedding）`层。该层采用整数编码的词汇表，并查找每个词索引的嵌入向量（embedding vector）。这些向量是通过模型训练学习到的。向量向输出数组增加了一个维度。得到的维度为：`(batch, sequence, embedding)`。
|
||||
1. 第一层是`嵌入（Embedding）`层。该层采用整数编码的词汇表，并查找每个词索引的嵌入向量（embedding vector）。这些向量是通过模型训练学习到的。向量向输出数组增加了一个维度。得到的维度为: `(batch, sequence, embedding)`。
|
||||
2. 接下来，`GlobalAveragePooling1D` 将通过对序列维度求平均值来为每个样本返回一个定长输出向量。这允许模型以尽可能最简单的方式处理变长输入。
|
||||
3. 该定长输出向量通过一个有 16 个隐层单元的全连接（`Dense`）层传输。
|
||||
4. 最后一层与单个输出结点密集连接。使用 `Sigmoid` 激活函数，其函数值为介于 0 与 1 之间的浮点数，表示概率或置信度。
|
||||
|
|
@ -184,7 +184,7 @@ model.summary()
|
|||
|
||||
稍后，当我们研究回归问题（例如，预测房价）时，我们将介绍如何使用另一种叫做均方误差的损失函数。
|
||||
|
||||
现在，配置模型来使用优化器和损失函数：
|
||||
现在，配置模型来使用优化器和损失函数:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -208,7 +208,7 @@ partial_y_train = train_labels[10000:]
|
|||
|
||||
## 训练模型
|
||||
|
||||
以 512 个样本的 mini-batch 大小迭代 40 个 epoch 来训练模型。这是指对 `x_train` 和 `y_train` 张量中所有样本的的 40 次迭代。在训练过程中，监测来自验证集的 10,000 个样本上的损失值（loss）和准确率（accuracy）：
|
||||
以 512 个样本的 mini-batch 大小迭代 40 个 epoch 来训练模型。这是指对 `x_train` 和 `y_train` 张量中所有样本的的 40 次迭代。在训练过程中，监测来自验证集的 10,000 个样本上的损失值（loss）和准确率（accuracy）:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -235,7 +235,7 @@ print(results)
|
|||
|
||||
## 创建一个准确率（accuracy）和损失值（loss）随时间变化的图表
|
||||
|
||||
`model.fit()` 返回一个 `History` 对象，该对象包含一个字典，其中包含训练阶段所发生的一切事件：
|
||||
`model.fit()` 返回一个 `History` 对象，该对象包含一个字典，其中包含训练阶段所发生的一切事件:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -243,7 +243,7 @@ history_dict = history.history
|
|||
history_dict.keys()
|
||||
```
|
||||
|
||||
有四个条目：在训练和验证期间，每个条目对应一个监控指标。我们可以使用这些条目来绘制训练与验证过程的损失值（loss）和准确率（accuracy），以便进行比较。
|
||||
有四个条目: 在训练和验证期间，每个条目对应一个监控指标。我们可以使用这些条目来绘制训练与验证过程的损失值（loss）和准确率（accuracy），以便进行比较。
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -287,7 +287,7 @@ plt.show()
|
|||
|
||||
注意训练损失值随每一个 epoch *下降*而训练准确率（accuracy）随每一个 epoch *上升*。这在使用梯度下降优化时是可预期的——理应在每次迭代中最小化期望值。
|
||||
|
||||
验证过程的损失值（loss）与准确率（accuracy）的情况却并非如此——它们似乎在 20 个 epoch 后达到峰值。这是过拟合的一个实例：模型在训练数据上的表现比在以前从未见过的数据上的表现要更好。在此之后，模型过度优化并学习*特定*于训练数据的表示，而不能够*泛化*到测试数据。
|
||||
验证过程的损失值（loss）与准确率（accuracy）的情况却并非如此——它们似乎在 20 个 epoch 后达到峰值。这是过拟合的一个实例: 模型在训练数据上的表现比在以前从未见过的数据上的表现要更好。在此之后，模型过度优化并学习*特定*于训练数据的表示，而不能够*泛化*到测试数据。
|
||||
|
||||
对于这种特殊情况，我们可以通过在 20 个左右的 epoch 后停止训练来避免过拟合。稍后，您将看到如何通过回调自动执行此操作。
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Note: 我们的 TensorFlow 社区翻译了这些文档。因为社区翻译是
|
|||
|
||||
在 *回归 (regression)* 问题中，我们的目的是预测出如价格或概率这样连续值的输出。相对于*分类(classification)* 问题，*分类(classification)* 的目的是从一系列的分类出选择出一个分类 （如，给出一张包含苹果或橘子的图片，识别出图片中是哪种水果）。
|
||||
|
||||
本 notebook 使用经典的 [Auto MPG](https://archive.ics.uci.edu/ml/datasets/auto+mpg) 数据集，构建了一个用来预测70年代末到80年代初汽车燃油效率的模型。为了做到这一点，我们将为该模型提供许多那个时期的汽车描述。这个描述包含：气缸数，排量，马力以及重量。
|
||||
本 notebook 使用经典的 [Auto MPG](https://archive.ics.uci.edu/ml/datasets/auto+mpg) 数据集，构建了一个用来预测70年代末到80年代初汽车燃油效率的模型。为了做到这一点，我们将为该模型提供许多那个时期的汽车描述。这个描述包含: 气缸数，排量，马力以及重量。
|
||||
|
||||
本示例使用 `tf.keras` API，相关细节请参阅 [本指南](https://tensorflow.google.cn/guide/keras)。
|
||||
|
||||
|
|
@ -499,7 +499,7 @@ test_labels = test_dataset.pop('MPG')
|
|||
|
||||
使用不同的尺度和范围对特征归一化是好的实践。尽管模型*可能* 在没有特征归一化的情况下收敛，它会使得模型训练更加复杂，并会造成生成的模型依赖输入所使用的单位选择。
|
||||
|
||||
注意：尽管我们仅仅从训练集中有意生成这些统计数据，但是这些统计信息也会用于归一化的测试数据集。我们需要这样做，将测试数据集放入到与已经训练过的模型相同的分布中。
|
||||
注意: 尽管我们仅仅从训练集中有意生成这些统计数据，但是这些统计信息也会用于归一化的测试数据集。我们需要这样做，将测试数据集放入到与已经训练过的模型相同的分布中。
|
||||
|
||||
|
||||
```python
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
换句话说，我们的模型将 *过拟合* 训练数据。学习如何应对过拟合很重要。尽管通常可以在*训练集*上达到高精度，但我们真正想要的是开发能够很好地推广到*测试集*（或之前未见的数据）的模型。
|
||||
|
||||
过拟合的反面是*欠拟合*。当测试数据仍有改进空间时，就会发生欠拟合。发生这种情况的原因有很多：如果模型不够强大，模型过于规范化，或者仅仅是没有经过足够长时间的训练。这意味着网络尚未学习训练数据中的相关模式。
|
||||
过拟合的反面是*欠拟合*。当测试数据仍有改进空间时，就会发生欠拟合。发生这种情况的原因有很多: 如果模型不够强大，模型过于规范化，或者仅仅是没有经过足够长时间的训练。这意味着网络尚未学习训练数据中的相关模式。
|
||||
|
||||
但是，如果训练时间过长，则模型将开始过拟合并从训练数据中学习无法推广到测试数据的模式。我们需要保持平衡。如下所述，了解如何训练适当的时期是一项有用的技能。
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ train_data = multi_hot_sequences(train_data, dimension=NUM_WORDS)
|
|||
test_data = multi_hot_sequences(test_data, dimension=NUM_WORDS)
|
||||
```
|
||||
|
||||
让我们看一下产生的 multi-hot 向量之一。 单词索引按频率排序，因此可以预期在索引零附近有更多的1值，如我们在该图中所看到的：
|
||||
让我们看一下产生的 multi-hot 向量之一。 单词索引按频率排序，因此可以预期在索引零附近有更多的1值，如我们在该图中所看到的:
|
||||
|
||||
```python
|
||||
plt.plot(train_data[0])
|
||||
|
|
@ -67,7 +67,7 @@ plt.plot(train_data[0])
|
|||
|
||||
防止过拟合的最简单方法是减小模型的大小，即减小模型中可学习的参数的数量（由层数和每层单元数确定）。在深度学习中，模型中可学习参数的数量通常称为模型的“容量”。直观地讲，具有更多参数的模型将具有更多的“记忆能力”，因此将能够轻松学习训练样本与其目标之间的完美的字典式映射，这种映射没有任何泛化能力，但是在进行预测时这将是无用的根据以前看不见的数据。
|
||||
|
||||
始终牢记这一点：深度学习模型往往擅长拟合训练数据，但真正的挑战是泛化而不是拟合。
|
||||
始终牢记这一点: 深度学习模型往往擅长拟合训练数据，但真正的挑战是泛化而不是拟合。
|
||||
|
||||
另一方面，如果网络的存储资源有限，则将无法轻松地学习映射。为了最大程度地减少损失，它必须学习具有更强预测能力的压缩表示形式。同时，如果您使模型过小，将难以拟合训练数据。 “容量过多”和“容量不足”之间存在平衡。
|
||||
|
||||
|
|
@ -152,7 +152,7 @@ Epoch 20/20
|
|||
|
||||
### 创建 smaller model
|
||||
|
||||
让我们创建一个隐藏单元更少的模型，以与我们刚刚创建的基线模型进行比较：
|
||||
让我们创建一个隐藏单元更少的模型，以与我们刚刚创建的基线模型进行比较:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -169,7 +169,7 @@ smaller_model.compile(optimizer='adam',
|
|||
smaller_model.summary()
|
||||
```
|
||||
|
||||
并使用相同的数据训练模型：
|
||||
并使用相同的数据训练模型:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -227,7 +227,7 @@ Epoch 20/20
|
|||
|
||||
### 创建 bigger model
|
||||
|
||||
作为练习，您可以创建一个更大的模型，并查看它开始过拟合的速度。 接下来，让我们将具有更大容量的网络添加到此基准网络中，远远超出问题所能保证的范围：
|
||||
作为练习，您可以创建一个更大的模型，并查看它开始过拟合的速度。 接下来，让我们将具有更大容量的网络添加到此基准网络中，远远超出问题所能保证的范围:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -244,7 +244,7 @@ bigger_model.compile(optimizer='adam',
|
|||
bigger_model.summary()
|
||||
```
|
||||
|
||||
再次，使用相同的数据训练模型：
|
||||
再次，使用相同的数据训练模型:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -303,7 +303,7 @@ Epoch 20/20
|
|||
|
||||
<!--TODO(markdaoust): This should be a one-liner with tensorboard -->
|
||||
|
||||
实线表示训练损失，而虚线表示验证损失（请记住：验证损失越小表示模型越好）。 在这里，较小的网络比基准模型开始过度拟合（在6个时期而不是4个周期之后），并且一旦开始过度拟合，其性能下降的速度就会慢得多。
|
||||
实线表示训练损失，而虚线表示验证损失（请记住: 验证损失越小表示模型越好）。 在这里，较小的网络比基准模型开始过度拟合（在6个时期而不是4个周期之后），并且一旦开始过度拟合，其性能下降的速度就会慢得多。
|
||||
|
||||
```python
|
||||
def plot_history(histories, key='binary_crossentropy'):
|
||||
|
|
@ -335,13 +335,13 @@ plot_history([('baseline', baseline_history),
|
|||
|
||||
### 添加权重正则化
|
||||
|
||||
您可能熟悉Occam的Razor原理：给某事两种解释，最可能正确的解释是“最简单”的解释，即假设最少的一种。这也适用于通过神经网络学习的模型：给定一些训练数据和网络体系结构，可以使用多组权重值（多个模型）来解释数据，并且较简单的模型比复杂的模型不太可能过拟合。
|
||||
您可能熟悉Occam的Razor原理: 给某事两种解释，最可能正确的解释是“最简单”的解释，即假设最少的一种。这也适用于通过神经网络学习的模型: 给定一些训练数据和网络体系结构，可以使用多组权重值（多个模型）来解释数据，并且较简单的模型比复杂的模型不太可能过拟合。
|
||||
|
||||
在这种情况下，“简单模型”是参数值的分布具有较小熵的模型（或如上节所述，具有总共较少参数的模型）。因此，减轻过拟合的一种通用方法是通过仅将网络的权重强制取小的值来对网络的复杂性施加约束，这使得权重值的分布更加“规则”。这称为“权重调整”，它是通过向网络的损失函数中添加与权重较大相关的成本来完成的。以下有两种形式：
|
||||
在这种情况下，“简单模型”是参数值的分布具有较小熵的模型（或如上节所述，具有总共较少参数的模型）。因此，减轻过拟合的一种通用方法是通过仅将网络的权重强制取小的值来对网络的复杂性施加约束，这使得权重值的分布更加“规则”。这称为“权重调整”，它是通过向网络的损失函数中添加与权重较大相关的成本来完成的。以下有两种形式:
|
||||
|
||||
* [L1正则化](https://developers.google.com/machine-learning/glossary/#L1_regularization)，其中增加的成本与权重系数的绝对值成正比（即所谓的“ L1规范” ”）。
|
||||
|
||||
* [L2正则化](https://developers.google.com/machine-learning/glossary/#L2_regularization)，其中增加的成本与权重系数的值的平方成正比（即与平方的平方成正比）权重的“ L2规范”。 L2正则化在神经网络中也称为权重衰减。不要让其他名称使您感到困惑：权重衰减在数学上与L2正则化完全相同。
|
||||
* [L2正则化](https://developers.google.com/machine-learning/glossary/#L2_regularization)，其中增加的成本与权重系数的值的平方成正比（即与平方的平方成正比）权重的“ L2规范”。 L2正则化在神经网络中也称为权重衰减。不要让其他名称使您感到困惑: 权重衰减在数学上与L2正则化完全相同。
|
||||
|
||||
L1正则化引入稀疏性，以使您的某些权重参数为零。 L2正则化将惩罚权重参数而不使其稀疏，这是L2更为常见的原因之一。
|
||||
|
||||
|
|
@ -414,7 +414,7 @@ Epoch 20/20
|
|||
|
||||
`l2(0.001)` 表示该层权重矩阵中的每个系数将为网络的总损耗增加 `0.001 * weight_coefficient_value**2`。 请注意，由于此惩罚仅在训练时增加，因此在训练时此网络的损失将比在测试时高得多。
|
||||
|
||||
这是我们的L2正则化惩罚的影响：
|
||||
这是我们的L2正则化惩罚的影响:
|
||||
|
||||
```python
|
||||
plot_history([('baseline', baseline_history),
|
||||
|
|
@ -431,7 +431,7 @@ dropout 是 Hinton 和他在多伦多大学的学生开发的最有效，最常
|
|||
|
||||
在tf.keras中，您可以通过Dropout层在网络中引入Dropout，该层将立即应用于该层的输出。
|
||||
|
||||
让我们在IMDB网络中添加两个Dropout层，看看它们在减少过拟合方面的表现如何：
|
||||
让我们在IMDB网络中添加两个Dropout层，看看它们在减少过拟合方面的表现如何:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -508,7 +508,7 @@ plot_history([('baseline', baseline_history),
|
|||
|
||||
添加 dropout 是对基线模型的明显改进。
|
||||
|
||||
回顾一下：以下是防止神经网络过拟合的最常用方法：
|
||||
回顾一下: 以下是防止神经网络过拟合的最常用方法:
|
||||
|
||||
* 获取更多训练数据
|
||||
* 减少网络容量
|
||||
|
|
|
|||
|
|
@ -0,0 +1,62 @@
|
|||
# Bert 项目实战
|
||||
|
||||
```
|
||||
题外话:
|
||||
我感觉的确很惭愧
|
||||
那些在NLP领域一直都说自己很牛逼的公司？
|
||||
为啥中文通用的预训练模型是Google，而不是我们热熟能详的国内互联网公司？
|
||||
```
|
||||
|
||||
## 基本介绍
|
||||
|
||||
BERT的全称为Bidirectional Encoder Representation from Transformers，是一个预训练的语言表征模型。
|
||||
|
||||
该模型有以下主要优点:
|
||||
|
||||
1. 采用MLM对`双向的Transformers`进行预训练，以生成深层的双向语言表征，可以更好的理解上下文信息
|
||||
2. 预训练后，只需要添加一个额外的输出层进行fine-tune，就可以在各种各样的下游任务中取得state-of-the-art的表现。在这过程中并不需要对BERT进行任务特定的结构修改。
|
||||
|
||||
|
||||
|
||||
|
||||
总结一下:
|
||||
|
||||
1. token embeddings 表示的是词向量，第一个单词是CLS，可以用于之后的分类任务；SEP分割句子的
|
||||
2. segment embeddings 用来区别两种句子，因为预训练不光做LM还要做以两个句子为输入的分类任务
|
||||
3. position embeddings 表示位置信息（索引ID）
|
||||
|
||||
例如:
|
||||
|
||||
这里包含keras-bert的三个例子，分别是文本分类、关系抽取和主体抽取，都是在官方发布的预训练权重基础上进行微调来做的。
|
||||
|
||||
---
|
||||
|
||||
## 提问环节:
|
||||
|
||||
> 1.bert中的[CLS]甚意思？
|
||||
|
||||
bert论文中提到: “GPT uses a sentence separator ([SEP]) and classifier token ([CLS]) which are only introduced at fine-tuning time; BERT learns [SEP], [CLS] and sentence A/B embeddings during pre-training.”
|
||||
|
||||
说明[CLS]不是bert原创，在GPT中就有。在GPT中用于句子的分类，判断[CLS]开头的句子是不是下一句。
|
||||
|
||||
> 2.单向语言模型和双向语言模型
|
||||
|
||||
* 单向语言模型是指: 从左到右或者从右到左，使其只能获取单方向的上下文信息
|
||||
* 双向语言模型是指: 不受单向的限制，可以更好的理解上下文信息
|
||||
|
||||
|
||||
> 3.预训练模型
|
||||
|
||||
例如我们今天利用A数据训练了一个A模型，第二次我们有新的预料，在A的基础上，做了微调(fine-tuning)，得到一个更好的B模型。而模型在这个过程中，是预先训练好，方便下一个预料进行迭代式训练。
|
||||
|
||||
---
|
||||
|
||||
* https://www.cnblogs.com/dogecheng/p/11617940.html
|
||||
* https://blog.csdn.net/zkq_1986/article/details/100155596
|
||||
* https://blog.csdn.net/yangfengling1023/article/details/84025313
|
||||
* https://zhuanlan.zhihu.com/p/98855346
|
||||
* https://blog.csdn.net/weixin_42598761/article/details/104592171
|
||||
* https://storage.googleapis.com/bert_models/2018_11_03/chinese_L-12_H-768_A-12.zip
|
||||
* pip install git+https://www.github.com/keras-team/keras-contrib.git
|
||||
* pip install keras-bert
|
||||
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
# CNN原理
|
||||
|
||||
> 建议：看懂原理就行
|
||||
> 建议: 看懂原理就行
|
||||
|
||||
# [【深度学习系列】卷积神经网络CNN原理详解(一)——基本原理](https://www.cnblogs.com/charlotte77/p/7759802.html)
|
||||
|
||||
|
|
@ -16,7 +16,7 @@
|
|||
|
||||
大家可能会疑惑，对于同一个分类任务，我们可以用机器学习的算法来做，为什么要用神经网络呢？大家回顾一下，一个分类任务，我们在用机器学习算法来做时，首先要明确feature和label，然后把这个数据"灌"到算法里去训练，最后保存模型，再来预测分类的准确性。但是这就有个问题，即我们需要实现确定好特征，每一个特征即为一个维度，特征数目过少，我们可能无法精确的分类出来，即我们所说的欠拟合，如果特征数目过多，可能会导致我们在分类过程中过于注重某个特征导致分类错误，即过拟合。
|
||||
|
||||
举个简单的例子，现在有一堆数据集，让我们分类出西瓜和冬瓜，如果只有两个特征：形状和颜色，可能没法分区来；如果特征的维度有：形状、颜色、瓜瓤颜色、瓜皮的花纹等等，可能很容易分类出来；如果我们的特征是：形状、颜色、瓜瓤颜色、瓜皮花纹、瓜蒂、瓜籽的数量，瓜籽的颜色、瓜籽的大小、瓜籽的分布情况、瓜籽的XXX等等，很有可能会过拟合，譬如有的冬瓜的瓜籽数量和西瓜的类似，模型训练后这类特征的权重较高，就很容易分错。这就导致我们在特征工程上需要花很多时间和精力，才能使模型训练得到一个好的效果。然而神经网络的出现使我们不需要做大量的特征工程，譬如提前设计好特征的内容或者说特征的数量等等，我们可以直接把数据灌进去，让它自己训练，自我“修正”，即可得到一个较好的效果。
|
||||
举个简单的例子，现在有一堆数据集，让我们分类出西瓜和冬瓜，如果只有两个特征: 形状和颜色，可能没法分区来；如果特征的维度有: 形状、颜色、瓜瓤颜色、瓜皮的花纹等等，可能很容易分类出来；如果我们的特征是: 形状、颜色、瓜瓤颜色、瓜皮花纹、瓜蒂、瓜籽的数量，瓜籽的颜色、瓜籽的大小、瓜籽的分布情况、瓜籽的XXX等等，很有可能会过拟合，譬如有的冬瓜的瓜籽数量和西瓜的类似，模型训练后这类特征的权重较高，就很容易分错。这就导致我们在特征工程上需要花很多时间和精力，才能使模型训练得到一个好的效果。然而神经网络的出现使我们不需要做大量的特征工程，譬如提前设计好特征的内容或者说特征的数量等等，我们可以直接把数据灌进去，让它自己训练，自我“修正”，即可得到一个较好的效果。
|
||||
|
||||
* 数据格式的简易性
|
||||
|
||||
|
|
@ -48,7 +48,7 @@
|
|||
|
||||
** 传统神经网络的劣势**
|
||||
|
||||
前面说到在图像领域，用传统的神经网络并不合适。我们知道，图像是由一个个像素点构成，每个像素点有三个通道，分别代表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个参数了)
|
||||
前面说到在图像领域，用传统的神经网络并不合适。我们知道，图像是由一个个像素点构成，每个像素点有三个通道，分别代表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个参数了)
|
||||
|
||||
|
||||
|
||||
|
|
@ -66,7 +66,7 @@
|
|||
|
||||
图2 4*4 image与两个2*2的卷积核操作结果
|
||||
|
||||
由上图可以看到，原始图片是一张灰度图片,每个位置表示的是像素值，0表示白色，1表示黑色，（0，1）区间的数值表示灰色。对于这个4*4的图像，我们采用两个2*2的卷积核来计算。设定步长为1，即每次以2*2的固定窗口往右滑动一个单位。以第一个卷积核filter1为例，计算过程如下：
|
||||
由上图可以看到，原始图片是一张灰度图片,每个位置表示的是像素值，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
|
||||
|
|
@ -75,7 +75,7 @@ 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里是这样定义的：
|
||||
可以看到这就是最简单的内积公式。feature_map1(1,1)表示在通过第一个卷积核计算完后得到的feature_map的第一行第一列的值，随着卷积核的窗口不断的滑动，我们可以计算出一个3\*3的feature_map1;同理可以计算通过第二个卷积核进行卷积运算后的feature_map2，那么这一层卷积操作就完成了。feature_map尺寸计算公式: [ (原图片尺寸 -卷积核尺寸)/ 步长 ] + 1。这一层我们设定了两个2\*2的卷积核，在paddlepaddle里是这样定义的:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -89,7 +89,7 @@ conv_pool_1 = paddle.networks.simple_img_conv_pool(
|
|||
```
|
||||
|
||||
|
||||
这里调用了networks里simple_img_conv_pool函数，激活函数是Relu(修正线性单元)，我们来看一看源码里外层接口是如何定义的：
|
||||
这里调用了networks里simple_img_conv_pool函数，激活函数是Relu(修正线性单元)，我们来看一看源码里外层接口是如何定义的:
|
||||
|
||||
|
||||
```python
|
||||
|
|
@ -177,7 +177,7 @@ def simple_img_conv_pool(input,
|
|||
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这个函数的定义：
|
||||
我们在 [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,
|
||||
|
|
@ -207,7 +207,7 @@ def simple_img_conv_pool(input,
|
|||
return pool_out
|
||||
```
|
||||
|
||||
可以看到这里面有两个输出，conv_out是卷积输出值，pool_out是池化输出值，最后只返回池化输出的值。conv_out和pool_out分别又调用了layers.py的conv2d和pool2d，去layers.py里我们可以看到conv2d和pool2d是如何实现的：
|
||||
可以看到这里面有两个输出，conv_out是卷积输出值，pool_out是池化输出值，最后只返回池化输出的值。conv_out和pool_out分别又调用了layers.py的conv2d和pool2d，去layers.py里我们可以看到conv2d和pool2d是如何实现的:
|
||||
|
||||
conv2d:
|
||||
|
||||
|
|
@ -521,7 +521,7 @@ class LayerHelper(object):
|
|||
|
||||
仔细思考一下，这个时候，我们设计的两个卷积核分别能够提取，或者说检测出原始图片的特定的特征。此时我们其实就可以把卷积核就理解为特征提取器啊！现在就明白了，为什么我们只需要把图片数据灌进去，设计好卷积核的尺寸、数量和滑动的步长就可以让自动提取出图片的某些特征，从而达到分类的效果啊！
|
||||
|
||||
**注**：1.此处的卷积运算是两个卷积核大小的矩阵的内积运算，不是矩阵乘法。即相同位置的数字相乘再相加求和。不要弄混淆了。
|
||||
**注**: 1.此处的卷积运算是两个卷积核大小的矩阵的内积运算，不是矩阵乘法。即相同位置的数字相乘再相加求和。不要弄混淆了。
|
||||
|
||||
2.卷积核的公式有很多，这只是最简单的一种。我们所说的卷积核在数字信号处理里也叫滤波器，那滤波器的种类就多了，均值滤波器，高斯滤波器，拉普拉斯滤波器等等，不过，不管是什么滤波器，都只是一种数学运算，无非就是计算更复杂一点。
|
||||
|
||||
|
|
@ -529,17 +529,17 @@ class LayerHelper(object):
|
|||
|
||||
* **池化层（Pooling Layer）**
|
||||
|
||||
通过上一层2*2的卷积核操作后，我们将原始图像由4*4的尺寸变为了3*3的一个新的图片。池化层的主要目的是通过降采样的方式，在不影响图像质量的情况下，压缩图片，减少参数。简单来说，假设现在设定池化层采用MaxPooling，大小为2*2，步长为1，取每个窗口最大的数值重新，那么图片的尺寸就会由3*3变为2*2：(3-2)+1=2。从上例来看，会有如下变换：
|
||||
通过上一层2*2的卷积核操作后，我们将原始图像由4*4的尺寸变为了3*3的一个新的图片。池化层的主要目的是通过降采样的方式，在不影响图像质量的情况下，压缩图片，减少参数。简单来说，假设现在设定池化层采用MaxPooling，大小为2*2，步长为1，取每个窗口最大的数值重新，那么图片的尺寸就会由3*3变为2*2: (3-2)+1=2。从上例来看，会有如下变换:
|
||||
|
||||
|
||||
|
||||
|
||||
图3 Max Pooling结果
|
||||
|
||||
通常来说，池化方法一般有一下两种：
|
||||
通常来说，池化方法一般有一下两种:
|
||||
|
||||
* MaxPooling：取滑动窗口里最大的值
|
||||
* AveragePooling：取滑动窗口内所有值的平均值
|
||||
* MaxPooling: 取滑动窗口里最大的值
|
||||
* AveragePooling: 取滑动窗口内所有值的平均值
|
||||
|
||||
为什么采用Max Pooling？
|
||||
|
||||
|
|
@ -551,7 +551,7 @@ class LayerHelper(object):
|
|||
|
||||
Zero Padding
|
||||
|
||||
所以到现在为止，我们的图片由4*4，通过卷积层变为3*3，再通过池化层变化2*2，如果我们再添加层，那么图片岂不是会越变越小？这个时候我们就会引出“Zero Padding”（补零），它可以帮助我们保证每次经过卷积或池化输出后图片的大小不变，如，上述例子我们如果加入Zero Padding，再采用3*3的卷积核，那么变换后的图片尺寸与原图片尺寸相同，如下图所示：
|
||||
所以到现在为止，我们的图片由4*4，通过卷积层变为3*3，再通过池化层变化2*2，如果我们再添加层，那么图片岂不是会越变越小？这个时候我们就会引出“Zero Padding”（补零），它可以帮助我们保证每次经过卷积或池化输出后图片的大小不变，如，上述例子我们如果加入Zero Padding，再采用3*3的卷积核，那么变换后的图片尺寸与原图片尺寸相同，如下图所示:
|
||||
|
||||
|
||||
|
||||
|
|
@ -559,7 +559,7 @@ class LayerHelper(object):
|
|||
|
||||
通常情况下，我们希望图片做完卷积操作后保持图片大小不变，所以我们一般会选择尺寸为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，如果两者不相等，可以分开计算，分别补零。
|
||||
注: 这里的width也可换成height，此处是默认正方形的卷积核，weight = height，如果两者不相等，可以分开计算，分别补零。
|
||||
|
||||
* **Flatten层 & Fully Connected Layer**
|
||||
|
||||
|
|
@ -573,7 +573,7 @@ class LayerHelper(object):
|
|||
|
||||
* **小结**
|
||||
|
||||
这一节我们介绍了最基本的卷积神经网络的基本层的定义，计算方式和起的作用。有几个小问题可以供大家思考一下：
|
||||
这一节我们介绍了最基本的卷积神经网络的基本层的定义，计算方式和起的作用。有几个小问题可以供大家思考一下:
|
||||
|
||||
1.卷积核的尺寸必须为正方形吗？可以为长方形吗？如果是长方形应该怎么计算？
|
||||
|
||||
|
|
@ -581,9 +581,9 @@ class LayerHelper(object):
|
|||
|
||||
3.步长的向右和向下移动的幅度必须是一样的吗？
|
||||
|
||||
如果对上面的讲解真的弄懂了的话，其实这几个问题并不难回答。下面给出我的想法，可以作为参考：
|
||||
如果对上面的讲解真的弄懂了的话，其实这几个问题并不难回答。下面给出我的想法，可以作为参考:
|
||||
|
||||
1.卷积核的尺寸不一定非得为正方形。长方形也可以，只不过通常情况下为正方形。如果要设置为长方形，那么首先得保证这层的输出形状是整数，不能是小数。如果你的图像是边长为 28 的正方形。那么卷积层的输出就满足 [ (28 - kernel_size)/ stride ] + 1 ，这个数值得是整数才行，否则没有物理意义。譬如，你算得一个边长为 3.6 的 feature map 是没有物理意义的。 pooling 层同理。FC 层的输出形状总是满足整数，其唯一的要求就是整个训练过程中 FC 层的输入得是定长的。如果你的图像不是正方形。那么在制作数据时，可以缩放到统一大小（非正方形），再使用非正方形的 kernel_size 来使得卷积层的输出依然是整数。总之，撇开网络结果设定的好坏不谈，其本质上就是在做算术应用题：如何使得各层的输出是整数。
|
||||
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”的数字，你看到这个特征，能推测是什么数字呢？只有越往后，检测识别的特征越多，试过能识别这几个特征，那么我就能够确定这个数字是“0”。
|
||||
|
|
@ -624,22 +624,22 @@ def convolutional_neural_network_org(img):
|
|||
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的概率。
|
||||
|
||||
那么这个时候我考虑的问题是，既然上面我们已经了解了卷积核，改变卷积核的大小是否会对我的结果造成影响？增多卷积核的数目能够提高准确率？于是我做了个实验：
|
||||
那么这个时候我考虑的问题是，既然上面我们已经了解了卷积核，改变卷积核的大小是否会对我的结果造成影响？增多卷积核的数目能够提高准确率？于是我做了个实验:
|
||||
|
||||
|
||||
|
||||
* 第一次改进：仅改变第一层与第二层的卷积核数目的大小，其他保持不变。可以看到结果提升了0.06%
|
||||
* 第二次改进：保持3*3的卷积核大小，仅改变第二层的卷积核数目，其他保持不变，可以看到结果相较于原始参数提升了0.08%
|
||||
* 第一次改进: 仅改变第一层与第二层的卷积核数目的大小，其他保持不变。可以看到结果提升了0.06%
|
||||
* 第二次改进: 保持3*3的卷积核大小，仅改变第二层的卷积核数目，其他保持不变，可以看到结果相较于原始参数提升了0.08%
|
||||
|
||||
由以上结果可以看出，改变卷积核的大小与卷积核的数目会对结果产生一定影响，在目前手写数字识别的项目中，缩小卷积核尺寸，增加卷积核数目都会提高准确率。不过以上实验只是一个小测试，有兴趣的同学可以多做几次实验，看看参数带来的具体影响，下篇文章我们会着重分析参数的影响。
|
||||
|
||||
这篇文章主要介绍了神经网络的预备知识，卷积神经网络的常见的层及基本的计算过程，看完后希望大家明白以下几个知识点：
|
||||
这篇文章主要介绍了神经网络的预备知识，卷积神经网络的常见的层及基本的计算过程，看完后希望大家明白以下几个知识点:
|
||||
|
||||
> * 为什么卷积神经网络更适合于图像分类？相比于传统的神经网络优势在哪里？
|
||||
> * 卷积层中的卷积过程是如何计算的？为什么卷积核是有效的？
|
||||
|
|
@ -648,7 +648,7 @@ def convolutional_neural_network_org(img):
|
|||
> * 为什么要采用池化层，Max Pooling有什么好处？
|
||||
> * Zero Padding有什么作用？如果已知一个feature map的尺寸，如何确定zero padding的数目？
|
||||
|
||||
上面的问题，有些在文章中已经详细讲过，有些大家可以根据文章的内容多思考一下。最后给大家留几个问题思考一下：
|
||||
上面的问题，有些在文章中已经详细讲过，有些大家可以根据文章的内容多思考一下。最后给大家留几个问题思考一下:
|
||||
|
||||
> * 为什么改变卷积核的大小能够提高结果的准确率？卷积核大小对于分类结果是如何影响的？
|
||||
> * 卷积核的参数是怎么求的？一开始随机定义一个，那么后来是如何训练才能使这个卷积核识别某些特定的特征呢？
|
||||
|
|
@ -656,7 +656,7 @@ def convolutional_neural_network_org(img):
|
|||
|
||||
|
||||
|
||||
下篇文章我们会着重讲解以下几点：
|
||||
下篇文章我们会着重讲解以下几点:
|
||||
|
||||
> * 卷积核的参数如何确定？随机初始化一个数值后，是如何训练得到一个能够识别某些特征的卷积核的？
|
||||
> * CNN是如何进行反向传播的？
|
||||
|
|
@ -664,10 +664,10 @@ def convolutional_neural_network_org(img):
|
|||
> * 如何设计最适合的CNN网络结构？
|
||||
> * 能够不用调用框架的api，手写一个CNN，并和paddlepaddle里的实现过程做对比，看看有哪些可以改进的？
|
||||
|
||||
ps：本篇文章是基于个人对CNN的理解来写的，本人能力有限，有些地方可能写的不是很严谨，如有错误或疏漏之处，请留言给我，我一定会仔细核实并修改的^_^！不接受无脑喷哦~此外，文中的图表结构均为自己所做，希望不要被人随意抄袭，可以进行非商业性质的转载，需要转载留言或发邮件即可，希望能够尊重劳动成果，谢谢！有不懂的也请留言给我，我会尽力解答的哈~
|
||||
ps: 本篇文章是基于个人对CNN的理解来写的，本人能力有限，有些地方可能写的不是很严谨，如有错误或疏漏之处，请留言给我，我一定会仔细核实并修改的^_^！不接受无脑喷哦~此外，文中的图表结构均为自己所做，希望不要被人随意抄袭，可以进行非商业性质的转载，需要转载留言或发邮件即可，希望能够尊重劳动成果，谢谢！有不懂的也请留言给我，我会尽力解答的哈~
|
||||
|
||||
---
|
||||
|
||||
* 作者：Charlotte77
|
||||
* 出处：http://www.cnblogs.com/charlotte77/
|
||||
* 作者: Charlotte77
|
||||
* 出处: http://www.cnblogs.com/charlotte77/
|
||||
* 本文以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，非商业用途！
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
# 长短期记忆网络（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能够记住长期的信息。
|
||||
**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能够记住长期的信息。
|
||||
|
||||
 vs 
|
||||
|
||||
|
|
@ -15,12 +15,12 @@
|
|||
|
||||
**在LSTM中，第一阶段是遗忘门，遗忘层决定哪些信息需要从细胞状态中被遗忘，下一阶段是输入门，输入门确定哪些新信息能够被存放到细胞状态中，最后一个阶段是输出门，输出门确定输出什么值**。下面我们把LSTM就着各个门的子结构和数学表达式进行分析。
|
||||
|
||||
* 遗忘门：遗忘门是以上一层的输出和本层要输入的序列数据作为输入，通过一个激活函数sigmoid，得到输出为。的输出取值在[0,1]区间，表示上一层细胞状态被遗忘的概率，1是“完全保留”，0是“完全舍弃”
|
||||
* 遗忘门: 遗忘门是以上一层的输出和本层要输入的序列数据作为输入，通过一个激活函数sigmoid，得到输出为。的输出取值在[0,1]区间，表示上一层细胞状态被遗忘的概率，1是“完全保留”，0是“完全舍弃”
|
||||
|
||||
|
||||
|
||||
|
||||
* 输入门：输入门包含两个部分，第一部分使用sigmoid激活函数，输出为，第二部分使用tanh激活函数，输出为。**【个人通俗理解：在RNN网络中就是本层的输出，是在[0,1]区间取值，表示中的信息被保留的程度，表示该层被保留的新信息】**
|
||||
* 输入门: 输入门包含两个部分，第一部分使用sigmoid激活函数，输出为，第二部分使用tanh激活函数，输出为。**【个人通俗理解: 在RNN网络中就是本层的输出，是在[0,1]区间取值，表示中的信息被保留的程度，表示该层被保留的新信息】**
|
||||
|
||||
|
||||
|
||||
|
|
@ -30,7 +30,7 @@
|
|||
|
||||
|
||||
|
||||
* 输出门：输出门用来控制该层的细胞状态有多少被过滤。首先使用sigmoid激活函数得到一个[0,1]区间取值的，接着将细胞状态通过tanh激活函数处理后与相乘，即是本层的输出。
|
||||
* 输出门: 输出门用来控制该层的细胞状态有多少被过滤。首先使用sigmoid激活函数得到一个[0,1]区间取值的，接着将细胞状态通过tanh激活函数处理后与相乘，即是本层的输出。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -6,26 +6,26 @@
|
|||
|
||||
循环神经网络的应用场景比较多，比如暂时能写论文，写程序，写诗，但是，（总是会有但是的），但是他们现在还不能正常使用，学习出来的东西没有逻辑，所以要想真正让它更有用，路还很远。
|
||||
|
||||
这是一般的神经网络应该有的结构：
|
||||
这是一般的神经网络应该有的结构:
|
||||
|
||||
|
||||
既然我们已经有了人工神经网络和卷积神经网络，为什么还要循环神经网络？
|
||||
原因很简单，无论是卷积神经网络，还是人工神经网络，他们的前提假设都是：元素之间是相互独立的，**输入与输出也是独立的**，比如猫和狗。
|
||||
但现实世界中，很多元素都是相互连接的，比如股票随时间的变化，一个人说了：我喜欢旅游，其中最喜欢的地方是云南，以后有机会一定要去___这里填空，人应该都知道是填“云南“。因为我们是根据上下文的内容推断出来的，但机会要做到这一步就相当得难了。因此，就有了现在的循环神经网络，他的本质是**：像人一样拥有记忆的能力。**因此，他的输出就依赖于当前的输入和记忆。
|
||||
原因很简单，无论是卷积神经网络，还是人工神经网络，他们的前提假设都是: 元素之间是相互独立的，**输入与输出也是独立的**，比如猫和狗。
|
||||
但现实世界中，很多元素都是相互连接的，比如股票随时间的变化，一个人说了: 我喜欢旅游，其中最喜欢的地方是云南，以后有机会一定要去___这里填空，人应该都知道是填“云南“。因为我们是根据上下文的内容推断出来的，但机会要做到这一步就相当得难了。因此，就有了现在的循环神经网络，他的本质是**: 像人一样拥有记忆的能力。**因此，他的输出就依赖于当前的输入和记忆。
|
||||
|
||||
## 2.RNN的网络结构及原理
|
||||
|
||||
它的网络结构如下：
|
||||
它的网络结构如下:
|
||||
|
||||
其中每个圆圈可以看作是一个单元，而且每个单元做的事情也是一样的，因此可以折叠呈左半图的样子。用一句话解释RNN，就是**一个单元结构重复使用**。
|
||||
|
||||
RNN是一个序列到序列的模型，假设是一个输入：“我是中国“，那么就应该对应”是”，”中国”这两个，预测下一个词最有可能是什么？就是应该是”人”的概率比较大。
|
||||
RNN是一个序列到序列的模型，假设是一个输入: “我是中国“，那么就应该对应”是”，”中国”这两个，预测下一个词最有可能是什么？就是应该是”人”的概率比较大。
|
||||
|
||||
因此，我们可以做这样的定义：
|
||||
因此，我们可以做这样的定义:
|
||||
|
||||
|
||||
|
||||
。因为我们当前时刻的输出是由记忆和当前时刻的输入决定的，就像你现在大四，你的知识是由大四学到的知识（当前输入）和大三以及大三以前学到的东西的（记忆）的结合，RNN在这点上也类似，神经网络最擅长做的就是通过一系列参数把很多内容整合到一起，然后学习这个参数，因此就定义了RNN的基础：
|
||||
。因为我们当前时刻的输出是由记忆和当前时刻的输入决定的，就像你现在大四，你的知识是由大四学到的知识（当前输入）和大三以及大三以前学到的东西的（记忆）的结合，RNN在这点上也类似，神经网络最擅长做的就是通过一系列参数把很多内容整合到一起，然后学习这个参数，因此就定义了RNN的基础:
|
||||
|
||||
|
||||
|
||||
|
|
@ -40,16 +40,16 @@ RNN是一个序列到序列的模型，假设就表示时刻t的输出。
|
||||
|
||||
RNN中的结构细节：
|
||||
RNN中的结构细节:
|
||||
1.可以把St当作隐状态，捕捉了之前时间点上的信息。就像你去考研一样，考的时候记住了你能记住的所有信息。
|
||||
2.Ot是由当前时间以及之前所有的记忆得到的。就是你考研之后做的考试卷子，是用你的记忆得到的。
|
||||
3.很可惜的是，St并不能捕捉之前所有时间点的信息。就像你考研不能记住所有的英语单词一样。
|
||||
4.和卷积神经网络一样，这里的网络中每个cell都共享了一组参数（U，V，W）,这样就能极大的降低计算量了。
|
||||
5.Ot在很多情况下都是不存在的，因为很多任务，比如文本情感分析，都是只关注最后的结果的。就像考研之后选择学校，学校不会管你到底怎么努力，怎么心酸的准备考研，而只关注你最后考了多少分。
|
||||
|
||||
## 3.RNN的改进1：双向RNN
|
||||
## 3.RNN的改进1: 双向RNN
|
||||
|
||||
在有些情况，比如有一部电视剧，在第三集的时候才出现的人物，现在让预测一下在第三集中出现的人物名字，你用前面两集的内容是预测不出来的，所以你需要用到第四，第五集的内容来预测第三集的内容，这就是双向RNN的想法。如图是双向RNN的图解：
|
||||
在有些情况，比如有一部电视剧，在第三集的时候才出现的人物，现在让预测一下在第三集中出现的人物名字，你用前面两集的内容是预测不出来的，所以你需要用到第四，第五集的内容来预测第三集的内容，这就是双向RNN的想法。如图是双向RNN的图解:
|
||||
|
||||
|
||||
|
||||
|
|
@ -57,7 +57,7 @@ RNN中的结构细节：
|
|||
|
||||
双向RNN需要的内存是单向RNN的两倍，因为在同一时间点，双向RNN需要保存两个方向上的权重参数，在分类的时候，需要同时输入两个隐藏层输出的信息。
|
||||
|
||||
## 4.RNN的改进2：深层双向RNN
|
||||
## 4.RNN的改进2: 深层双向RNN
|
||||
|
||||
深层双向RNN 与双向RNN相比，多了几个隐藏层，因为他的想法是很多信息记一次记不下来，比如你去考研，复习考研英语的时候，背英语单词一定不会就看一次就记住了所有要考的考研单词吧，你应该也是带着先前几次背过的单词，然后选择那些背过，但不熟的内容，或者没背过的单词来背吧。
|
||||
|
||||
|
|
@ -66,12 +66,12 @@ RNN中的结构细节：
|
|||
|
||||
我们用公式来表示是这样的:
|
||||
|
||||
然后再利用最后一层来进行分类，分类公式如下：
|
||||
然后再利用最后一层来进行分类，分类公式如下:
|
||||
|
||||
|
||||
### 4.1 Pyramidal RNN
|
||||
|
||||
其他类似的网络还有Pyramidal RNN：
|
||||
其他类似的网络还有Pyramidal RNN:
|
||||
|
||||
我们现在有一个很长的输入序列，可以看到这是一个双向的RNN，上图是谷歌的W.Chan做的一个测试，它原先要做的是语音识别，他要用序列到序列的模型做语音识别，序列到序列就是说，输入一个序列然后就输出一个序列。
|
||||
|
||||
|
|
@ -82,61 +82,61 @@ RNN中的结构细节：
|
|||
|
||||
## 5.RNN的训练-BPTT
|
||||
|
||||
如前面我们讲的，如果要预测t时刻的输出，我们必须先利用上一时刻（t-1）的记忆和当前时刻的输入，得到t时刻的记忆：
|
||||
如前面我们讲的，如果要预测t时刻的输出，我们必须先利用上一时刻（t-1）的记忆和当前时刻的输入，得到t时刻的记忆:
|
||||
|
||||
|
||||
|
||||
然后利用当前时刻的记忆，通过softmax分类器输出每个词出现的概率：
|
||||
然后利用当前时刻的记忆，通过softmax分类器输出每个词出现的概率:
|
||||
|
||||
|
||||
|
||||
为了找出模型最好的参数，U，W，V，我们就要知道当前参数得到的结果怎么样，因此就要定义我们的损失函数，用交叉熵损失函数：
|
||||
为了找出模型最好的参数，U，W，V，我们就要知道当前参数得到的结果怎么样，因此就要定义我们的损失函数，用交叉熵损失函数:
|
||||
|
||||
|
||||
|
||||
其中
|
||||
t时刻的标准答案，是一个只有一个是1，其他都是0的向量； 是我们预测出来的结果，与
|
||||
的维度一样，但它是一个概率向量，里面是每个词出现的概率。因为对结果的影响，肯定不止一个时刻，因此需要把所有时刻的造成的损失都加起来：
|
||||
的维度一样，但它是一个概率向量，里面是每个词出现的概率。因为对结果的影响，肯定不止一个时刻，因此需要把所有时刻的造成的损失都加起来:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
如图所示，你会发现每个cell都会有一个损失，我们已经定义好了损失函数，接下来就是熟悉的一步了，那就是根据损失函数利用SGD来求解最优参数，在CNN中使用反向传播BP算法来求解最优参数，但在RNN就要用到BPTT，它和BP算法的本质区别，也是CNN和RNN的本质区别：CNN没有记忆功能，它的输出仅依赖与输入，但RNN有记忆功能，它的输出不仅依赖与当前输入，还依赖与当前的记忆。这个记忆是序列到序列的，也就是当前时刻收到上一时刻的影响，比如股市的变化。
|
||||
如图所示，你会发现每个cell都会有一个损失，我们已经定义好了损失函数，接下来就是熟悉的一步了，那就是根据损失函数利用SGD来求解最优参数，在CNN中使用反向传播BP算法来求解最优参数，但在RNN就要用到BPTT，它和BP算法的本质区别，也是CNN和RNN的本质区别: CNN没有记忆功能，它的输出仅依赖与输入，但RNN有记忆功能，它的输出不仅依赖与当前输入，还依赖与当前的记忆。这个记忆是序列到序列的，也就是当前时刻收到上一时刻的影响，比如股市的变化。
|
||||
|
||||
因此，在对参数求偏导的时候，对当前时刻求偏导，一定会涉及前一时刻，我们用例子看一下：
|
||||
因此，在对参数求偏导的时候，对当前时刻求偏导，一定会涉及前一时刻，我们用例子看一下:
|
||||
|
||||
|
||||
|
||||
假设我们对E3的W求偏导：它的损失首先来源于预测的输出
|
||||
，预测的输出又是来源于当前时刻的记忆s3,当前的记忆又是来源于当前的输出和截止到上一时刻的记忆：
|
||||
假设我们对E3的W求偏导: 它的损失首先来源于预测的输出
|
||||
，预测的输出又是来源于当前时刻的记忆s3,当前的记忆又是来源于当前的输出和截止到上一时刻的记忆: 
|
||||
因此，根据链式法则可以有:
|
||||
|
||||
|
||||
但是，你会发现，
|
||||
，也就是s2里面的函数还包含了W，因此，这个链式法则还没到底，就像图上画的那样，所以真正的链式法则是这样的：
|
||||
，也就是s2里面的函数还包含了W，因此，这个链式法则还没到底，就像图上画的那样，所以真正的链式法则是这样的:
|
||||
|
||||
我们要把当前时刻造成的损失，和以往每个时刻造成的损失加起来，因为我们每一个时刻都用到了权重参数W。和以往的网络不同，一般的网络，比如人工神经网络，参数是不同享的，但在循环神经网络，和CNN一样，设立了参数共享机制，来降低模型的计算量。
|
||||
|
||||
## 6.RNN与CNN的结合应用：看图说话
|
||||
## 6.RNN与CNN的结合应用: 看图说话
|
||||
|
||||
在图像处理中，目前做的最好的是CNN，而自然语言处理中，表现比较好的是RNN，因此，我们能否把他们结合起来，一起用呢？那就是看图说话了，这个原理也比较简单，举个小栗子：假设我们有CNN的模型训练了一个网络结构，比如是这个
|
||||
在图像处理中，目前做的最好的是CNN，而自然语言处理中，表现比较好的是RNN，因此，我们能否把他们结合起来，一起用呢？那就是看图说话了，这个原理也比较简单，举个小栗子: 假设我们有CNN的模型训练了一个网络结构，比如是这个
|
||||
|
||||
|
||||
|
||||
最后我们不是要分类嘛，那在分类前，是不是已经拿到了图像的特征呀，那我们能不能把图像的特征拿出来，放到RNN的输入里，让他学习呢？
|
||||
|
||||
之前的RNN是这样的：
|
||||
之前的RNN是这样的:
|
||||
|
||||
|
||||
|
||||
我们把图像的特征加在里面，可以得到：
|
||||
我们把图像的特征加在里面，可以得到:
|
||||
|
||||
|
||||
|
||||
其中的X就是图像的特征。如果用的是上面的CNN网络，X应该是一个4096X1的向量。
|
||||
|
||||
注：这个公式只在第一步做，后面每次更新就没有V了，因为给RNN数据只在第一次迭代的时候给。
|
||||
注: 这个公式只在第一步做，后面每次更新就没有V了，因为给RNN数据只在第一次迭代的时候给。
|
||||
|
||||
## 7.RNN项目练手
|
||||
|
||||
|
|
|
|||
|
|
@ -1,26 +1,26 @@
|
|||
# 反向传递
|
||||
|
||||
> 建议：一定要看懂推导过程
|
||||
> 建议: 一定要看懂推导过程
|
||||
|
||||
# [一文弄懂神经网络中的反向传播法——BackPropagation](https://www.cnblogs.com/charlotte77/p/5629865.html)
|
||||
|
||||
最近在看深度学习的东西，一开始看的吴恩达的UFLDL教程，有中文版就直接看了，后来发现有些地方总是不是很明确，又去看英文版，然后又找了些资料看，才发现，中文版的译者在翻译的时候会对省略的公式推导过程进行补充，但是补充的又是错的，难怪觉得有问题。反向传播法其实是神经网络的基础了，但是很多人在学的时候总是会遇到一些问题，或者看到大篇的公式觉得好像很难就退缩了，其实不难，就是一个链式求导法则反复用。如果不想看公式，可以直接把数值带进去，实际的计算一下，体会一下这个过程之后再来推导公式，这样就会觉得很容易了。
|
||||
|
||||
说到神经网络，大家看到这个图应该不陌生：
|
||||
说到神经网络，大家看到这个图应该不陌生:
|
||||
|
||||
|
||||
|
||||
这是典型的三层神经网络的基本构成，Layer L1是输入层，Layer L2是隐含层，Layer L3是隐含层，我们现在手里有一堆数据{x1,x2,x3,...,xn},输出也是一堆数据{y1,y2,y3,...,yn},现在要他们在隐含层做某种变换，让你把数据灌进去后得到你期望的输出。如果你希望你的输出和原始输入一样，那么就是最常见的自编码模型（Auto-Encoder）。可能有人会问，为什么要输入输出都一样呢？有什么用啊？其实应用挺广的，在图像识别，文本分类等等都会用到，我会专门再写一篇Auto-Encoder的文章来说明，包括一些变种之类的。如果你的输出和原始输入不一样，那么就是很常见的人工神经网络了，相当于让原始数据通过一个映射来得到我们想要的输出数据，也就是我们今天要讲的话题。
|
||||
|
||||
本文直接举一个例子，带入数值演示反向传播法的过程，公式的推导等到下次写Auto-Encoder的时候再写，其实也很简单，感兴趣的同学可以自己推导下试试：）（注：本文假设你已经懂得基本的神经网络构成，如果完全不懂，可以参考Poll写的笔记：[[Mechine Learning & Algorithm] 神经网络基础](http://www.cnblogs.com/maybe2030/p/5597716.html)）
|
||||
本文直接举一个例子，带入数值演示反向传播法的过程，公式的推导等到下次写Auto-Encoder的时候再写，其实也很简单，感兴趣的同学可以自己推导下试试: ）（注: 本文假设你已经懂得基本的神经网络构成，如果完全不懂，可以参考Poll写的笔记: [[Mechine Learning & Algorithm] 神经网络基础](http://www.cnblogs.com/maybe2030/p/5597716.html)）
|
||||
|
||||
假设，你有这样一个网络层：
|
||||
假设，你有这样一个网络层:
|
||||
|
||||
|
||||
|
||||
第一层是输入层，包含两个神经元i1，i2，和截距项b1；第二层是隐含层，包含两个神经元h1,h2和截距项b2，第三层是输出o1,o2，每条线上标的wi是层与层之间连接的权重，激活函数我们默认为sigmoid函数。
|
||||
|
||||
现在对他们赋上初值，如下图：
|
||||
现在对他们赋上初值，如下图:
|
||||
|
||||
|
||||
|
||||
|
|
@ -32,27 +32,27 @@
|
|||
|
||||
w5=0.40,w6=0.45,w7=0.50,w8=0.55
|
||||
|
||||
目标：给出输入数据i1,i2(0.05和0.10)，使输出尽可能与原始输出o1,o2(0.01和0.99)接近。
|
||||
目标: 给出输入数据i1,i2(0.05和0.10)，使输出尽可能与原始输出o1,o2(0.01和0.99)接近。
|
||||
|
||||
**Step 1 前向传播**
|
||||
|
||||
1.输入层---->隐含层：
|
||||
1.输入层---->隐含层:
|
||||
|
||||
计算神经元h1的输入加权和：
|
||||
计算神经元h1的输入加权和:
|
||||
|
||||
|
||||
|
||||
神经元h1的输出o1:(此处用到激活函数为sigmoid函数)：
|
||||
神经元h1的输出o1:(此处用到激活函数为sigmoid函数):
|
||||
|
||||
|
||||
|
||||
同理，可计算出神经元h2的输出o2：
|
||||
同理，可计算出神经元h2的输出o2:
|
||||
|
||||
|
||||
|
||||
2.隐含层---->输出层：
|
||||
2.隐含层---->输出层:
|
||||
|
||||
计算输出层神经元o1和o2的值：
|
||||
计算输出层神经元o1和o2的值:
|
||||
|
||||
|
||||
|
||||
|
|
@ -64,11 +64,11 @@
|
|||
|
||||
1.计算总误差
|
||||
|
||||
总误差：(square error)
|
||||
总误差: (square error)
|
||||
|
||||
|
||||
|
||||
但是有两个输出，所以分别计算o1和o2的误差，总误差为两者之和：
|
||||
但是有两个输出，所以分别计算o1和o2的误差，总误差为两者之和:
|
||||
|
||||
|
||||
|
||||
|
|
@ -76,55 +76,55 @@
|
|||
|
||||
|
||||
|
||||
2.隐含层---->输出层的权值更新：
|
||||
2.隐含层---->输出层的权值更新:
|
||||
|
||||
以权重参数w5为例，如果我们想知道w5对整体误差产生了多少影响，可以用整体误差对w5求偏导求出：（链式法则）
|
||||
以权重参数w5为例，如果我们想知道w5对整体误差产生了多少影响，可以用整体误差对w5求偏导求出: （链式法则）
|
||||
|
||||
|
||||
|
||||
下面的图可以更直观的看清楚误差是怎样反向传播的：
|
||||
下面的图可以更直观的看清楚误差是怎样反向传播的:
|
||||
|
||||
|
||||
|
||||
现在我们来分别计算每个式子的值：
|
||||
现在我们来分别计算每个式子的值:
|
||||
|
||||
计算：
|
||||
计算:
|
||||
|
||||
|
||||
|
||||
计算：
|
||||
计算:
|
||||
|
||||
|
||||
|
||||
（这一步实际上就是对sigmoid函数求导，比较简单，可以自己推导一下）
|
||||
|
||||
计算：
|
||||
计算:
|
||||
|
||||
|
||||
|
||||
最后三者相乘：
|
||||
最后三者相乘:
|
||||
|
||||
|
||||
|
||||
这样我们就计算出整体误差E(total)对w5的偏导值。
|
||||
|
||||
回过头来再看看上面的公式，我们发现：
|
||||
回过头来再看看上面的公式，我们发现:
|
||||
|
||||
|
||||
|
||||
为了表达方便，用来表示输出层的误差：
|
||||
为了表达方便，用来表示输出层的误差:
|
||||
|
||||
|
||||
|
||||
因此，整体误差E(total)对w5的偏导公式可以写成：
|
||||
因此，整体误差E(total)对w5的偏导公式可以写成:
|
||||
|
||||
|
||||
|
||||
如果输出层误差计为负的话，也可以写成：
|
||||
如果输出层误差计为负的话，也可以写成:
|
||||
|
||||
|
||||
|
||||
最后我们来更新w5的值：
|
||||
最后我们来更新w5的值:
|
||||
|
||||
|
||||
|
||||
|
|
@ -134,17 +134,17 @@
|
|||
|
||||
|
||||
|
||||
3.隐含层---->隐含层的权值更新：
|
||||
3.隐含层---->隐含层的权值更新:
|
||||
|
||||
方法其实与上面说的差不多，但是有个地方需要变一下，在上文计算总误差对w5的偏导时，是从out(o1)---->net(o1)---->w5,但是在隐含层之间的权值更新时，是out(h1)---->net(h1)---->w1,而out(h1)会接受E(o1)和E(o2)两个地方传来的误差，所以这个地方两个都要计算。
|
||||
|
||||
|
||||
|
||||
计算：
|
||||
计算:
|
||||
|
||||
|
||||
|
||||
先计算：
|
||||
先计算:
|
||||
|
||||
|
||||
|
||||
|
|
@ -154,35 +154,35 @@
|
|||
|
||||
|
||||
|
||||
同理，计算出：
|
||||
同理，计算出:
|
||||
|
||||
|
||||
|
||||
两者相加得到总值：
|
||||
两者相加得到总值:
|
||||
|
||||
|
||||
|
||||
再计算：
|
||||
再计算:
|
||||
|
||||
|
||||
|
||||
再计算：
|
||||
再计算:
|
||||
|
||||
|
||||
|
||||
最后，三者相乘：
|
||||
最后，三者相乘:
|
||||
|
||||
|
||||
|
||||
为了简化公式，用sigma(h1)表示隐含层单元h1的误差：
|
||||
为了简化公式，用sigma(h1)表示隐含层单元h1的误差:
|
||||
|
||||
|
||||
|
||||
最后，更新w1的权值：
|
||||
最后，更新w1的权值:
|
||||
|
||||
|
||||
|
||||
同理，额可更新w2,w3,w4的权值：
|
||||
同理，额可更新w2,w3,w4的权值:
|
||||
|
||||
|
||||
|
||||
|
|
@ -197,11 +197,11 @@ import random
|
|||
import math
|
||||
|
||||
#
|
||||
# 参数解释：
|
||||
# "pd_" ：偏导的前缀
|
||||
# "d_" ：导数的前缀
|
||||
# "w_ho" ：隐含层到输出层的权重系数索引
|
||||
# "w_ih" ：输入层到隐含层的权重系数的索引
|
||||
# 参数解释:
|
||||
# "pd_" : 偏导的前缀
|
||||
# "d_" : 导数的前缀
|
||||
# "w_ho" : 隐含层到输出层的权重系数索引
|
||||
# "w_ih" : 输入层到隐含层的权重系数的索引
|
||||
|
||||
class NeuralNetwork:
|
||||
LEARNING_RATE = 0.5
|
||||
|
|
@ -396,17 +396,17 @@ for i in range(10000):
|
|||
# print(i, nn.calculate_total_error(training_sets))
|
||||
```
|
||||
|
||||
最后写到这里就结束了，现在还不会用latex编辑数学公式，本来都直接想写在草稿纸上然后扫描了传上来，但是觉得太影响阅读体验了。以后会用公式编辑器后再重把公式重新编辑一遍。稳重使用的是sigmoid激活函数，实际还有几种不同的激活函数可以选择，具体的可以参考文献[3]，最后推荐一个在线演示神经网络变化的网址：http://www.emergentmind.com/neural-network，可以自己填输入输出，然后观看每一次迭代权值的变化，很好玩~如果有错误的或者不懂的欢迎留言：）
|
||||
最后写到这里就结束了，现在还不会用latex编辑数学公式，本来都直接想写在草稿纸上然后扫描了传上来，但是觉得太影响阅读体验了。以后会用公式编辑器后再重把公式重新编辑一遍。稳重使用的是sigmoid激活函数，实际还有几种不同的激活函数可以选择，具体的可以参考文献[3]，最后推荐一个在线演示神经网络变化的网址: http://www.emergentmind.com/neural-network，可以自己填输入输出，然后观看每一次迭代权值的变化，很好玩~如果有错误的或者不懂的欢迎留言: ）
|
||||
|
||||
参考文献：
|
||||
参考文献:
|
||||
|
||||
1. Poll的笔记：[[Mechine Learning & Algorithm] 神经网络基础](http://www.cnblogs.com/maybe2030/p/5597716.html)（http://www.cnblogs.com/maybe2030/p/5597716.html#3457159 ）
|
||||
1. Poll的笔记: [[Mechine Learning & Algorithm] 神经网络基础](http://www.cnblogs.com/maybe2030/p/5597716.html)（http://www.cnblogs.com/maybe2030/p/5597716.html#3457159 ）
|
||||
2. Rachel_Zhang:http://blog.csdn.net/abcjennifer/article/details/7758797
|
||||
3. http://www.cedar.buffalo.edu/%7Esrihari/CSE574/Chap5/Chap5.3-BackProp.pdf
|
||||
4. https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/
|
||||
|
||||
---
|
||||
|
||||
* 作者：Charlotte77
|
||||
* 出处：http://www.cnblogs.com/charlotte77/
|
||||
* 作者: Charlotte77
|
||||
* 出处: http://www.cnblogs.com/charlotte77/
|
||||
* 本文以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，非商业用途！
|
||||
|
|
|
|||
|
|
@ -2,21 +2,21 @@
|
|||
|
||||
## 线性回归
|
||||
|
||||
令 $z = w^T x + b$，得到：
|
||||
令 $z = w^T x + b$，得到:
|
||||
|
||||
$y = z + \epsilon, \, \epsilon \sim N(0, \sigma^2)$
|
||||
|
||||
于是：
|
||||
于是:
|
||||
|
||||
$y|x \sim N(z, \sigma^2)$
|
||||
|
||||
为啥是 $y|x$，因为判别模型的输出只能是 $y|x$。
|
||||
|
||||
它的概率密度函数：
|
||||
它的概率密度函数:
|
||||
|
||||
$f_{Y|X}(y)=\frac{1}{\sqrt{2 \pi} \sigma} \exp(\frac{-(y -z)^2}{2\sigma^2}) \\ = A \exp(-B (y - z)^2), \, A, B > 0$
|
||||
|
||||
计算损失函数：
|
||||
计算损失函数:
|
||||
|
||||
$L = -\sum_i \log f_{Y|X}(y^{(i)}) \\ = -\sum_i(\log A - B(y^{(i)} - z^{(i)})^2) \\ = B \sum_i(y^{(i)} - z^{(i)})^2 + C$
|
||||
|
||||
|
|
@ -24,21 +24,21 @@ $L = -\sum_i \log f_{Y|X}(y^{(i)}) \\ = -\sum_i(\log A - B(y^{(i)} - z^{(i)})^2)
|
|||
|
||||
## 逻辑回归
|
||||
|
||||
令 $z = w^T x + b, a = \sigma(z)$，我们观察到在假设中：
|
||||
令 $z = w^T x + b, a = \sigma(z)$，我们观察到在假设中:
|
||||
|
||||
$P(y=1|x) = a \\ P(y=0|x) = 1 - a$
|
||||
|
||||
也就是说：
|
||||
也就是说:
|
||||
|
||||
$y|x \sim B(1, a)$
|
||||
|
||||
> 其实任何二分类器的输出都是伯努利分布。因为变量只能取两个值，加起来得一，所以只有一种分布。
|
||||
|
||||
它的概率质量函数（因为是离散分布，只有概率质量函数，不过无所谓）：
|
||||
它的概率质量函数（因为是离散分布，只有概率质量函数，不过无所谓）:
|
||||
|
||||
$p_{Y|X}(y) = a^y(1-a)^{1-y}$
|
||||
|
||||
然后计算损失函数：
|
||||
然后计算损失函数:
|
||||
|
||||
$L = -\sum_i \log p_{Y|X}(y^{(i)}) \\ = -\sum_i(y^{(i)} \log a^{(i)} + (1-y^{(i)})\log(1-a^{(i)}))$
|
||||
|
||||
|
|
|
|||
|
|
@ -12,15 +12,15 @@
|
|||
|
||||
## 机器学习 研究意义
|
||||
|
||||
机器学习是一门人工智能的科学，该领域的主要研究对象是人工智能，特别是如何在经验学习中改善具体算法的性能”。 “机器学习是对能通过经验自动改进的计算机算法的研究”。 “机器学习是用数据或以往的经验，以此优化计算机程序的性能标准。” 一种经常引用的英文定义是：A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.
|
||||
机器学习是一门人工智能的科学，该领域的主要研究对象是人工智能，特别是如何在经验学习中改善具体算法的性能”。 “机器学习是对能通过经验自动改进的计算机算法的研究”。 “机器学习是用数据或以往的经验，以此优化计算机程序的性能标准。” 一种经常引用的英文定义是: A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.
|
||||
|
||||
机器学习已经有了十分广泛的应用，例如：数据挖掘、计算机视觉、自然语言处理、生物特征识别、搜索引擎、医学诊断、检测信用卡欺诈、证券市场分析、DNA序列测序、语音和手写识别、战略游戏和机器人运用。
|
||||
机器学习已经有了十分广泛的应用，例如: 数据挖掘、计算机视觉、自然语言处理、生物特征识别、搜索引擎、医学诊断、检测信用卡欺诈、证券市场分析、DNA序列测序、语音和手写识别、战略游戏和机器人运用。
|
||||
## 机器学习 场景
|
||||
|
||||
* 例如：识别动物猫
|
||||
* 模式识别（官方标准）：人们通过大量的经验，得到结论，从而判断它就是猫。
|
||||
* 机器学习（数据学习）：人们通过阅读进行学习，观察它会叫、小眼睛、两只耳朵、四条腿、一条尾巴，得到结论，从而判断它就是猫。
|
||||
* 深度学习（深入数据）：人们通过深入了解它，发现它会'喵喵'的叫、与同类的猫科动物很类似，得到结论，从而判断它就是猫。（深度学习常用领域：语音识别、图像识别）
|
||||
* 例如: 识别动物猫
|
||||
* 模式识别（官方标准）: 人们通过大量的经验，得到结论，从而判断它就是猫。
|
||||
* 机器学习（数据学习）: 人们通过阅读进行学习，观察它会叫、小眼睛、两只耳朵、四条腿、一条尾巴，得到结论，从而判断它就是猫。
|
||||
* 深度学习（深入数据）: 人们通过深入了解它，发现它会'喵喵'的叫、与同类的猫科动物很类似，得到结论，从而判断它就是猫。（深度学习常用领域: 语音识别、图像识别）
|
||||
|
||||
* 模式识别（pattern recognition）: 模式识别是最古老的（作为一个术语而言，可以说是很过时的）。
|
||||
* 我们把环境与客体统称为“模式”，识别是对模式的一种认知，是如何让一个计算机程序去做一些看起来很“智能”的事情。
|
||||
|
|
@ -32,12 +32,12 @@
|
|||
* 深度学习（deep learning）: 深度学习是非常崭新和有影响力的前沿领域，我们甚至不会去思考-后深度学习时代。
|
||||
* 深度学习是机器学习研究中的一个新的领域，其动机在于建立、模拟人脑进行分析学习的神经网络，它模仿人脑的机制来解释数据，例如图像，声音和文本。
|
||||
|
||||
* 参考地址：
|
||||
* 参考地址:
|
||||
* [深度学习 vs 机器学习 vs 模式识别](http://www.csdn.net/article/2015-03-24/2824301)
|
||||
* [深度学习 百科资料](http://baike.baidu.com/link?url=76P-uA4EBrC3G-I__P1tqeO7eoDS709Kp4wYuHxc7GNkz_xn0NxuAtEohbpey7LUa2zUQLJxvIKUx4bnrEfOmsWLKbDmvG1PCoRkJisMTQka6-QReTrIxdYY3v93f55q)
|
||||
|
||||
|
||||
> 机器学习已应用于多个领域，远远超出大多数人的想象，横跨：计算机科学、工程技术和统计学等多个学科。
|
||||
> 机器学习已应用于多个领域，远远超出大多数人的想象，横跨: 计算机科学、工程技术和统计学等多个学科。
|
||||
|
||||
* 搜索引擎: 根据你的搜索点击，优化你下次的搜索结果,是机器学习来帮助搜索引擎判断哪个结果更适合你（也判断哪个广告更适合你）。
|
||||
* 垃圾邮件: 会自动的过滤垃圾广告邮件到垃圾箱内。
|
||||
|
|
@ -50,37 +50,37 @@
|
|||
|
||||
### 主要任务
|
||||
|
||||
* 分类（classification）：将实例数据划分到合适的类别中。
|
||||
* 应用实例：判断网站是否被黑客入侵（二分类 ），手写数字的自动识别（多分类）
|
||||
* 回归（regression）：主要用于预测数值型数据。
|
||||
* 应用实例：股票价格波动的预测，房屋价格的预测等。
|
||||
* 分类（classification）: 将实例数据划分到合适的类别中。
|
||||
* 应用实例: 判断网站是否被黑客入侵（二分类 ），手写数字的自动识别（多分类）
|
||||
* 回归（regression）: 主要用于预测数值型数据。
|
||||
* 应用实例: 股票价格波动的预测，房屋价格的预测等。
|
||||
|
||||
### 监督学习（supervised learning）
|
||||
|
||||
* 必须确定目标变量的值，以便机器学习算法可以发现特征和目标变量之间的关系。在监督学习中，给定一组数据，我们知道正确的输出结果应该是什么样子，并且知道在输入和输出之间有着一个特定的关系。 (包括：分类和回归)
|
||||
* 样本集：训练数据 + 测试数据
|
||||
* 必须确定目标变量的值，以便机器学习算法可以发现特征和目标变量之间的关系。在监督学习中，给定一组数据，我们知道正确的输出结果应该是什么样子，并且知道在输入和输出之间有着一个特定的关系。 (包括: 分类和回归)
|
||||
* 样本集: 训练数据 + 测试数据
|
||||
* 训练样本 = 特征(feature) + 目标变量(label: 分类-离散值/回归-连续值)
|
||||
* 特征通常是训练样本集的列，它们是独立测量得到的。
|
||||
* 目标变量: 目标变量是机器学习预测算法的测试结果。
|
||||
* 在分类算法中目标变量的类型通常是标称型(如：真与假)，而在回归算法中通常是连续型(如：1~100)。
|
||||
* 监督学习需要注意的问题：
|
||||
* 在分类算法中目标变量的类型通常是标称型(如: 真与假)，而在回归算法中通常是连续型(如: 1~100)。
|
||||
* 监督学习需要注意的问题:
|
||||
* 偏置方差权衡
|
||||
* 功能的复杂性和数量的训练数据
|
||||
* 输入空间的维数
|
||||
* 噪声中的输出值
|
||||
* `知识表示`：
|
||||
* 可以采用规则集的形式【例如：数学成绩大于90分为优秀】
|
||||
* 可以采用概率分布的形式【例如：通过统计分布发现，90%的同学数学成绩，在70分以下，那么大于70分定为优秀】
|
||||
* 可以使用训练样本集中的一个实例【例如：通过样本集合，我们训练出一个模型实例，得出 年轻，数学成绩中高等，谈吐优雅，我们认为是优秀】
|
||||
* `知识表示`:
|
||||
* 可以采用规则集的形式【例如: 数学成绩大于90分为优秀】
|
||||
* 可以采用概率分布的形式【例如: 通过统计分布发现，90%的同学数学成绩，在70分以下，那么大于70分定为优秀】
|
||||
* 可以使用训练样本集中的一个实例【例如: 通过样本集合，我们训练出一个模型实例，得出 年轻，数学成绩中高等，谈吐优雅，我们认为是优秀】
|
||||
|
||||
### 非监督学习（unsupervised learing）
|
||||
|
||||
* 在机器学习，无监督学习的问题是，在未加标签的数据中，试图找到隐藏的结构。因为提供给学习者的实例是未标记的，因此没有错误或报酬信号来评估潜在的解决方案。
|
||||
* 无监督学习是密切相关的统计数据密度估计的问题。然而无监督学习还包括寻求，总结和解释数据的主要特点等诸多技术。在无监督学习使用的许多方法是基于用于处理数据的数据挖掘方法。
|
||||
* 数据没有类别信息，也不会给定目标值。
|
||||
* 非监督学习包括的类型：
|
||||
* 聚类：在无监督学习中，将数据集分成由类似的对象组成多个类的过程称为聚类。
|
||||
* 密度估计：通过样本分布的紧密程度，来估计与分组的相似性。
|
||||
* 非监督学习包括的类型:
|
||||
* 聚类: 在无监督学习中，将数据集分成由类似的对象组成多个类的过程称为聚类。
|
||||
* 密度估计: 通过样本分布的紧密程度，来估计与分组的相似性。
|
||||
* 此外，无监督学习还可以减少数据特征的维度，以便我们可以使用二维或三维图形更加直观地展示数据信息。
|
||||
### 强化学习
|
||||
这个算法可以训练程序做出某一决定。程序在某一情况下尝试所有的可能行动，记录不同行动的结果并试着找出最好的一次尝试来做决定。 属于这一类算法的有马尔可夫决策过程。
|
||||
|
|
@ -127,54 +127,54 @@
|
|||
### Python语言
|
||||
|
||||
1. 可执行伪代码
|
||||
2. Python比较流行：使用广泛、代码范例多、丰富模块库，开发周期短
|
||||
3. Python语言的特色：清晰简练、易于理解
|
||||
4. Python语言的缺点：唯一不足的是性能问题
|
||||
2. Python比较流行: 使用广泛、代码范例多、丰富模块库，开发周期短
|
||||
3. Python语言的特色: 清晰简练、易于理解
|
||||
4. Python语言的缺点: 唯一不足的是性能问题
|
||||
5. Python相关的库
|
||||
* 科学函数库：`SciPy`、`NumPy`(底层语言：C和Fortran)
|
||||
* 绘图工具库：`Matplotlib`
|
||||
* 科学函数库: `SciPy`、`NumPy`(底层语言: C和Fortran)
|
||||
* 绘图工具库: `Matplotlib`
|
||||
* 数据分析库 `Pandas`
|
||||
### 数学工具
|
||||
* Matlab
|
||||
## 附：机器学习专业术语
|
||||
* 模型（model）：计算机层面的认知
|
||||
## 附: 机器学习专业术语
|
||||
* 模型（model）: 计算机层面的认知
|
||||
* 学习算法（learning algorithm），从数据中产生模型的方法
|
||||
* 数据集（data set）：一组记录的合集
|
||||
* 示例（instance）：对于某个对象的描述
|
||||
* 样本（sample）：也叫示例
|
||||
* 属性（attribute）：对象的某方面表现或特征
|
||||
* 特征（feature）：同属性
|
||||
* 属性值（attribute value）：属性上的取值
|
||||
* 属性空间（attribute space）：属性张成的空间
|
||||
* 样本空间/输入空间（samplespace）：同属性空间
|
||||
* 特征向量（feature vector）：在属性空间里每个点对应一个坐标向量，把一个示例称作特征向量
|
||||
* 维数（dimensionality）：描述样本参数的个数（也就是空间是几维的）
|
||||
* 学习（learning）/训练（training）：从数据中学得模型
|
||||
* 训练数据（training data）：训练过程中用到的数据
|
||||
* 数据集（data set）: 一组记录的合集
|
||||
* 示例（instance）: 对于某个对象的描述
|
||||
* 样本（sample）: 也叫示例
|
||||
* 属性（attribute）: 对象的某方面表现或特征
|
||||
* 特征（feature）: 同属性
|
||||
* 属性值（attribute value）: 属性上的取值
|
||||
* 属性空间（attribute space）: 属性张成的空间
|
||||
* 样本空间/输入空间（samplespace）: 同属性空间
|
||||
* 特征向量（feature vector）: 在属性空间里每个点对应一个坐标向量，把一个示例称作特征向量
|
||||
* 维数（dimensionality）: 描述样本参数的个数（也就是空间是几维的）
|
||||
* 学习（learning）/训练（training）: 从数据中学得模型
|
||||
* 训练数据（training data）: 训练过程中用到的数据
|
||||
* 训练样本（training sample）:训练用到的每个样本
|
||||
* 训练集（training set）：训练样本组成的集合
|
||||
* 假设（hypothesis）：学习模型对应了关于数据的某种潜在规则
|
||||
* 训练集（training set）: 训练样本组成的集合
|
||||
* 假设（hypothesis）: 学习模型对应了关于数据的某种潜在规则
|
||||
* 真相（ground-truth）:真正存在的潜在规律
|
||||
* 学习器（learner）：模型的另一种叫法，把学习算法在给定数据和参数空间的实例化
|
||||
* 预测（prediction）：判断一个东西的属性
|
||||
* 标记（label）：关于示例的结果信息，比如我是一个“好人”。
|
||||
* 样例（example）：拥有标记的示例
|
||||
* 标记空间/输出空间（label space）：所有标记的集合
|
||||
* 分类（classification）：预测是离散值，比如把人分为好人和坏人之类的学习任务
|
||||
* 回归（regression）：预测值是连续值，比如你的好人程度达到了0.9，0.6之类的
|
||||
* 二分类（binary classification）：只涉及两个类别的分类任务
|
||||
* 正类（positive class）：二分类里的一个
|
||||
* 反类（negative class）：二分类里的另外一个
|
||||
* 多分类（multi-class classification）：涉及多个类别的分类
|
||||
* 测试（testing）：学习到模型之后对样本进行预测的过程
|
||||
* 测试样本（testing sample）：被预测的样本
|
||||
* 聚类（clustering）：把训练集中的对象分为若干组
|
||||
* 簇（cluster）：每一个组叫簇
|
||||
* 监督学习（supervised learning）：典范--分类和回归
|
||||
* 无监督学习（unsupervised learning）：典范--聚类
|
||||
* 未见示例（unseen instance）：“新样本“，没训练过的样本
|
||||
* 泛化（generalization）能力：学得的模型适用于新样本的能力
|
||||
* 分布（distribution）：样本空间的全体样本服从的一种规律
|
||||
* 学习器（learner）: 模型的另一种叫法，把学习算法在给定数据和参数空间的实例化
|
||||
* 预测（prediction）: 判断一个东西的属性
|
||||
* 标记（label）: 关于示例的结果信息，比如我是一个“好人”。
|
||||
* 样例（example）: 拥有标记的示例
|
||||
* 标记空间/输出空间（label space）: 所有标记的集合
|
||||
* 分类（classification）: 预测是离散值，比如把人分为好人和坏人之类的学习任务
|
||||
* 回归（regression）: 预测值是连续值，比如你的好人程度达到了0.9，0.6之类的
|
||||
* 二分类（binary classification）: 只涉及两个类别的分类任务
|
||||
* 正类（positive class）: 二分类里的一个
|
||||
* 反类（negative class）: 二分类里的另外一个
|
||||
* 多分类（multi-class classification）: 涉及多个类别的分类
|
||||
* 测试（testing）: 学习到模型之后对样本进行预测的过程
|
||||
* 测试样本（testing sample）: 被预测的样本
|
||||
* 聚类（clustering）: 把训练集中的对象分为若干组
|
||||
* 簇（cluster）: 每一个组叫簇
|
||||
* 监督学习（supervised learning）: 典范--分类和回归
|
||||
* 无监督学习（unsupervised learning）: 典范--聚类
|
||||
* 未见示例（unseen instance）: “新样本“，没训练过的样本
|
||||
* 泛化（generalization）能力: 学得的模型适用于新样本的能力
|
||||
* 分布（distribution）: 样本空间的全体样本服从的一种规律
|
||||
* 独立同分布（independent and identically distributed，简称i,i,d.）:获得的每个样本都是独立地从这个分布上采样获得的。
|
||||
|
||||
## 机器学习基础补充
|
||||
|
|
@ -187,10 +187,10 @@
|
|||
|
||||
### 模型拟合程度
|
||||
|
||||
* 欠拟合（Underfitting）：模型没有很好地捕捉到数据特征，不能够很好地拟合数据，对训练样本的一般性质尚未学好。类比，光看书不做题觉得自己什么都会了，上了考场才知道自己啥都不会。
|
||||
* 过拟合（Overfitting）：模型把训练样本学习“太好了”，可能把一些训练样本自身的特性当做了所有潜在样本都有的一般性质，导致泛化能力下降。类比，做课后题全都做对了，超纲题也都认为是考试必考题目，上了考场还是啥都不会。
|
||||
* 欠拟合（Underfitting）: 模型没有很好地捕捉到数据特征，不能够很好地拟合数据，对训练样本的一般性质尚未学好。类比，光看书不做题觉得自己什么都会了，上了考场才知道自己啥都不会。
|
||||
* 过拟合（Overfitting）: 模型把训练样本学习“太好了”，可能把一些训练样本自身的特性当做了所有潜在样本都有的一般性质，导致泛化能力下降。类比，做课后题全都做对了，超纲题也都认为是考试必考题目，上了考场还是啥都不会。
|
||||
|
||||
通俗来说，欠拟合和过拟合都可以用一句话来说，欠拟合就是：“你太天真了！”，过拟合就是：“你想太多了！”。
|
||||
通俗来说，欠拟合和过拟合都可以用一句话来说，欠拟合就是: “你太天真了！”，过拟合就是: “你想太多了！”。
|
||||
|
||||
### 常见的模型指标
|
||||
|
||||
|
|
@ -198,22 +198,22 @@
|
|||
* 召回率 —— 提取出的正确信息条数 / 样本中的信息条数
|
||||
* F 值 —— 正确率 * 召回率 * 2 / （正确率 + 召回率）（F值即为正确率和召回率的调和平均值）
|
||||
|
||||
举个例子如下：
|
||||
举个例子如下:
|
||||
|
||||
举个例子如下：
|
||||
举个例子如下:
|
||||
某池塘有 1400 条鲤鱼，300 只虾，300 只乌龟。现在以捕鲤鱼为目的。撒了一张网，逮住了 700 条鲤鱼，200 只
|
||||
虾， 100 只乌龟。那么这些指标分别如下：
|
||||
虾， 100 只乌龟。那么这些指标分别如下:
|
||||
正确率 = 700 / (700 + 200 + 100) = 70%
|
||||
召回率 = 700 / 1400 = 50%
|
||||
F 值 = 70% * 50% * 2 / (70% + 50%) = 58.3%
|
||||
|
||||
### 模型
|
||||
|
||||
* 分类问题 —— 说白了就是将一些未知类别的数据分到现在已知的类别中去。比如，根据你的一些信息，判断你是高富帅，还是穷屌丝。评判分类效果好坏的三个指标就是上面介绍的三个指标：正确率，召回率，F值。
|
||||
* 分类问题 —— 说白了就是将一些未知类别的数据分到现在已知的类别中去。比如，根据你的一些信息，判断你是高富帅，还是穷屌丝。评判分类效果好坏的三个指标就是上面介绍的三个指标: 正确率，召回率，F值。
|
||||
* 回归问题 —— 对数值型连续随机变量进行预测和建模的监督学习算法。回归往往会通过计算 误差（Error）来确定模型的精确性。
|
||||
* 聚类问题 —— 聚类是一种无监督学习任务，该算法基于数据的内部结构寻找观察样本的自然族群（即集群）。聚类问题的标准一般基于距离：簇内距离（Intra-cluster Distance） 和 簇间距离（Inter-cluster Distance） 。簇内距离是越小越好，也就是簇内的元素越相似越好；而簇间距离越大越好，也就是说簇间（不同簇）元素越不相同越好。一般的，衡量聚类问题会给出一个结合簇内距离和簇间距离的公式。
|
||||
* 聚类问题 —— 聚类是一种无监督学习任务，该算法基于数据的内部结构寻找观察样本的自然族群（即集群）。聚类问题的标准一般基于距离: 簇内距离（Intra-cluster Distance） 和 簇间距离（Inter-cluster Distance） 。簇内距离是越小越好，也就是簇内的元素越相似越好；而簇间距离越大越好，也就是说簇间（不同簇）元素越不相同越好。一般的，衡量聚类问题会给出一个结合簇内距离和簇间距离的公式。
|
||||
|
||||
下面这个图可以比较直观地展示出来：
|
||||
下面这个图可以比较直观地展示出来:
|
||||
|
||||
|
||||
|
||||
|
|
@ -223,17 +223,17 @@ F 值 = 70% * 50% * 2 / (70% + 50%) = 58.3%
|
|||
|
||||
* 特征提取 —— 特征提取是计算机视觉和图像处理中的一个概念。它指的是使用计算机提取图像信息，决定每个图像的点是否属于一个图像特征。特征提取的结果是把图像上的点分为不同的子集，这些子集往往属于孤立的点，连续的曲线或者连续的区域。
|
||||
|
||||
下面给出一个特征工程的图：
|
||||
下面给出一个特征工程的图:
|
||||
|
||||
|
||||
|
||||
### 其他
|
||||
|
||||
* Learning rate —— 学习率，通俗地理解，可以理解为步长，步子大了，很容易错过最佳结果。就是本来目标尽在咫尺，可是因为我迈的步子很大，却一下子走过了。步子小了呢，就是同样的距离，我却要走很多很多步，这样导致训练的耗时费力还不讨好。
|
||||
* 一个总结的知识点很棒的链接 ：https://zhuanlan.zhihu.com/p/25197792
|
||||
* 一个总结的知识点很棒的链接 : https://zhuanlan.zhihu.com/p/25197792
|
||||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [1988](http://cwiki.apachecn.org/display/~lihuisong)**
|
||||
* **作者: [片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [1988](http://cwiki.apachecn.org/display/~lihuisong)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -1,15 +1,26 @@
|
|||
|
||||
# 第 10 章 K-Means（K-均值）聚类算法
|
||||
|
||||
|
||||
|
||||
## 聚类
|
||||
|
||||
聚类，简单来说，就是将一个庞杂数据集中具有相似特征的数据自动归类到一起，称为一个簇，簇内的对象越相似，聚类的效果越好。它是一种无监督的学习(Unsupervised Learning)方法,不需要预先标注好的训练集。聚类与分类最大的区别就是分类的目标事先已知，例如猫狗识别，你在分类之前已经预先知道要将它分为猫、狗两个种类；而在你聚类之前，你对你的目标是未知的，同样以动物为例，对于一个动物集来说，你并不清楚这个数据集内部有多少种类的动物，你能做的只是利用聚类方法将它自动按照特征分为多类，然后人为给出这个聚类结果的定义（即簇识别）。例如，你将一个动物集分为了三簇（类），然后通过观察这三类动物的特征，你为每一个簇起一个名字，如大象、狗、猫等，这就是聚类的基本思想。
|
||||
|
||||
至于“相似”这一概念，是利用距离这个评价标准来衡量的，我们通过计算对象与对象之间的距离远近来判断它们是否属于同一类别，即是否是同一个簇。至于距离如何计算，科学家们提出了许多种距离的计算方法，其中欧式距离是最为简单和常用的，除此之外还有曼哈顿距离和余弦相似性距离等。
|
||||
|
||||
欧式距离，我想大家再熟悉不过了，但为免有一些基础薄弱的同学，在此再说明一下，它的定义为：
|
||||
对于x点(坐标为(x1,x2,x3,...,xn))和 y点（坐标为(y1,y2,y3,...,yn)），两者的欧式距离为
|
||||
|
||||
欧式距离，我想大家再熟悉不过了，但为免有一些基础薄弱的同学，在此再说明一下，它的定义为:
|
||||
对于x点坐标为(x1,x2,x3,...,xn)和 y点坐标为(y1,y2,y3,...,yn)，两者的欧式距离为:
|
||||
|
||||
$$
|
||||
d(x,y)
|
||||
={\sqrt{
|
||||
(x_{1}-y_{1})^{2}+(x_{2}-y_{2})^{2} + \cdots +(x_{n}-y_{n})^{2}
|
||||
}}
|
||||
={\sqrt{
|
||||
\sum_{ {i=1} }^{n}(x_{i}-y_{i})^{2}
|
||||
}}
|
||||
$$
|
||||
|
||||
在二维平面，它就是我们初中时就学过的两点距离公式
|
||||
|
||||
## K-Means 算法
|
||||
|
|
@ -68,12 +79,12 @@ kmeans，如前所述，用于数据集内种类属性不明晰，希望能够
|
|||
### K-Means 开发流程
|
||||
|
||||
```
|
||||
收集数据：使用任意方法
|
||||
准备数据：需要数值型数据类计算距离, 也可以将标称型数据映射为二值型数据再用于距离计算
|
||||
分析数据：使用任意方法
|
||||
训练算法：不适用于无监督学习，即无监督学习不需要训练步骤
|
||||
测试算法：应用聚类算法、观察结果.可以使用量化的误差指标如误差平方和（后面会介绍）来评价算法的结果.
|
||||
使用算法：可以用于所希望的任何应用.通常情况下, 簇质心可以代表整个簇的数据来做出决策.
|
||||
收集数据: 使用任意方法
|
||||
准备数据: 需要数值型数据类计算距离, 也可以将标称型数据映射为二值型数据再用于距离计算
|
||||
分析数据: 使用任意方法
|
||||
训练算法: 不适用于无监督学习，即无监督学习不需要训练步骤
|
||||
测试算法: 应用聚类算法、观察结果.可以使用量化的误差指标如误差平方和（后面会介绍）来评价算法的结果.
|
||||
使用算法: 可以用于所希望的任何应用.通常情况下, 簇质心可以代表整个簇的数据来做出决策.
|
||||
```
|
||||
### K-Means 的评价标准
|
||||
k-means算法因为手动选取k值和初始化随机质心的缘故，每一次的结果不会完全一样，而且由于手动选取k值，我们需要知道我们选取的k值是否合理，聚类效果好不好，那么如何来评价某一次的聚类效果呢？也许将它们画在图上直接观察是最好的办法，但现实是，我们的数据不会仅仅只有两个特征，一般来说都有十几个特征，而观察十几维的空间对我们来说是一个无法完成的任务。因此，我们需要一个公式来帮助我们判断聚类的性能，这个公式就是**SSE** (Sum of Squared Error, 误差平方和 ），它其实就是每一个点到其簇内质心的距离的平方值的总和，这个数值对应kmeans函数中**clusterAssment**矩阵的第一列之和。 **SSE**值越小表示数据点越接近于它们的质心，聚类效果也越好。 因为对误差取了平方，因此更加重视那些远离中心的点。一种肯定可以降低**SSE**值的方法是增加簇的个数，但这违背了聚类的目标。聚类的目标是在保持簇数目不变的情况下提高簇的质量。
|
||||
|
|
@ -166,7 +177,7 @@ def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
|
|||
|
||||
为了保持簇总数不变，可以将某两个簇进行合并。从上图中很明显就可以看出，应该将上图下部两个出错的簇质心进行合并。那么问题来了，我们可以很容易对二维数据上的聚类进行可视化， 但是如果遇到40维的数据应该如何去做？
|
||||
|
||||
有两种可以量化的办法：合并最近的质心，或者合并两个使得**SSE**增幅最小的质心。 第一种思路通过计算所有质心之间的距离， 然后合并距离最近的两个点来实现。第二种方法需要合并两个簇然后计算总**SSE**值。必须在所有可能的两个簇上重复上述处理过程，直到找到合并最佳的两个簇为止。
|
||||
有两种可以量化的办法: 合并最近的质心，或者合并两个使得**SSE**增幅最小的质心。 第一种思路通过计算所有质心之间的距离， 然后合并距离最近的两个点来实现。第二种方法需要合并两个簇然后计算总**SSE**值。必须在所有可能的两个簇上重复上述处理过程，直到找到合并最佳的两个簇为止。
|
||||
|
||||
因为上述后处理过程实在是有些繁琐，所以有更厉害的大佬提出了另一个称之为二分K-均值（bisecting K-Means）的算法.
|
||||
|
||||
|
|
@ -206,7 +217,7 @@ def biKMeans(dataSet, k, distMeas=distEclud):
|
|||
sseSplit = sum(splitClustAss[:,1]) # 将二分 kMeans 结果中的平方和的距离进行求和
|
||||
sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:,0].A!=i)[0],1]) # 将未参与二分 kMeans 分配结果中的平方和的距离进行求和
|
||||
print "sseSplit, and notSplit: ",sseSplit,sseNotSplit
|
||||
if (sseSplit + sseNotSplit) < lowestSSE: # 总的（未拆分和已拆分）误差和越小，越相似，效果越优化，划分的结果更好（注意：这里的理解很重要，不明白的地方可以和我们一起讨论）
|
||||
if (sseSplit + sseNotSplit) < lowestSSE: # 总的（未拆分和已拆分）误差和越小，越相似，效果越优化，划分的结果更好（注意: 这里的理解很重要，不明白的地方可以和我们一起讨论）
|
||||
bestCentToSplit = i
|
||||
bestNewCents = centroidMat
|
||||
bestClustAss = splitClustAss.copy()
|
||||
|
|
@ -230,6 +241,6 @@ def biKMeans(dataSet, k, distMeas=distEclud):
|
|||
运行参考结果如下:
|
||||
|
||||
|
||||
* **作者：[那伊抹微笑](http://cwiki.apachecn.org/display/~xuxin), [清都江水郎](http://cwiki.apachecn.org/display/~xuzhaoqing)**
|
||||
* **作者: [那伊抹微笑](http://cwiki.apachecn.org/display/~xuxin), [清都江水郎](http://cwiki.apachecn.org/display/~xuzhaoqing)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
@ -47,20 +47,20 @@
|
|||
Apriori 算法优缺点
|
||||
|
||||
```
|
||||
* 优点：易编码实现
|
||||
* 缺点：在大数据集上可能较慢
|
||||
* 适用数据类型：数值型 或者 标称型数据。
|
||||
* 优点: 易编码实现
|
||||
* 缺点: 在大数据集上可能较慢
|
||||
* 适用数据类型: 数值型 或者 标称型数据。
|
||||
```
|
||||
|
||||
Apriori 算法流程步骤：
|
||||
Apriori 算法流程步骤:
|
||||
|
||||
```
|
||||
* 收集数据：使用任意方法。
|
||||
* 准备数据：任何数据类型都可以，因为我们只保存集合。
|
||||
* 分析数据：使用任意方法。
|
||||
* 训练数据：使用Apiori算法来找到频繁项集。
|
||||
* 测试算法：不需要测试过程。
|
||||
* 使用算法：用于发现频繁项集以及物品之间的关联规则。
|
||||
* 收集数据: 使用任意方法。
|
||||
* 准备数据: 任何数据类型都可以，因为我们只保存集合。
|
||||
* 分析数据: 使用任意方法。
|
||||
* 训练数据: 使用Apiori算法来找到频繁项集。
|
||||
* 测试算法: 不需要测试过程。
|
||||
* 使用算法: 用于发现频繁项集以及物品之间的关联规则。
|
||||
```
|
||||
|
||||
## Apriori 算法的使用
|
||||
|
|
@ -288,7 +288,7 @@ def apriori(dataSet, minSupport=0.5):
|
|||
# 计算可信度（confidence）
|
||||
def calcConf(freqSet, H
|
||||
, supportData, brl, minConf=0.7):
|
||||
"""calcConf（对两个元素的频繁项，计算可信度，例如： {1,2}/{1} 或者 {1,2}/{2} 看是否满足条件）
|
||||
"""calcConf（对两个元素的频繁项，计算可信度，例如: {1,2}/{1} 或者 {1,2}/{2} 看是否满足条件）
|
||||
|
||||
Args:
|
||||
freqSet 频繁项集中的元素，例如: frozenset([1, 3])
|
||||
|
|
@ -369,7 +369,7 @@ def generateRules(L, supportData, minConf=0.7):
|
|||
for i in range(1, len(L)):
|
||||
# 获取频繁项集中每个组合的所有元素
|
||||
for freqSet in L[i]:
|
||||
# 假设：freqSet= frozenset([1, 3]), H1=[frozenset([1]), frozenset([3])]
|
||||
# 假设: freqSet= frozenset([1, 3]), H1=[frozenset([1]), frozenset([3])]
|
||||
# 组合总的元素并遍历子元素，并转化为 frozenset 集合，再存放到 list 列表中
|
||||
H1 = [frozenset([item]) for item in freqSet]
|
||||
# 2 个的组合，走 else, 2 个以上的组合，走 if
|
||||
|
|
@ -382,15 +382,15 @@ def generateRules(L, supportData, minConf=0.7):
|
|||
|
||||
到这里为止，通过调用 generateRules 函数即可得出我们所需的 `关联规则`。
|
||||
|
||||
* 分级法： 频繁项集->关联规则
|
||||
* 分级法: 频繁项集->关联规则
|
||||
* 1.首先从一个频繁项集开始，接着创建一个规则列表，其中规则右部分只包含一个元素，然后对这个规则进行测试。
|
||||
* 2.接下来合并所有剩余规则来创建一个新的规则列表，其中规则右部包含两个元素。
|
||||
* 如下图：
|
||||
* 如下图:
|
||||
* 
|
||||
* 最后： 每次增加频繁项集的大小，Apriori 算法都会重新扫描整个数据集，是否有优化空间呢？ 下一章：FP-growth算法等着你的到来
|
||||
* 最后: 每次增加频繁项集的大小，Apriori 算法都会重新扫描整个数据集，是否有优化空间呢？ 下一章: FP-growth算法等着你的到来
|
||||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](https://github.com/jiangzhonglian)**
|
||||
* **作者: [片刻](https://github.com/jiangzhonglian)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -69,13 +69,13 @@ class treeNode:
|
|||
FP-growth 算法优缺点:
|
||||
|
||||
```
|
||||
* 优点： 1. 因为 FP-growth 算法只需要对数据集遍历两次，所以速度更快。
|
||||
* 优点: 1. 因为 FP-growth 算法只需要对数据集遍历两次，所以速度更快。
|
||||
2. FP树将集合按照支持度降序排序，不同路径如果有相同前缀路径共用存储空间，使得数据得到了压缩。
|
||||
3. 不需要生成候选集。
|
||||
4. 比Apriori更快。
|
||||
* 缺点： 1. FP-Tree第二次遍历会存储很多中间过程的值，会占用很多内存。
|
||||
* 缺点: 1. FP-Tree第二次遍历会存储很多中间过程的值，会占用很多内存。
|
||||
2. 构建FP-Tree是比较昂贵的。
|
||||
* 适用数据类型：标称型数据(离散型数据)。
|
||||
* 适用数据类型: 标称型数据(离散型数据)。
|
||||
```
|
||||
|
||||
|
||||
|
|
@ -97,6 +97,6 @@ if __name__ == "__main__":
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[mikechengwei](https://github.com/mikechengwei)**
|
||||
* **作者: [mikechengwei](https://github.com/mikechengwei)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
* 人们实时的将显示器上的百万像素转换成为一个三维图像，该图像就给出运动场上球的位置。
|
||||
* 在这个过程中，人们已经将百万像素点的数据，降至为三维。这个过程就称为`降维(dimensionality reduction)`
|
||||
|
||||
> 数据显示 并非大规模特征下的唯一难题，对数据进行简化还有如下一系列的原因：
|
||||
> 数据显示 并非大规模特征下的唯一难题，对数据进行简化还有如下一系列的原因:
|
||||
|
||||
* 1) 使得数据集更容易使用
|
||||
* 2) 降低很多算法的计算开销
|
||||
|
|
@ -26,19 +26,19 @@
|
|||
> 在以下3种降维技术中， PCA的应用目前最为广泛，因此本章主要关注PCA。
|
||||
|
||||
* 1) 主成分分析(Principal Component Analysis, PCA)
|
||||
* `通俗理解：就是找出一个最主要的特征，然后进行分析。`
|
||||
* `例如： 考察一个人的智力情况，就直接看数学成绩就行(存在：数学、语文、英语成绩)`
|
||||
* `通俗理解: 就是找出一个最主要的特征，然后进行分析。`
|
||||
* `例如: 考察一个人的智力情况，就直接看数学成绩就行(存在: 数学、语文、英语成绩)`
|
||||
* 2) 因子分析(Factor Analysis)
|
||||
* `通俗理解：将多个实测变量转换为少数几个综合指标。它反映一种降维的思想，通过降维将相关性高的变量聚在一起,从而减少需要分析的变量的数量,而减少问题分析的复杂性`
|
||||
* `例如： 考察一个人的整体情况，就直接组合3样成绩(隐变量)，看平均成绩就行(存在：数学、语文、英语成绩)`
|
||||
* 应用的领域：社会科学、金融和其他领域
|
||||
* `通俗理解: 将多个实测变量转换为少数几个综合指标。它反映一种降维的思想，通过降维将相关性高的变量聚在一起,从而减少需要分析的变量的数量,而减少问题分析的复杂性`
|
||||
* `例如: 考察一个人的整体情况，就直接组合3样成绩(隐变量)，看平均成绩就行(存在: 数学、语文、英语成绩)`
|
||||
* 应用的领域: 社会科学、金融和其他领域
|
||||
* 在因子分析中，我们
|
||||
* 假设观察数据的成分中有一些观察不到的隐变量(latent variable)。
|
||||
* 假设观察数据是这些隐变量和某些噪音的线性组合。
|
||||
* 那么隐变量的数据可能比观察数据的数目少，也就说通过找到隐变量就可以实现数据的降维。
|
||||
* 3) 独立成分分析(Independ Component Analysis, ICA)
|
||||
* `通俗理解：ICA 认为观测信号是若干个独立信号的线性组合，ICA 要做的是一个解混过程。`
|
||||
* `例如：我们去ktv唱歌，想辨别唱的是什么歌曲？ICA 是观察发现是原唱唱的一首歌【2个独立的声音（原唱／主唱）】。`
|
||||
* `通俗理解: ICA 认为观测信号是若干个独立信号的线性组合，ICA 要做的是一个解混过程。`
|
||||
* `例如: 我们去ktv唱歌，想辨别唱的是什么歌曲？ICA 是观察发现是原唱唱的一首歌【2个独立的声音（原唱／主唱）】。`
|
||||
* ICA 是假设数据是从 N 个数据源混合组成的，这一点和因子分析有些类似，这些数据源之间在统计上是相互独立的，而在 PCA 中只假设数据是不 相关（线性关系）的。
|
||||
* 同因子分析一样，如果数据源的数目少于观察数据的数目，则可以实现降维过程。
|
||||
|
||||
|
|
@ -47,11 +47,11 @@
|
|||
|
||||
### PCA 概述
|
||||
|
||||
主成分分析(Principal Component Analysis, PCA)：`通俗理解：就是找出一个最主要的特征，然后进行分析。`
|
||||
主成分分析(Principal Component Analysis, PCA): `通俗理解: 就是找出一个最主要的特征，然后进行分析。`
|
||||
|
||||
### PCA 场景
|
||||
|
||||
`例如： 考察一个人的智力情况，就直接看数学成绩就行(存在：数学、语文、英语成绩)`
|
||||
`例如: 考察一个人的智力情况，就直接看数学成绩就行(存在: 数学、语文、英语成绩)`
|
||||
|
||||
### PCA 原理
|
||||
|
||||
|
|
@ -68,16 +68,16 @@
|
|||
1. 正交是为了数据有效性损失最小
|
||||
2. 正交的一个原因是特征值的特征向量是正交的
|
||||
|
||||
例如下图：
|
||||
例如下图:
|
||||
|
||||
|
||||
|
||||
> PCA 优缺点
|
||||
|
||||
```
|
||||
优点：降低数据的复杂性，识别最重要的多个特征。
|
||||
缺点：不一定需要，且可能损失有用信息。
|
||||
适用数据类型：数值型数据。
|
||||
优点: 降低数据的复杂性，识别最重要的多个特征。
|
||||
缺点: 不一定需要，且可能损失有用信息。
|
||||
适用数据类型: 数值型数据。
|
||||
```
|
||||
|
||||
### 项目案例: 对半导体数据进行降维处理
|
||||
|
|
@ -92,16 +92,16 @@
|
|||
具体来讲，它拥有590个特征。我们看看能否对这些特征进行降维处理。
|
||||
|
||||
对于数据的缺失值的问题，我们有一些处理方法(参考第5章)
|
||||
目前该章节处理的方案是：将缺失值NaN(Not a Number缩写)，全部用平均值来替代(如果用0来处理的策略就太差劲了)。
|
||||
目前该章节处理的方案是: 将缺失值NaN(Not a Number缩写)，全部用平均值来替代(如果用0来处理的策略就太差劲了)。
|
||||
```
|
||||
|
||||
#### 开发流程
|
||||
|
||||
> 收集数据：提供文本文件
|
||||
> 收集数据: 提供文本文件
|
||||
|
||||
文件名：secom.data
|
||||
文件名: secom.data
|
||||
|
||||
文本文件数据格式如下：
|
||||
文本文件数据格式如下:
|
||||
|
||||
```
|
||||
3030.93 2564 2187.7333 1411.1265 1.3602 100 97.6133 0.1242 1.5005 0.0162 -0.0034 0.9455 202.4396 0 7.9558 414.871 10.0433 0.968 192.3963 12.519 1.4026 -5419 2916.5 -4043.75 751 0.8955 1.773 3.049 64.2333 2.0222 0.1632 3.5191 83.3971 9.5126 50.617 64.2588 49.383 66.3141 86.9555 117.5132 61.29 4.515 70 352.7173 10.1841 130.3691 723.3092 1.3072 141.2282 1 624.3145 218.3174 0 4.592 4.841 2834 0.9317 0.9484 4.7057 -1.7264 350.9264 10.6231 108.6427 16.1445 21.7264 29.5367 693.7724 0.9226 148.6009 1 608.17 84.0793 NaN NaN 0 0.0126 -0.0206 0.0141 -0.0307 -0.0083 -0.0026 -0.0567 -0.0044 7.2163 0.132 NaN 2.3895 0.969 1747.6049 0.1841 8671.9301 -0.3274 -0.0055 -0.0001 0.0001 0.0003 -0.2786 0 0.3974 -0.0251 0.0002 0.0002 0.135 -0.0042 0.0003 0.0056 0 -0.2468 0.3196 NaN NaN NaN NaN 0.946 0 748.6115 0.9908 58.4306 0.6002 0.9804 6.3788 15.88 2.639 15.94 15.93 0.8656 3.353 0.4098 3.188 -0.0473 0.7243 0.996 2.2967 1000.7263 39.2373 123 111.3 75.2 46.2 350.671 0.3948 0 6.78 0.0034 0.0898 0.085 0.0358 0.0328 12.2566 0 4.271 10.284 0.4734 0.0167 11.8901 0.41 0.0506 NaN NaN 1017 967 1066 368 0.09 0.048 0.095 2 0.9 0.069 0.046 0.725 0.1139 0.3183 0.5888 0.3184 0.9499 0.3979 0.16 0 0 20.95 0.333 12.49 16.713 0.0803 5.72 0 11.19 65.363 0 0 0 0 0 0 0.292 5.38 20.1 0.296 10.62 10.3 5.38 4.04 16.23 0.2951 8.64 0 10.3 97.314 0 0.0772 0.0599 0.07 0.0547 0.0704 0.052 0.0301 0.1135 3.4789 0.001 NaN 0.0707 0.0211 175.2173 0.0315 1940.3994 0 0.0744 0.0546 0 0 0 0 0 0 0 0 0 0.0027 0.004 0 0 0 0 NaN NaN NaN NaN 0.0188 0 219.9453 0.0011 2.8374 0.0189 0.005 0.4269 0 0 0 0 0 0 0 0 0 0 0 0.0472 40.855 4.5152 30.9815 33.9606 22.9057 15.9525 110.2144 0.131 0 2.5883 0.001 0.0319 0.0197 0.012 0.0109 3.9321 0 1.5123 3.5811 0.1337 0.0055 3.8447 0.1077 0.0167 NaN NaN 418.1363 398.3185 496.1582 158.333 0.0373 0.0202 0.0462 0.6083 0.3032 0.02 0.0174 0.2827 0.0434 0.1342 0.2419 0.1343 0.367 0.1431 0.061 0 0 0 6.2698 0.1181 3.8208 5.3737 0.0254 1.6252 0 3.2461 18.0118 0 0 0 0 0 0 0.0752 1.5989 6.5893 0.0913 3.0911 8.4654 1.5989 1.2293 5.3406 0.0867 2.8551 0 2.9971 31.8843 NaN NaN 0 0.0215 0.0274 0.0315 0.0238 0.0206 0.0238 0.0144 0.0491 1.2708 0.0004 NaN 0.0229 0.0065 55.2039 0.0105 560.2658 0 0.017 0.0148 0.0124 0.0114 0 0 0 0 0 0 0 0.001 0.0013 0 0 0 0 NaN NaN NaN NaN 0.0055 0 61.5932 0.0003 0.9967 0.0082 0.0017 0.1437 0 0 0 0 0 0 0 0 0 0 0 0.0151 14.2396 1.4392 5.6188 3.6721 2.9329 2.1118 24.8504 29.0271 0 6.9458 2.738 5.9846 525.0965 0 3.4641 6.0544 0 53.684 2.4788 4.7141 1.7275 6.18 3.275 3.6084 18.7673 33.1562 26.3617 49.0013 10.0503 2.7073 3.1158 3.1136 44.5055 42.2737 1.3071 0.8693 1.1975 0.6288 0.9163 0.6448 1.4324 0.4576 0.1362 0 0 0 5.9396 3.2698 9.5805 2.3106 6.1463 4.0502 0 1.7924 29.9394 0 0 0 0 0 0 6.2052 311.6377 5.7277 2.7864 9.7752 63.7987 24.7625 13.6778 2.3394 31.9893 5.8142 0 1.6936 115.7408 0 613.3069 291.4842 494.6996 178.1759 843.1138 0 53.1098 0 48.2091 0.7578 NaN 2.957 2.1739 10.0261 17.1202 22.3756 0 0 0 0 0 0 0 0 0 0 0 0 64.6707 0 0 0 0 0 NaN NaN NaN NaN 1.9864 0 29.3804 0.1094 4.856 3.1406 0.5064 6.6926 0 0 0 0 0 0 0 0 0 0 0 2.057 4.0825 11.5074 0.1096 0.0078 0.0026 7.116 1.0616 395.57 75.752 0.4234 12.93 0.78 0.1827 5.7349 0.3363 39.8842 3.2687 1.0297 1.0344 0.4385 0.1039 42.3877 NaN NaN NaN NaN NaN NaN NaN NaN 533.85 2.1113 8.95 0.3157 3.0624 0.1026 1.6765 14.9509 NaN NaN NaN NaN 0.5005 0.0118 0.0035 2.363 NaN NaN NaN NaN
|
||||
|
|
@ -111,7 +111,7 @@
|
|||
3032.24 2502.87 2233.3667 1326.52 1.5334 100 100.3967 0.1235 1.5031 -0.0031 -0.0072 0.9569 201.9424 0 10.5661 420.5925 10.3387 0.9735 191.6037 12.4735 1.3888 -5476.25 2635.25 -3987.5 117 1.2887 1.9912 7.2748 62.8333 3.1556 0.2696 3.2728 86.3269 8.7677 50.248 64.1511 49.752 66.1542 86.1468 121.4364 76.39 2.209 70 353.34 10.4091 176.3136 789.7523 1.0341 138.0882 1 667.7418 233.5491 0 4.624 4.894 2865 0.9298 0.9449 4.6414 -12.2945 355.0809 9.7948 144.0191 21.9782 32.2945 44.1498 745.6025 0.9256 146.6636 1 645.7636 65.8417 NaN NaN 0 -0.0534 0.0183 -0.0167 -0.0449 0.0034 -0.0178 -0.0123 -0.0048 7.5017 0.1342 NaN 2.453 0.9902 1828.3846 0.1829 9014.46 0.0448 -0.0077 -0.0001 -0.0001 -0.0001 0.2189 0 -0.6704 -0.0167 0.0004 -0.0003 0.0696 -0.0045 0.0002 0.0078 0 -0.0799 -0.2038 NaN NaN NaN NaN 0.9424 0 796.595 0.9908 58.3858 0.5913 0.9628 6.3551 15.75 3.148 15.73 15.71 0.946 3.027 0.5328 3.299 -0.5677 0.778 1.001 2.3715 993.1274 38.1448 119 143.2 123.1 48.8 296.303 0.3744 0 3.64 0.0041 0.0634 0.0451 0.0623 0.024 14.2354 0 9.005 12.506 0.4434 0.0126 13.9047 0.43 0.0538 NaN NaN 699 283 1747 1443 0.147 0.04 0.113 3.9 0.8 0.101 0.499 0.576 0.0631 0.3053 0.583 0.3053 0.8285 0.1308 0.922 0 0 15.24 0.282 10.85 37.715 0.1189 3.98 0 25.54 72.149 0 0 0 0 0 0 0.25 5.52 15.76 0.519 10.71 19.77 5.52 8.446 33.832 0.3951 9.09 0 19.77 92.307 0 0.0915 0.0506 0.0769 0.1079 0.0797 0.1047 0.0924 0.1015 4.1338 0.003 NaN 0.0802 0.0004 69.151 0.197 1406.4004 0 0.0227 0.0272 0 0 0 0 0 0 0 0 0 0.0067 0.0031 0 0 0 0 NaN NaN NaN NaN 0.024 0 149.2172 0.0006 2.5775 0.0177 0.0214 0.4051 0 0 0 0 0 0 0 0 0 0 0 0.0488 19.862 3.6163 34.125 55.9626 53.0876 17.4864 88.7672 0.1092 0 1.0929 0.0013 0.0257 0.0116 0.0163 0.008 4.4239 0 3.2376 3.6536 0.1293 0.004 4.3474 0.1275 0.0181 NaN NaN 319.1252 128.0296 799.5884 628.3083 0.0755 0.0181 0.0476 1.35 0.2698 0.032 0.1541 0.2155 0.031 0.1354 0.2194 0.1354 0.3072 0.0582 0.3574 0 0 0 4.8956 0.0766 2.913 11.0583 0.0327 1.1229 0 7.3296 23.116 0 0 0 0 0 0 0.0822 1.6216 4.7279 0.1773 3.155 9.7777 1.6216 2.5923 10.5352 0.1301 3.0939 0 6.3767 32.0537 NaN NaN 0 0.0246 0.0221 0.0329 0.0522 0.0256 0.0545 0.0476 0.0463 1.553 0.001 NaN 0.0286 0.0001 21.0312 0.0573 494.7368 0 0.0063 0.0077 0.0052 0.0027 0 0 0 0 0 0 0 0.0025 0.0012 0 0 0 0 NaN NaN NaN NaN 0.0089 0 57.2692 0.0002 0.8495 0.0065 0.0077 0.1356 0 0 0 0 0 0 0 0 0 0 0 0.0165 7.1493 1.1704 5.3823 4.7226 4.9184 2.185 22.3369 24.4142 0 3.6256 3.3208 4.2178 0 866.0295 2.5046 7.0492 0 85.2255 2.9734 4.2892 1.2943 7.257 3.4473 3.8754 12.7642 10.739 43.8119 0 11.4064 2.0088 1.5533 6.2069 25.3521 37.4691 15.247 0.6672 0.7198 0.6076 0.9088 0.6136 1.2524 0.1518 0.7592 0 0 0 4.3131 2.7092 6.1538 4.7756 11.4945 2.8822 0 3.8248 30.8924 0 0 0 0 0 0 5.3863 44.898 4.4384 5.2987 7.4365 89.9529 17.0927 19.1303 4.5375 42.6838 6.1979 0 3.0615 140.1953 0 171.4486 276.881 461.8619 240.1781 0 587.3773 748.1781 0 55.1057 2.2358 NaN 3.2712 0.0372 3.7821 107.6905 15.6016 0 293.1396 0 0 0 0 0 0 0 0 0 0 148.0663 0 0 0 0 0 NaN NaN NaN NaN 2.5512 0 18.7319 0.0616 4.4146 2.9954 2.2181 6.3745 0 0 0 0 0 0 0 0 0 0 0 2.0579 1.9999 9.4805 0.1096 0.0078 0.0026 7.116 1.4636 399.914 79.156 1.0388 19.63 1.98 0.4287 9.7608 0.8311 70.9706 4.9086 2.5014 0.9778 0.2156 0.0461 22.05 NaN NaN NaN NaN NaN NaN NaN NaN 532.0155 2.0275 8.83 0.2224 3.1776 0.0706 1.6597 10.9698 NaN NaN NaN NaN 0.48 0.4766 0.1045 99.3032 0.0202 0.0149 0.0044 73.8432
|
||||
```
|
||||
|
||||
> 准备数据：将value为NaN的替换为均值
|
||||
> 准备数据: 将value为NaN的替换为均值
|
||||
|
||||
```python
|
||||
def replaceNanWithMean():
|
||||
|
|
@ -126,7 +126,7 @@ def replaceNanWithMean():
|
|||
return datMat
|
||||
```
|
||||
|
||||
> 分析数据：统计分析 N 的阈值
|
||||
> 分析数据: 统计分析 N 的阈值
|
||||
|
||||
|
||||
|
||||
|
|
@ -134,7 +134,7 @@ def replaceNanWithMean():
|
|||
|
||||
在等式 Av=入v 中，v 是特征向量， 入是特征值。<br/>
|
||||
表示 如果特征向量 v 被某个矩阵 A 左乘，那么它就等于某个标量 入 乘以 v.<br/>
|
||||
幸运的是： Numpy 中有寻找特征向量和特征值的模块 linalg，它有 eig() 方法，该方法用于求解特征向量和特征值。
|
||||
幸运的是: Numpy 中有寻找特征向量和特征值的模块 linalg，它有 eig() 方法，该方法用于求解特征向量和特征值。
|
||||
|
||||
```python
|
||||
def pca(dataMat, topNfeat=9999999):
|
||||
|
|
@ -158,9 +158,9 @@ def pca(dataMat, topNfeat=9999999):
|
|||
|
||||
# cov协方差=[(x1-x均值)*(y1-y均值)+(x2-x均值)*(y2-y均值)+...+(xn-x均值)*(yn-y均值)+]/(n-1)
|
||||
'''
|
||||
方差：（一维）度量两个随机变量关系的统计量
|
||||
协方差： （二维）度量各个维度偏离其均值的程度
|
||||
协方差矩阵：（多维）度量各个维度偏离其均值的程度
|
||||
方差: （一维）度量两个随机变量关系的统计量
|
||||
协方差: （二维）度量各个维度偏离其均值的程度
|
||||
协方差矩阵: （多维）度量各个维度偏离其均值的程度
|
||||
|
||||
当 cov(X, Y)>0时，表明X与Y正相关；(X越大，Y也越大；X越小Y，也越小。这种情况，我们称为“正相关”。)
|
||||
当 cov(X, Y)<0时，表明X与Y负相关；
|
||||
|
|
@ -212,7 +212,7 @@ def pca(dataMat, topNfeat=9999999):
|
|||
```
|
||||
降维技术使得数据变的更易使用，并且它们往往能够去除数据中的噪音，使得其他机器学习任务更加精确。
|
||||
降维往往作为预处理步骤，在数据应用到其他算法之前清洗数据。
|
||||
比较流行的降维技术： 独立成分分析、因子分析 和 主成分分析， 其中又以主成分分析应用最广泛。
|
||||
比较流行的降维技术: 独立成分分析、因子分析 和 主成分分析， 其中又以主成分分析应用最广泛。
|
||||
|
||||
本章中的PCA将所有的数据集都调入了内存，如果无法做到，就需要其他的方法来寻找其特征值。
|
||||
如果使用在线PCA分析的方法，你可以参考一篇优秀的论文 "Incremental Eigenanalysis for Classification"。
|
||||
|
|
@ -221,6 +221,6 @@ def pca(dataMat, topNfeat=9999999):
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [1988](http://cwiki.apachecn.org/display/~lihuisong)**
|
||||
* **作者: [片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [1988](http://cwiki.apachecn.org/display/~lihuisong)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
> 信息检索-隐性语义检索（Latent Semantic Indexing, LSI）或 隐形语义分析（Latent Semantic Analysis, LSA）
|
||||
|
||||
隐性语义索引：矩阵 = 文档 + 词语
|
||||
隐性语义索引: 矩阵 = 文档 + 词语
|
||||
* 是最早的 SVD 应用之一，我们称利用 SVD 的方法为隐性语义索引（LSI）或隐性语义分析（LSA）。
|
||||
|
||||
|
||||
|
|
@ -30,7 +30,7 @@
|
|||
|
||||
> 图像压缩
|
||||
|
||||
例如：`32*32=1024 => 32*2+2*1+32*2=130`(2*1表示去掉了除对角线的0), 几乎获得了10倍的压缩比。
|
||||
例如: `32*32=1024 => 32*2+2*1+32*2=130`(2*1表示去掉了除对角线的0), 几乎获得了10倍的压缩比。
|
||||
|
||||
|
||||
|
||||
|
|
@ -42,12 +42,12 @@
|
|||
|
||||
* 矩阵分解是将数据矩阵分解为多个独立部分的过程。
|
||||
* 矩阵分解可以将原始矩阵表示成新的易于处理的形式，这种新形式是两个或多个矩阵的乘积。（类似代数中的因数分解）
|
||||
* 举例：如何将12分解成两个数的乘积？（1，12）、（2，6）、（3，4）都是合理的答案。
|
||||
* 举例: 如何将12分解成两个数的乘积？（1，12）、（2，6）、（3，4）都是合理的答案。
|
||||
|
||||
> SVD 是矩阵分解的一种类型，也是矩阵分解最常见的技术
|
||||
|
||||
* SVD 将原始的数据集矩阵 Data 分解成三个矩阵 U、∑、V
|
||||
* 举例：如果原始矩阵 \\(Data_{m*n}\\) 是m行n列，
|
||||
* 举例: 如果原始矩阵 \\(Data_{m*n}\\) 是m行n列，
|
||||
* \\(U_{m * k}\\) 表示m行k列
|
||||
* \\(∑_{k * k}\\) 表示k行k列
|
||||
* \\(V_{k * n}\\) 表示k行n列。
|
||||
|
|
@ -56,20 +56,20 @@
|
|||
|
||||
|
||||
|
||||
具体的案例：（大家可以试着推导一下：https://wenku.baidu.com/view/b7641217866fb84ae45c8d17.html ）
|
||||
具体的案例: （大家可以试着推导一下: https://wenku.baidu.com/view/b7641217866fb84ae45c8d17.html ）
|
||||
|
||||
|
||||
|
||||
* 上述分解中会构建出一个矩阵∑，该矩阵只有对角元素，其他元素均为0(近似于0)。另一个惯例就是，∑的对角元素是从大到小排列的。这些对角元素称为奇异值。
|
||||
* 奇异值与特征值(PCA 数据中重要特征)是有关系的。这里的奇异值就是矩阵 \\(Data * Data^T\\) 特征值的平方根。
|
||||
* 普遍的事实：在某个奇异值的数目(r 个=>奇异值的平方和累加到总值的90%以上)之后，其他的奇异值都置为0(近似于0)。这意味着数据集中仅有 r 个重要特征，而其余特征则都是噪声或冗余特征。
|
||||
* 普遍的事实: 在某个奇异值的数目(r 个=>奇异值的平方和累加到总值的90%以上)之后，其他的奇异值都置为0(近似于0)。这意味着数据集中仅有 r 个重要特征，而其余特征则都是噪声或冗余特征。
|
||||
|
||||
### SVD 算法特点
|
||||
|
||||
```
|
||||
优点：简化数据，去除噪声，优化算法的结果
|
||||
缺点：数据的转换可能难以理解
|
||||
使用的数据类型：数值型数据
|
||||
优点: 简化数据，去除噪声，优化算法的结果
|
||||
缺点: 数据的转换可能难以理解
|
||||
使用的数据类型: 数值型数据
|
||||
```
|
||||
|
||||
## 推荐系统
|
||||
|
|
@ -89,17 +89,17 @@
|
|||
> 基于协同过滤(collaborative filtering) 的推荐引擎
|
||||
|
||||
* 利用Python 实现 SVD(Numpy 有一个称为 linalg 的线性代数工具箱)
|
||||
* 协同过滤：是通过将用户和其他用户的数据进行对比来实现推荐的。
|
||||
* 协同过滤: 是通过将用户和其他用户的数据进行对比来实现推荐的。
|
||||
* 当知道了两个用户或两个物品之间的相似度，我们就可以利用已有的数据来预测未知用户的喜好。
|
||||
|
||||
> 基于物品的相似度和基于用户的相似度：物品比较少则选择物品相似度，用户比较少则选择用户相似度。【矩阵还是小一点好计算】
|
||||
> 基于物品的相似度和基于用户的相似度: 物品比较少则选择物品相似度，用户比较少则选择用户相似度。【矩阵还是小一点好计算】
|
||||
|
||||
* 基于物品的相似度：计算物品之间的距离。【耗时会随物品数量的增加而增加】
|
||||
* 基于物品的相似度: 计算物品之间的距离。【耗时会随物品数量的增加而增加】
|
||||
* 由于物品A和物品C 相似度(相关度)很高，所以给买A的人推荐C。
|
||||
|
||||
|
||||
|
||||
* 基于用户的相似度：计算用户之间的距离。【耗时会随用户数量的增加而增加】
|
||||
* 基于用户的相似度: 计算用户之间的距离。【耗时会随用户数量的增加而增加】
|
||||
* 由于用户A和用户C 相似度(相关度)很高，所以A和C是兴趣相投的人，对于C买的物品就会推荐给A。
|
||||
|
||||
|
||||
|
|
@ -107,15 +107,15 @@
|
|||
> 相似度计算
|
||||
|
||||
* inA, inB 对应的是 列向量
|
||||
1. 欧氏距离：指在m维空间中两个点之间的真实距离，或者向量的自然长度（即该点到原点的距离）。二维或三维中的欧氏距离就是两点之间的实际距离。
|
||||
1. 欧氏距离: 指在m维空间中两个点之间的真实距离，或者向量的自然长度（即该点到原点的距离）。二维或三维中的欧氏距离就是两点之间的实际距离。
|
||||
* 相似度= 1/(1+欧式距离)
|
||||
* `相似度= 1.0/(1.0 + la.norm(inA - inB))`
|
||||
* 物品对越相似，它们的相似度值就越大。
|
||||
2. 皮尔逊相关系数：度量的是两个向量之间的相似度。
|
||||
2. 皮尔逊相关系数: 度量的是两个向量之间的相似度。
|
||||
* 相似度= 0.5 + 0.5*corrcoef() 【皮尔逊相关系数的取值范围从 -1 到 +1，通过函数0.5 + 0.5\*corrcoef()这个函数计算，把值归一化到0到1之间】
|
||||
* `相似度= 0.5 + 0.5 * corrcoef(inA, inB, rowvar = 0)[0][1]`
|
||||
* 相对欧氏距离的优势：它对用户评级的量级并不敏感。
|
||||
3. 余弦相似度：计算的是两个向量夹角的余弦值。
|
||||
* 相对欧氏距离的优势: 它对用户评级的量级并不敏感。
|
||||
3. 余弦相似度: 计算的是两个向量夹角的余弦值。
|
||||
* 余弦值 = (A·B)/(||A||·||B||) 【余弦值的取值范围也在-1到+1之间】
|
||||
* 相似度= 0.5 + 0.5*余弦值
|
||||
* `相似度= 0.5 + 0.5*( float(inA.T*inB) / la.norm(inA)*la.norm(inB))`
|
||||
|
|
@ -124,15 +124,15 @@
|
|||
> 推荐系统的评价
|
||||
|
||||
* 采用交叉测试的方法。【拆分数据为训练集和测试集】
|
||||
* 推荐引擎评价的指标： 最小均方根误差(Root mean squared error, RMSE)，也称标准误差(Standard error)，就是计算均方误差的平均值然后取其平方根。
|
||||
* 推荐引擎评价的指标: 最小均方根误差(Root mean squared error, RMSE)，也称标准误差(Standard error)，就是计算均方误差的平均值然后取其平方根。
|
||||
* 如果RMSE=1, 表示相差1个星级；如果RMSE=2.5, 表示相差2.5个星级。
|
||||
|
||||
### 推荐系统 原理
|
||||
|
||||
* 推荐系统的工作过程：给定一个用户，系统会为此用户返回N个最好的推荐菜。
|
||||
* 实现流程大致如下：
|
||||
* 推荐系统的工作过程: 给定一个用户，系统会为此用户返回N个最好的推荐菜。
|
||||
* 实现流程大致如下:
|
||||
1. 寻找用户没有评级的菜肴，即在用户-物品矩阵中的0值。
|
||||
2. 在用户没有评级的所有物品中，对每个物品预计一个可能的评级分数。这就是说：我们认为用户可能会对物品的打分（这就是相似度计算的初衷）。
|
||||
2. 在用户没有评级的所有物品中，对每个物品预计一个可能的评级分数。这就是说: 我们认为用户可能会对物品的打分（这就是相似度计算的初衷）。
|
||||
3. 对这些物品的评分从高到低进行排序，返回前N个物品。
|
||||
|
||||
|
||||
|
|
@ -152,9 +152,9 @@
|
|||
def loadExData3():
|
||||
# 利用SVD提高推荐效果，菜肴矩阵
|
||||
"""
|
||||
行：代表人
|
||||
列：代表菜肴名词
|
||||
值：代表人对菜肴的评分，0表示未评分
|
||||
行: 代表人
|
||||
列: 代表菜肴名词
|
||||
值: 代表人对菜肴的评分，0表示未评分
|
||||
"""
|
||||
return[[2, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0],
|
||||
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],
|
||||
|
|
@ -227,7 +227,7 @@ def standEst(dataMat, user, simMeas, item):
|
|||
return ratSimTotal/simTotal
|
||||
```
|
||||
|
||||
* 2.基于SVD(参考地址：http://www.codeweblog.com/svd-%E7%AC%94%E8%AE%B0/)
|
||||
* 2.基于SVD(参考地址: http://www.codeweblog.com/svd-%E7%AC%94%E8%AE%B0/)
|
||||
|
||||
|
||||
|
||||
|
|
@ -315,14 +315,14 @@ def recommend(dataMat, user, N=3, simMeas=cosSim, estMethod=standEst):
|
|||
|
||||
1. 通过各种标签来标记菜肴
|
||||
2. 将这些属性作为相似度计算所需要的数据
|
||||
3. 这就是：基于内容的推荐。
|
||||
3. 这就是: 基于内容的推荐。
|
||||
|
||||
> 构建推荐引擎面临的挑战
|
||||
|
||||
问题
|
||||
* 1）在大规模的数据集上，SVD分解会降低程序的速度
|
||||
* 2）存在其他很多规模扩展性的挑战性问题，比如矩阵的表示方法和计算相似度得分消耗资源。
|
||||
* 3）如何在缺乏数据时给出好的推荐-称为冷启动【简单说：用户不会喜欢一个无效的物品，而用户不喜欢的物品又无效】
|
||||
* 3）如何在缺乏数据时给出好的推荐-称为冷启动【简单说: 用户不会喜欢一个无效的物品，而用户不喜欢的物品又无效】
|
||||
|
||||
建议
|
||||
* 1）在大型系统中，SVD分解(可以在程序调入时运行一次)每天运行一次或者其频率更低，并且还要离线运行。
|
||||
|
|
@ -372,13 +372,13 @@ def analyse_data(Sigma, loopNum=20):
|
|||
|
||||
通常保留矩阵 80% ～ 90% 的能量，就可以得到重要的特征并取出噪声。
|
||||
'''
|
||||
print '主成分：%s, 方差占比：%s%%' % (format(i+1, '2.0f'), format(SigmaI/SigmaSum*100, '4.2f'))
|
||||
print '主成分: %s, 方差占比: %s%%' % (format(i+1, '2.0f'), format(SigmaI/SigmaSum*100, '4.2f'))
|
||||
```
|
||||
|
||||
> 使用算法: 对比使用 SVD 前后的数据差异对比，对于存储大家可以试着写写
|
||||
|
||||
|
||||
例如：`32*32=1024 => 32*2+2*1+32*2=130`(2*1表示去掉了除对角线的0), 几乎获得了10倍的压缩比。
|
||||
例如: `32*32=1024 => 32*2+2*1+32*2=130`(2*1表示去掉了除对角线的0), 几乎获得了10倍的压缩比。
|
||||
|
||||
```python
|
||||
# 打印矩阵
|
||||
|
|
@ -428,6 +428,6 @@ def imgCompress(numSV=3, thresh=0.8):
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [1988](http://cwiki.apachecn.org/display/~lihuisong)**
|
||||
* **作者: [片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [1988](http://cwiki.apachecn.org/display/~lihuisong)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
假如你为一家网络购物商店工作，很多用户访问该网站，其中有些人会购买商品，有些人则随意浏览后就离开。
|
||||
对于你来说，可能很想识别那些有购物意愿的用户。
|
||||
那么问题就来了，数据集可能会非常大，在单机上训练要运行好几天。
|
||||
接下来：我们讲讲 MapRedece 如何来解决这样的问题
|
||||
接下来: 我们讲讲 MapRedece 如何来解决这样的问题
|
||||
```
|
||||
|
||||
|
||||
|
|
@ -79,17 +79,17 @@ cat data/15.BigData_MapReduce/inputFile.txt | python src/python/15.BigData_MapRe
|
|||
|
||||
#### Mahout in Action
|
||||
|
||||
1. 简单贝叶斯：它属于为数不多的可以很自然的使用MapReduce的算法。通过统计在某个类别下某特征的概率。
|
||||
2. k-近邻算法：高维数据下（如文本、图像和视频）流行的近邻查找方法是局部敏感哈希算法。
|
||||
3. 支持向量机(SVM)：使用随机梯度下降算法求解，如Pegasos算法。
|
||||
4. 奇异值分解：Lanczos算法是一个有效的求解近似特征值的算法。
|
||||
5. k-均值聚类：canopy算法初始化k个簇，然后再运行K-均值求解结果。
|
||||
1. 简单贝叶斯: 它属于为数不多的可以很自然的使用MapReduce的算法。通过统计在某个类别下某特征的概率。
|
||||
2. k-近邻算法: 高维数据下（如文本、图像和视频）流行的近邻查找方法是局部敏感哈希算法。
|
||||
3. 支持向量机(SVM): 使用随机梯度下降算法求解，如Pegasos算法。
|
||||
4. 奇异值分解: Lanczos算法是一个有效的求解近似特征值的算法。
|
||||
5. k-均值聚类: canopy算法初始化k个簇，然后再运行K-均值求解结果。
|
||||
|
||||
### 使用 mrjob 库将 MapReduce 自动化
|
||||
|
||||
> 理论简介
|
||||
|
||||
* MapReduce 作业流自动化的框架：Cascading 和 Oozie.
|
||||
* MapReduce 作业流自动化的框架: Cascading 和 Oozie.
|
||||
* mrjob 是一个不错的学习工具，与2010年底实现了开源，来之于 Yelp(一个餐厅点评网站).
|
||||
|
||||
```Shell
|
||||
|
|
@ -106,7 +106,7 @@ python src/python/15.BigData_MapReduce/mrMean.py < data/15.BigData_MapReduce/inp
|
|||
python src/python/15.BigData_MapReduce/mrMean.py < data/15.BigData_MapReduce/inputFile.txt
|
||||
```
|
||||
|
||||
### 项目案例：分布式 SVM 的 Pegasos 算法
|
||||
### 项目案例: 分布式 SVM 的 Pegasos 算法
|
||||
|
||||
Pegasos是指原始估计梯度求解器(Peimal Estimated sub-GrAdient Solver)
|
||||
|
||||
|
|
@ -118,14 +118,14 @@ Pegasos是指原始估计梯度求解器(Peimal Estimated sub-GrAdient Solver)
|
|||
* 如果不是则将其加入到待更新集合。
|
||||
3. 批处理完毕后，权重向量按照这些错分的样本进行更新。
|
||||
|
||||
上述算法伪代码如下：
|
||||
上述算法伪代码如下:
|
||||
|
||||
```
|
||||
将 回归系数w 初始化为0
|
||||
对每次批处理
|
||||
随机选择 k 个样本点(向量)
|
||||
对每个向量
|
||||
如果该向量被错分：
|
||||
如果该向量被错分:
|
||||
更新权重向量 w
|
||||
累加对 w 的更新
|
||||
```
|
||||
|
|
@ -133,17 +133,17 @@ Pegasos是指原始估计梯度求解器(Peimal Estimated sub-GrAdient Solver)
|
|||
#### 开发流程
|
||||
|
||||
```
|
||||
收集数据：数据按文本格式存放。
|
||||
准备数据：输入数据已经是可用的格式，所以不需任何准备工作。如果你需要解析一个大规模的数据集，建议使用 map 作业来完成，从而达到并行处理的目的。
|
||||
分析数据：无。
|
||||
训练算法：与普通的 SVM 一样，在分类器训练上仍需花费大量的时间。
|
||||
测试算法：在二维空间上可视化之后，观察超平面，判断算法是否有效。
|
||||
使用算法：本例不会展示一个完整的应用，但会展示如何在大数据集上训练SVM。该算法其中一个应用场景就是本文分类，通常在文本分类里可能有大量的文档和成千上万的特征。
|
||||
收集数据: 数据按文本格式存放。
|
||||
准备数据: 输入数据已经是可用的格式，所以不需任何准备工作。如果你需要解析一个大规模的数据集，建议使用 map 作业来完成，从而达到并行处理的目的。
|
||||
分析数据: 无。
|
||||
训练算法: 与普通的 SVM 一样，在分类器训练上仍需花费大量的时间。
|
||||
测试算法: 在二维空间上可视化之后，观察超平面，判断算法是否有效。
|
||||
使用算法: 本例不会展示一个完整的应用，但会展示如何在大数据集上训练SVM。该算法其中一个应用场景就是本文分类，通常在文本分类里可能有大量的文档和成千上万的特征。
|
||||
```
|
||||
|
||||
> 收集数据
|
||||
|
||||
文本文件数据格式如下：
|
||||
文本文件数据格式如下:
|
||||
|
||||
```python
|
||||
0.365032 2.465645 -1
|
||||
|
|
@ -213,11 +213,11 @@ def batchPegasos(dataSet, labels, lam, T, k):
|
|||
|
||||
[完整代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/15.BigData_MapReduce/pegasos.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/15.BigData_MapReduce/pegasos.py>
|
||||
|
||||
运行方式：`python /opt/git/MachineLearning/src/python/15.BigData_MapReduce/mrSVM.py < data/15.BigData_MapReduce/inputFile.txt`
|
||||
运行方式: `python /opt/git/MachineLearning/src/python/15.BigData_MapReduce/mrSVM.py < data/15.BigData_MapReduce/inputFile.txt`
|
||||
[MR版本的代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/15.BigData_MapReduce/mrSVM.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/15.BigData_MapReduce/mrSVM.py>
|
||||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* **作者: [片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -2,9 +2,9 @@
|
|||
|
||||
## 背景与挖掘目标
|
||||
|
||||
随着互联网的快速发展，用户很难快速从海量信息中寻找到自己感兴趣的信息。因此诞生了：搜索引擎+推荐系统
|
||||
随着互联网的快速发展，用户很难快速从海量信息中寻找到自己感兴趣的信息。因此诞生了: 搜索引擎+推荐系统
|
||||
|
||||
本章节-推荐系统：
|
||||
本章节-推荐系统:
|
||||
|
||||
1. 帮助用户发现其感兴趣和可能感兴趣的信息。
|
||||
2. 让网站价值信息脱颖而出，得到广大用户的认可。
|
||||
|
|
@ -23,9 +23,9 @@
|
|||
|
||||
正常的情况下，需要对用户的兴趣爱好以及需求进行分类。
|
||||
因为在用户访问记录中，没有记录用户访问页面时间的长短，因此不容易判断用户兴趣爱好。
|
||||
因此，本文根据用户浏览的网页信息进行分析处理，主要采用以下方法处理：以用户浏览网页的类型进行分类，然后对每个类型中的内容进行推荐。
|
||||
因此，本文根据用户浏览的网页信息进行分析处理，主要采用以下方法处理: 以用户浏览网页的类型进行分类，然后对每个类型中的内容进行推荐。
|
||||
|
||||
分析过程如下：
|
||||
分析过程如下:
|
||||
|
||||
* 从系统中获取用户访问网站的原始记录。
|
||||
* 对数据进行多维分析，包括用户访问内容，流失用户分析以及用户分类等分析。
|
||||
|
|
@ -65,21 +65,21 @@
|
|||
* 矩阵分解通过把原始的评分矩阵R分解为两个矩阵相乘，并且只考虑有评分的值，训练时不考虑missing项的值。R矩阵分解成为U与V两个矩阵后，评分矩阵R中missing的值就可以通过U矩阵中的某列和V矩阵的某行相乘得到
|
||||
* 矩阵分解的目标函数: U矩阵与V矩阵的可以通过梯度下降(gradient descent)算法求得，通过交替更新u与v多次迭代收敛之后可求出U与V。
|
||||
* 矩阵分解背后的核心思想，找到两个矩阵，它们相乘之后得到的那个矩阵的值，与评分矩阵R中有值的位置中的值尽可能接近。这样一来，分解出来的两个矩阵相乘就尽可能还原了评分矩阵R，因为有值的地方，值都相差得尽可能地小，那么missing的值通过这样的方式计算得到，比较符合趋势。
|
||||
* 协同过滤中主要存在如下两个问题：稀疏性与冷启动问题。已有的方案通常会通过引入多个不同的数据源或者辅助信息(Side information)来解决这些问题，用户的Side information可以是用户的基本个人信息、用户画像信息等，而Item的Side information可以是物品的content信息等。
|
||||
* 协同过滤中主要存在如下两个问题: 稀疏性与冷启动问题。已有的方案通常会通过引入多个不同的数据源或者辅助信息(Side information)来解决这些问题，用户的Side information可以是用户的基本个人信息、用户画像信息等，而Item的Side information可以是物品的content信息等。
|
||||
|
||||
## 效果评估
|
||||
|
||||
1. 召回率和准确率 【人为统计分析】
|
||||
2. F值(P-R曲线) 【偏重：非均衡问题】
|
||||
3. ROC和AUC 【偏重：不同结果的对比】
|
||||
2. F值(P-R曲线) 【偏重: 非均衡问题】
|
||||
3. ROC和AUC 【偏重: 不同结果的对比】
|
||||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](https://github.com/jiangzhonglian)**
|
||||
* **作者: [片刻](https://github.com/jiangzhonglian)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
||||
> 摘录的原文地址：
|
||||
> 摘录的原文地址:
|
||||
|
||||
* [推荐系统中常用算法 以及优点缺点对比](http://www.36dsj.com/archives/9519)
|
||||
* [推荐算法的基于知识推荐](https://zhidao.baidu.com/question/2013524494179442228.html)
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
`k-近邻（kNN, k-NearestNeighbor）算法是一种基本分类与回归方法，我们这里只讨论分类问题中的 k-近邻算法。`
|
||||
|
||||
**一句话总结：近朱者赤近墨者黑！**
|
||||
**一句话总结: 近朱者赤近墨者黑！**
|
||||
|
||||
`k 近邻算法的输入为实例的特征向量，对应于特征空间的点；输出为实例的类别，可以取多类。k 近邻算法假设给定一个训练数据集，其中的实例类别已定。分类时，对新的实例，根据其 k 个最近邻的训练实例的类别，通过多数表决等方式进行预测。因此，k近邻算法不具有显式的学习过程。`
|
||||
|
||||
|
|
@ -16,8 +16,8 @@
|
|||
## KNN 场景
|
||||
|
||||
电影可以按照题材分类，那么如何区分 `动作片` 和 `爱情片` 呢？<br/>
|
||||
1. 动作片：打斗次数更多
|
||||
2. 爱情片：亲吻次数更多
|
||||
1. 动作片: 打斗次数更多
|
||||
2. 爱情片: 亲吻次数更多
|
||||
|
||||
基于电影中的亲吻、打斗出现的次数，使用 k-近邻算法构造程序，就可以自动划分电影的题材类型。
|
||||
|
||||
|
|
@ -47,20 +47,20 @@ knn 算法按照距离最近的三部电影的类型，决定未知电影的类
|
|||
> KNN 开发流程
|
||||
|
||||
```
|
||||
收集数据：任何方法
|
||||
准备数据：距离计算所需要的数值，最好是结构化的数据格式
|
||||
分析数据：任何方法
|
||||
训练算法：此步骤不适用于 k-近邻算法
|
||||
测试算法：计算错误率
|
||||
使用算法：输入样本数据和结构化的输出结果，然后运行 k-近邻算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理
|
||||
收集数据: 任何方法
|
||||
准备数据: 距离计算所需要的数值，最好是结构化的数据格式
|
||||
分析数据: 任何方法
|
||||
训练算法: 此步骤不适用于 k-近邻算法
|
||||
测试算法: 计算错误率
|
||||
使用算法: 输入样本数据和结构化的输出结果，然后运行 k-近邻算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理
|
||||
```
|
||||
|
||||
> KNN 算法特点
|
||||
|
||||
```
|
||||
优点：精度高、对异常值不敏感、无数据输入假定
|
||||
缺点：计算复杂度高、空间复杂度高
|
||||
适用数据范围：数值型和标称型
|
||||
优点: 精度高、对异常值不敏感、无数据输入假定
|
||||
缺点: 计算复杂度高、空间复杂度高
|
||||
适用数据范围: 数值型和标称型
|
||||
```
|
||||
|
||||
## KNN 项目案例
|
||||
|
|
@ -76,7 +76,7 @@ knn 算法按照距离最近的三部电影的类型，决定未知电影的类
|
|||
* 魅力一般的人
|
||||
* 极具魅力的人
|
||||
|
||||
她希望：
|
||||
她希望:
|
||||
1. 工作日与魅力一般的人约会
|
||||
2. 周末与极具魅力的人约会
|
||||
3. 不喜欢的人则直接排除掉
|
||||
|
|
@ -86,25 +86,25 @@ knn 算法按照距离最近的三部电影的类型，决定未知电影的类
|
|||
#### 开发流程
|
||||
|
||||
```
|
||||
收集数据：提供文本文件
|
||||
准备数据：使用 Python 解析文本文件
|
||||
分析数据：使用 Matplotlib 画二维散点图
|
||||
训练算法：此步骤不适用于 k-近邻算法
|
||||
测试算法：使用海伦提供的部分数据作为测试样本。
|
||||
测试样本和非测试样本的区别在于：
|
||||
收集数据: 提供文本文件
|
||||
准备数据: 使用 Python 解析文本文件
|
||||
分析数据: 使用 Matplotlib 画二维散点图
|
||||
训练算法: 此步骤不适用于 k-近邻算法
|
||||
测试算法: 使用海伦提供的部分数据作为测试样本。
|
||||
测试样本和非测试样本的区别在于:
|
||||
测试样本是已经完成分类的数据，如果预测分类与实际类别不同，则标记为一个错误。
|
||||
使用算法：产生简单的命令行程序，然后海伦可以输入一些特征数据以判断对方是否为自己喜欢的类型。
|
||||
使用算法: 产生简单的命令行程序，然后海伦可以输入一些特征数据以判断对方是否为自己喜欢的类型。
|
||||
```
|
||||
|
||||
> 收集数据：提供文本文件
|
||||
> 收集数据: 提供文本文件
|
||||
|
||||
海伦把这些约会对象的数据存放在文本文件 [datingTestSet2.txt](/data/2.KNN/datingTestSet2.txt) 中，总共有 1000 行。海伦约会的对象主要包含以下 3 种特征：
|
||||
海伦把这些约会对象的数据存放在文本文件 [datingTestSet2.txt](/data/2.KNN/datingTestSet2.txt) 中，总共有 1000 行。海伦约会的对象主要包含以下 3 种特征:
|
||||
|
||||
* 每年获得的飞行常客里程数
|
||||
* 玩视频游戏所耗时间百分比
|
||||
* 每周消费的冰淇淋公升数
|
||||
|
||||
文本文件数据格式如下：
|
||||
文本文件数据格式如下:
|
||||
```
|
||||
40920 8.326976 0.953952 3
|
||||
14488 7.153469 1.673904 2
|
||||
|
|
@ -112,7 +112,7 @@ knn 算法按照距离最近的三部电影的类型，决定未知电影的类
|
|||
75136 13.147394 0.428964 1
|
||||
38344 1.669788 0.134296 1
|
||||
```
|
||||
> 准备数据：使用 Python 解析文本文件
|
||||
> 准备数据: 使用 Python 解析文本文件
|
||||
|
||||
将文本记录转换为 NumPy 的解析程序
|
||||
|
||||
|
|
@ -130,7 +130,7 @@ def file2matrix(filename):
|
|||
# 获得文件中的数据行的行数
|
||||
numberOfLines = len(fr.readlines())
|
||||
# 生成对应的空矩阵
|
||||
# 例如：zeros(2，3)就是生成一个 2*3的矩阵，各个位置上全是 0
|
||||
# 例如: zeros(2，3)就是生成一个 2*3的矩阵，各个位置上全是 0
|
||||
returnMat = zeros((numberOfLines, 3)) # prepare matrix to return
|
||||
classLabelVector = [] # prepare labels return
|
||||
fr = open(filename)
|
||||
|
|
@ -149,7 +149,7 @@ def file2matrix(filename):
|
|||
return returnMat, classLabelVector
|
||||
```
|
||||
|
||||
> 分析数据：使用 Matplotlib 画二维散点图
|
||||
> 分析数据: 使用 Matplotlib 画二维散点图
|
||||
|
||||
```python
|
||||
import matplotlib
|
||||
|
|
@ -164,7 +164,7 @@ plt.show()
|
|||
|
||||
|
||||
|
||||
* 归一化数据 （归一化是一个让权重变为统一的过程，更多细节请参考： https://www.zhihu.com/question/19951858 ）
|
||||
* 归一化数据 （归一化是一个让权重变为统一的过程，更多细节请参考: https://www.zhihu.com/question/19951858 ）
|
||||
|
||||
| 序号 | 玩视频游戏所耗时间百分比 | 每年获得的飞行常客里程数 | 每周消费的冰淇淋公升数 | 样本分类 |
|
||||
| ------------- |:-------------:| -----:| -----:| -----:|
|
||||
|
|
@ -173,34 +173,34 @@ plt.show()
|
|||
| 3 | 0 | 20 000 | 1.1 | 2 |
|
||||
| 4 | 67 | 32 000 | 0.1 | 2 |
|
||||
|
||||
样本3和样本4的距离：
|
||||
样本3和样本4的距离:
|
||||
$$\sqrt{(0-67)^2 + (20000-32000)^2 + (1.1-0.1)^2 }$$
|
||||
|
||||
归一化特征值，消除特征之间量级不同导致的影响
|
||||
|
||||
**归一化定义：** 我是这样认为的，归一化就是要把你需要处理的数据经过处理后（通过某种算法）限制在你需要的一定范围内。首先归一化是为了后面数据处理的方便，其次是保正程序运行时收敛加快。 方法有如下：
|
||||
**归一化定义: ** 我是这样认为的，归一化就是要把你需要处理的数据经过处理后（通过某种算法）限制在你需要的一定范围内。首先归一化是为了后面数据处理的方便，其次是保正程序运行时收敛加快。 方法有如下:
|
||||
|
||||
1) 线性函数转换，表达式如下：
|
||||
1) 线性函数转换，表达式如下:
|
||||
|
||||
y=(x-MinValue)/(MaxValue-MinValue)
|
||||
|
||||
说明：x、y分别为转换前、后的值，MaxValue、MinValue分别为样本的最大值和最小值。
|
||||
说明: x、y分别为转换前、后的值，MaxValue、MinValue分别为样本的最大值和最小值。
|
||||
|
||||
2) 对数函数转换，表达式如下：
|
||||
2) 对数函数转换，表达式如下:
|
||||
|
||||
y=log10(x)
|
||||
|
||||
说明：以10为底的对数函数转换。
|
||||
说明: 以10为底的对数函数转换。
|
||||
|
||||
如图：
|
||||
如图:
|
||||
|
||||
|
||||
|
||||
3) 反余切函数转换，表达式如下：
|
||||
3) 反余切函数转换，表达式如下:
|
||||
|
||||
y=arctan(x)*2/PI
|
||||
|
||||
如图：
|
||||
如图:
|
||||
|
||||
|
||||
|
||||
|
|
@ -220,7 +220,7 @@ def autoNorm(dataSet):
|
|||
return:
|
||||
归一化后的数据集 normDataSet. ranges和minVals即最小值与范围，并没有用到
|
||||
|
||||
归一化公式：
|
||||
归一化公式:
|
||||
Y = (X-Xmin)/(Xmax-Xmin)
|
||||
其中的 min 和 max 分别是数据集中的最小特征值和最大特征值。该函数可以自动将数字特征值转化为0到1的区间。
|
||||
"""
|
||||
|
|
@ -238,15 +238,15 @@ def autoNorm(dataSet):
|
|||
return normDataSet, ranges, minVals
|
||||
```
|
||||
|
||||
> 训练算法：此步骤不适用于 k-近邻算法
|
||||
> 训练算法: 此步骤不适用于 k-近邻算法
|
||||
|
||||
因为测试数据每一次都要与全量的训练数据进行比较，所以这个过程是没有必要的。
|
||||
|
||||
kNN 算法伪代码：
|
||||
kNN 算法伪代码:
|
||||
|
||||
对于每一个在数据集中的数据点：
|
||||
对于每一个在数据集中的数据点:
|
||||
计算目标的数据点（需要分类的数据点）与该数据点的距离
|
||||
将距离排序：从小到大
|
||||
将距离排序: 从小到大
|
||||
选取前K个最短距离
|
||||
选取这K个中最多的分类类别
|
||||
返回该类别来作为目标数据点的预测值
|
||||
|
|
@ -259,11 +259,11 @@ def classify0(inX, dataSet, labels, k):
|
|||
sqDistances = sqDiffMat.sum(axis=1)
|
||||
distances = sqDistances**0.5
|
||||
|
||||
#将距离排序：从小到大
|
||||
#将距离排序: 从小到大
|
||||
sortedDistIndicies = distances.argsort()
|
||||
#选取前K个最短距离， 选取这K个中最多的分类类别
|
||||
classCount={}
|
||||
for i in range(k)：
|
||||
for i in range(k):
|
||||
voteIlabel = labels[sortedDistIndicies[i]]
|
||||
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
|
||||
sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
|
||||
|
|
@ -271,7 +271,7 @@ def classify0(inX, dataSet, labels, k):
|
|||
```
|
||||
|
||||
|
||||
> 测试算法：使用海伦提供的部分数据作为测试样本。如果预测分类与实际类别不同，则标记为一个错误。
|
||||
> 测试算法: 使用海伦提供的部分数据作为测试样本。如果预测分类与实际类别不同，则标记为一个错误。
|
||||
|
||||
kNN 分类器针对约会网站的测试代码
|
||||
|
||||
|
|
@ -306,7 +306,7 @@ def datingClassTest():
|
|||
print errorCount
|
||||
```
|
||||
|
||||
> 使用算法：产生简单的命令行程序，然后海伦可以输入一些特征数据以判断对方是否为自己喜欢的类型。
|
||||
> 使用算法: 产生简单的命令行程序，然后海伦可以输入一些特征数据以判断对方是否为自己喜欢的类型。
|
||||
|
||||
约会网站预测函数
|
||||
|
||||
|
|
@ -343,19 +343,19 @@ You will probably like this person: in small doses
|
|||
|
||||
构造一个能识别数字 0 到 9 的基于 KNN 分类器的手写数字识别系统。
|
||||
|
||||
需要识别的数字是存储在文本文件中的具有相同的色彩和大小：宽高是 32 像素 * 32 像素的黑白图像。
|
||||
需要识别的数字是存储在文本文件中的具有相同的色彩和大小: 宽高是 32 像素 * 32 像素的黑白图像。
|
||||
|
||||
#### 开发流程
|
||||
|
||||
```
|
||||
收集数据：提供文本文件。
|
||||
准备数据：编写函数 img2vector(), 将图像格式转换为分类器使用的向量格式
|
||||
分析数据：在 Python 命令提示符中检查数据，确保它符合要求
|
||||
训练算法：此步骤不适用于 KNN
|
||||
测试算法：编写函数使用提供的部分数据集作为测试样本，测试样本与非测试样本的
|
||||
收集数据: 提供文本文件。
|
||||
准备数据: 编写函数 img2vector(), 将图像格式转换为分类器使用的向量格式
|
||||
分析数据: 在 Python 命令提示符中检查数据，确保它符合要求
|
||||
训练算法: 此步骤不适用于 KNN
|
||||
测试算法: 编写函数使用提供的部分数据集作为测试样本，测试样本与非测试样本的
|
||||
区别在于测试样本是已经完成分类的数据，如果预测分类与实际类别不同，
|
||||
则标记为一个错误
|
||||
使用算法：本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从图像中提取
|
||||
使用算法: 本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从图像中提取
|
||||
数字，并完成数字识别，美国的邮件分拣系统就是一个实际运行的类似系统
|
||||
```
|
||||
|
||||
|
|
@ -380,7 +380,7 @@ def img2vector(filename):
|
|||
return returnVect
|
||||
```
|
||||
|
||||
> 分析数据：在 Python 命令提示符中检查数据，确保它符合要求
|
||||
> 分析数据: 在 Python 命令提示符中检查数据，确保它符合要求
|
||||
|
||||
在 Python 命令行中输入下列命令测试 img2vector 函数，然后与文本编辑器打开的文件进行比较:
|
||||
|
||||
|
|
@ -392,11 +392,11 @@ array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 0
|
|||
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
|
||||
```
|
||||
|
||||
> 训练算法：此步骤不适用于 KNN
|
||||
> 训练算法: 此步骤不适用于 KNN
|
||||
|
||||
因为测试数据每一次都要与全量的训练数据进行比较，所以这个过程是没有必要的。
|
||||
|
||||
> 测试算法：编写函数使用提供的部分数据集作为测试样本，如果预测分类与实际类别不同，则标记为一个错误
|
||||
> 测试算法: 编写函数使用提供的部分数据集作为测试样本，如果预测分类与实际类别不同，则标记为一个错误
|
||||
|
||||
```python
|
||||
def handwritingClassTest():
|
||||
|
|
@ -430,17 +430,17 @@ def handwritingClassTest():
|
|||
print "\nthe total error rate is: %f" % (errorCount / float(mTest))
|
||||
```
|
||||
|
||||
> 使用算法：本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从图像中提取数字，并完成数字识别，美国的邮件分拣系统就是一个实际运行的类似系统。
|
||||
> 使用算法: 本例没有完成此步骤，若你感兴趣可以构建完整的应用程序，从图像中提取数字，并完成数字识别，美国的邮件分拣系统就是一个实际运行的类似系统。
|
||||
|
||||
## KNN 小结
|
||||
|
||||
KNN 是什么？定义： 监督学习？ 非监督学习？
|
||||
KNN 是什么？定义: 监督学习？ 非监督学习？
|
||||
|
||||
KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模型。在分类和回归中均有应用。
|
||||
|
||||
### 基本原理
|
||||
|
||||
简单来说： 通过距离度量来计算查询点（query point）与每个训练数据点的距离，然后选出与查询点（query point）相近的K个最邻点（K nearest neighbors），使用分类决策来选出对应的标签来作为该查询点的标签。
|
||||
简单来说: 通过距离度量来计算查询点（query point）与每个训练数据点的距离，然后选出与查询点（query point）相近的K个最邻点（K nearest neighbors），使用分类决策来选出对应的标签来作为该查询点的标签。
|
||||
|
||||
### KNN 三要素
|
||||
|
||||
|
|
@ -454,7 +454,7 @@ KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模
|
|||
|
||||
>>>>太大太小都不太好，可以用交叉验证（cross validation）来选取适合的k值。
|
||||
|
||||
>>>>近似误差和估计误差，请看这里：https://www.zhihu.com/question/60793482
|
||||
>>>>近似误差和估计误差，请看这里: https://www.zhihu.com/question/60793482
|
||||
|
||||
>距离度量 Metric/Distance Measure
|
||||
|
||||
|
|
@ -464,7 +464,7 @@ KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模
|
|||
|
||||
>>>>分类决策 在 分类问题中 通常为通过少数服从多数 来选取票数最多的标签，在回归问题中通常为 K个最邻点的标签的平均值。
|
||||
|
||||
### 算法：（sklearn 上有三种）
|
||||
### 算法: （sklearn 上有三种）
|
||||
|
||||
>Brute Force 暴力计算/线性扫描
|
||||
|
||||
|
|
@ -474,27 +474,27 @@ KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模
|
|||
|
||||
>树结构的算法都有建树和查询两个过程。Brute Force 没有建树的过程。
|
||||
|
||||
>算法特点：
|
||||
>算法特点:
|
||||
|
||||
>>>>优点： High Accuracy， No Assumption on data， not sensitive to outliers
|
||||
>>>>优点: High Accuracy， No Assumption on data， not sensitive to outliers
|
||||
|
||||
>>>>缺点：时间和空间复杂度 高
|
||||
>>>>缺点: 时间和空间复杂度 高
|
||||
|
||||
>>>>适用范围： continuous values and nominal values
|
||||
>>>>适用范围: continuous values and nominal values
|
||||
|
||||
>相似同源产物：
|
||||
>相似同源产物:
|
||||
|
||||
>>>>radius neighbors 根据制定的半径来找寻邻点
|
||||
|
||||
>影响算法因素：
|
||||
>影响算法因素:
|
||||
|
||||
>>>>N 数据集样本数量(number of samples)， D 数据维度 (number of features)
|
||||
|
||||
>总消耗：
|
||||
>总消耗:
|
||||
|
||||
>>>>Brute Force: O[DN^2]
|
||||
|
||||
>>>>此处考虑的是最蠢的方法：把所有训练的点之间的距离都算一遍。当然有更快的实现方式, 比如 O(ND + kN) 和 O(NDK) , 最快的是 O[DN] 。感兴趣的可以阅读这个链接： [k-NN computational complexity](https://stats.stackexchange.com/questions/219655/k-nn-computational-complexity)
|
||||
>>>>此处考虑的是最蠢的方法: 把所有训练的点之间的距离都算一遍。当然有更快的实现方式, 比如 O(ND + kN) 和 O(NDK) , 最快的是 O[DN] 。感兴趣的可以阅读这个链接: [k-NN computational complexity](https://stats.stackexchange.com/questions/219655/k-nn-computational-complexity)
|
||||
|
||||
>>>>KD Tree: O[DN log(N)]
|
||||
|
||||
|
|
@ -530,7 +530,7 @@ KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模
|
|||
|
||||
>>>>查询点较少的时候用Brute Force。查询点较多的时候可以使用树结构算法。
|
||||
|
||||
>关于 sklearn 中模型的一些额外干货：
|
||||
>关于 sklearn 中模型的一些额外干货:
|
||||
|
||||
>>>>如果KD Tree，Ball Tree 和Brute Force 应用场景傻傻分不清楚，可以直接使用 含有algorithm='auto'的模组。 algorithm='auto' 自动为您选择最优算法。
|
||||
>>>>有 regressor 和 classifier 可以来选择。
|
||||
|
|
@ -539,11 +539,11 @@ KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模
|
|||
|
||||
>leaf size 对KD Tree 和 Ball Tree 的影响
|
||||
|
||||
>>>>建树时间：leaf size 比较大的时候，建树时间也就快点。
|
||||
>>>>建树时间: leaf size 比较大的时候，建树时间也就快点。
|
||||
|
||||
>>>>查询时间： leaf size 太大太小都不太好。如果leaf size 趋向于 N（训练数据的样本数量），算法其实就是 brute force了。如果leaf size 太小了，趋向于1，那查询的时候 遍历树的时间就会大大增加。leaf size 建议的数值是 30，也就是默认值。
|
||||
>>>>查询时间: leaf size 太大太小都不太好。如果leaf size 趋向于 N（训练数据的样本数量），算法其实就是 brute force了。如果leaf size 太小了，趋向于1，那查询的时候 遍历树的时间就会大大增加。leaf size 建议的数值是 30，也就是默认值。
|
||||
|
||||
>>>>内存： leaf size 变大，存树结构的内存变小。
|
||||
>>>>内存: leaf size 变大，存树结构的内存变小。
|
||||
|
||||
>Nearest Centroid Classifier
|
||||
|
||||
|
|
@ -551,17 +551,17 @@ KNN 是一个简单的无显示学习过程，非泛化学习的监督学习模
|
|||
|
||||
>>>>该模型假设在所有维度中方差相同。 是一个很好的base line。
|
||||
|
||||
>进阶版： Nearest Shrunken Centroid
|
||||
>进阶版: Nearest Shrunken Centroid
|
||||
|
||||
>>>>可以通过shrink_threshold来设置。
|
||||
|
||||
>>>>作用： 可以移除某些影响分类的特征，例如移除噪音特征的影响
|
||||
>>>>作用: 可以移除某些影响分类的特征，例如移除噪音特征的影响
|
||||
|
||||
|
||||
|
||||
|
||||
* * *
|
||||
|
||||
* **作者：[羊三](http://cwiki.apachecn.org/display/~xuxin) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* **作者: [羊三](http://cwiki.apachecn.org/display/~xuxin) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
102
docs/ml/3.决策树.md
102
docs/ml/3.决策树.md
|
|
@ -10,13 +10,13 @@
|
|||
|
||||
`决策树模型呈树形结构，在分类问题中，表示基于特征对实例进行分类的过程。它可以认为是 if-then 规则的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。`
|
||||
|
||||
`决策树学习通常包括 3 个步骤：特征选择、决策树的生成和决策树的修剪。`
|
||||
`决策树学习通常包括 3 个步骤: 特征选择、决策树的生成和决策树的修剪。`
|
||||
|
||||
## 决策树 场景
|
||||
|
||||
一个叫做 "二十个问题" 的游戏，游戏的规则很简单：参与游戏的一方在脑海中想某个事物，其他参与者向他提问，只允许提 20 个问题，问题的答案也只能用对或错回答。问问题的人通过推断分解，逐步缩小待猜测事物的范围，最后得到游戏的答案。
|
||||
一个叫做 "二十个问题" 的游戏，游戏的规则很简单: 参与游戏的一方在脑海中想某个事物，其他参与者向他提问，只允许提 20 个问题，问题的答案也只能用对或错回答。问问题的人通过推断分解，逐步缩小待猜测事物的范围，最后得到游戏的答案。
|
||||
|
||||
一个邮件分类系统，大致工作流程如下：
|
||||
一个邮件分类系统，大致工作流程如下:
|
||||
|
||||
|
||||
|
||||
|
|
@ -26,11 +26,11 @@
|
|||
如果不包含则将邮件归类到 "无需阅读的垃圾邮件" 。
|
||||
```
|
||||
|
||||
决策树的定义：
|
||||
决策树的定义:
|
||||
|
||||
分类决策树模型是一种描述对实例进行分类的树形结构。决策树由结点（node）和有向边（directed edge）组成。结点有两种类型：内部结点（internal node）和叶结点（leaf node）。内部结点表示一个特征或属性(features)，叶结点表示一个类(labels)。
|
||||
分类决策树模型是一种描述对实例进行分类的树形结构。决策树由结点（node）和有向边（directed edge）组成。结点有两种类型: 内部结点（internal node）和叶结点（leaf node）。内部结点表示一个特征或属性(features)，叶结点表示一个类(labels)。
|
||||
|
||||
用决策树对需要测试的实例进行分类：从根节点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子结点；这时，每一个子结点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直至达到叶结点。最后将实例分配到叶结点的类中。
|
||||
用决策树对需要测试的实例进行分类: 从根节点开始，对实例的某一特征进行测试，根据测试结果，将实例分配到其子结点；这时，每一个子结点对应着该特征的一个取值。如此递归地对实例进行测试并分配，直至达到叶结点。最后将实例分配到叶结点的类中。
|
||||
|
||||
## 决策树 原理
|
||||
|
||||
|
|
@ -38,19 +38,19 @@
|
|||
|
||||
#### 信息熵 & 信息增益
|
||||
|
||||
熵（entropy）：
|
||||
熵（entropy）:
|
||||
熵指的是体系的混乱的程度，在不同的学科中也有引申出的更为具体的定义，是各领域十分重要的参量。
|
||||
|
||||
信息论（information theory）中的熵（香农熵）：
|
||||
是一种信息的度量方式，表示信息的混乱程度，也就是说：信息越有序，信息熵越低。例如：火柴有序放在火柴盒里，熵值很低，相反，熵值很高。
|
||||
信息论（information theory）中的熵（香农熵）:
|
||||
是一种信息的度量方式，表示信息的混乱程度，也就是说: 信息越有序，信息熵越低。例如: 火柴有序放在火柴盒里，熵值很低，相反，熵值很高。
|
||||
|
||||
信息增益（information gain）：
|
||||
信息增益（information gain）:
|
||||
在划分数据集前后信息发生的变化称为信息增益。
|
||||
|
||||
### 决策树 工作原理
|
||||
|
||||
如何构造一个决策树?<br/>
|
||||
我们使用 createBranch() 方法，如下所示：
|
||||
我们使用 createBranch() 方法，如下所示:
|
||||
|
||||
```
|
||||
def createBranch():
|
||||
|
|
@ -71,20 +71,20 @@ def createBranch():
|
|||
### 决策树 开发流程
|
||||
|
||||
```
|
||||
收集数据：可以使用任何方法。
|
||||
准备数据：树构造算法 (这里使用的是ID3算法，只适用于标称型数据，这就是为什么数值型数据必须离散化。 还有其他的树构造算法，比如CART)
|
||||
分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。
|
||||
训练算法：构造树的数据结构。
|
||||
测试算法：使用训练好的树计算错误率。
|
||||
使用算法：此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义。
|
||||
收集数据: 可以使用任何方法。
|
||||
准备数据: 树构造算法 (这里使用的是ID3算法，只适用于标称型数据，这就是为什么数值型数据必须离散化。 还有其他的树构造算法，比如CART)
|
||||
分析数据: 可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。
|
||||
训练算法: 构造树的数据结构。
|
||||
测试算法: 使用训练好的树计算错误率。
|
||||
使用算法: 此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义。
|
||||
```
|
||||
|
||||
### 决策树 算法特点
|
||||
|
||||
```
|
||||
优点：计算复杂度不高，输出结果易于理解，数据有缺失也能跑，可以处理不相关特征。
|
||||
缺点：容易过拟合。
|
||||
适用数据类型：数值型和标称型。
|
||||
优点: 计算复杂度不高，输出结果易于理解，数据有缺失也能跑，可以处理不相关特征。
|
||||
缺点: 容易过拟合。
|
||||
适用数据类型: 数值型和标称型。
|
||||
```
|
||||
|
||||
## 决策树 项目案例
|
||||
|
|
@ -93,9 +93,9 @@ def createBranch():
|
|||
|
||||
#### 项目概述
|
||||
|
||||
根据以下 2 个特征，将动物分成两类：鱼类和非鱼类。
|
||||
根据以下 2 个特征，将动物分成两类: 鱼类和非鱼类。
|
||||
|
||||
特征：
|
||||
特征:
|
||||
1. 不浮出水面是否可以生存
|
||||
2. 是否有脚蹼
|
||||
|
||||
|
|
@ -104,15 +104,15 @@ def createBranch():
|
|||
[完整代码地址](/src/py2.x/ml/3.DecisionTree/DecisionTree.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/3.DecisionTree/DecisionTree.py>
|
||||
|
||||
```
|
||||
收集数据：可以使用任何方法
|
||||
准备数据：树构造算法（这里使用的是ID3算法，因此数值型数据必须离散化。）
|
||||
分析数据：可以使用任何方法，构造树完成之后，我们可以将树画出来。
|
||||
训练算法：构造树结构
|
||||
测试算法：使用习得的决策树执行分类
|
||||
使用算法：此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义
|
||||
收集数据: 可以使用任何方法
|
||||
准备数据: 树构造算法（这里使用的是ID3算法，因此数值型数据必须离散化。）
|
||||
分析数据: 可以使用任何方法，构造树完成之后，我们可以将树画出来。
|
||||
训练算法: 构造树结构
|
||||
测试算法: 使用习得的决策树执行分类
|
||||
使用算法: 此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义
|
||||
```
|
||||
|
||||
> 收集数据：可以使用任何方法
|
||||
> 收集数据: 可以使用任何方法
|
||||
|
||||
|
||||
|
||||
|
|
@ -128,11 +128,11 @@ def createDataSet():
|
|||
labels = ['no surfacing', 'flippers']
|
||||
return dataSet, labels
|
||||
```
|
||||
> 准备数据：树构造算法
|
||||
> 准备数据: 树构造算法
|
||||
|
||||
此处，由于我们输入的数据本身就是离散化数据，所以这一步就省略了。
|
||||
|
||||
> 分析数据：可以使用任何方法，构造树完成之后，我们可以将树画出来。
|
||||
> 分析数据: 可以使用任何方法，构造树完成之后，我们可以将树画出来。
|
||||
|
||||
|
||||
|
||||
|
|
@ -187,7 +187,7 @@ def splitDataSet(dataSet, index, value):
|
|||
# [:index]表示前index行，即若 index 为2，就是取 featVec 的前 index 行
|
||||
reducedFeatVec = featVec[:index]
|
||||
'''
|
||||
请百度查询一下： extend和append的区别
|
||||
请百度查询一下: extend和append的区别
|
||||
music_media.append(object) 向列表中添加一个对象object
|
||||
music_media.extend(sequence) 把一个序列seq的内容添加到列表中 (跟 += 在list运用类似， music_media += sequence)
|
||||
1、使用append的时候，是将object看作一个对象，整体打包添加到music_media对象中。
|
||||
|
|
@ -195,17 +195,17 @@ def splitDataSet(dataSet, index, value):
|
|||
music_media = []
|
||||
music_media.extend([1,2,3])
|
||||
print music_media
|
||||
#结果：
|
||||
#结果:
|
||||
#[1, 2, 3]
|
||||
|
||||
music_media.append([4,5,6])
|
||||
print music_media
|
||||
#结果：
|
||||
#结果:
|
||||
#[1, 2, 3, [4, 5, 6]]
|
||||
|
||||
music_media.extend([7,8,9])
|
||||
print music_media
|
||||
#结果：
|
||||
#结果:
|
||||
#[1, 2, 3, [4, 5, 6], 7, 8, 9]
|
||||
'''
|
||||
reducedFeatVec.extend(featVec[index+1:])
|
||||
|
|
@ -261,25 +261,25 @@ def chooseBestFeatureToSplit(dataSet):
|
|||
```
|
||||
|
||||
```
|
||||
问：上面的 newEntropy 为什么是根据子集计算的呢？
|
||||
答：因为我们在根据一个特征计算香农熵的时候，该特征的分类值是相同，这个特征这个分类的香农熵为 0；
|
||||
问: 上面的 newEntropy 为什么是根据子集计算的呢？
|
||||
答: 因为我们在根据一个特征计算香农熵的时候，该特征的分类值是相同，这个特征这个分类的香农熵为 0；
|
||||
这就是为什么计算新的香农熵的时候使用的是子集。
|
||||
```
|
||||
|
||||
> 训练算法：构造树的数据结构
|
||||
> 训练算法: 构造树的数据结构
|
||||
|
||||
创建树的函数代码如下：
|
||||
创建树的函数代码如下:
|
||||
|
||||
```python
|
||||
def createTree(dataSet, labels):
|
||||
classList = [example[-1] for example in dataSet]
|
||||
# 如果数据集的最后一列的第一个值出现的次数=整个集合的数量，也就说只有一个类别，就只直接返回结果就行
|
||||
# 第一个停止条件：所有的类标签完全相同，则直接返回该类标签。
|
||||
# 第一个停止条件: 所有的类标签完全相同，则直接返回该类标签。
|
||||
# count() 函数是统计括号中的值在list中出现的次数
|
||||
if classList.count(classList[0]) == len(classList):
|
||||
return classList[0]
|
||||
# 如果数据集只有1列，那么最初出现label次数最多的一类，作为结果
|
||||
# 第二个停止条件：使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
|
||||
# 第二个停止条件: 使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
|
||||
if len(dataSet[0]) == 1:
|
||||
return majorityCnt(classList)
|
||||
|
||||
|
|
@ -289,7 +289,7 @@ def createTree(dataSet, labels):
|
|||
bestFeatLabel = labels[bestFeat]
|
||||
# 初始化myTree
|
||||
myTree = {bestFeatLabel: {}}
|
||||
# 注：labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
|
||||
# 注: labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
|
||||
# 所以这行代码导致函数外的同名变量被删除了元素，造成例句无法执行，提示'no surfacing' is not in list
|
||||
del(labels[bestFeat])
|
||||
# 取出最优列，然后它的branch做分类
|
||||
|
|
@ -304,7 +304,7 @@ def createTree(dataSet, labels):
|
|||
return myTree
|
||||
```
|
||||
|
||||
> 测试算法：使用决策树执行分类
|
||||
> 测试算法: 使用决策树执行分类
|
||||
|
||||
```python
|
||||
def classify(inputTree, featLabels, testVec):
|
||||
|
|
@ -335,7 +335,7 @@ def classify(inputTree, featLabels, testVec):
|
|||
return classLabel
|
||||
```
|
||||
|
||||
> 使用算法：此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义。
|
||||
> 使用算法: 此步骤可以适用于任何监督学习任务，而使用决策树可以更好地理解数据的内在含义。
|
||||
|
||||
|
||||
### 项目案例2: 使用决策树预测隐形眼镜类型
|
||||
|
|
@ -355,9 +355,9 @@ def classify(inputTree, featLabels, testVec):
|
|||
5. 测试算法: 编写测试函数验证决策树可以正确分类给定的数据实例。
|
||||
6. 使用算法: 存储树的数据结构，以便下次使用时无需重新构造树。
|
||||
|
||||
> 收集数据：提供的文本文件
|
||||
> 收集数据: 提供的文本文件
|
||||
|
||||
文本文件数据格式如下：
|
||||
文本文件数据格式如下:
|
||||
|
||||
```
|
||||
young myope no reduced no lenses
|
||||
|
|
@ -365,20 +365,20 @@ pre myope no reduced no lenses
|
|||
presbyopic myope no reduced no lenses
|
||||
```
|
||||
|
||||
> 解析数据：解析 tab 键分隔的数据行
|
||||
> 解析数据: 解析 tab 键分隔的数据行
|
||||
|
||||
```python
|
||||
lecses = [inst.strip().split('\t') for inst in fr.readlines()]
|
||||
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
|
||||
```
|
||||
|
||||
> 分析数据：快速检查数据，确保正确地解析数据内容，使用 createPlot() 函数绘制最终的树形图。
|
||||
> 分析数据: 快速检查数据，确保正确地解析数据内容，使用 createPlot() 函数绘制最终的树形图。
|
||||
|
||||
```python
|
||||
>>> treePlotter.createPlot(lensesTree)
|
||||
```
|
||||
|
||||
> 训练算法：使用 createTree() 函数
|
||||
> 训练算法: 使用 createTree() 函数
|
||||
|
||||
```python
|
||||
>>> lensesTree = trees.createTree(lenses, lensesLabels)
|
||||
|
|
@ -412,6 +412,6 @@ def grabTree(filename):
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](https://github.com/jiangzhonglian) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* **作者: [片刻](https://github.com/jiangzhonglian) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
|
||||
# 第4章 基于概率论的分类方法：朴素贝叶斯
|
||||
# 第4章 基于概率论的分类方法: 朴素贝叶斯
|
||||
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
|
||||
|
||||
|
||||
|
|
@ -12,11 +12,11 @@
|
|||
|
||||
### 贝叶斯理论
|
||||
|
||||
我们现在有一个数据集，它由两类数据组成，数据分布如下图所示：
|
||||
我们现在有一个数据集，它由两类数据组成，数据分布如下图所示:
|
||||
|
||||
|
||||
|
||||
我们现在用 p1(x,y) 表示数据点 (x,y) 属于类别 1（图中用圆点表示的类别）的概率，用 p2(x,y) 表示数据点 (x,y) 属于类别 2（图中三角形表示的类别）的概率，那么对于一个新数据点 (x,y)，可以用下面的规则来判断它的类别：
|
||||
我们现在用 p1(x,y) 表示数据点 (x,y) 属于类别 1（图中用圆点表示的类别）的概率，用 p2(x,y) 表示数据点 (x,y) 属于类别 2（图中三角形表示的类别）的概率，那么对于一个新数据点 (x,y)，可以用下面的规则来判断它的类别:
|
||||
* 如果 p1(x,y) > p2(x,y) ，那么类别为1
|
||||
* 如果 p2(x,y) > p1(x,y) ，那么类别为2
|
||||
|
||||
|
|
@ -36,13 +36,13 @@
|
|||
|
||||
计算 P(white) 或者 P(black) ，如果事先我们知道石头所在桶的信息是会改变结果的。这就是所谓的条件概率（conditional probablity）。假定计算的是从 B 桶取到白色石头的概率，这个概率可以记作 P(white|bucketB) ，我们称之为“在已知石头出自 B 桶的条件下，取出白色石头的概率”。很容易得到，P(white|bucketA) 值为 2/4 ，P(white|bucketB) 的值为 1/3 。
|
||||
|
||||
条件概率的计算公式如下：
|
||||
条件概率的计算公式如下:
|
||||
|
||||
P(white|bucketB) = P(white and bucketB) / P(bucketB)
|
||||
|
||||
首先，我们用 B 桶中白色石头的个数除以两个桶中总的石头数，得到 P(white and bucketB) = 1/7 .其次，由于 B 桶中有 3 块石头，而总石头数为 7 ，于是 P(bucketB) 就等于 3/7 。于是又 P(white|bucketB) = P(white and bucketB) / P(bucketB) = (1/7) / (3/7) = 1/3 。
|
||||
|
||||
另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知 P(x|c)，要求 P(c|x)，那么可以使用下面的计算方法：
|
||||
另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知 P(x|c)，要求 P(c|x)，那么可以使用下面的计算方法:
|
||||
|
||||
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ def setOfWords2Vec(vocabList, inputSet):
|
|||
'stupid', 'so', 'take', 'mr', 'steak', 'my']
|
||||
```
|
||||
|
||||
检查函数有效性。例如：myVocabList 中索引为 2 的元素是什么单词？应该是是 help 。该单词在第一篇文档中出现了，现在检查一下看看它是否出现在第四篇文档中。
|
||||
检查函数有效性。例如: myVocabList 中索引为 2 的元素是什么单词？应该是是 help 。该单词在第一篇文档中出现了，现在检查一下看看它是否出现在第四篇文档中。
|
||||
|
||||
```python
|
||||
>>> bayes.setOfWords2Vec(myVocabList, listOPosts[0])
|
||||
|
|
@ -219,7 +219,7 @@ def setOfWords2Vec(vocabList, inputSet):
|
|||
|
||||
问: 上述代码实现中，为什么没有计算P(w)？
|
||||
|
||||
答：根据上述公式可知，我们右边的式子等同于左边的式子，由于对于每个ci，P(w)是固定的。并且我们只需要比较左边式子值的大小来决策分类，那么我们就可以简化为通过比较右边分子值得大小来做决策分类。
|
||||
答: 根据上述公式可知，我们右边的式子等同于左边的式子，由于对于每个ci，P(w)是固定的。并且我们只需要比较左边式子值的大小来决策分类，那么我们就可以简化为通过比较右边分子值得大小来做决策分类。
|
||||
|
||||
首先可以通过类别 i (侮辱性留言或者非侮辱性留言)中的文档数除以总的文档数来计算概率 p(ci) 。接下来计算 p(<b>w</b> | ci) ，这里就要用到朴素贝叶斯假设。如果将 w 展开为一个个独立特征，那么就可以将上述概率写作 p(w0, w1, w2...wn | ci) 。这里假设所有词都互相独立，该假设也称作条件独立性假设（例如 A 和 B 两个人抛骰子，概率是互不影响的，也就是相互独立的，A 抛 2点的同时 B 抛 3 点的概率就是 1/6 * 1/6），它意味着可以使用 p(w0 | ci)p(w1 | ci)p(w2 | ci)...p(wn | ci) 来计算上述概率，这样就极大地简化了计算的过程。
|
||||
|
||||
|
|
@ -326,10 +326,10 @@ def trainNB0(trainMatrix, trainCategory):
|
|||
```python
|
||||
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
|
||||
"""
|
||||
使用算法：
|
||||
使用算法:
|
||||
# 将乘法转换为加法
|
||||
乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
乘法: P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法: P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
:param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
|
||||
:param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
|
||||
:param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
|
||||
|
|
@ -340,7 +340,7 @@ def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
|
|||
# 大家可能会发现，上面的计算公式，没有除以贝叶斯准则的公式的分母，也就是 P(w) （P(w) 指的是此文档在所有的文档中出现的概率）就进行概率大小的比较了，
|
||||
# 因为 P(w) 针对的是包含侮辱和非侮辱的全部文档，所以 P(w) 是相同的。
|
||||
# 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
|
||||
# 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
# 我的理解是: 这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
p1 = sum(vec2Classify * p1Vec) + log(pClass1) # P(w|c1) * P(c1) ，即贝叶斯准则的分子
|
||||
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1) # P(w|c0) * P(c0) ，即贝叶斯准则的分子·
|
||||
if p1 > p0:
|
||||
|
|
@ -562,7 +562,7 @@ def spamTest():
|
|||
|
||||
> 收集数据: 从 RSS 源收集内容，这里需要对 RSS 源构建一个接口
|
||||
|
||||
也就是导入 RSS 源，我们使用 python 下载文本，在http://code.google.com/p/feedparser/ 下浏览相关文档，安装 feedparse，首先解压下载的包，并将当前目录切换到解压文件所在的文件夹，然后在 python 提示符下输入：
|
||||
也就是导入 RSS 源，我们使用 python 下载文本，在http://code.google.com/p/feedparser/ 下浏览相关文档，安装 feedparse，首先解压下载的包，并将当前目录切换到解压文件所在的文件夹，然后在 python 提示符下输入:
|
||||
|
||||
```python
|
||||
>>> python setup.py install
|
||||
|
|
@ -729,7 +729,7 @@ the error rate is: 0.55
|
|||
|
||||
接下来，我们要分析一下数据，显示地域相关的用词
|
||||
|
||||
可以先对向量pSF与pNY进行排序，然后按照顺序打印出来，将下面的代码添加到文件中：
|
||||
可以先对向量pSF与pNY进行排序，然后按照顺序打印出来，将下面的代码添加到文件中:
|
||||
|
||||
```python
|
||||
#最具表征性的词汇显示函数
|
||||
|
|
@ -752,7 +752,7 @@ def getTopWords(ny,sf):
|
|||
|
||||
函数 getTopWords() 使用两个 RSS 源作为输入，然后训练并测试朴素贝叶斯分类器，返回使用的概率值。然后创建两个列表用于元组的存储，与之前返回排名最高的 X 个单词不同，这里可以返回大于某个阈值的所有词，这些元组会按照它们的条件概率进行排序。
|
||||
|
||||
保存 bayes.py 文件，在python提示符下输入：
|
||||
保存 bayes.py 文件，在python提示符下输入:
|
||||
|
||||
```python
|
||||
>>> reload(bayes)
|
||||
|
|
@ -788,7 +788,7 @@ strings
|
|||
|
||||
***
|
||||
|
||||
* **作者：[羊三](http://cwiki.apachecn.org/display/~xuxin) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* **作者: [羊三](http://cwiki.apachecn.org/display/~xuxin) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
||||
|
|
|
|||
|
|
@ -64,19 +64,19 @@ Sigmoid 函数的输入记为 z ，由下面公式得到:
|
|||
|
||||
该公式将一直被迭代执行，直至达到某个停止条件为止，比如迭代次数达到某个指定值或者算法达到某个可以允许的误差范围。
|
||||
|
||||
介绍一下几个相关的概念：
|
||||
介绍一下几个相关的概念:
|
||||
```
|
||||
例如：y = w0 + w1x1 + w2x2 + ... + wnxn
|
||||
梯度：参考上图的例子，二维图像，x方向代表第一个系数，也就是 w1，y方向代表第二个系数也就是 w2，这样的向量就是梯度。
|
||||
α：上面的梯度算法的迭代公式中的阿尔法，这个代表的是移动步长（step length）。移动步长会影响最终结果的拟合程度，最好的方法就是随着迭代次数更改移动步长。
|
||||
例如: y = w0 + w1x1 + w2x2 + ... + wnxn
|
||||
梯度: 参考上图的例子，二维图像，x方向代表第一个系数，也就是 w1，y方向代表第二个系数也就是 w2，这样的向量就是梯度。
|
||||
α: 上面的梯度算法的迭代公式中的阿尔法，这个代表的是移动步长（step length）。移动步长会影响最终结果的拟合程度，最好的方法就是随着迭代次数更改移动步长。
|
||||
步长通俗的理解，100米，如果我一步走10米，我需要走10步；如果一步走20米，我只需要走5步。这里的一步走多少米就是步长的意思。
|
||||
▽f(w)：代表沿着梯度变化的方向。
|
||||
▽f(w): 代表沿着梯度变化的方向。
|
||||
```
|
||||
|
||||
|
||||
问：有人会好奇为什么有些书籍上说的是梯度下降法（Gradient Decent）?
|
||||
问: 有人会好奇为什么有些书籍上说的是梯度下降法（Gradient Decent）?
|
||||
|
||||
答： 其实这个两个方法在此情况下本质上是相同的。关键在于代价函数（cost function）或者叫目标函数（objective function）。如果目标函数是损失函数，那就是最小化损失函数来求函数的最小值，就用梯度下降。 如果目标函数是似然函数（Likelihood function），就是要最大化似然函数来求函数的最大值，那就用梯度上升。在逻辑回归中， 损失函数和似然函数无非就是互为正负关系。
|
||||
答: 其实这个两个方法在此情况下本质上是相同的。关键在于代价函数（cost function）或者叫目标函数（objective function）。如果目标函数是损失函数，那就是最小化损失函数来求函数的最小值，就用梯度下降。 如果目标函数是似然函数（Likelihood function），就是要最大化似然函数来求函数的最大值，那就用梯度上升。在逻辑回归中， 损失函数和似然函数无非就是互为正负关系。
|
||||
|
||||
只需要在迭代公式中的加法变成减法。因此，对应的公式可以写成
|
||||
|
||||
|
|
@ -210,7 +210,7 @@ Logistic 回归梯度上升优化算法
|
|||
|
||||
```python
|
||||
# 正常的处理方案
|
||||
# 两个参数：第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
|
||||
# 两个参数: 第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
|
||||
# 第二个参数==> classLabels 是类别标签，它是一个 1*100 的行向量。为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给labelMat。
|
||||
def gradAscent(dataMatIn, classLabels):
|
||||
# 转化为矩阵[[1,1,2],[1,1,2]....]
|
||||
|
|
@ -231,8 +231,8 @@ def gradAscent(dataMatIn, classLabels):
|
|||
weights = ones((n,1))
|
||||
for k in range(maxCycles): #heavy on matrix operations
|
||||
# m*3 的矩阵 * 3*1 的矩阵 ＝ m*1的矩阵
|
||||
# 那么乘上矩阵的意义，就代表：通过公式得到的理论值
|
||||
# 参考地址： 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
|
||||
# 那么乘上矩阵的意义，就代表: 通过公式得到的理论值
|
||||
# 参考地址: 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
|
||||
# print 'dataMatrix====', dataMatrix
|
||||
# print 'weights====', weights
|
||||
# n*3 * 3*1 = n*1
|
||||
|
|
@ -284,7 +284,7 @@ def plotBestFit(dataArr, labelMat, weights):
|
|||
dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
|
||||
w0*x0+w1*x1+w2*x2=f(x)
|
||||
x0最开始就设置为1叻， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了
|
||||
所以： w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2
|
||||
所以: w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2
|
||||
"""
|
||||
y = (-weights[0]-weights[1]*x)/weights[2]
|
||||
ax.plot(x, y)
|
||||
|
|
@ -433,7 +433,7 @@ def stocGradAscent1(dataMatrix, classLabels, numIter=150):
|
|||
假设有100个样本和20个特征，这些数据都是机器收集回来的。若机器上的某个传感器损坏导致一个特征无效时该怎么办？此时是否要扔掉整个数据？这种情况下，另外19个特征怎么办？
|
||||
它们是否还可以用？答案是肯定的。因为有时候数据相当昂贵，扔掉和重新获取都是不可取的，所以必须采用一些方法来解决这个问题。
|
||||
|
||||
下面给出了一些可选的做法：
|
||||
下面给出了一些可选的做法:
|
||||
* 使用可用特征的均值来填补缺失值；
|
||||
* 使用特殊值来填补缺失值，如 -1；
|
||||
* 忽略有缺失值的样本；
|
||||
|
|
@ -465,7 +465,7 @@ def stocGradAscent1(dataMatrix, classLabels, numIter=150):
|
|||
|
||||
```python
|
||||
# 正常的处理方案
|
||||
# 两个参数：第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
|
||||
# 两个参数: 第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
|
||||
# 第二个参数==> classLabels 是类别标签，它是一个 1*100 的行向量。为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给labelMat。
|
||||
def gradAscent(dataMatIn, classLabels):
|
||||
# 转化为矩阵[[1,1,2],[1,1,2]....]
|
||||
|
|
@ -486,8 +486,8 @@ def gradAscent(dataMatIn, classLabels):
|
|||
weights = ones((n,1))
|
||||
for k in range(maxCycles): #heavy on matrix operations
|
||||
# m*3 的矩阵 * 3*1 的单位矩阵 ＝ m*1的矩阵
|
||||
# 那么乘上单位矩阵的意义，就代表：通过公式得到的理论值
|
||||
# 参考地址： 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
|
||||
# 那么乘上单位矩阵的意义，就代表: 通过公式得到的理论值
|
||||
# 参考地址: 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
|
||||
# print 'dataMatrix====', dataMatrix
|
||||
# print 'weights====', weights
|
||||
# n*3 * 3*1 = n*1
|
||||
|
|
@ -634,11 +634,11 @@ Logistic回归和最大熵模型 都属于对数线性模型 （log linear model
|
|||
|
||||
## 多标签分类
|
||||
|
||||
逻辑回归也可以用作于多标签分类。 思路如下：
|
||||
逻辑回归也可以用作于多标签分类。 思路如下:
|
||||
|
||||
假设我们标签A中有a0,a1,a2....an个标签，对于每个标签 ai (ai 是标签A之一)，我们训练一个逻辑回归分类器。
|
||||
|
||||
即，训练该标签的逻辑回归分类器的时候，将ai看作一类标签，非ai的所有标签看作一类标签。那么相当于整个数据集里面只有两类标签：ai 和其他。
|
||||
即，训练该标签的逻辑回归分类器的时候，将ai看作一类标签，非ai的所有标签看作一类标签。那么相当于整个数据集里面只有两类标签: ai 和其他。
|
||||
|
||||
剩下步骤就跟我们训练正常的逻辑回归分类器一样了。
|
||||
|
||||
|
|
@ -646,6 +646,6 @@ Logistic回归和最大熵模型 都属于对数线性模型 （log linear model
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[羊三](http://cwiki.apachecn.org/display/~xuxin) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* **作者: [羊三](http://cwiki.apachecn.org/display/~xuxin) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -38,11 +38,11 @@ Classification Machine，是分类器，这个没什么好说的。也可以理
|
|||
|
||||
### “支持向量” 又是什么？
|
||||
|
||||
<b>通俗理解</b>：
|
||||
<b>通俗理解</b>:
|
||||
support vector （支持向量）的意思就是 <b>数据集中的某些点</b>，位置比较特殊。比如 x+y-2=0 这条直线，直线上面区域 x+y-2>0 的全是 A 类，下面的 x+y-2<0 的全是 B 类，我们找这条直线的时候，一般就看聚集在一起的两类数据，他们各自的 <b>最边缘</b> 位置的点，也就是最靠近划分直线的那几个点，而其他点对这条直线的最终位置的确定起不了作用，所以我姑且叫这些点叫 “支持点”（意思就是有用的点），但是在数学上，没这种说法，数学里的点，又可以叫向量，比如 二维点 (x,y) 就是二维向量，三维度的就是三维向量 (x,y,z)。所以 “<b>支持点</b>” 改叫 “<b>支持向量</b>” ，听起来比较专业，而且又装逼，何乐而不为呢？是吧...
|
||||
|
||||
<b>不通俗的理解</b>：
|
||||
在 maximum margin （最大间隔）上的这些点就叫 “支持向量”，我想补充的是为啥这些点就叫 “支持向量” ，因为最后的 classification machine （分类器）的表达式里只含有这些 “支持向量” 的信息，而与其他数据点无关：
|
||||
<b>不通俗的理解</b>:
|
||||
在 maximum margin （最大间隔）上的这些点就叫 “支持向量”，我想补充的是为啥这些点就叫 “支持向量” ，因为最后的 classification machine （分类器）的表达式里只含有这些 “支持向量” 的信息，而与其他数据点无关:
|
||||
|
||||
|
||||
|
||||
|
|
@ -79,13 +79,13 @@ support vector （支持向量）的意思就是 <b>数据集中的某些点</b>
|
|||
|
||||
## How does it work? （SVM 原理）
|
||||
|
||||
### 1、引用知乎上 [@简之](https://www.zhihu.com/people/wangjianzhi/answers) 大佬的回答：
|
||||
### 1、引用知乎上 [@简之](https://www.zhihu.com/people/wangjianzhi/answers) 大佬的回答:
|
||||
|
||||
首先我们讲个故事:
|
||||
|
||||
在很久以前的情人节，大侠要去救他的爱人，但魔鬼和他玩了一个游戏。
|
||||
|
||||
魔鬼在桌子上似乎有规律放了两种颜色的球，说：“你用一根棍分开它们？要求：尽量在放更多球之后，仍然适用。”
|
||||
魔鬼在桌子上似乎有规律放了两种颜色的球，说: “你用一根棍分开它们？要求: 尽量在放更多球之后，仍然适用。”
|
||||
|
||||
|
||||
|
||||
|
|
@ -119,12 +119,12 @@ SVM 就是试图把棍放在最佳位置，好让在棍的两边有尽可能大
|
|||
|
||||
再之后，无聊的大人们，把这些球叫做 <b>「data」</b>，把棍子叫做 <b>「classifier」</b>, 最大间隙 trick 叫做<b>「optimization」</b>， 拍桌子叫做<b>「kernelling」</b>, 那张纸叫做<b>「hyperplane」</b> 。
|
||||
|
||||
有梯子的童鞋，可以看一下这个地方，看视频来更直观的感受：
|
||||
有梯子的童鞋，可以看一下这个地方，看视频来更直观的感受:
|
||||
|
||||
https://www.youtube.com/watch?v=3liCbRZPrZA
|
||||
|
||||
|
||||
### 2、引用知乎 [@开膛手水货](https://www.zhihu.com/people/kai-tang-shou-xin/answers) 大佬的回答，我认为是超级通俗的一个版本：
|
||||
### 2、引用知乎 [@开膛手水货](https://www.zhihu.com/people/kai-tang-shou-xin/answers) 大佬的回答，我认为是超级通俗的一个版本:
|
||||
|
||||
支持向量机是用来解决分类问题的。
|
||||
|
||||
|
|
@ -150,15 +150,15 @@ d<D,米粒
|
|||
|
||||
以此类推，还有三维的，四维的，N维的 属性的分类，这样构造的也许就不是直线，而是平面，超平面。
|
||||
|
||||
一个三维的函数分类 ：x+y+z-2=0，这就是个分类的平面了。
|
||||
一个三维的函数分类 : x+y+z-2=0，这就是个分类的平面了。
|
||||
|
||||
有时候，分类的那条线不一定是直线，还有可能是曲线，我们通过某些函数来转换，就可以转化成刚才的哪种多维的分类问题，这个就是核函数的思想。
|
||||
|
||||
例如：分类的函数是个圆形 x^2+y^2-4=0 。这个时候令 x^2=a ; y^2=b ,还不就变成了a+b-4=0 这种直线问题了。
|
||||
例如: 分类的函数是个圆形 x^2+y^2-4=0 。这个时候令 x^2=a ; y^2=b ,还不就变成了a+b-4=0 这种直线问题了。
|
||||
|
||||
这就是支持向量机的思想。
|
||||
|
||||
### 3、引用 [@胡KF](https://www.zhihu.com/people/hu-kf/answers) 大佬的回答（这个需要一些数学知识）：
|
||||
### 3、引用 [@胡KF](https://www.zhihu.com/people/hu-kf/answers) 大佬的回答（这个需要一些数学知识）:
|
||||
|
||||
如图的例子，（训练集）红色点是我们已知的分类1，（训练集）蓝色点是已知的分类2，我们想寻找一个分隔超平面（图中绿线）（因为示例是二维数据点，所以只是一条线，如果数据是三维的就是平面，如果是三维以上就是超平面）把这两类完全分开，这样的话再来一个样本点需要我们预测的话，我们就可以根据这个分界超平面预测出分类结果。
|
||||
|
||||
|
|
@ -172,7 +172,7 @@ d<D,米粒
|
|||
|
||||
不同于传统的最小二乘策略的思想，我们采用一种新的思路，这个分界面有什么样的特征呢？
|
||||
|
||||
第一，它 “夹” 在两类样本点之间；第二，它离两类样本点中所有 “离它最近的点” ，都离它尽可能的远。如图所示：
|
||||
第一，它 “夹” 在两类样本点之间；第二，它离两类样本点中所有 “离它最近的点” ，都离它尽可能的远。如图所示:
|
||||
|
||||
|
||||
|
||||
|
|
@ -182,7 +182,7 @@ d<D,米粒
|
|||
|
||||
介绍完 SVM 的基本思想，我们来探讨一下如何用数学的方法进行 SVM 分类。
|
||||
|
||||
首先我们需要把刚刚说的最大间隔分类器的思想用数学公式表达出来。先定义几何间隔的概念，几何间隔就是在多维空间中一个多维点到一个超平面的距离，根据向量的知识可以算出来：
|
||||
首先我们需要把刚刚说的最大间隔分类器的思想用数学公式表达出来。先定义几何间隔的概念，几何间隔就是在多维空间中一个多维点到一个超平面的距离，根据向量的知识可以算出来:
|
||||
|
||||
|
||||
|
||||
|
|
@ -196,9 +196,9 @@ d<D,米粒
|
|||
|
||||
总之，在计算的过程中，我们不需要了解支持向量以外的其他样本点，只需要利用相对于所有样本点来说为数不多的支持向量，就可以求出分类超平面，计算复杂度大为降低。
|
||||
|
||||
### 4、引用知乎 [@靠靠靠谱](https://www.zhihu.com/people/kao-kao-kao-pu/answers) 大佬的理解（这个需要的数学知识更加厉害一点）：
|
||||
### 4、引用知乎 [@靠靠靠谱](https://www.zhihu.com/people/kao-kao-kao-pu/answers) 大佬的理解（这个需要的数学知识更加厉害一点）:
|
||||
|
||||
先看思维导图：
|
||||
先看思维导图:
|
||||
|
||||
* 左边是求解基本的SVM问题
|
||||
* 右边是相关扩展
|
||||
|
|
@ -225,7 +225,7 @@ Support Vector Machine, 一个普通的 SVM 就是一条直线罢了，用来完
|
|||
|
||||
|
||||
|
||||
（可以把 margin 看作是 boundary 的函数，并且想要找到使得是使得 margin 最大化的boundary，而 margin(*) 这个函数是：输入一个 boundary ，计算（正确分类的）所有苹果和香蕉中，到 boundary 的最小距离。）
|
||||
（可以把 margin 看作是 boundary 的函数，并且想要找到使得是使得 margin 最大化的boundary，而 margin(*) 这个函数是: 输入一个 boundary ，计算（正确分类的）所有苹果和香蕉中，到 boundary 的最小距离。）
|
||||
|
||||
又有最大又有最小看起来好矛盾。实际上『最大』是对这个整体使用不同 boundary 层面的最大，『最小』是在比较『点』的层面上的最小。外层在比较 boundary 找最大的 margin ，内层在比较点点找最小的距离。
|
||||
|
||||
|
|
@ -243,11 +243,11 @@ Support Vector Machine, 一个普通的 SVM 就是一条直线罢了，用来完
|
|||
|
||||
|
||||
|
||||
稍微借用刚刚数学表达里面的内容看个有趣的东西：
|
||||
稍微借用刚刚数学表达里面的内容看个有趣的东西:
|
||||
|
||||
还记得我们怎么预测一个新的水果是苹果还是香蕉吗？我们代入到分界的直线里，然后通过符号来判断。
|
||||
|
||||
刚刚w已经被表达出来了也就是说这个直线现在变成了： 
|
||||
刚刚w已经被表达出来了也就是说这个直线现在变成了: 
|
||||
|
||||
看似仿佛用到了所有的训练水果，但是其中  的水果都没有起到作用，剩下的就是小部分靠边边的 Support vectors 呀。
|
||||
|
||||
|
|
@ -277,13 +277,13 @@ Kernel trick.
|
|||
|
||||
|
||||
|
||||
可以每个类别做一次 SVM：是苹果还是不是苹果？是香蕉还是不是香蕉？是梨子还是不是梨子？从中选出可能性最大的。这是 one-versus-the-rest approach。
|
||||
可以每个类别做一次 SVM: 是苹果还是不是苹果？是香蕉还是不是香蕉？是梨子还是不是梨子？从中选出可能性最大的。这是 one-versus-the-rest approach。
|
||||
|
||||
也可以两两做一次 SVM：是苹果还是香蕉？是香蕉还是梨子？是梨子还是苹果？最后三个分类器投票决定。这是 one-versus-one approace。
|
||||
也可以两两做一次 SVM: 是苹果还是香蕉？是香蕉还是梨子？是梨子还是苹果？最后三个分类器投票决定。这是 one-versus-one approace。
|
||||
|
||||
但这其实都多多少少有问题，比如苹果特别多，香蕉特别少，我就无脑判断为苹果也不会错太多；多个分类器要放到一个台面上，万一他们的 scale 没有在一个台面上也未可知。
|
||||
|
||||
课后题：
|
||||
课后题:
|
||||
1、vector 不愿意 support 怎么办？
|
||||
2、苹果好吃还是香蕉好吃？
|
||||
|
||||
|
|
|
|||
|
|
@ -5,14 +5,14 @@
|
|||
|
||||
## 支持向量机 概述
|
||||
|
||||
支持向量机(Support Vector Machines, SVM)：是一种监督学习算法。
|
||||
支持向量机(Support Vector Machines, SVM): 是一种监督学习算法。
|
||||
* 支持向量(Support Vector)就是离分隔超平面最近的那些点。
|
||||
* 机(Machine)就是表示一种算法，而不是表示机器。
|
||||
|
||||
## 支持向量机 场景
|
||||
|
||||
* 要给左右两边的点进行分类
|
||||
* 明显发现：选择D会比B、C分隔的效果要好很多。
|
||||
* 明显发现: 选择D会比B、C分隔的效果要好很多。
|
||||
|
||||
|
||||
|
||||
|
|
@ -39,7 +39,7 @@
|
|||
#### 为什么寻找最大间隔
|
||||
|
||||
```
|
||||
摘录地址：http://slideplayer.com/slide/8610144 (第12条信息)
|
||||
摘录地址: http://slideplayer.com/slide/8610144 (第12条信息)
|
||||
Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why Maximum Margin?
|
||||
|
||||
1.Intuitively this feels safest.
|
||||
|
|
@ -62,7 +62,7 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
|
|||
> 点到超平面的距离
|
||||
|
||||
* 分隔超平面`函数间距`: \\(y(x)=w^Tx+b\\)
|
||||
* 分类的结果： \\(f(x)=sign(w^Tx+b)\\) (sign表示>0为1，<0为-1，=0为0)
|
||||
* 分类的结果: \\(f(x)=sign(w^Tx+b)\\) (sign表示>0为1，<0为-1，=0为0)
|
||||
* 点到超平面的`几何间距`: \\(d(x)=(w^Tx+b)/||w||\\) （||w||表示w矩阵的二范数=> \\(\sqrt{w^T*w}\\), 点到超平面的距离也是类似的）
|
||||
|
||||
|
||||
|
|
@ -71,12 +71,12 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
|
|||
|
||||
* 类别标签用-1、1，是为了后期方便 \\(label*(w^Tx+b)\\) 的标识和距离计算；如果 \\(label*(w^Tx+b)>0\\) 表示预测正确，否则预测错误。
|
||||
* 现在目标很明确，就是要找到`w`和`b`，因此我们必须要找到最小间隔的数据点，也就是前面所说的`支持向量`。
|
||||
* 也就说，让最小的距离取最大.(最小的距离：就是最小间隔的数据点；最大：就是最大间距，为了找出最优超平面--最终就是支持向量)
|
||||
* 目标函数：\\(arg: max_{关于w, b} \left( min[label*(w^Tx+b)]*\frac{1}{||w||} \right) \\)
|
||||
* 也就说，让最小的距离取最大.(最小的距离: 就是最小间隔的数据点；最大: 就是最大间距，为了找出最优超平面--最终就是支持向量)
|
||||
* 目标函数: \\(arg: max_{关于w, b} \left( min[label*(w^Tx+b)]*\frac{1}{||w||} \right) \\)
|
||||
1. 如果 \\(label*(w^Tx+b)>0\\) 表示预测正确，也称`函数间隔`，\\(||w||\\) 可以理解为归一化，也称`几何间隔`。
|
||||
2. 令 \\(label*(w^Tx+b)>=1\\)， 因为0～1之间，得到的点是存在误判的可能性，所以要保障 \\(min[label*(w^Tx+b)]=1\\)，才能更好降低噪音数据影响。
|
||||
3. 所以本质上是求 \\(arg: max_{关于w, b} \frac{1}{||w||} \\)；也就说，我们约束(前提)条件是: \\(label*(w^Tx+b)=1\\)
|
||||
* 新的目标函数求解： \\(arg: max_{关于w, b} \frac{1}{||w||} \\)
|
||||
* 新的目标函数求解: \\(arg: max_{关于w, b} \frac{1}{||w||} \\)
|
||||
* => 就是求: \\(arg: min_{关于w, b} ||w|| \\) (求矩阵会比较麻烦，如果x只是 \\(\frac{1}{2}*x^2\\) 的偏导数，那么。。同样是求最小值)
|
||||
* => 就是求: \\(arg: min_{关于w, b} (\frac{1}{2}*||w||^2)\\) (二次函数求导，求极值，平方也方便计算)
|
||||
* 本质上就是求线性不等式的二次优化问题(求分隔超平面，等价于求解相应的凸二次规划问题)
|
||||
|
|
@ -85,66 +85,66 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
|
|||
* 设g(x,y)=M-φ(x,y) # 临时φ(x,y)表示下文中 \\(label*(w^Tx+b)\\)
|
||||
* 定义一个新函数: F(x,y,λ)=f(x,y)+λg(x,y)
|
||||
* a为λ（a>=0），代表要引入的拉格朗日乘子(Lagrange multiplier)
|
||||
* 那么： \\(L(w,b,\alpha)=\frac{1}{2} * ||w||^2 + \sum_{i=1}^{n} \alpha_i * [1 - label * (w^Tx+b)]\\)
|
||||
* 因为：\\(label*(w^Tx+b)>=1, \alpha>=0\\) , 所以 \\(\alpha*[1-label*(w^Tx+b)]<=0\\) , \\(\sum_{i=1}^{n} \alpha_i * [1-label*(w^Tx+b)]<=0\\)
|
||||
* 那么: \\(L(w,b,\alpha)=\frac{1}{2} * ||w||^2 + \sum_{i=1}^{n} \alpha_i * [1 - label * (w^Tx+b)]\\)
|
||||
* 因为: \\(label*(w^Tx+b)>=1, \alpha>=0\\) , 所以 \\(\alpha*[1-label*(w^Tx+b)]<=0\\) , \\(\sum_{i=1}^{n} \alpha_i * [1-label*(w^Tx+b)]<=0\\)
|
||||
* 当 \\(label*(w^Tx+b)>1\\) 则 \\(\alpha=0\\) ，表示该点为<font color=red>非支持向量</font>
|
||||
* 相当于求解： \\(max_{关于\alpha} L(w,b,\alpha) = \frac{1}{2} *||w||^2\\)
|
||||
* 如果求： \\(min_{关于w, b} \frac{1}{2} *||w||^2\\) , 也就是要求： \\(min_{关于w, b} \left( max_{关于\alpha} L(w,b,\alpha)\right)\\)
|
||||
* 相当于求解: \\(max_{关于\alpha} L(w,b,\alpha) = \frac{1}{2} *||w||^2\\)
|
||||
* 如果求: \\(min_{关于w, b} \frac{1}{2} *||w||^2\\) , 也就是要求: \\(min_{关于w, b} \left( max_{关于\alpha} L(w,b,\alpha)\right)\\)
|
||||
* 现在转化到对偶问题的求解
|
||||
* \\(min_{关于w, b} \left(max_{关于\alpha} L(w,b,\alpha) \right) \\) >= \\(max_{关于\alpha} \left(min_{关于w, b}\ L(w,b,\alpha) \right) \\)
|
||||
* 现在分2步
|
||||
* 先求： \\(min_{关于w, b} L(w,b,\alpha)=\frac{1}{2} * ||w||^2 + \sum_{i=1}^{n} \alpha_i * [1 - label * (w^Tx+b)]\\)
|
||||
* 就是求`L(w,b,a)`关于[w, b]的偏导数, 得到`w和b的值`，并化简为：`L和a的方程`。
|
||||
* 参考： 如果公式推导还是不懂，也可以参考《统计学习方法》李航-P103<学习的对偶算法>
|
||||
* 先求: \\(min_{关于w, b} L(w,b,\alpha)=\frac{1}{2} * ||w||^2 + \sum_{i=1}^{n} \alpha_i * [1 - label * (w^Tx+b)]\\)
|
||||
* 就是求`L(w,b,a)`关于[w, b]的偏导数, 得到`w和b的值`，并化简为: `L和a的方程`。
|
||||
* 参考: 如果公式推导还是不懂，也可以参考《统计学习方法》李航-P103<学习的对偶算法>
|
||||
|
||||
* 终于得到课本上的公式： \\(max_{关于\alpha} \left( \sum_{i=1}^{m} \alpha_i - \frac{1}{2} \sum_{i, j=1}^{m} label_i·label_j·\alpha_i·\alpha_j·<x_i, x_j> \right) \\)
|
||||
* 约束条件： \\(a>=0\\) 并且 \\(\sum_{i=1}^{m} a_i·label_i=0\\)
|
||||
* 终于得到课本上的公式: \\(max_{关于\alpha} \left( \sum_{i=1}^{m} \alpha_i - \frac{1}{2} \sum_{i, j=1}^{m} label_i·label_j·\alpha_i·\alpha_j·<x_i, x_j> \right) \\)
|
||||
* 约束条件: \\(a>=0\\) 并且 \\(\sum_{i=1}^{m} a_i·label_i=0\\)
|
||||
|
||||
> 松弛变量(slack variable)
|
||||
|
||||
参考地址：http://blog.csdn.net/wusecaiyun/article/details/49659183
|
||||
参考地址: http://blog.csdn.net/wusecaiyun/article/details/49659183
|
||||
|
||||
|
||||
|
||||
* 我们知道几乎所有的数据都不那么干净, 通过引入松弛变量来 `允许数据点可以处于分隔面错误的一侧`。
|
||||
* 约束条件： \\(C>=a>=0\\) 并且 \\(\sum_{i=1}^{m} a_i·label_i=0\\)
|
||||
* 总的来说：
|
||||
* 约束条件: \\(C>=a>=0\\) 并且 \\(\sum_{i=1}^{m} a_i·label_i=0\\)
|
||||
* 总的来说:
|
||||
*  表示 `松弛变量`
|
||||
* 常量C是 `惩罚因子`, 表示离群点的权重（用于控制“最大化间隔”和“保证大部分点的函数间隔小于1.0” ）
|
||||
* \\(label*(w^Tx+b) > 1\\) and alpha = 0 (在边界外，就是非支持向量)
|
||||
* \\(label*(w^Tx+b) = 1\\) and 0< alpha < C (在分割超平面上，就支持向量)
|
||||
* \\(label*(w^Tx+b) < 1\\) and alpha = C (在分割超平面内，是误差点 -> C表示它该受到的惩罚因子程度)
|
||||
* 参考地址：https://www.zhihu.com/question/48351234/answer/110486455
|
||||
* 参考地址: https://www.zhihu.com/question/48351234/answer/110486455
|
||||
* C值越大，表示离群点影响越大，就越容易过度拟合；反之有可能欠拟合。
|
||||
* 我们看到，目标函数控制了离群点的数目和程度，使大部分样本点仍然遵守限制条件。
|
||||
* 例如：正类有10000个样本，而负类只给了100个（C越大表示100个负样本的影响越大，就会出现过度拟合，所以C决定了负样本对模型拟合程度的影响！，C就是一个非常关键的优化点！）
|
||||
* 例如: 正类有10000个样本，而负类只给了100个（C越大表示100个负样本的影响越大，就会出现过度拟合，所以C决定了负样本对模型拟合程度的影响！，C就是一个非常关键的优化点！）
|
||||
* 这一结论十分直接，SVM中的主要工作就是要求解 alpha.
|
||||
|
||||
### SMO 高效优化算法
|
||||
|
||||
* SVM有很多种实现，最流行的一种实现是： `序列最小优化(Sequential Minimal Optimization, SMO)算法`。
|
||||
* SVM有很多种实现，最流行的一种实现是: `序列最小优化(Sequential Minimal Optimization, SMO)算法`。
|
||||
* 下面还会介绍一种称为 `核函数(kernel)` 的方式将SVM扩展到更多数据集上。
|
||||
* 注意：`SVM几何含义比较直观，但其算法实现较复杂，牵扯大量数学公式的推导。`
|
||||
* 注意: `SVM几何含义比较直观，但其算法实现较复杂，牵扯大量数学公式的推导。`
|
||||
|
||||
> 序列最小优化(Sequential Minimal Optimization, SMO)
|
||||
|
||||
* 创建作者：John Platt
|
||||
* 创建时间：1996年
|
||||
* SMO用途：用于训练 SVM
|
||||
* SMO目标：求出一系列 alpha 和 b,一旦求出 alpha，就很容易计算出权重向量 w 并得到分隔超平面。
|
||||
* SMO思想：是将大优化问题分解为多个小优化问题来求解的。
|
||||
* SMO原理：每次循环选择两个 alpha 进行优化处理，一旦找出一对合适的 alpha，那么就增大一个同时减少一个。
|
||||
* 创建作者: John Platt
|
||||
* 创建时间: 1996年
|
||||
* SMO用途: 用于训练 SVM
|
||||
* SMO目标: 求出一系列 alpha 和 b,一旦求出 alpha，就很容易计算出权重向量 w 并得到分隔超平面。
|
||||
* SMO思想: 是将大优化问题分解为多个小优化问题来求解的。
|
||||
* SMO原理: 每次循环选择两个 alpha 进行优化处理，一旦找出一对合适的 alpha，那么就增大一个同时减少一个。
|
||||
* 这里指的合适必须要符合一定的条件
|
||||
1. 这两个 alpha 必须要在间隔边界之外
|
||||
2. 这两个 alpha 还没有进行过区间化处理或者不在边界上。
|
||||
* 之所以要同时改变2个 alpha；原因是我们有一个约束条件： \\(\sum_{i=1}^{m} a_i·label_i=0\\)；如果只是修改一个 alpha，很可能导致约束条件失效。
|
||||
* 之所以要同时改变2个 alpha；原因是我们有一个约束条件: \\(\sum_{i=1}^{m} a_i·label_i=0\\)；如果只是修改一个 alpha，很可能导致约束条件失效。
|
||||
|
||||
> SMO 伪代码大致如下：
|
||||
> SMO 伪代码大致如下:
|
||||
|
||||
```
|
||||
创建一个 alpha 向量并将其初始化为0向量
|
||||
当迭代次数小于最大迭代次数时(外循环)
|
||||
对数据集中的每个数据向量(内循环)：
|
||||
对数据集中的每个数据向量(内循环):
|
||||
如果该数据向量可以被优化
|
||||
随机选择另外一个数据向量
|
||||
同时优化这两个向量
|
||||
|
|
@ -155,20 +155,20 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
|
|||
### SVM 开发流程
|
||||
|
||||
```
|
||||
收集数据：可以使用任意方法。
|
||||
准备数据：需要数值型数据。
|
||||
分析数据：有助于可视化分隔超平面。
|
||||
训练算法：SVM的大部分时间都源自训练，该过程主要实现两个参数的调优。
|
||||
测试算法：十分简单的计算过程就可以实现。
|
||||
使用算法：几乎所有分类问题都可以使用SVM，值得一提的是，SVM本身是一个二类分类器，对多类问题应用SVM需要对代码做一些修改。
|
||||
收集数据: 可以使用任意方法。
|
||||
准备数据: 需要数值型数据。
|
||||
分析数据: 有助于可视化分隔超平面。
|
||||
训练算法: SVM的大部分时间都源自训练，该过程主要实现两个参数的调优。
|
||||
测试算法: 十分简单的计算过程就可以实现。
|
||||
使用算法: 几乎所有分类问题都可以使用SVM，值得一提的是，SVM本身是一个二类分类器，对多类问题应用SVM需要对代码做一些修改。
|
||||
```
|
||||
|
||||
### SVM 算法特点
|
||||
|
||||
```
|
||||
优点：泛化（由具体的、个别的扩大为一般的，就是说：模型训练完后的新样本）错误率低，计算开销不大，结果易理解。
|
||||
缺点：对参数调节和核函数的选择敏感，原始分类器不加修改仅适合于处理二分类问题。
|
||||
使用数据类型：数值型和标称型数据。
|
||||
优点: 泛化（由具体的、个别的扩大为一般的，就是说: 模型训练完后的新样本）错误率低，计算开销不大，结果易理解。
|
||||
缺点: 对参数调节和核函数的选择敏感，原始分类器不加修改仅适合于处理二分类问题。
|
||||
使用数据类型: 数值型和标称型数据。
|
||||
```
|
||||
|
||||
### 课本案例（无核函数）
|
||||
|
|
@ -181,7 +181,7 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
|
|||
|
||||
> 收集数据
|
||||
|
||||
文本文件格式：
|
||||
文本文件格式:
|
||||
|
||||
```python
|
||||
3.542485 1.977398 -1
|
||||
|
|
@ -261,7 +261,7 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
|
||||
# 约束条件 (KKT条件是解决最优化问题的时用到的一种方法。我们这里提到的最优化问题通常是指对于给定的某一函数，求其在指定作用域上的全局最小值)
|
||||
# 0<=alphas[i]<=C，但由于0和C是边界值，我们无法进行优化，因为需要增加一个alphas和降低一个alphas。
|
||||
# 表示发生错误的概率：labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
# 表示发生错误的概率: labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
'''
|
||||
# 检验训练样本(xi, yi)是否满足KKT条件
|
||||
yi*f(i) >= 1 and alpha = 0 (outside the boundary)
|
||||
|
|
@ -310,7 +310,7 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
|
||||
# 在对alpha[i], alpha[j] 进行优化之后，给这两个alpha值设置一个常数b。
|
||||
# w= Σ[1~n] ai*yi*xi => b = yj- Σ[1~n] ai*yi(xi*xj)
|
||||
# 所以： b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 所以: b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 为什么减2遍？ 因为是 减去Σ[1~n]，正好2个变量i和j，所以减2遍
|
||||
b1 = b - Ei- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i, :]*dataMatrix[i, :].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[i, :]*dataMatrix[j, :].T
|
||||
b2 = b - Ej- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i, :]*dataMatrix[j, :].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[j, :]*dataMatrix[j, :].T
|
||||
|
|
@ -332,9 +332,9 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
return b, alphas
|
||||
```
|
||||
|
||||
[完整代码地址：SVM简化版，应用简化版SMO算法处理小规模数据集](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-simple.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-simple.py>
|
||||
[完整代码地址: SVM简化版，应用简化版SMO算法处理小规模数据集](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-simple.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-simple.py>
|
||||
|
||||
[完整代码地址：SVM完整版，使用完整 Platt SMO算法加速优化，优化点：选择alpha的方式不同](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-complete_Non-Kernel.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-complete_Non-Kernel.py>
|
||||
[完整代码地址: SVM完整版，使用完整 Platt SMO算法加速优化，优化点: 选择alpha的方式不同](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-complete_Non-Kernel.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-complete_Non-Kernel.py>
|
||||
|
||||
## 核函数(kernel) 使用
|
||||
|
||||
|
|
@ -343,13 +343,13 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
|
||||
> 利用核函数将数据映射到高维空间
|
||||
|
||||
* 使用核函数：可以将数据从某个特征空间到另一个特征空间的映射。（通常情况下：这种映射会将低维特征空间映射到高维空间。）
|
||||
* 使用核函数: 可以将数据从某个特征空间到另一个特征空间的映射。（通常情况下: 这种映射会将低维特征空间映射到高维空间。）
|
||||
* 如果觉得特征空间很装逼、很难理解。
|
||||
* 可以把核函数想象成一个包装器(wrapper)或者是接口(interface)，它能将数据从某个很难处理的形式转换成为另一个较容易处理的形式。
|
||||
* 经过空间转换后：低维需要解决的非线性问题，就变成了高维需要解决的线性问题。
|
||||
* 经过空间转换后: 低维需要解决的非线性问题，就变成了高维需要解决的线性问题。
|
||||
* SVM 优化特别好的地方，在于所有的运算都可以写成内积(inner product: 是指2个向量相乘，得到单个标量 或者 数值)；内积替换成核函数的方式被称为`核技巧(kernel trick)`或者`核"变电"(kernel substation)`
|
||||
* 核函数并不仅仅应用于支持向量机，很多其他的机器学习算法也都用到核函数。最流行的核函数：径向基函数(radial basis function)
|
||||
* 径向基函数的高斯版本，其具体的公式为：
|
||||
* 核函数并不仅仅应用于支持向量机，很多其他的机器学习算法也都用到核函数。最流行的核函数: 径向基函数(radial basis function)
|
||||
* 径向基函数的高斯版本，其具体的公式为:
|
||||
|
||||
|
||||
|
||||
|
|
@ -358,13 +358,13 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
#### 项目概述
|
||||
|
||||
```python
|
||||
你的老板要求：你写的那个手写识别程序非常好，但是它占用内存太大。顾客无法通过无线的方式下载我们的应用。
|
||||
所以：我们可以考虑使用支持向量机，保留支持向量就行（knn需要保留所有的向量），就可以获得非常好的效果。
|
||||
你的老板要求: 你写的那个手写识别程序非常好，但是它占用内存太大。顾客无法通过无线的方式下载我们的应用。
|
||||
所以: 我们可以考虑使用支持向量机，保留支持向量就行（knn需要保留所有的向量），就可以获得非常好的效果。
|
||||
```
|
||||
|
||||
#### 开发流程
|
||||
|
||||
> 收集数据：提供的文本文件
|
||||
> 收集数据: 提供的文本文件
|
||||
|
||||
```python
|
||||
00000000000000001111000000000000
|
||||
|
|
@ -402,7 +402,7 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
|
||||
```
|
||||
|
||||
> 准备数据：基于二值图像构造向量
|
||||
> 准备数据: 基于二值图像构造向量
|
||||
|
||||
`将 32*32的文本转化为 1*1024的矩阵`
|
||||
|
||||
|
|
@ -435,9 +435,9 @@ def loadImages(dirName):
|
|||
return trainingMat, hwLabels
|
||||
```
|
||||
|
||||
> 分析数据：对图像向量进行目测
|
||||
> 分析数据: 对图像向量进行目测
|
||||
|
||||
> 训练算法：采用两种不同的核函数，并对径向基核函数采用不同的设置来运行SMO算法
|
||||
> 训练算法: 采用两种不同的核函数，并对径向基核函数采用不同的设置来运行SMO算法
|
||||
|
||||
```python
|
||||
def kernelTrans(X, A, kTup): # calc the kernel or transform data to a higher dimensional space
|
||||
|
|
@ -489,7 +489,7 @@ def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup=('lin', 0)):
|
|||
entireSet = True
|
||||
alphaPairsChanged = 0
|
||||
|
||||
# 循环遍历：循环maxIter次 并且 （alphaPairsChanged存在可以改变 or 所有行遍历一遍）
|
||||
# 循环遍历: 循环maxIter次 并且 （alphaPairsChanged存在可以改变 or 所有行遍历一遍）
|
||||
while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):
|
||||
alphaPairsChanged = 0
|
||||
|
||||
|
|
@ -520,7 +520,7 @@ def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup=('lin', 0)):
|
|||
return oS.b, oS.alphas
|
||||
```
|
||||
|
||||
> 测试算法：便携一个函数来测试不同的和函数并计算错误率
|
||||
> 测试算法: 便携一个函数来测试不同的和函数并计算错误率
|
||||
|
||||
```python
|
||||
def testDigits(kTup=('rbf', 10)):
|
||||
|
|
@ -557,12 +557,12 @@ def testDigits(kTup=('rbf', 10)):
|
|||
print("the test error rate is: %f" % (float(errorCount) / m))
|
||||
```
|
||||
|
||||
> 使用算法：一个图像识别的完整应用还需要一些图像处理的知识，这里并不打算深入介绍
|
||||
> 使用算法: 一个图像识别的完整应用还需要一些图像处理的知识，这里并不打算深入介绍
|
||||
|
||||
[完整代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-complete.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/6.SVM/svm-complete.py>
|
||||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [geekidentity](http://cwiki.apachecn.org/display/~houfachao)**
|
||||
* **作者: [片刻](http://cwiki.apachecn.org/display/~jiangzhonglian) [geekidentity](http://cwiki.apachecn.org/display/~houfachao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -4,11 +4,11 @@
|
|||
|
||||
## 集成方法: ensemble method（元算法: meta algorithm） 概述
|
||||
|
||||
* 概念：是对其他算法进行组合的一种形式。
|
||||
* 通俗来说： 当做重要决定时，大家可能都会考虑吸取多个专家而不只是一个人的意见。
|
||||
* 概念: 是对其他算法进行组合的一种形式。
|
||||
* 通俗来说: 当做重要决定时，大家可能都会考虑吸取多个专家而不只是一个人的意见。
|
||||
机器学习处理问题时又何尝不是如此？ 这就是集成方法背后的思想。
|
||||
|
||||
* 集成方法：
|
||||
* 集成方法:
|
||||
1. 投票选举(bagging: 自举汇聚法 bootstrap aggregating): 是基于数据随机重抽样分类器构造的方法
|
||||
2. 再学习(boosting): 是基于所有分类器的加权求和的方法
|
||||
|
||||
|
|
@ -16,10 +16,10 @@
|
|||
## 集成方法 场景
|
||||
|
||||
目前 bagging 方法最流行的版本是: 随机森林(random forest)<br/>
|
||||
选男友：美女选择择偶对象的时候，会问几个闺蜜的建议，最后选择一个综合得分最高的一个作为男朋友
|
||||
选男友: 美女选择择偶对象的时候，会问几个闺蜜的建议，最后选择一个综合得分最高的一个作为男朋友
|
||||
|
||||
目前 boosting 方法最流行的版本是: AdaBoost<br/>
|
||||
追女友：3个帅哥追同一个美女，第1个帅哥失败->(传授经验：姓名、家庭情况) 第2个帅哥失败->(传授经验：兴趣爱好、性格特点) 第3个帅哥成功
|
||||
追女友: 3个帅哥追同一个美女，第1个帅哥失败->(传授经验: 姓名、家庭情况) 第2个帅哥失败->(传授经验: 兴趣爱好、性格特点) 第3个帅哥成功
|
||||
|
||||
> bagging 和 boosting 区别是什么？
|
||||
|
||||
|
|
@ -38,15 +38,15 @@
|
|||
### 随机森林 原理
|
||||
|
||||
那随机森林具体如何构建呢？<br/>
|
||||
有两个方面：<br/>
|
||||
有两个方面: <br/>
|
||||
1. 数据的随机性化<br/>
|
||||
2. 待选特征的随机化<br/>
|
||||
|
||||
使得随机森林中的决策树都能够彼此不同，提升系统的多样性，从而提升分类性能。
|
||||
|
||||
> 数据的随机化：使得随机森林中的决策树更普遍化一点，适合更多的场景。
|
||||
> 数据的随机化: 使得随机森林中的决策树更普遍化一点，适合更多的场景。
|
||||
|
||||
（有放回的准确率在：70% 以上， 无放回的准确率在：60% 以上）
|
||||
（有放回的准确率在: 70% 以上， 无放回的准确率在: 60% 以上）
|
||||
1. 采取有放回的抽样方式 构造子数据集，保证不同子集之间的数量级一样（不同子集／同一子集 之间的元素可以重复）
|
||||
2. 利用子数据集来构建子决策树，将这个数据放到每个子决策树中，每个子决策树输出一个结果。
|
||||
3. 然后统计子决策树的投票结果，得到最终的分类 就是 随机森林的输出结果。
|
||||
|
|
@ -68,20 +68,20 @@
|
|||
> 随机森林 开发流程
|
||||
|
||||
```
|
||||
收集数据：任何方法
|
||||
准备数据：转换样本集
|
||||
分析数据：任何方法
|
||||
训练算法：通过数据随机化和特征随机化，进行多实例的分类评估
|
||||
测试算法：计算错误率
|
||||
使用算法：输入样本数据，然后运行 随机森林 算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理
|
||||
收集数据: 任何方法
|
||||
准备数据: 转换样本集
|
||||
分析数据: 任何方法
|
||||
训练算法: 通过数据随机化和特征随机化，进行多实例的分类评估
|
||||
测试算法: 计算错误率
|
||||
使用算法: 输入样本数据，然后运行 随机森林 算法判断输入数据分类属于哪个分类，最后对计算出的分类执行后续处理
|
||||
```
|
||||
|
||||
> 随机森林 算法特点
|
||||
|
||||
```
|
||||
优点：几乎不需要输入准备、可实现隐式特征选择、训练速度非常快、其他模型很难超越、很难建立一个糟糕的随机森林模型、大量优秀、免费以及开源的实现。
|
||||
缺点：劣势在于模型大小、是个很难去解释的黑盒子。
|
||||
适用数据范围：数值型和标称型
|
||||
优点: 几乎不需要输入准备、可实现隐式特征选择、训练速度非常快、其他模型很难超越、很难建立一个糟糕的随机森林模型、大量优秀、免费以及开源的实现。
|
||||
缺点: 劣势在于模型大小、是个很难去解释的黑盒子。
|
||||
适用数据范围: 数值型和标称型
|
||||
```
|
||||
|
||||
### 项目案例: 声纳信号分类
|
||||
|
|
@ -93,17 +93,17 @@
|
|||
#### 开发流程
|
||||
|
||||
```
|
||||
收集数据：提供的文本文件
|
||||
准备数据：转换样本集
|
||||
分析数据：手工检查数据
|
||||
训练算法：在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
|
||||
测试算法：在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分
|
||||
使用算法：若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码
|
||||
收集数据: 提供的文本文件
|
||||
准备数据: 转换样本集
|
||||
分析数据: 手工检查数据
|
||||
训练算法: 在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
|
||||
测试算法: 在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分
|
||||
使用算法: 若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码
|
||||
```
|
||||
|
||||
> 收集数据：提供的文本文件
|
||||
> 收集数据: 提供的文本文件
|
||||
|
||||
样本数据：sonar-all-data.txt
|
||||
样本数据: sonar-all-data.txt
|
||||
|
||||
```
|
||||
0.02,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.066,0.2273,0.31,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.555,0.6711,0.6415,0.7104,0.808,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.051,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.018,0.0084,0.009,0.0032,R
|
||||
|
|
@ -111,7 +111,7 @@
|
|||
0.0262,0.0582,0.1099,0.1083,0.0974,0.228,0.2431,0.3771,0.5598,0.6194,0.6333,0.706,0.5544,0.532,0.6479,0.6931,0.6759,0.7551,0.8929,0.8619,0.7974,0.6737,0.4293,0.3648,0.5331,0.2413,0.507,0.8533,0.6036,0.8514,0.8512,0.5045,0.1862,0.2709,0.4232,0.3043,0.6116,0.6756,0.5375,0.4719,0.4647,0.2587,0.2129,0.2222,0.2111,0.0176,0.1348,0.0744,0.013,0.0106,0.0033,0.0232,0.0166,0.0095,0.018,0.0244,0.0316,0.0164,0.0095,0.0078,R
|
||||
```
|
||||
|
||||
> 准备数据：转换样本集
|
||||
> 准备数据: 转换样本集
|
||||
|
||||
```python
|
||||
# 导入csv文件
|
||||
|
|
@ -135,9 +135,9 @@ def loadDataSet(filename):
|
|||
return dataset
|
||||
```
|
||||
|
||||
> 分析数据：手工检查数据
|
||||
> 分析数据: 手工检查数据
|
||||
|
||||
> 训练算法：在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
|
||||
> 训练算法: 在数据上，利用 random_forest() 函数进行优化评估，返回模型的综合分类结果
|
||||
|
||||
* 样本数据随机无放回抽样-用于交叉验证
|
||||
|
||||
|
|
@ -149,7 +149,7 @@ def cross_validation_split(dataset, n_folds):
|
|||
dataset 原始数据集
|
||||
n_folds 数据集dataset分成n_flods份
|
||||
Returns:
|
||||
dataset_split list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复抽取
|
||||
dataset_split list集合，存放的是: 将数据集进行抽重抽样 n_folds 份，数据可以重复抽取
|
||||
"""
|
||||
dataset_split = list()
|
||||
dataset_copy = list(dataset) # 复制一份 dataset,防止 dataset 的内容改变
|
||||
|
|
@ -249,7 +249,7 @@ def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_feat
|
|||
return predictions
|
||||
```
|
||||
|
||||
> 测试算法：在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分。
|
||||
> 测试算法: 在采用自定义 n_folds 份随机重抽样 进行测试评估，得出综合的预测评分。
|
||||
|
||||
* 计算随机森林的预测结果的正确率
|
||||
|
||||
|
|
@ -302,7 +302,7 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
|
|||
return scores
|
||||
```
|
||||
|
||||
> 使用算法：若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码
|
||||
> 使用算法: 若你感兴趣可以构建完整的应用程序，从案例进行封装，也可以参考我们的代码
|
||||
|
||||
[完整代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/7.RandomForest/randomForest.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/7.RandomForest/randomForest.py>
|
||||
|
||||
|
|
@ -322,22 +322,22 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
|
|||
> AdaBoost 开发流程
|
||||
|
||||
```
|
||||
收集数据：可以使用任意方法
|
||||
准备数据：依赖于所使用的弱分类器类型，本章使用的是单层决策树，这种分类器可以处理任何数据类型。
|
||||
收集数据: 可以使用任意方法
|
||||
准备数据: 依赖于所使用的弱分类器类型，本章使用的是单层决策树，这种分类器可以处理任何数据类型。
|
||||
当然也可以使用任意分类器作为弱分类器，第2章到第6章中的任一分类器都可以充当弱分类器。
|
||||
作为弱分类器，简单分类器的效果更好。
|
||||
分析数据：可以使用任意方法。
|
||||
训练算法：AdaBoost 的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
|
||||
测试算法：计算分类的错误率。
|
||||
使用算法：通SVM一样，AdaBoost 预测两个类别中的一个。如果想把它应用到多个类别的场景，那么就要像多类 SVM 中的做法一样对 AdaBoost 进行修改。
|
||||
分析数据: 可以使用任意方法。
|
||||
训练算法: AdaBoost 的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
|
||||
测试算法: 计算分类的错误率。
|
||||
使用算法: 通SVM一样，AdaBoost 预测两个类别中的一个。如果想把它应用到多个类别的场景，那么就要像多类 SVM 中的做法一样对 AdaBoost 进行修改。
|
||||
```
|
||||
|
||||
> AdaBoost 算法特点
|
||||
|
||||
```
|
||||
* 优点：泛化（由具体的、个别的扩大为一般的）错误率低，易编码，可以应用在大部分分类器上，无参数调节。
|
||||
* 缺点：对离群点敏感。
|
||||
* 适用数据类型：数值型和标称型数据。
|
||||
* 优点: 泛化（由具体的、个别的扩大为一般的）错误率低，易编码，可以应用在大部分分类器上，无参数调节。
|
||||
* 缺点: 对离群点敏感。
|
||||
* 适用数据类型: 数值型和标称型数据。
|
||||
```
|
||||
|
||||
### 项目案例: 马疝病的预测
|
||||
|
|
@ -356,18 +356,18 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
|
|||
#### 开发流程
|
||||
|
||||
```
|
||||
收集数据：提供的文本文件
|
||||
准备数据：确保类别标签是+1和-1，而非1和0
|
||||
分析数据：统计分析
|
||||
训练算法：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器
|
||||
测试算法：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较
|
||||
使用算法：观察该例子上的错误率。不过，也可以构建一个 Web 网站，让驯马师输入马的症状然后预测马是否会死去
|
||||
收集数据: 提供的文本文件
|
||||
准备数据: 确保类别标签是+1和-1，而非1和0
|
||||
分析数据: 统计分析
|
||||
训练算法: 在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器
|
||||
测试算法: 我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较
|
||||
使用算法: 观察该例子上的错误率。不过，也可以构建一个 Web 网站，让驯马师输入马的症状然后预测马是否会死去
|
||||
```
|
||||
|
||||
> 收集数据：提供的文本文件
|
||||
> 收集数据: 提供的文本文件
|
||||
|
||||
训练数据：horseColicTraining.txt<br/>
|
||||
测试数据：horseColicTest.txt
|
||||
训练数据: horseColicTraining.txt<br/>
|
||||
测试数据: horseColicTest.txt
|
||||
|
||||
```
|
||||
2.000000 1.000000 38.500000 66.000000 28.000000 3.000000 3.000000 0.000000 2.000000 5.000000 4.000000 4.000000 0.000000 0.000000 0.000000 3.000000 5.000000 45.000000 8.400000 0.000000 0.000000 -1.000000
|
||||
|
|
@ -375,7 +375,7 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
|
|||
2.000000 1.000000 38.300000 40.000000 24.000000 1.000000 1.000000 3.000000 1.000000 3.000000 3.000000 1.000000 0.000000 0.000000 0.000000 1.000000 1.000000 33.000000 6.700000 0.000000 0.000000 1.000000
|
||||
```
|
||||
|
||||
> 准备数据：确保类别标签是+1和-1，而非1和0
|
||||
> 准备数据: 确保类别标签是+1和-1，而非1和0
|
||||
|
||||
```python
|
||||
def loadDataSet(fileName):
|
||||
|
|
@ -394,18 +394,18 @@ def loadDataSet(fileName):
|
|||
return dataArr, labelArr
|
||||
```
|
||||
|
||||
> 分析数据：统计分析
|
||||
> 分析数据: 统计分析
|
||||
|
||||
过拟合(overfitting, 也称为过学习)
|
||||
* 发现测试错误率在达到一个最小值之后有开始上升，这种现象称为过拟合。
|
||||
|
||||
|
||||
|
||||
* 通俗来说：就是把一些噪音数据也拟合进去的，如下图。
|
||||
* 通俗来说: 就是把一些噪音数据也拟合进去的，如下图。
|
||||
|
||||
|
||||
|
||||
> 训练算法：在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器
|
||||
> 训练算法: 在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器
|
||||
|
||||
```python
|
||||
def adaBoostTrainDS(dataArr, labelArr, numIt=40):
|
||||
|
|
@ -435,21 +435,21 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
|
|||
weakClassArr.append(bestStump)
|
||||
|
||||
print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)
|
||||
# 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
|
||||
# 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
|
||||
# 分类正确: 乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
|
||||
# 分类错误: 乘积为 -1，结果会受影响，所以也乘以 -1
|
||||
expon = multiply(-1*alpha*mat(labelArr).T, classEst)
|
||||
print '(-1取反)预测值expon=', expon.T
|
||||
# 计算e的expon次方，然后计算得到一个综合的概率的值
|
||||
# 结果发现： 判断错误的样本，D中相对应的样本权重值会变大。
|
||||
# 结果发现: 判断错误的样本，D中相对应的样本权重值会变大。
|
||||
D = multiply(D, exp(expon))
|
||||
D = D/D.sum()
|
||||
|
||||
# 预测的分类结果值，在上一轮结果的基础上，进行加和操作
|
||||
print '当前的分类结果：', alpha*classEst.T
|
||||
print '当前的分类结果: ', alpha*classEst.T
|
||||
aggClassEst += alpha*classEst
|
||||
print "叠加后的分类结果aggClassEst: ", aggClassEst.T
|
||||
# sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
|
||||
# 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
|
||||
# 结果为: 错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
|
||||
aggErrors = multiply(sign(aggClassEst) != mat(labelArr).T, ones((m, 1)))
|
||||
errorRate = aggErrors.sum()/m
|
||||
# print "total error=%s " % (errorRate)
|
||||
|
|
@ -459,16 +459,16 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
|
|||
```
|
||||
|
||||
```
|
||||
发现：
|
||||
发现:
|
||||
alpha （模型权重）目的主要是计算每一个分类器实例的权重(加和就是分类结果)
|
||||
分类的权重值：最大的值= alpha 的加和，最小值=-最大值
|
||||
D （样本权重）的目的是为了计算错误概率： weightedError = D.T*errArr，求最佳分类器
|
||||
样本的权重值：如果一个值误判的几率越小，那么 D 的样本权重越小
|
||||
分类的权重值: 最大的值= alpha 的加和，最小值=-最大值
|
||||
D （样本权重）的目的是为了计算错误概率: weightedError = D.T*errArr，求最佳分类器
|
||||
样本的权重值: 如果一个值误判的几率越小，那么 D 的样本权重越小
|
||||
```
|
||||
|
||||
|
||||
|
||||
> 测试算法：我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
|
||||
> 测试算法: 我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
|
||||
|
||||
```python
|
||||
def adaClassify(datToClass, classifierArr):
|
||||
|
|
@ -486,14 +486,14 @@ def adaClassify(datToClass, classifierArr):
|
|||
|
||||
# 循环 多个分类器
|
||||
for i in range(len(classifierArr)):
|
||||
# 前提： 我们已经知道了最佳的分类器的实例
|
||||
# 前提: 我们已经知道了最佳的分类器的实例
|
||||
# 通过分类器来核算每一次的分类结果，然后通过alpha*每一次的结果 得到最后的权重加和的值。
|
||||
classEst = stumpClassify(dataMat, classifierArr[i]['dim'], classifierArr[i]['thresh'], classifierArr[i]['ineq'])
|
||||
aggClassEst += classifierArr[i]['alpha']*classEst
|
||||
return sign(aggClassEst)
|
||||
```
|
||||
|
||||
> 使用算法：观察该例子上的错误率。不过，也可以构建一个 Web 网站，让驯马师输入马的症状然后预测马是否会死去。
|
||||
> 使用算法: 观察该例子上的错误率。不过，也可以构建一个 Web 网站，让驯马师输入马的症状然后预测马是否会死去。
|
||||
|
||||
```python
|
||||
# 马疝病数据集
|
||||
|
|
@ -508,7 +508,7 @@ dataArrTest, labelArrTest = loadDataSet("data/7.AdaBoost/horseColicTest2.txt")
|
|||
m = shape(dataArrTest)[0]
|
||||
predicting10 = adaClassify(dataArrTest, weakClassArr)
|
||||
errArr = mat(ones((m, 1)))
|
||||
# 测试：计算总样本数，错误样本数，错误率
|
||||
# 测试: 计算总样本数，错误样本数，错误率
|
||||
print m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10 != mat(labelArrTest).T].sum()/m
|
||||
```
|
||||
|
||||
|
|
@ -516,7 +516,7 @@ print m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10
|
|||
|
||||
#### 要点补充
|
||||
|
||||
> 非均衡现象：
|
||||
> 非均衡现象:
|
||||
|
||||
`在分类器训练时，正例数目和反例数目不相等（相差很大）。或者发生在正负例分类错误的成本不同的时候。`
|
||||
|
||||
|
|
@ -525,9 +525,9 @@ print m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10
|
|||
* 不能放过传染病的人
|
||||
* 不能随便认为别人犯罪
|
||||
|
||||
我们有多种方法来处理这个问题： 具体可参考[此链接](https://machinelearningmastery.com/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/)
|
||||
我们有多种方法来处理这个问题: 具体可参考[此链接](https://machinelearningmastery.com/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/)
|
||||
|
||||
再结合书中的方法，可以归为八大类：
|
||||
再结合书中的方法，可以归为八大类:
|
||||
|
||||
##### 1.能否收集到更多的数据？
|
||||
|
||||
|
|
@ -538,13 +538,13 @@ print m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10
|
|||
|
||||
Accuracy 或者error rate 不能用于非均衡的数据集。这会误导人。这时候可以尝试其他的评价指标。
|
||||
|
||||
Confusion Matrix 混淆矩阵：使用一个表格对分类器所预测的类别与其真实的类别的样本统计，分别为：TP、FN、FP与TN。
|
||||
Confusion Matrix 混淆矩阵: 使用一个表格对分类器所预测的类别与其真实的类别的样本统计，分别为: TP、FN、FP与TN。
|
||||
|
||||
Precision：精确度
|
||||
Precision: 精确度
|
||||
|
||||
Recall： 召回率
|
||||
Recall: 召回率
|
||||
|
||||
F1 Score (or F-Score)： 精确度和召回率的加权平均
|
||||
F1 Score (or F-Score): 精确度和召回率的加权平均
|
||||
|
||||
或者使用
|
||||
|
||||
|
|
@ -577,7 +577,7 @@ ROC Curves
|
|||
|
||||
或者结合上述两种方法进行抽样
|
||||
|
||||
一些经验法则：
|
||||
一些经验法则:
|
||||
|
||||
* 考虑样本（超过1万、十万甚至更多）进行欠采样，即删除部分样本；
|
||||
|
||||
|
|
@ -609,11 +609,11 @@ python实现可以查阅[UnbalancedDataset](https://github.com/scikit-learn-cont
|
|||
|
||||
惩罚的模型就是对于不同的分类错误给予不同的代价（惩罚）。比如对于错分的小类给予更高的代价。这种方式会使模型偏差，更加关注小类。
|
||||
|
||||
通常来说这种代价/惩罚或者比重在学习中算法是特定的。比如使用代价函数来实现：
|
||||
通常来说这种代价/惩罚或者比重在学习中算法是特定的。比如使用代价函数来实现:
|
||||
|
||||
> 代价函数
|
||||
|
||||
* 基于代价函数的分类器决策控制：`TP*(-5)+FN*1+FP*50+TN*0`
|
||||
* 基于代价函数的分类器决策控制: `TP*(-5)+FN*1+FP*50+TN*0`
|
||||
|
||||
|
||||
|
||||
|
|
@ -627,7 +627,7 @@ python实现可以查阅[UnbalancedDataset](https://github.com/scikit-learn-cont
|
|||
|
||||
从它们的角度看看你的问题，思考你的问题，说不定会有新的想法。
|
||||
|
||||
两个领域您可以考虑： anomaly detection(异常值检测) 和 change detection（变化趋势检测）。
|
||||
两个领域您可以考虑: anomaly detection(异常值检测) 和 change detection（变化趋势检测）。
|
||||
|
||||
Anomaly dectection 就是检测稀有事件。 比如通过机器震动来识别机器谷中或者根据一系列系统的调用来检测恶意操作。与常规操作相比，这些事件是罕见的。
|
||||
|
||||
|
|
@ -641,7 +641,7 @@ change detection 变化趋势检测类似于异常值检测。但是他不是寻
|
|||
|
||||
仔细思考你的问题然后想想看如何将这问题细分为几个更切实际的小问题。
|
||||
|
||||
比如：
|
||||
比如:
|
||||
|
||||
将你的大类分解成多个较小的类；
|
||||
|
||||
|
|
@ -655,6 +655,6 @@ change detection 变化趋势检测类似于异常值检测。但是他不是寻
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](https://github.com/jiangzhonglian)**
|
||||
* **作者: [片刻](https://github.com/jiangzhonglian)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
124
docs/ml/8.回归.md
124
docs/ml/8.回归.md
|
|
@ -1,4 +1,4 @@
|
|||
# 第8章 预测数值型数据：回归
|
||||
# 第8章 预测数值型数据: 回归
|
||||
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
|
||||
|
||||
|
||||
|
|
@ -19,7 +19,7 @@ HorsePower = 0.0015 * annualSalary - 0.99 * hoursListeningToPublicRadio
|
|||
|
||||
说到回归，一般都是指 `线性回归(linear regression)`。线性回归意味着可以将输入项分别乘以一些常量，再将结果加起来得到输出。
|
||||
|
||||
补充：
|
||||
补充:
|
||||
线性回归假设特征和结果满足线性关系。其实线性关系的表达能力非常强大，每个特征对结果的影响强弱可以由前面的参数体现，而且每个特征变量可以首先映射到一个函数，然后再参与线性计算。这样就可以表达特征与结果之间的非线性关系。
|
||||
|
||||
## 回归 原理
|
||||
|
|
@ -75,9 +75,9 @@ HorsePower = 0.0015 * annualSalary - 0.99 * hoursListeningToPublicRadio
|
|||
#### 1.4、线性回归 算法特点
|
||||
|
||||
```
|
||||
优点：结果易于理解，计算上不复杂。
|
||||
缺点：对非线性的数据拟合不好。
|
||||
适用于数据类型：数值型和标称型数据。
|
||||
优点: 结果易于理解，计算上不复杂。
|
||||
缺点: 对非线性的数据拟合不好。
|
||||
适用于数据类型: 数值型和标称型数据。
|
||||
```
|
||||
|
||||
#### 1.5、线性回归 项目案例
|
||||
|
|
@ -106,9 +106,9 @@ x0 x1 y
|
|||
def loadDataSet(fileName):
|
||||
""" 加载数据
|
||||
解析以tab键分隔的文件中的浮点数
|
||||
Returns：
|
||||
dataMat ： feature 对应的数据集
|
||||
labelMat ： feature 对应的分类标签，即类别标签
|
||||
Returns:
|
||||
dataMat : feature 对应的数据集
|
||||
labelMat : feature 对应的分类标签，即类别标签
|
||||
|
||||
"""
|
||||
# 获取样本特征的总数，不算最后的目标变量
|
||||
|
|
@ -134,13 +134,13 @@ def loadDataSet(fileName):
|
|||
|
||||
def standRegres(xArr,yArr):
|
||||
'''
|
||||
Description：
|
||||
Description:
|
||||
线性回归
|
||||
Args:
|
||||
xArr ：输入的样本数据，包含每个样本数据的 feature
|
||||
yArr ：对应于输入数据的类别标签，也就是每个样本对应的目标变量
|
||||
xArr : 输入的样本数据，包含每个样本数据的 feature
|
||||
yArr : 对应于输入数据的类别标签，也就是每个样本对应的目标变量
|
||||
Returns:
|
||||
ws：回归系数
|
||||
ws: 回归系数
|
||||
'''
|
||||
|
||||
# mat()函数将xArr，yArr转换为矩阵 mat().T 代表的是对矩阵进行转置操作
|
||||
|
|
@ -239,20 +239,20 @@ LWLR 使用 “核”（与支持向量机中的核类似）来对附近的点
|
|||
# 局部加权线性回归
|
||||
def lwlr(testPoint,xArr,yArr,k=1.0):
|
||||
'''
|
||||
Description：
|
||||
Description:
|
||||
局部加权线性回归，在待预测点附近的每个点赋予一定的权重，在子集上基于最小均方差来进行普通的回归。
|
||||
Args：
|
||||
testPoint：样本点
|
||||
xArr：样本的特征数据，即 feature
|
||||
yArr：每个样本对应的类别标签，即目标变量
|
||||
Args:
|
||||
testPoint: 样本点
|
||||
xArr: 样本的特征数据，即 feature
|
||||
yArr: 每个样本对应的类别标签，即目标变量
|
||||
k:关于赋予权重矩阵的核的一个参数，与权重的衰减速率有关
|
||||
Returns:
|
||||
testPoint * ws：数据点与具有权重的系数相乘得到的预测点
|
||||
testPoint * ws: 数据点与具有权重的系数相乘得到的预测点
|
||||
Notes:
|
||||
这其中会用到计算权重的公式，w = e^((x^((i))-x) / -2k^2)
|
||||
理解：x为某个预测点，x^((i))为样本点，样本点距离预测点越近，贡献的误差越大（权值越大），越远则贡献的误差越小（权值越小）。
|
||||
理解: x为某个预测点，x^((i))为样本点，样本点距离预测点越近，贡献的误差越大（权值越大），越远则贡献的误差越小（权值越小）。
|
||||
关于预测点的选取，在我的代码中取的是样本点。其中k是带宽参数，控制w（钟形函数）的宽窄程度，类似于高斯函数的标准差。
|
||||
算法思路：假设预测点取样本点中的第i个样本点（共m个样本点），遍历1到m个样本点（含第i个），算出每一个样本点与预测点的距离，
|
||||
算法思路: 假设预测点取样本点中的第i个样本点（共m个样本点），遍历1到m个样本点（含第i个），算出每一个样本点与预测点的距离，
|
||||
也就可以计算出每个样本贡献误差的权值，可以看出w是一个有m个元素的向量（写成对角阵形式）。
|
||||
'''
|
||||
# mat() 函数是将array转换为矩阵的函数， mat().T 是转换为矩阵之后，再进行转置操作
|
||||
|
|
@ -279,15 +279,15 @@ def lwlr(testPoint,xArr,yArr,k=1.0):
|
|||
|
||||
def lwlrTest(testArr,xArr,yArr,k=1.0):
|
||||
'''
|
||||
Description：
|
||||
Description:
|
||||
测试局部加权线性回归，对数据集中每个点调用 lwlr() 函数
|
||||
Args：
|
||||
testArr：测试所用的所有样本点
|
||||
xArr：样本的特征数据，即 feature
|
||||
yArr：每个样本对应的类别标签，即目标变量
|
||||
k：控制核函数的衰减速率
|
||||
Returns：
|
||||
yHat：预测点的估计值
|
||||
Args:
|
||||
testArr: 测试所用的所有样本点
|
||||
xArr: 样本的特征数据，即 feature
|
||||
yArr: 每个样本对应的类别标签，即目标变量
|
||||
k: 控制核函数的衰减速率
|
||||
Returns:
|
||||
yHat: 预测点的估计值
|
||||
'''
|
||||
# 得到样本点的总数
|
||||
m = shape(testArr)[0]
|
||||
|
|
@ -303,13 +303,13 @@ def lwlrTestPlot(xArr,yArr,k=1.0):
|
|||
'''
|
||||
Description:
|
||||
首先将 X 排序，其余的都与lwlrTest相同，这样更容易绘图
|
||||
Args：
|
||||
xArr：样本的特征数据，即 feature
|
||||
yArr：每个样本对应的类别标签，即目标变量，实际值
|
||||
k：控制核函数的衰减速率的有关参数，这里设定的是常量值 1
|
||||
Return：
|
||||
yHat：样本点的估计值
|
||||
xCopy：xArr的复制
|
||||
Args:
|
||||
xArr: 样本的特征数据，即 feature
|
||||
yArr: 每个样本对应的类别标签，即目标变量，实际值
|
||||
k: 控制核函数的衰减速率的有关参数，这里设定的是常量值 1
|
||||
Return:
|
||||
yHat: 样本点的估计值
|
||||
xCopy: xArr的复制
|
||||
'''
|
||||
# 生成一个与目标变量数目相同的 0 向量
|
||||
yHat = zeros(shape(yArr))
|
||||
|
|
@ -397,9 +397,9 @@ def rssError(yArr,yHatArr):
|
|||
'''
|
||||
Desc:
|
||||
返回真实值与预测值误差大小
|
||||
Args：
|
||||
yArr：样本的真实值
|
||||
yHatArr：样本的预测值
|
||||
Args:
|
||||
yArr: 样本的真实值
|
||||
yHatArr: 样本的预测值
|
||||
Returns:
|
||||
一个数字，代表误差
|
||||
'''
|
||||
|
|
@ -461,7 +461,7 @@ def abaloneTest():
|
|||
#### 4.1、岭回归
|
||||
|
||||
简单来说，岭回归就是在矩阵  上加一个 λI 从而使得矩阵非奇异，进而能对  求逆。其中矩阵I是一个 n * n （等于列数） 的单位矩阵，
|
||||
对角线上元素全为1，其他元素全为0。而λ是一个用户定义的数值，后面会做介绍。在这种情况下，回归系数的计算公式将变成：
|
||||
对角线上元素全为1，其他元素全为0。而λ是一个用户定义的数值，后面会做介绍。在这种情况下，回归系数的计算公式将变成:
|
||||
|
||||
|
||||
|
||||
|
|
@ -480,16 +480,16 @@ def abaloneTest():
|
|||
```python
|
||||
def ridgeRegres(xMat,yMat,lam=0.2):
|
||||
'''
|
||||
Desc：
|
||||
Desc:
|
||||
这个函数实现了给定 lambda 下的岭回归求解。
|
||||
如果数据的特征比样本点还多，就不能再使用上面介绍的的线性回归和局部线性回归了，因为计算 (xTx)^(-1)会出现错误。
|
||||
如果特征比样本点还多（n > m），也就是说，输入数据的矩阵x不是满秩矩阵。非满秩矩阵在求逆时会出现问题。
|
||||
为了解决这个问题，我们下边讲一下：岭回归，这是我们要讲的第一种缩减方法。
|
||||
Args：
|
||||
xMat：样本的特征数据，即 feature
|
||||
yMat：每个样本对应的类别标签，即目标变量，实际值
|
||||
lam：引入的一个λ值，使得矩阵非奇异
|
||||
Returns：
|
||||
为了解决这个问题，我们下边讲一下: 岭回归，这是我们要讲的第一种缩减方法。
|
||||
Args:
|
||||
xMat: 样本的特征数据，即 feature
|
||||
yMat: 每个样本对应的类别标签，即目标变量，实际值
|
||||
lam: 引入的一个λ值，使得矩阵非奇异
|
||||
Returns:
|
||||
经过岭回归公式计算得到的回归系数
|
||||
'''
|
||||
|
||||
|
|
@ -506,13 +506,13 @@ def ridgeRegres(xMat,yMat,lam=0.2):
|
|||
|
||||
def ridgeTest(xArr,yArr):
|
||||
'''
|
||||
Desc：
|
||||
Desc:
|
||||
函数 ridgeTest() 用于在一组 λ 上测试结果
|
||||
Args：
|
||||
xArr：样本数据的特征，即 feature
|
||||
yArr：样本数据的类别标签，即真实数据
|
||||
Returns：
|
||||
wMat：将所有的回归系数输出到一个矩阵并返回
|
||||
Args:
|
||||
xArr: 样本数据的特征，即 feature
|
||||
yArr: 样本数据的类别标签，即真实数据
|
||||
Returns:
|
||||
wMat: 将所有的回归系数输出到一个矩阵并返回
|
||||
'''
|
||||
|
||||
xMat = mat(xArr)
|
||||
|
|
@ -674,12 +674,12 @@ Dangler 喜欢为乐高套装估价，我们用回归技术来帮助他建立一
|
|||
##### 开发流程
|
||||
|
||||
```
|
||||
(1) 收集数据：用 Google Shopping 的API收集数据。
|
||||
(2) 准备数据：从返回的JSON数据中抽取价格。
|
||||
(3) 分析数据：可视化并观察数据。
|
||||
(4) 训练算法：构建不同的模型，采用逐步线性回归和直接的线性回归模型。
|
||||
(5) 测试算法：使用交叉验证来测试不同的模型，分析哪个效果最好。
|
||||
(6) 使用算法：这次练习的目标就是生成数据模型。
|
||||
(1) 收集数据: 用 Google Shopping 的API收集数据。
|
||||
(2) 准备数据: 从返回的JSON数据中抽取价格。
|
||||
(3) 分析数据: 可视化并观察数据。
|
||||
(4) 训练算法: 构建不同的模型，采用逐步线性回归和直接的线性回归模型。
|
||||
(5) 测试算法: 使用交叉验证来测试不同的模型，分析哪个效果最好。
|
||||
(6) 使用算法: 这次练习的目标就是生成数据模型。
|
||||
```
|
||||
|
||||
> 收集数据: 使用 Google 购物的 API
|
||||
|
|
@ -753,7 +753,7 @@ def setDataCollect(retX, retY):
|
|||
scrapePage(retX, retY, 'data/8.Regression/setHtml/lego10196.html', 2009, 3263, 249.99)
|
||||
```
|
||||
|
||||
> 测试算法：使用交叉验证来测试不同的模型，分析哪个效果最好
|
||||
> 测试算法: 使用交叉验证来测试不同的模型，分析哪个效果最好
|
||||
|
||||
```python
|
||||
# 交叉验证测试岭回归
|
||||
|
|
@ -823,7 +823,7 @@ def regression5():
|
|||
crossValidation(lgX, lgY, 10)
|
||||
```
|
||||
|
||||
> 使用算法：这次练习的目标就是生成数据模型
|
||||
> 使用算法: 这次练习的目标就是生成数据模型
|
||||
|
||||
## 7、选读内容
|
||||
|
||||
|
|
@ -843,6 +843,6 @@ def regression5():
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[小瑶](http://cwiki.apachecn.org/display/~chenyao) [片刻](https://github.com/jiangzhonglian)**
|
||||
* **作者: [小瑶](http://cwiki.apachecn.org/display/~chenyao) [片刻](https://github.com/jiangzhonglian)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -74,20 +74,20 @@ CART 和 C4.5 之间主要差异在于分类结果上，CART 可以回归分析
|
|||
### 1.4、树回归 开发流程
|
||||
|
||||
```
|
||||
(1) 收集数据：采用任意方法收集数据。
|
||||
(2) 准备数据：需要数值型数据，标称型数据应该映射成二值型数据。
|
||||
(3) 分析数据：绘出数据的二维可视化显示结果，以字典方式生成树。
|
||||
(4) 训练算法：大部分时间都花费在叶节点树模型的构建上。
|
||||
(5) 测试算法：使用测试数据上的R^2值来分析模型的效果。
|
||||
(6) 使用算法：使用训练处的树做预测，预测结果还可以用来做很多事情。
|
||||
(1) 收集数据: 采用任意方法收集数据。
|
||||
(2) 准备数据: 需要数值型数据，标称型数据应该映射成二值型数据。
|
||||
(3) 分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树。
|
||||
(4) 训练算法: 大部分时间都花费在叶节点树模型的构建上。
|
||||
(5) 测试算法: 使用测试数据上的R^2值来分析模型的效果。
|
||||
(6) 使用算法: 使用训练处的树做预测，预测结果还可以用来做很多事情。
|
||||
```
|
||||
|
||||
### 1.5、树回归 算法特点
|
||||
|
||||
```
|
||||
优点：可以对复杂和非线性的数据建模。
|
||||
缺点：结果不易理解。
|
||||
适用数据类型：数值型和标称型数据。
|
||||
优点: 可以对复杂和非线性的数据建模。
|
||||
缺点: 结果不易理解。
|
||||
适用数据类型: 数值型和标称型数据。
|
||||
```
|
||||
|
||||
### 1.6、回归树 项目案例
|
||||
|
|
@ -99,15 +99,15 @@ CART 和 C4.5 之间主要差异在于分类结果上，CART 可以回归分析
|
|||
#### 1.6.2、开发流程
|
||||
|
||||
```
|
||||
收集数据：采用任意方法收集数据
|
||||
准备数据：需要数值型数据，标称型数据应该映射成二值型数据
|
||||
分析数据：绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
训练算法：大部分时间都花费在叶节点树模型的构建上
|
||||
测试算法：使用测试数据上的R^2值来分析模型的效果
|
||||
使用算法：使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
收集数据: 采用任意方法收集数据
|
||||
准备数据: 需要数值型数据，标称型数据应该映射成二值型数据
|
||||
分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
训练算法: 大部分时间都花费在叶节点树模型的构建上
|
||||
测试算法: 使用测试数据上的R^2值来分析模型的效果
|
||||
使用算法: 使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
```
|
||||
|
||||
> 收集数据：采用任意方法收集数据
|
||||
> 收集数据: 采用任意方法收集数据
|
||||
|
||||
data1.txt 文件中存储的数据格式如下:
|
||||
|
||||
|
|
@ -119,9 +119,9 @@ data1.txt 文件中存储的数据格式如下:
|
|||
0.343554 -0.371700
|
||||
0.098016 -0.332760
|
||||
```
|
||||
> 准备数据：需要数值型数据，标称型数据应该映射成二值型数据
|
||||
> 准备数据: 需要数值型数据，标称型数据应该映射成二值型数据
|
||||
|
||||
> 分析数据：绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
> 分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
|
||||
基于 CART 算法构建回归树的简单数据集
|
||||
|
||||
|
|
@ -135,7 +135,7 @@ data1.txt 文件中存储的数据格式如下:
|
|||
```python
|
||||
def binSplitDataSet(dataSet, feature, value):
|
||||
"""binSplitDataSet(将数据集，按照feature列的value进行 二元切分)
|
||||
Description：在给定特征和特征值的情况下，该函数通过数组过滤方式将上述数据集合切分得到两个子集并返回。
|
||||
Description: 在给定特征和特征值的情况下，该函数通过数组过滤方式将上述数据集合切分得到两个子集并返回。
|
||||
Args:
|
||||
dataMat 数据集
|
||||
feature 待切分的特征列
|
||||
|
|
@ -224,7 +224,7 @@ def chooseBestSplit(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
|||
# 假设 dataSet 是 NumPy Mat 类型的，那么我们可以进行 array 过滤
|
||||
def createTree(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
||||
"""createTree(获取回归树)
|
||||
Description：递归函数：如果构建的是回归树，该模型是一个常数，如果是模型树，其模型师一个线性方程。
|
||||
Description: 递归函数: 如果构建的是回归树，该模型是一个常数，如果是模型树，其模型师一个线性方程。
|
||||
Args:
|
||||
dataSet 加载的原始数据集
|
||||
leafType 建立叶子点的函数
|
||||
|
|
@ -233,7 +233,7 @@ def createTree(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
|||
Returns:
|
||||
retTree 决策树最后的结果
|
||||
"""
|
||||
# 选择最好的切分方式： feature索引值，最优切分值
|
||||
# 选择最好的切分方式: feature索引值，最优切分值
|
||||
# choose the best split
|
||||
feat, val = chooseBestSplit(dataSet, leafType, errType, ops)
|
||||
# if the splitting hit a stop condition return val
|
||||
|
|
@ -252,9 +252,9 @@ def createTree(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
|||
```
|
||||
[完整代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/9.RegTrees/regTrees.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/9.RegTrees/regTrees.py>
|
||||
|
||||
> 测试算法：使用测试数据上的R^2值来分析模型的效果
|
||||
> 测试算法: 使用测试数据上的R^2值来分析模型的效果
|
||||
|
||||
> 使用算法：使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
> 使用算法: 使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
|
||||
## 2、树剪枝
|
||||
|
||||
|
|
@ -349,7 +349,7 @@ def prune(tree, testData):
|
|||
# 1. 如果正确
|
||||
# * 那么计算一下总方差 和 该结果集的本身不分枝的总方差比较
|
||||
# * 如果 合并的总方差 < 不合并的总方差，那么就进行合并
|
||||
# 注意返回的结果： 如果可以合并，原来的dict就变为了 数值
|
||||
# 注意返回的结果: 如果可以合并，原来的dict就变为了 数值
|
||||
if not isTree(tree['left']) and not isTree(tree['right']):
|
||||
lSet, rSet = binSplitDataSet(testData, tree['spInd'], tree['spVal'])
|
||||
# power(x, y)表示x的y次方
|
||||
|
|
@ -387,7 +387,7 @@ def prune(tree, testData):
|
|||
模型树的叶节点生成函数
|
||||
|
||||
```python
|
||||
# 得到模型的ws系数：f(x) = x0 + x1*featrue1+ x3*featrue2 ...
|
||||
# 得到模型的ws系数: f(x) = x0 + x1*featrue1+ x3*featrue2 ...
|
||||
# create linear model and return coeficients
|
||||
def modelLeaf(dataSet):
|
||||
"""
|
||||
|
|
@ -467,17 +467,17 @@ def linearSolve(dataSet):
|
|||
#### 4.1.2、开发流程
|
||||
|
||||
```
|
||||
收集数据：采用任意方法收集数据
|
||||
准备数据：需要数值型数据，标称型数据应该映射成二值型数据
|
||||
分析数据：绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
训练算法：模型树的构建
|
||||
测试算法：使用测试数据上的R^2值来分析模型的效果
|
||||
使用算法：使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
收集数据: 采用任意方法收集数据
|
||||
准备数据: 需要数值型数据，标称型数据应该映射成二值型数据
|
||||
分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
训练算法: 模型树的构建
|
||||
测试算法: 使用测试数据上的R^2值来分析模型的效果
|
||||
使用算法: 使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
```
|
||||
|
||||
> 收集数据: 采用任意方法收集数据
|
||||
|
||||
> 准备数据：需要数值型数据，标称型数据应该映射成二值型数据
|
||||
> 准备数据: 需要数值型数据，标称型数据应该映射成二值型数据
|
||||
|
||||
数据存储格式:
|
||||
```
|
||||
|
|
@ -488,11 +488,11 @@ def linearSolve(dataSet):
|
|||
15.000000 139.737693
|
||||
```
|
||||
|
||||
> 分析数据：绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
> 分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树
|
||||
|
||||
|
||||
|
||||
> 训练算法：模型树的构建
|
||||
> 训练算法: 模型树的构建
|
||||
|
||||
用树回归进行预测的代码
|
||||
```python
|
||||
|
|
@ -583,13 +583,13 @@ def createForeCast(tree, testData, modelEval=regTreeEval):
|
|||
```
|
||||
[完整代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/9.RegTrees/regTrees.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/9.RegTrees/regTrees.py>
|
||||
|
||||
> 测试算法：使用测试数据上的R^2值来分析模型的效果
|
||||
> 测试算法: 使用测试数据上的R^2值来分析模型的效果
|
||||
|
||||
R^2 判定系数就是拟合优度判定系数，它体现了回归模型中自变量的变异在因变量的变异中所占的比例。如 R^2=0.99999 表示在因变量 y 的变异中有 99.999% 是由于变量 x 引起。当 R^2=1 时表示，所有观测点都落在拟合的直线或曲线上；当 R^2=0 时，表示自变量与因变量不存在直线或曲线关系。
|
||||
|
||||
所以我们看出， R^2 的值越接近 1.0 越好。
|
||||
|
||||
> 使用算法：使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
> 使用算法: 使用训练出的树做预测，预测结果还可以用来做很多事情
|
||||
|
||||
|
||||
## 5、附加 Python 中 GUI 的使用
|
||||
|
|
@ -628,6 +628,6 @@ Tkinter 是 Python 的一个 GUI 工具包。虽然并不是唯一的包，但
|
|||
|
||||
* * *
|
||||
|
||||
* **作者：[片刻](https://github.com/jiangzhonglian) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* **作者: [片刻](https://github.com/jiangzhonglian) [小瑶](http://cwiki.apachecn.org/display/~chenyao)**
|
||||
* [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>
|
||||
* **版权声明：欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
* **版权声明: 欢迎转载学习 => 请标注信息来源于 [ApacheCN](http://www.apachecn.org/)**
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
* 第一个不靠吹嘘学校or公司，完全靠实力开源的一个项目
|
||||
* 知乎上网友评论是腾讯，而最近GitHub上看到的是百度邮箱
|
||||
* “结巴”中文分词：做最好的 Python 中文分词组件（这个的确没吹牛！）
|
||||
* “结巴”中文分词: 做最好的 Python 中文分词组件（这个的确没吹牛！）
|
||||
* GitHub上面 README.md 为中文版本（别看这个小事，很多中国公司开源项目都是英文）
|
||||
|
||||
## 部署使用
|
||||
|
|
@ -86,7 +86,7 @@ seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所
|
|||
print(", ".join(seg_list))
|
||||
|
||||
# 输出结果
|
||||
#【搜索引擎模式】： 小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, 后, 在, 日本, 京都, 大学, 日本京都大学, 深造
|
||||
#【搜索引擎模式】: 小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, 后, 在, 日本, 京都, 大学, 日本京都大学, 深造
|
||||
```
|
||||
|
||||
> 4.paddle 模式
|
||||
|
|
@ -177,9 +177,9 @@ if __name__ == "__main__":
|
|||
|
||||
* 开发者可以指定自己自定义的词典，以便包含 jieba 词库里没有的词
|
||||
* 虽然 jieba 有新词识别能力，但是自行添加新词可以保证更高的正确率
|
||||
* 用法： `jieba.load_userdict(file_name)` # file_name 为文件类对象或自定义词典的路径
|
||||
* 用法: `jieba.load_userdict(file_name)` # file_name 为文件类对象或自定义词典的路径
|
||||
* 词典格式和 dict.txt 一样，一个词占一行
|
||||
* 每一行分三部分：词语、词频（可省略）、词性（可省略），`用空格隔开`，`顺序不可颠倒`
|
||||
* 每一行分三部分: 词语、词频（可省略）、词性（可省略），`用空格隔开`，`顺序不可颠倒`
|
||||
* file_name 若为路径或二进制方式打开的文件，则文件必须为 UTF-8 编码
|
||||
* 词频省略时使用自动计算的能保证分出该词的词频
|
||||
|
||||
|
|
@ -201,8 +201,8 @@ jieba.load_userdict(file_name)
|
|||
seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
|
||||
print("Default Mode: " + "/ ".join(seg_list)) # 精确模式
|
||||
|
||||
# 加载自定义词库前： 李小福 / 是 / 创新 / 办 / 主任 / 也 / 是 / 云 / 计算 / 方面 / 的 / 专家 /
|
||||
# 加载自定义词库后： 李小福 / 是 / 创新办 / 主任 / 也 / 是 / 云计算 / 方面 / 的 / 专家 /
|
||||
# 加载自定义词库前: 李小福 / 是 / 创新 / 办 / 主任 / 也 / 是 / 云 / 计算 / 方面 / 的 / 专家 /
|
||||
# 加载自定义词库后: 李小福 / 是 / 创新办 / 主任 / 也 / 是 / 云计算 / 方面 / 的 / 专家 /
|
||||
```
|
||||
|
||||
## 调整词典的词
|
||||
|
|
@ -210,9 +210,9 @@ print("Default Mode: " + "/ ".join(seg_list)) # 精确模式
|
|||
* 使用 `add_word(word, freq=None, tag=None)` 和 `del_word(word)` 可在程序中动态修改词典。
|
||||
* 使用 `suggest_freq(segment, tune=True)` 可调节单个词语的词频，使其能（或不能）被分出来。
|
||||
|
||||
**注意：自动计算的词频在使用 HMM 新词发现功能时可能无效**
|
||||
**注意: 自动计算的词频在使用 HMM 新词发现功能时可能无效**
|
||||
|
||||
代码示例：
|
||||
代码示例:
|
||||
|
||||
```python
|
||||
print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
|
||||
|
|
@ -355,11 +355,11 @@ for word, flag in words:
|
|||
|
||||
## 并行分词
|
||||
|
||||
原理：将目标文本按行分隔后，把各行文本分配到多个 Python 进程并行分词，然后归并结果，从而获得分词速度的可观提升
|
||||
原理: 将目标文本按行分隔后，把各行文本分配到多个 Python 进程并行分词，然后归并结果，从而获得分词速度的可观提升
|
||||
|
||||
基于 python 自带的 multiprocessing 模块，目前暂不支持 Windows
|
||||
|
||||
用法：
|
||||
用法:
|
||||
|
||||
* `jieba.enable_parallel(4)` # 开启并行分词模式，参数为并行进程数
|
||||
* `jieba.disable_parallel()` # 关闭并行分词模式
|
||||
|
|
@ -385,11 +385,11 @@ log_f.write(words.encode('utf-8'))
|
|||
print('speed %s bytes/second' % (len(content)/tm_cost))
|
||||
```
|
||||
|
||||
实验结果：在 4 核 3.4GHz Linux 机器上，对金庸全集进行精确分词，获得了 1MB/s 的速度，是单进程版的 3.3 倍。
|
||||
实验结果: 在 4 核 3.4GHz Linux 机器上，对金庸全集进行精确分词，获得了 1MB/s 的速度，是单进程版的 3.3 倍。
|
||||
|
||||
注意：并行分词仅支持默认分词器 `jieba.dt` 和 `jieba.posseg.dt`
|
||||
注意: 并行分词仅支持默认分词器 `jieba.dt` 和 `jieba.posseg.dt`
|
||||
|
||||
## Tokenize：返回词语在原文的起止位置
|
||||
## Tokenize: 返回词语在原文的起止位置
|
||||
|
||||
注意，输入参数只接受 unicode
|
||||
|
||||
|
|
|
|||
|
|
@ -2,28 +2,28 @@
|
|||
|
||||
## 篇章分析变迁
|
||||
|
||||
1. 内容生态： 新浪 -> 百家号、今日头条（自媒体）
|
||||
2. 用户成为信息的生产中心： web 1.0 -> 百度贴吧、新浪微博、团购网站（用户评论，富有个人情感和用户观点的信息）
|
||||
3. 移动、无屏： 显示屏 -> 手机、Siri（展示的终端）
|
||||
1. 内容生态: 新浪 -> 百家号、今日头条（自媒体）
|
||||
2. 用户成为信息的生产中心: web 1.0 -> 百度贴吧、新浪微博、团购网站（用户评论，富有个人情感和用户观点的信息）
|
||||
3. 移动、无屏: 显示屏 -> 手机、Siri（展示的终端）
|
||||
|
||||
## 篇章分析场景
|
||||
|
||||
篇章分析重要性：让人们最平等`便捷`地`获取信息`，`找到所求`。
|
||||
篇章分析重要性: 让人们最平等`便捷`地`获取信息`，`找到所求`。
|
||||
|
||||
1. 个性化信息获取（搜索引擎的理解和推荐）：从搜索的角度来看，通过对内容的深入理解，我们能够精准地对内容进行分析，然后将内容推荐给需要的用户，达到不搜即得。
|
||||
2. 便捷咨询阅读（头条的热门推荐）：从资讯阅读的角度来看，我们通过对内容进行概括总结、形成摘要，就能搞让用户更快捷地浏览信息、获取知识。
|
||||
3. 信息直接满足：更进一步说，对用户的问题，我们可以基于内容理解，直接给出答案，从而满足用户的需求。
|
||||
1. 个性化信息获取（搜索引擎的理解和推荐）: 从搜索的角度来看，通过对内容的深入理解，我们能够精准地对内容进行分析，然后将内容推荐给需要的用户，达到不搜即得。
|
||||
2. 便捷咨询阅读（头条的热门推荐）: 从资讯阅读的角度来看，我们通过对内容进行概括总结、形成摘要，就能搞让用户更快捷地浏览信息、获取知识。
|
||||
3. 信息直接满足: 更进一步说，对用户的问题，我们可以基于内容理解，直接给出答案，从而满足用户的需求。
|
||||
|
||||
`总之`：通过篇章分析，我们能够进行内容理解，从而更好地服务用户。
|
||||
`总之`: 通过篇章分析，我们能够进行内容理解，从而更好地服务用户。
|
||||
|
||||
## 篇章分析概述
|
||||
|
||||
`篇章是形式上互相衔接、语义上前后连贯的句子序列。`
|
||||
|
||||
有以下3种：
|
||||
* 1.文章：新闻稿、博客、微博
|
||||
* 2.评论：O2O服务的用户评论、豆瓣的影评、微博上的动态
|
||||
* 3.对话：话题上是相互衔接的、语义上也是连贯的一个对话序列
|
||||
有以下3种:
|
||||
* 1.文章: 新闻稿、博客、微博
|
||||
* 2.评论: O2O服务的用户评论、豆瓣的影评、微博上的动态
|
||||
* 3.对话: 话题上是相互衔接的、语义上也是连贯的一个对话序列
|
||||
|
||||
## 篇章分析任务
|
||||
|
||||
|
|
|
|||
|
|
@ -14,9 +14,9 @@
|
|||
* 在很多的媒体网站，经常会有频道划分，使用了就是文章的分类标签
|
||||
|
||||
3. 话题聚合
|
||||
* 标签也可以用来做话题聚合（例如：#人民的名义# 集合所有关于这个话题的信息，让用户更深入的了解信息）
|
||||
* 标签也可以用来做话题聚合（例如: #人民的名义# 集合所有关于这个话题的信息，让用户更深入的了解信息）
|
||||
|
||||
## 应用：个性化推荐
|
||||
## 应用: 个性化推荐
|
||||
|
||||
* 标签可以用来建立用户的画像
|
||||
|
||||
|
|
@ -32,19 +32,19 @@
|
|||
|
||||
|
||||
|
||||
## 标签体系：面向推荐的标签图谱
|
||||
## 标签体系: 面向推荐的标签图谱
|
||||
|
||||
* 标签图谱刻画了用户的兴趣点，以及兴趣点之间的关联关系。
|
||||
* 节点表示了用户的兴趣点，而边表示了兴趣点之间的关联关系（边是带有权重的，表示关联强度）。
|
||||
* 包括3种节点：主题标签-绿色，话题标签-紫色，实体标签-蓝色。
|
||||
* 有了关联关系，我们可以进行一定程度的探索和泛化。（例如：无人驾驶和人工智能关联很强，如果有人看了无人驾驶，我们就给他推荐人工智能）
|
||||
* 包括3种节点: 主题标签-绿色，话题标签-紫色，实体标签-蓝色。
|
||||
* 有了关联关系，我们可以进行一定程度的探索和泛化。（例如: 无人驾驶和人工智能关联很强，如果有人看了无人驾驶，我们就给他推荐人工智能）
|
||||
|
||||
|
||||
|
||||
## 标签体系：基于大数据分析的图谱构建
|
||||
## 标签体系: 基于大数据分析的图谱构建
|
||||
|
||||
* 用户信息来源：贴吧、微博
|
||||
* 标签的相关性分析：通过关联规则，发现2个标签总同时出现，我们觉得这是高相关的。
|
||||
* 用户信息来源: 贴吧、微博
|
||||
* 标签的相关性分析: 通过关联规则，发现2个标签总同时出现，我们觉得这是高相关的。
|
||||
|
||||
|
||||
|
||||
|
|
@ -52,31 +52,31 @@
|
|||
|
||||
> 主题分类
|
||||
|
||||
* 主题标签的计算，是一种很典型的文本分类问题：传统的朴素贝叶斯、最大熵、SVM 等解决方案。
|
||||
* 当前我们主要采用的是：基于神经网络的方法（可以看右侧的示意图）
|
||||
* 整个网络分成3层次：
|
||||
* 第一层 原始特征层：抽取简单的原始特征，例如说文章出现的单词、词组 等等
|
||||
* 第二层 表示层：通过一些 embedding的算法、CNN、LSTM的方法
|
||||
* 第三层 排序层：计算文章与主题之间的相似度，具体会计算每个主题与文章的相似度，并将相似度作为最终的一个主题分类的结果。这种计算的好处能够天然的支持多标记，也就是一篇文章可以同时计算出多个主题标签。
|
||||
* 主题标签的计算，是一种很典型的文本分类问题: 传统的朴素贝叶斯、最大熵、SVM 等解决方案。
|
||||
* 当前我们主要采用的是: 基于神经网络的方法（可以看右侧的示意图）
|
||||
* 整个网络分成3层次:
|
||||
* 第一层 原始特征层: 抽取简单的原始特征，例如说文章出现的单词、词组 等等
|
||||
* 第二层 表示层: 通过一些 embedding的算法、CNN、LSTM的方法
|
||||
* 第三层 排序层: 计算文章与主题之间的相似度，具体会计算每个主题与文章的相似度，并将相似度作为最终的一个主题分类的结果。这种计算的好处能够天然的支持多标记，也就是一篇文章可以同时计算出多个主题标签。
|
||||
|
||||
|
||||
|
||||
> 通用标签
|
||||
|
||||
* 通用标签主要是计算内容中的实体和话题，我们综合了两种策略。
|
||||
* 第一种策略： 针对比较热门的高频标签
|
||||
* 这种标签我们主要通过一些预测的方法得到，预测的方法：基于相似度计算得到的---这种方法并不要求标签一定在文章中出现
|
||||
* 例如：美国大选这种标签，如果一篇文章出现了 `希拉里` `特朗普` `辩论` 等一些词，即使没有出现美国大选，我们通过语义相似度的方法也能把这个标签计算出来。
|
||||
* 第二种策略： 面向中低频的标签
|
||||
* 第一种策略: 针对比较热门的高频标签
|
||||
* 这种标签我们主要通过一些预测的方法得到，预测的方法: 基于相似度计算得到的---这种方法并不要求标签一定在文章中出现
|
||||
* 例如: 美国大选这种标签，如果一篇文章出现了 `希拉里` `特朗普` `辩论` 等一些词，即使没有出现美国大选，我们通过语义相似度的方法也能把这个标签计算出来。
|
||||
* 第二种策略: 面向中低频的标签
|
||||
* 这种标签相关的信息，不是那么丰富，所以我们计算的时候更多依赖的是标签在文章中的信息
|
||||
* 比如：这个标签在文章中出现的频率 或 出现的位置；如果出现在标题，那么它可能就会比较重要。
|
||||
* 比如: 这个标签在文章中出现的频率 或 出现的位置；如果出现在标题，那么它可能就会比较重要。
|
||||
* 通过融合这2种策略，形成我们通用标签的结果。
|
||||
|
||||
|
||||
|
||||
## 内容标签在Feed流中的应用
|
||||
|
||||
1. 标签可以用来话题聚合：比如表示人工智能的标签全部都会集合到同一个话题下面。这样用户可以对人工智能这个话题进行非常充分的浏览。
|
||||
2. 话题频道划分：比如我们在手机百度上面就可以看到，Feed流上面有多个栏目，用户可以点击 `体育` `时尚`等频道
|
||||
1. 标签可以用来话题聚合: 比如表示人工智能的标签全部都会集合到同一个话题下面。这样用户可以对人工智能这个话题进行非常充分的浏览。
|
||||
2. 话题频道划分: 比如我们在手机百度上面就可以看到，Feed流上面有多个栏目，用户可以点击 `体育` `时尚`等频道
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -23,9 +23,9 @@
|
|||
|
||||
> 观点挖掘
|
||||
|
||||
* 观点聚类：主要目标是对大量的评论数据进行聚类，将相同的观点抽取出来，并形成一个情感搭配词典（算法是：搭配抽取、词法分析、聚类归一，从而获得一个情感搭配。我们就可以进行观点抽取）
|
||||
* 观点抽取：就是对输入的文本进行计算，将其中的情感标签抽取出来，这里的标签，都是来自于情感搭配词典的，也就是观点聚类获得的词典。
|
||||
* 观点抽取一种简单的做法是直接通过标签匹配的方式得到，比如：服务不错这个情感搭配，恰好在文本中出现，我们就可以把它抽取出来。
|
||||
* 观点聚类: 主要目标是对大量的评论数据进行聚类，将相同的观点抽取出来，并形成一个情感搭配词典（算法是: 搭配抽取、词法分析、聚类归一，从而获得一个情感搭配。我们就可以进行观点抽取）
|
||||
* 观点抽取: 就是对输入的文本进行计算，将其中的情感标签抽取出来，这里的标签，都是来自于情感搭配词典的，也就是观点聚类获得的词典。
|
||||
* 观点抽取一种简单的做法是直接通过标签匹配的方式得到，比如: 服务不错这个情感搭配，恰好在文本中出现，我们就可以把它抽取出来。
|
||||
* 但是这种简单的抽取方法，其实上只能从字面上抽取情感搭配，而无法解决字面不一致的，但是意思一样的情感搭配抽取，因此我们还引入了语义相似度的方法。这种方法主要是通过神经网络进行计算的。它能解决这种字面不一致，语义一样的抽取问题。
|
||||
|
||||
|
||||
|
|
@ -36,10 +36,10 @@
|
|||
|
||||
|
||||
|
||||
## 百度应用：评论观点
|
||||
## 百度应用: 评论观点
|
||||
|
||||
|
||||
|
||||
## 百度应用：推荐理由
|
||||
## 百度应用: 推荐理由
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
* 便捷信息浏览
|
||||
* 我们可以为每个新闻抽取摘要，用户可以通过摘要快速了解新闻概况。
|
||||
* 进而决定是否要进一步细致地浏览。
|
||||
* 而更进一步说：摘要还可以直接进行信息满足。
|
||||
* 而更进一步说: 摘要还可以直接进行信息满足。
|
||||
* 信息满足
|
||||
* 传统搜索得到一大批网页信息
|
||||
* 现在通过问答技术我们能够将网页中最核心的片段摘要提取出来。
|
||||
|
|
|
|||
|
|
@ -0,0 +1,13 @@
|
|||
|
||||
|
||||
|
||||
使用Bakeoff-3评测中所采用的的BIO标注集:
|
||||
|
||||
B-PER、I-PER 代表人名首字、人名非首字，
|
||||
B-LOC、I-LOC 代表地名首字、地名非首字，
|
||||
B-ORG、I-ORG 代表组织机构名首字、组织机构名非首字，
|
||||
O 代表该字不属于命名实体的一部分。
|
||||
|
||||
|
||||
输入输出的计算方式:
|
||||
$$L_{out}=floor((L_{in}+2*padding-dilation*(kernerl\_size-1)-1)/stride+1)$$
|
||||
|
|
@ -5,20 +5,20 @@
|
|||
* Python 自然语言处理 第二版: <https://usyiyi.github.io/nlp-py-2e-zh>
|
||||
* 推荐一个[liuhuanyong大佬](https://github.com/liuhuanyong)整理的nlp全面知识体系: <https://liuhuanyong.github.io>
|
||||
|
||||
## nlp 学习书籍和工具：
|
||||
## nlp 学习书籍和工具:
|
||||
|
||||
* 百度搜索：Python自然语言处理
|
||||
* 读书笔记：<https://wnma3mz.github.io/hexo_blog/2018/05/13/《Python自然语言处理》阅读笔记（一）>
|
||||
* 百度搜索: Python自然语言处理
|
||||
* 读书笔记: <https://wnma3mz.github.io/hexo_blog/2018/05/13/《Python自然语言处理》阅读笔记（一）>
|
||||
* Python自然语言处理工具汇总: <https://blog.csdn.net/sa14023053/article/details/51823122>
|
||||
|
||||
## nlp 全局介绍视频：（简单做了解就行）
|
||||
## nlp 全局介绍视频: （简单做了解就行）
|
||||
|
||||
地址链接： http://bit.baidu.com/Course/detail/id/56.html
|
||||
地址链接: http://bit.baidu.com/Course/detail/id/56.html
|
||||
|
||||
1. 自然语言处理知识入门
|
||||
2. 百度机器翻译
|
||||
3. 篇章分析
|
||||
4. UNIT：语言理解与交互技术
|
||||
4. UNIT: 语言理解与交互技术
|
||||
|
||||
## 中文 NLP
|
||||
|
||||
|
|
@ -50,11 +50,11 @@
|
|||
训练需要正样本和负样本同时存在。
|
||||
|
||||
优势:
|
||||
负采样的本质：每次让一个训练样本只更新部分权重，其他权重全部固定；减少计算量；（一定程度上还可以增加随机性）
|
||||
负采样的本质: 每次让一个训练样本只更新部分权重，其他权重全部固定；减少计算量；（一定程度上还可以增加随机性）
|
||||
|
||||
## nlp 操作流程
|
||||
|
||||
[本项目](https://pytorch.apachecn.org/docs/1.0/#/char_rnn_classification_tutorial) 试图通过名字分类问题给大家描述一个基础的深度学习中自然语言处理模型，同时也向大家展示了Pytorch的基本玩法。 其实对于大部分基础的NLP工作，都是类似的套路：
|
||||
[本项目](https://pytorch.apachecn.org/docs/1.0/#/char_rnn_classification_tutorial) 试图通过名字分类问题给大家描述一个基础的深度学习中自然语言处理模型，同时也向大家展示了Pytorch的基本玩法。 其实对于大部分基础的NLP工作，都是类似的套路:
|
||||
|
||||
1. 收集数据
|
||||
2. 清洗数据
|
||||
|
|
@ -65,16 +65,16 @@
|
|||
7. 把输出的结果进行处理，得到最终想要的数据。常需要把向量化的结果根据字母表或者词表变回文本数据。
|
||||
8. 评估模型。
|
||||
|
||||
如果真的想要对自然语言处理或者序列模型有更加全面的了解，建议大家去网易云课堂看一看吴恩达深度学习微专业中的序列模型这一板块，可以说是讲的非常清楚了。 此外极力推荐两个blog：
|
||||
如果真的想要对自然语言处理或者序列模型有更加全面的了解，建议大家去网易云课堂看一看吴恩达深度学习微专业中的序列模型这一板块，可以说是讲的非常清楚了。 此外极力推荐两个blog:
|
||||
|
||||
1. 讲述RNN循环神经网络在深度学习中的各种应用场景。http://karpathy.github.io/2015/05/21/rnn-effectiveness/
|
||||
2. 讲述LSTM的来龙去脉。http://colah.github.io/posts/2015-08-Understanding-LSTMs/
|
||||
|
||||
最后，本文参考整合了:
|
||||
|
||||
* Pytorch中文文档：https://pytorch.apachecn.org
|
||||
* Pytorch官方文档：http://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html
|
||||
* Ngarneau小哥的博文：https://github.com/ngarneau/understanding-pytorch-batching-lstm
|
||||
* Pytorch中文文档: https://pytorch.apachecn.org
|
||||
* Pytorch官方文档: http://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html
|
||||
* Ngarneau小哥的博文: https://github.com/ngarneau/understanding-pytorch-batching-lstm
|
||||
* 另外，本项目搭配Sung Kim的Pytorch Zero To All的第13讲rnn_classification会更加方便食用喔，视频可以在油管和b站中找到。
|
||||
|
||||
## nlp - 比赛链接
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
## 介绍
|
||||
|
||||
**需要复习** 手写 Word2Vec 源码：https://blog.csdn.net/u014595019/article/details/51943428
|
||||
**需要复习** 手写 Word2Vec 源码: https://blog.csdn.net/u014595019/article/details/51943428
|
||||
|
||||
* 2013年，Google开源了一款用于词向量计算的工具—— `word2vec`，引起了工业界和学术界的关注。
|
||||
* `word2vec` 算法或模型的时候，其实指的是其背后用于计算 **word vector** 的 `CBoW` 模型和 `Skip-gram` 模型
|
||||
|
|
@ -32,17 +32,17 @@
|
|||
|
||||
|
||||
> 5.监督学习和无监督学习的区别：是否有目标变量（也就是：是否存在分类结果）
|
||||
> 5.监督学习和无监督学习的区别: 是否有目标变量（也就是: 是否存在分类结果）
|
||||
|
||||
> 6.电子书的下载位置：
|
||||
> 6.电子书的下载位置:
|
||||
|
||||
* 下载书籍： https://github.com/apachecn/AiLearning/tree/python-2.7/books
|
||||
* 下载书籍: https://github.com/apachecn/AiLearning/tree/python-2.7/books
|
||||
|
||||
> 7.性能不好是什么意思？
|
||||
|
||||
* 就是对比其他语言来说：资源的使用效率受限、处理速度慢。
|
||||
* 就是对比其他语言来说: 资源的使用效率受限、处理速度慢。
|
||||
|
||||
> 8.学习原理后，如果成为调包侠？调包侠是否很丑？
|
||||
|
||||
|
|
@ -57,17 +57,17 @@
|
|||
|
||||
## 4.复习的时间和资料
|
||||
|
||||
* 形式：直播+讨论组
|
||||
* 周期：周一 ～ 周五
|
||||
* 时间：20:30 ～ 21:30
|
||||
* 学习文档：https://github.com/apachecn/AiLearning
|
||||
* 下载书籍： https://github.com/apachecn/AiLearning/tree/python-2.7/books
|
||||
* 活动日期：2017-11-20 ～ 2017-12-08（共15天，1章1天）
|
||||
* 活动详情：http://www.apachecn.org/machinelearning/279.html
|
||||
* 形式: 直播+讨论组
|
||||
* 周期: 周一 ～ 周五
|
||||
* 时间: 20:30 ～ 21:30
|
||||
* 学习文档: https://github.com/apachecn/AiLearning
|
||||
* 下载书籍: https://github.com/apachecn/AiLearning/tree/python-2.7/books
|
||||
* 活动日期: 2017-11-20 ～ 2017-12-08（共15天，1章1天）
|
||||
* 活动详情: http://www.apachecn.org/machinelearning/279.html
|
||||
|
||||
## 5.直播方式
|
||||
|
||||
* QQ：在讨论组共享屏幕（实时）
|
||||
* QQ: 在讨论组共享屏幕（实时）
|
||||
* 视频会在 讨论组中进行分享
|
||||
* B站的直播地址（延迟）
|
||||
* 直播地址: http://live.bilibili.com/5427054
|
||||
|
|
|
|||
220
faq/直播问题汇总.md
220
faq/直播问题汇总.md
|
|
@ -1,55 +1,55 @@
|
|||
# 直播问题汇总
|
||||
|
||||
标签（空格分隔）： 机器学习 直播问题
|
||||
标签（空格分隔）: 机器学习 直播问题
|
||||
|
||||
---
|
||||
|
||||
## 1、机器学习基础（片刻）
|
||||
|
||||
1. 谷德 2017-11-20 20:45:09
|
||||
问：关于 github ，如果是管理员的话，那只能在 web 页面上做查看和审批吗？不能用 vscode 等编辑器进行吗？
|
||||
问: 关于 github ，如果是管理员的话，那只能在 web 页面上做查看和审批吗？不能用 vscode 等编辑器进行吗？
|
||||
|
||||
答：管理员啥权限都有的，删除和创建项目的权限都有，但是都是在网页上进行， vscode 还不可以。github 的 桌面客户端应该也可以，但是相对用的较少。
|
||||
答: 管理员啥权限都有的，删除和创建项目的权限都有，但是都是在网页上进行， vscode 还不可以。github 的 桌面客户端应该也可以，但是相对用的较少。
|
||||
|
||||
2. HY Serendipity 2017-11-20 20:58:39
|
||||
问：回归和函数拟合的区别在哪儿？
|
||||
问: 回归和函数拟合的区别在哪儿？
|
||||
|
||||
答：回归是预测结果，而函数拟合是预测结果的一个步骤。
|
||||
答: 回归是预测结果，而函数拟合是预测结果的一个步骤。
|
||||
|
||||
3. Michael❦ 2017-11-20 21:31:26
|
||||
问：话说 sklearn是啥 三方库么 听说好多次啦
|
||||
问: 话说 sklearn是啥 三方库么 听说好多次啦
|
||||
|
||||
答：scikit-learn 简称 sklearn 。是机器学习中一个常用的 python 第三方模块，英文官网：http://scikit-learn.org/stable/ 。中文官网（^_^）：http://sklearn.apachecn.org/ 。里面对一些常用的机器学习方法进行了封装，在进行机器学习任务时，并不需要每个人都实现所有的算法，只需要简单的调用 sklearn 里面的模块就可以实现大多数机器学习任务。
|
||||
答: scikit-learn 简称 sklearn 。是机器学习中一个常用的 python 第三方模块，英文官网: http://scikit-learn.org/stable/ 。中文官网（^_^）: http://sklearn.apachecn.org/ 。里面对一些常用的机器学习方法进行了封装，在进行机器学习任务时，并不需要每个人都实现所有的算法，只需要简单的调用 sklearn 里面的模块就可以实现大多数机器学习任务。
|
||||
|
||||
4. HY Serendipity 2017-11-20 21:33:38
|
||||
问：em，我想问，之后学习算法是调包实现还是自己写代码实现？
|
||||
问: em，我想问，之后学习算法是调包实现还是自己写代码实现？
|
||||
|
||||
答：最正确的做法，就是先了解原理之后，再做调包侠，因为咱们谁上来都不想做单纯的调包侠，那样显得咱们也比较 low 。
|
||||
答: 最正确的做法，就是先了解原理之后，再做调包侠，因为咱们谁上来都不想做单纯的调包侠，那样显得咱们也比较 low 。
|
||||
|
||||
5. HY Serendipity 2017-11-20 22:22:19
|
||||
问：那个我想问一下，比如我从apachecn上fork了一个项目，并且自己clone到了本地，之后apachecn的项目有了更新，我直接在本地pull了apachecn的远程仓库的项目，但是我push是只能push到自己的仓库的，那么我自己的origin仓库的更新操作是怎么实现的呢？
|
||||
问: 那个我想问一下，比如我从apachecn上fork了一个项目，并且自己clone到了本地，之后apachecn的项目有了更新，我直接在本地pull了apachecn的远程仓库的项目，但是我push是只能push到自己的仓库的，那么我自己的origin仓库的更新操作是怎么实现的呢？
|
||||
|
||||
答：是这样实现的，这算是一个基本的操作吧。下面我以第一人称来介绍啊。我先从 apachecn 上 fork 了ML项目到了我自己的 github 中，比如我的 github 用户名叫做 chenyyx ，我的项目中就有了一个叫做 ML 的项目，如 chenyyx/ML 。这样，我接下来，使用 git clone https://github.com/chenyyx/MachineLearning.git 命令，就将这个项目 克隆到我自己的本地计算机了。接下来就是我们的重头戏了。
|
||||
有一点需要知道：我的 git 默认创建的是本地与远程自己的 github （也就是 chenyyx）之间的关联。即，我在本地输入命令 git remote -v 看到的分支，只有一个 origin 分支，并且这个分支指向的是我自己的 github (也就是： https://github.com/chenyyx/MachineLearning)，现在可能你会发现一个问题，我现在本地的文件与远程关联，只是与远程的我自己的 github 项目关联，并没有与 apachecn 的项目关联（也就是https://github.com/apachecn/AiLearning），所以我们还需要创建一个管道来连接我的本地文件与apachecn的项目。创建的命令是（每个单词之间用空格隔开）：git remote add origin_ml(分支名称) https://github.com/apachecn/AiLearning.git（apachecn的远程分支） 。这样就在我本地文件与 apachecn 的远程分支建立了一个管道，可以用来同步 apachecn 的远程更新。使用命令如下：git pull origin_ml 或者麻烦点，使用：git fetch origin_ml 然后再使用 git merge origin_ml/master 这个命令，将远程的 master 分支上的更新与本地合并。（即达到了我的本地与 apachecn 的远程分支同步），然后再输入命令： git push 就可以将我同步提交到 我们自己的 github 上（实际上，就达到了我们的目的，将apachecn 的远程更新与我自己的github同步）。
|
||||
答: 是这样实现的，这算是一个基本的操作吧。下面我以第一人称来介绍啊。我先从 apachecn 上 fork 了ML项目到了我自己的 github 中，比如我的 github 用户名叫做 chenyyx ，我的项目中就有了一个叫做 ML 的项目，如 chenyyx/ML 。这样，我接下来，使用 git clone https://github.com/chenyyx/MachineLearning.git 命令，就将这个项目 克隆到我自己的本地计算机了。接下来就是我们的重头戏了。
|
||||
有一点需要知道: 我的 git 默认创建的是本地与远程自己的 github （也就是 chenyyx）之间的关联。即，我在本地输入命令 git remote -v 看到的分支，只有一个 origin 分支，并且这个分支指向的是我自己的 github (也就是: https://github.com/chenyyx/MachineLearning)，现在可能你会发现一个问题，我现在本地的文件与远程关联，只是与远程的我自己的 github 项目关联，并没有与 apachecn 的项目关联（也就是https://github.com/apachecn/AiLearning），所以我们还需要创建一个管道来连接我的本地文件与apachecn的项目。创建的命令是（每个单词之间用空格隔开）: git remote add origin_ml(分支名称) https://github.com/apachecn/AiLearning.git（apachecn的远程分支） 。这样就在我本地文件与 apachecn 的远程分支建立了一个管道，可以用来同步 apachecn 的远程更新。使用命令如下: git pull origin_ml 或者麻烦点，使用: git fetch origin_ml 然后再使用 git merge origin_ml/master 这个命令，将远程的 master 分支上的更新与本地合并。（即达到了我的本地与 apachecn 的远程分支同步），然后再输入命令: git push 就可以将我同步提交到 我们自己的 github 上（实际上，就达到了我们的目的，将apachecn 的远程更新与我自己的github同步）。
|
||||
|
||||
6. 风风 2017-11-21 00:05:22
|
||||
问：各位大佬，我装了anconda3，那vscode还需要安装Python3吗？
|
||||
问: 各位大佬，我装了anconda3，那vscode还需要安装Python3吗？
|
||||
|
||||
答：不需要了，实际上 anaconda3 就是一个 python 的集成环境，它本身集成了很多常用的库，当然里面已经有了 python3 了，就不需要安装了。
|
||||
答: 不需要了，实际上 anaconda3 就是一个 python 的集成环境，它本身集成了很多常用的库，当然里面已经有了 python3 了，就不需要安装了。
|
||||
|
||||
## 2、k-近邻算法（KNN）（小瑶）
|
||||
|
||||
1. 谷德 2017-11-21 20:39:38
|
||||
问：求距离还有其他的算法吗？
|
||||
问: 求距离还有其他的算法吗？
|
||||
|
||||
答：k 近邻模型的特征空间一般是 n 维实数向量空间  ，使用的距离是欧式距离。当然，我们还可以选择其他距离，比如更加一般的  距离（Lp distance），或者 Minkowski 距离（Minkowski distance），曼哈顿距离（Manhattan Distance），切比雪夫距离（Chebyshev Distance）。
|
||||
答: k 近邻模型的特征空间一般是 n 维实数向量空间  ，使用的距离是欧式距离。当然，我们还可以选择其他距离，比如更加一般的  距离（Lp distance），或者 Minkowski 距离（Minkowski distance），曼哈顿距离（Manhattan Distance），切比雪夫距离（Chebyshev Distance）。
|
||||
|
||||
更多参见链接：http://liyonghui160com.iteye.com/blog/2084557
|
||||
更多参见链接: http://liyonghui160com.iteye.com/blog/2084557
|
||||
|
||||
2. ~~ 2017-11-21 20:41:07
|
||||
问：用来求电影距离的 x y 具体含义是指什么？
|
||||
问: 用来求电影距离的 x y 具体含义是指什么？
|
||||
|
||||
答：如果大佬你说的是下面这种：
|
||||
答: 如果大佬你说的是下面这种:
|
||||
|
||||
|
||||
|
||||
|
|
@ -58,72 +58,72 @@
|
|||
如果不是上面的这种，那么 x 代表的就是特征，y 代表的是目标变量，也就是相应的分类。
|
||||
|
||||
3. 蓝色之旅 2017-11-21 20:41:22
|
||||
问：可以讲pearson计算相似评价值度量吗？
|
||||
问: 可以讲pearson计算相似评价值度量吗？
|
||||
|
||||
答：Pearson 相关系数可以参考下面两个链接：
|
||||
答: Pearson 相关系数可以参考下面两个链接:
|
||||
* http://www.codeweblog.com/%E7%9B%B8%E4%BC%BC%E6%80%A7%E5%BA%A6%E9%87%8F-pearson%E7%9B%B8%E5%85%B3%E7%B3%BB%E6%95%B0/
|
||||
* https://www.cnblogs.com/yulinfeng/p/4508930.html
|
||||
|
||||
4. QQ 2017-11-21 20:44:15
|
||||
问：那这个算法优化点在 k 和 距离上？
|
||||
问: 那这个算法优化点在 k 和 距离上？
|
||||
|
||||
答：对，但不全对。三个因素上都可以进行优化。
|
||||
答: 对，但不全对。三个因素上都可以进行优化。
|
||||
* 比如 k 值的选择上，我们可以选择一个近似误差和估计误差都较好的一个 k 值。
|
||||
* 距离度量上，我们上面说有很多种的距离度量方式，具体问题具体对待，根据不同的数据我们选择不同的距离度量方式，也可以达到优化的效果。
|
||||
* 分类决策规则这方面，我们也可以根据自己的经验选择适合的分类决策规则，KNN 最常用的就是多数表决。
|
||||
* 补充一点，还可以进行优化的部分。可以给训练数据集中的数据点加上适合的权重，距离新数据点相对较近的，权重较大，较远的，权重相应减小。这样也可以算是一种优化吧。
|
||||
|
||||
5. 谷德 2017-11-21 21:01:52
|
||||
问：如果数据的维度很多（列有很多）的话，这个靠内存计算是不是就很快就爆了？
|
||||
问: 如果数据的维度很多（列有很多）的话，这个靠内存计算是不是就很快就爆了？
|
||||
|
||||
答：是的啊，也可能不会爆炸，但是会很慢。当然大佬问的时候说到，那 KNN 在实际应用中的意义何在？之前的巨人们也做了一些相应的优化，比如 kd-tree 和 ball-tree 这些，详细内容可以参见链接：https://www.zhihu.com/question/30957691 。如果你感觉仍然达不到你的需求，对最初的数据进行预处理，也是可以的，比如降维等，在实用算法之前进行一些必要的处理，这样也可以使 KNN 的效率提升。当然，如果还是不如你的预期，那就考虑一下换一个算法试试。
|
||||
答: 是的啊，也可能不会爆炸，但是会很慢。当然大佬问的时候说到，那 KNN 在实际应用中的意义何在？之前的巨人们也做了一些相应的优化，比如 kd-tree 和 ball-tree 这些，详细内容可以参见链接: https://www.zhihu.com/question/30957691 。如果你感觉仍然达不到你的需求，对最初的数据进行预处理，也是可以的，比如降维等，在实用算法之前进行一些必要的处理，这样也可以使 KNN 的效率提升。当然，如果还是不如你的预期，那就考虑一下换一个算法试试。
|
||||
|
||||
6. QQ 2017-11-21 21:03:05
|
||||
问：归一化算法的选取标准是什么？
|
||||
问: 归一化算法的选取标准是什么？
|
||||
|
||||
答：归一化算法的选取标准可以参考下面两个链接：
|
||||
答: 归一化算法的选取标准可以参考下面两个链接:
|
||||
* https://www.zhihu.com/question/20455227
|
||||
* https://www.zhihu.com/question/26546711/answer/62085061
|
||||
|
||||
7. HY Serendipity 2017-11-21 21:25:18
|
||||
问：手写数字识别的时候，img2vector 所以是看成了32·32个特征么？
|
||||
问: 手写数字识别的时候，img2vector 所以是看成了32·32个特征么？
|
||||
|
||||
答：这么理解稍微有一些偏颇。并不是将图片文件看成 32*32 个特征，而是将之前 32 行 32 列的数据转换成为一行数据，也就是 1 * 1024 的形式，把它当成一条数据来处理，一个图片代表一个样本数据，这样更便于我们接下来的欧式距离的计算。
|
||||
答: 这么理解稍微有一些偏颇。并不是将图片文件看成 32*32 个特征，而是将之前 32 行 32 列的数据转换成为一行数据，也就是 1 * 1024 的形式，把它当成一条数据来处理，一个图片代表一个样本数据，这样更便于我们接下来的欧式距离的计算。
|
||||
|
||||
## 3、决策树（Decision Tree）（小瑶）
|
||||
|
||||
1. QQ 2017-11-22 20:38:06
|
||||
问：叶节点是提前分好的吗？
|
||||
问: 叶节点是提前分好的吗？
|
||||
|
||||
答：其实，不能这么说吧，叶节点是根据我们训练数据集中所有数据的分类来得到的，是我们训练出来的。训练数据集中有什么分类，我们就会得到什么叶节点。
|
||||
答: 其实，不能这么说吧，叶节点是根据我们训练数据集中所有数据的分类来得到的，是我们训练出来的。训练数据集中有什么分类，我们就会得到什么叶节点。
|
||||
|
||||
2. HY Serendipity 2017-11-22 20:42:12
|
||||
问：信息增益是信息熵的差么？
|
||||
问: 信息增益是信息熵的差么？
|
||||
|
||||
答：是的，是数据集划分之前的信息熵 减去 数据集划分之后的信息熵 的差值，得到的这个差值我们就称之为信息增益。
|
||||
答: 是的，是数据集划分之前的信息熵 减去 数据集划分之后的信息熵 的差值，得到的这个差值我们就称之为信息增益。
|
||||
|
||||
3. HY Serendipity 2017-11-22 20:45:46
|
||||
问：什么是划分后熵最小？
|
||||
问: 什么是划分后熵最小？
|
||||
|
||||
答：因为我们在构造决策树的过程中，是遍历数据集中所有的数据特征（N个特征，全部都遍历一次），在每一次会依据一个特征划分数据集之后，会计算一下划分后得到的子数据集的新的信息熵。我们从这些得到的新的信息熵中找到那个最小的信息熵，也就是划分数据集之前的信息熵与划分数据集之后的信息熵的差值是最大的。也就是咱们说的信息增益是最大的。
|
||||
答: 因为我们在构造决策树的过程中，是遍历数据集中所有的数据特征（N个特征，全部都遍历一次），在每一次会依据一个特征划分数据集之后，会计算一下划分后得到的子数据集的新的信息熵。我们从这些得到的新的信息熵中找到那个最小的信息熵，也就是划分数据集之前的信息熵与划分数据集之后的信息熵的差值是最大的。也就是咱们说的信息增益是最大的。
|
||||
|
||||
4. 谷德 2017-11-22 20:48:45
|
||||
问：那树的深度是多少呢？
|
||||
问: 那树的深度是多少呢？
|
||||
|
||||
答：在没有设置树的深度，或者没有设置树的停止条件下，树的深度是N，也就是训练数据集的 N 个特征数。
|
||||
答: 在没有设置树的深度，或者没有设置树的停止条件下，树的深度是N，也就是训练数据集的 N 个特征数。
|
||||
|
||||
当然树的深度可以自己设置，比如，我们在使用信息增益划分数据集的情况下，我们可以设置信息增益的最小值（作为阈值），只要大于我们设置的最小值就划分数据集，如果小于这个阈值的话，我们就不再划分数据集了。这其实就是一个剪枝的概念（预剪枝）。而既然有这种考虑的话，那我们就要想到，不再划分数据
|
||||
|
||||
还有就是在我们已经将树构建完成后，认为树的节点或者深度过多的话，可以通过一定的算法减少树的节点和深度，这样就得到了自定义的树的深度和节点。这也是另一种层面上的剪枝（后剪枝）。
|
||||
|
||||
5. HY Serendipity 2017-11-22 20:55:28
|
||||
问：这个示例里的特征的概率具体是怎么计算的？还有详细的信息熵计算。
|
||||
问: 这个示例里的特征的概率具体是怎么计算的？还有详细的信息熵计算。
|
||||
|
||||
答：首先我们看一下计算香农熵的公式，然后下面看计算给定数据集的香农熵的函数。
|
||||
答: 首先我们看一下计算香农熵的公式，然后下面看计算给定数据集的香农熵的函数。
|
||||
|
||||
其中的 $p(x_i)$ 是选择该分类的概率。
|
||||
|
||||
为了计算熵，我们需要计算所有类别所有可能值包含的信息期望值，通过下面的公式得到：
|
||||
为了计算熵，我们需要计算所有类别所有可能值包含的信息期望值，通过下面的公式得到:
|
||||
$$H = -\sum_{i=1}^{n}p(x_i)log_2p(x_i)$$
|
||||
|
||||
```python
|
||||
|
|
@ -164,155 +164,155 @@ def calcShannonEnt(dataSet):
|
|||
## 4、朴素贝叶斯算法（Naive Bayes）（如果迎着风就飞）
|
||||
|
||||
1. 小瑶 2017-11-23 20:45:05
|
||||
问：先验概率和后验概率都是什么意思？
|
||||
问: 先验概率和后验概率都是什么意思？
|
||||
|
||||
答：先验概率是在缺乏某个事实的情况下描述一个变量; 而后验概率是在考虑了一个事实之后的条件概率。所以后验概率也可以叫做条件概率。
|
||||
答: 先验概率是在缺乏某个事实的情况下描述一个变量; 而后验概率是在考虑了一个事实之后的条件概率。所以后验概率也可以叫做条件概率。
|
||||
|
||||
2. HY Serendipity 2017-11-23 20:52:56
|
||||
问：朴素是指条件独立吗？
|
||||
问: 朴素是指条件独立吗？
|
||||
|
||||
答：是的，朴素贝叶斯就是假设条件完全独立。
|
||||
答: 是的，朴素贝叶斯就是假设条件完全独立。
|
||||
|
||||
3. 那伊抹微笑 2017-11-23 21:16:45
|
||||
问：为什么概率最大是我们想要的结果？
|
||||
问: 为什么概率最大是我们想要的结果？
|
||||
|
||||
答：代价最小/风险最小（需要详细写一下吧）
|
||||
答: 代价最小/风险最小（需要详细写一下吧）
|
||||
|
||||
4. 超萌小宝贝 2017-11-23 21:20:18
|
||||
问：两种估计就差一个参数？
|
||||
问: 两种估计就差一个参数？
|
||||
|
||||
答：最大似然估计和贝叶斯估计，分母和分子是相差一个参数的，是为了避免概率值为0的情况。但是目的都是为了计算概率。
|
||||
答: 最大似然估计和贝叶斯估计，分母和分子是相差一个参数的，是为了避免概率值为0的情况。但是目的都是为了计算概率。
|
||||
|
||||
5. HY Serendipity 2017-11-23 21:21:01
|
||||
问：分母为什么要加上分子的 s 倍？
|
||||
问: 分母为什么要加上分子的 s 倍？
|
||||
|
||||
答：s倍取决于特征数，因为我要保证所有特征数属于某个类别的概率和为1。
|
||||
答: s倍取决于特征数，因为我要保证所有特征数属于某个类别的概率和为1。
|
||||
|
||||
6. 灵魂 2017-11-23 21:30:48
|
||||
问：拉普拉斯平滑是为了解决什么问题？
|
||||
问: 拉普拉斯平滑是为了解决什么问题？
|
||||
|
||||
答：有时候因为训练量不足，会令分类器质量大大降低。为了解决这个问题，我们引入Laplace校准（这就引出了我们的拉普拉斯平滑），它的思想非常简单，就是对没类别下所有划分的计数加1，这样如果训练样本集数量充分大时，并不会对结果产生影响，并且解决了上述频率为0的尴尬局面。(不知道回答的对不对)
|
||||
答: 有时候因为训练量不足，会令分类器质量大大降低。为了解决这个问题，我们引入Laplace校准（这就引出了我们的拉普拉斯平滑），它的思想非常简单，就是对没类别下所有划分的计数加1，这样如果训练样本集数量充分大时，并不会对结果产生影响，并且解决了上述频率为0的尴尬局面。(不知道回答的对不对)
|
||||
|
||||
## 5、Logistic 回归（逻辑斯蒂回归）（如果迎着风就飞）
|
||||
|
||||
1. HY Serendipity 2017-11-24 21:06:22
|
||||
问：我不清楚的是这里怎么引出梯度上升的？
|
||||
问: 我不清楚的是这里怎么引出梯度上升的？
|
||||
|
||||
答：因为逻辑回归在使用sigmoid函数的时候要找到每个特征是某个类别的权重，所以通过梯度上升来找到最优的权重比。
|
||||
答: 因为逻辑回归在使用sigmoid函数的时候要找到每个特征是某个类别的权重，所以通过梯度上升来找到最优的权重比。
|
||||
|
||||
2. HY Serendipity 2017-11-24 21:19:25
|
||||
问：为什么要使用梯度上升求极值呢？
|
||||
问: 为什么要使用梯度上升求极值呢？
|
||||
|
||||
答：梯度上升和梯度下降都可以用来求极值，我们这里用梯度上升来求某条数据是某个类别的最大的可能性。最大的可能性肯定就是求最大值呀。所以求极大值上升，极小值下降。
|
||||
答: 梯度上升和梯度下降都可以用来求极值，我们这里用梯度上升来求某条数据是某个类别的最大的可能性。最大的可能性肯定就是求最大值呀。所以求极大值上升，极小值下降。
|
||||
|
||||
3. ls 2017-11-24 21:26:32
|
||||
问：什么时候使用梯度上升，什么时候使用梯度下降？
|
||||
问: 什么时候使用梯度上升，什么时候使用梯度下降？
|
||||
|
||||
答：主要看你的数学问题，和二次方程一样，-x^2肯定有最大值，x^2肯定是最小值啊。
|
||||
答: 主要看你的数学问题，和二次方程一样，-x^2肯定有最大值，x^2肯定是最小值啊。
|
||||
|
||||
4. HY Serendipity 2017-11-24 21:35:11
|
||||
问：我其实更想知道似然函数，因为这里用到了梯度上升
|
||||
问: 我其实更想知道似然函数，因为这里用到了梯度上升
|
||||
|
||||
答：似然函数就一种条件概率，某个数据是某个类别的概率。
|
||||
答: 似然函数就一种条件概率，某个数据是某个类别的概率。
|
||||
|
||||
5. 为什么 LR 模型要使用 sigmoid 函数，背后的数学原理是什么？
|
||||
答：https://www.zhihu.com/question/35322351
|
||||
答: https://www.zhihu.com/question/35322351
|
||||
|
||||
|
||||
## 6、Support Vector Machine（支持向量机 SVM）（片刻）
|
||||
|
||||
1. HY Serendipity 2017-11-27 20:36:47
|
||||
问：这几个边界点是怎么选的？
|
||||
问: 这几个边界点是怎么选的？
|
||||
|
||||
答：
|
||||
答:
|
||||
|
||||
2. ls 2017-11-27 20:43:18
|
||||
问：函数间距怎么个意思啊？
|
||||
问: 函数间距怎么个意思啊？
|
||||
|
||||
答：函数距离是人为定义的，可以通过缩放w和b任意改变，所以不能用函数间距代表这个点到超平面的距离，用几何距离是一定的。
|
||||
答: 函数距离是人为定义的，可以通过缩放w和b任意改变，所以不能用函数间距代表这个点到超平面的距离，用几何距离是一定的。
|
||||
|
||||
3. 怎么找最大间隔？
|
||||
答：
|
||||
答:
|
||||
|
||||
4. 分子等于 1，怎么解释？
|
||||
答：
|
||||
答:
|
||||
|
||||
5. 我在网站上看到的公式是乱码？ A:github 没加载js，不会显示 LaTex?
|
||||
答：
|
||||
答:
|
||||
|
||||
6. 若果 w 之前没做平方的话，那这里求偏导不就没了？
|
||||
答：不做平方的话，就不是凸二次规划问题，就不能用拉格朗日替换了。
|
||||
答: 不做平方的话，就不是凸二次规划问题，就不能用拉格朗日替换了。
|
||||
|
||||
7. alpha是指什么？
|
||||
答：拉格朗日乘子
|
||||
答: 拉格朗日乘子
|
||||
|
||||
8. 这里的C是干嘛的，怎么选择的？
|
||||
答：
|
||||
答:
|
||||
|
||||
9. 不同的核函数，怎么使用？我的意思是什么情况下用什么核函数？
|
||||
答：
|
||||
答:
|
||||
|
||||
## 7、集成方法（ensemble method）（片刻）
|
||||
|
||||
1. HY Serendipity 2017-11-28 20:46:03
|
||||
问：这里的分裂特征是什么？
|
||||
问: 这里的分裂特征是什么？
|
||||
|
||||
答：
|
||||
答:
|
||||
|
||||
2. 风风 2017-11-28 20:55:44
|
||||
问：我有个问题，如果都是随机化，那是不是每次运行算法都会不一样？
|
||||
问: 我有个问题，如果都是随机化，那是不是每次运行算法都会不一样？
|
||||
|
||||
答：
|
||||
答:
|
||||
|
||||
3. 有放回 和无放回区别是什么哦？标准是：是否可以重复取样？
|
||||
答：
|
||||
3. 有放回 和无放回区别是什么哦？标准是: 是否可以重复取样？
|
||||
答:
|
||||
|
||||
4. 怎么使用这些已有代码呢？用于理解这些算法理论？
|
||||
答：
|
||||
答:
|
||||
|
||||
## 8、预测数值型数据：回归（regression）（小瑶）
|
||||
## 8、预测数值型数据: 回归（regression）（小瑶）
|
||||
|
||||
1. HY Serendipity 2017-11-29 20:42:04
|
||||
问：最后的表达特征与结果的非线性是什么意思？
|
||||
问: 最后的表达特征与结果的非线性是什么意思？
|
||||
|
||||
答：就是说，我们得到数据特征之后，这些特征可能与最终的结果没有关系（或者说有关系，但是是非线性关系），但是我们通过加一些权重，就可以使得特征与我们最终的结果之间有一个线性关系了，这就是我们说的，使用线性数据（特征）来表达非线性关系的意思了。
|
||||
答: 就是说，我们得到数据特征之后，这些特征可能与最终的结果没有关系（或者说有关系，但是是非线性关系），但是我们通过加一些权重，就可以使得特征与我们最终的结果之间有一个线性关系了，这就是我们说的，使用线性数据（特征）来表达非线性关系的意思了。
|
||||
|
||||
2. 介绍一下k折交叉验证。
|
||||
|
||||
答：K折交叉验证，初始采样分割成K个子样本，一个单独的子样本被保留作为验证模型的数据，其他K-1个样本用来训练。交叉验证重复K次，每个子样本验证一次，平均K次的结果或者使用其它结合方式，最终得到一个单一估测。这个方法的优势在于，同时重复运用随机产生的子样本进行训练和验证，每次的结果验证一次，10折交叉验证是最常用的。
|
||||
答: K折交叉验证，初始采样分割成K个子样本，一个单独的子样本被保留作为验证模型的数据，其他K-1个样本用来训练。交叉验证重复K次，每个子样本验证一次，平均K次的结果或者使用其它结合方式，最终得到一个单一估测。这个方法的优势在于，同时重复运用随机产生的子样本进行训练和验证，每次的结果验证一次，10折交叉验证是最常用的。
|
||||
|
||||
3. Cold 2017-11-29 21:43:42
|
||||
问：这个回归 应用场景 主要是预测么？
|
||||
问: 这个回归 应用场景 主要是预测么？
|
||||
|
||||
答：是的，主要是做预测，根据我们现在已有的一些数据，对接下来我们想要知道（而还未知道）的一些数值型数据做预测的。
|
||||
答: 是的，主要是做预测，根据我们现在已有的一些数据，对接下来我们想要知道（而还未知道）的一些数值型数据做预测的。
|
||||
|
||||
|
||||
## 9、树回归（小瑶）
|
||||
|
||||
1. 片刻 2017-11-30 21:07:31
|
||||
问：决策树和模型树的区别在哪里？还没听明白
|
||||
问: 决策树和模型树的区别在哪里？还没听明白
|
||||
|
||||
答：其实这个问题不能这么说吧。模型树本质上就是决策树的一种。大佬你想问的应该是分类树，回归树，模型树之间的一个区别在哪儿。
|
||||
- 分类树：在找划分数据集的最佳特征的时候，判断标准是等于不等于（是不是），而不是比较数值之间的大小，并且划分数据集（切分子数据集）的依据是信息增益（划分数据集之前的信息熵减去划分数据集之后的信息熵），测试数据根据我们构建完成的树结构走到最终的叶节点的时候，得到的是我们对测试数据的一个预测分类。
|
||||
- 回归树：在划分数据集的最佳特征的时候，判断标准是数值之间的大小比较，比如小于等于 value 值的进入左子树，而大于的进入右子树，并且，测试数据根据我们构建完成的树结构走到最终的叶节点的时候，得到的是我们对测试数据的一个预测值（预测值我们使用同一叶节点的均值）。
|
||||
- 模型树：对数据进行分段预测，只不过存储的子树中，是存储的线性回归模型的回归系数，这样从每个子树中我们就能够得到一个线性回归模型。通俗来说，就是决策树和线性回归的一个结合。
|
||||
答: 其实这个问题不能这么说吧。模型树本质上就是决策树的一种。大佬你想问的应该是分类树，回归树，模型树之间的一个区别在哪儿。
|
||||
- 分类树: 在找划分数据集的最佳特征的时候，判断标准是等于不等于（是不是），而不是比较数值之间的大小，并且划分数据集（切分子数据集）的依据是信息增益（划分数据集之前的信息熵减去划分数据集之后的信息熵），测试数据根据我们构建完成的树结构走到最终的叶节点的时候，得到的是我们对测试数据的一个预测分类。
|
||||
- 回归树: 在划分数据集的最佳特征的时候，判断标准是数值之间的大小比较，比如小于等于 value 值的进入左子树，而大于的进入右子树，并且，测试数据根据我们构建完成的树结构走到最终的叶节点的时候，得到的是我们对测试数据的一个预测值（预测值我们使用同一叶节点的均值）。
|
||||
- 模型树: 对数据进行分段预测，只不过存储的子树中，是存储的线性回归模型的回归系数，这样从每个子树中我们就能够得到一个线性回归模型。通俗来说，就是决策树和线性回归的一个结合。
|
||||
|
||||
2. HY Serendipity 2017-11-30 21:22:42
|
||||
问：后剪枝是将两个叶子变成一个叶子？
|
||||
问: 后剪枝是将两个叶子变成一个叶子？
|
||||
|
||||
答：后剪枝是从根节点遍历，一直找到最后的叶节点，然后计算，合并之后的两个叶子节点得到的误差值，与合并之前的两个叶子节点的误差值，做一个差值，看看是否小于我们设定的一个阈值，小于的话，我们就认为可以合并，然后，将两个叶子节点合并成一个叶子节点，并且使用两个叶子节点的所有数据的均值来代表这个叶子节点。
|
||||
答: 后剪枝是从根节点遍历，一直找到最后的叶节点，然后计算，合并之后的两个叶子节点得到的误差值，与合并之前的两个叶子节点的误差值，做一个差值，看看是否小于我们设定的一个阈值，小于的话，我们就认为可以合并，然后，将两个叶子节点合并成一个叶子节点，并且使用两个叶子节点的所有数据的均值来代表这个叶子节点。
|
||||
|
||||
3. 诺 2017-11-30 21:24:11
|
||||
问：后剪枝需要遍历每个节点吗？
|
||||
问: 后剪枝需要遍历每个节点吗？
|
||||
|
||||
答：是的，需要遍历每个节点，从根节点起，一步一步遍历到不是树的节点，也就是最后的叶子节点。然后考虑合并还是不合并。
|
||||
答: 是的，需要遍历每个节点，从根节点起，一步一步遍历到不是树的节点，也就是最后的叶子节点。然后考虑合并还是不合并。
|
||||
|
||||
## 10、K-Means（K-均值）聚类算法（那伊抹微笑）
|
||||
|
||||
1. 小瑶 2017-12-01 20:46:29
|
||||
问：kMeans 会不会陷入局部最优？
|
||||
问: kMeans 会不会陷入局部最优？
|
||||
|
||||
答：会陷入局部最优，咱们这里介绍了一个方法来解决这个问题，二分 kmeans 。
|
||||
答: 会陷入局部最优，咱们这里介绍了一个方法来解决这个问题，二分 kmeans 。
|
||||
|
||||
## 11、Apriori 算法关联分析（那伊抹微笑）
|
||||
|
||||
|
|
@ -321,46 +321,46 @@ def calcShannonEnt(dataSet):
|
|||
## 12、FP-growth算法发现频繁项集（如果迎着风就飞）
|
||||
|
||||
1. HY Serendipity 2017-12-05 20:41:38
|
||||
问：感觉这里的支持度有点问题啊，应该是出现次数比较妥当？
|
||||
问: 感觉这里的支持度有点问题啊，应该是出现次数比较妥当？
|
||||
|
||||
答：是的，这里我们省略分母，因为我们算支持度=出现次数/总的数目。 分母其实都是一样，所以我们省略了。
|
||||
答: 是的，这里我们省略分母，因为我们算支持度=出现次数/总的数目。 分母其实都是一样，所以我们省略了。
|
||||
|
||||
2. HY Serendipity 2017-12-05 21:09:45
|
||||
问：就是想问一下怎么一步步递归得到最后的t的所有频繁项集？
|
||||
问: 就是想问一下怎么一步步递归得到最后的t的所有频繁项集？
|
||||
|
||||
答：就是递归的去构造FP树，然后从FP树中挖掘频繁项集，当FP树节点为空，当前根递归才算结束。
|
||||
答: 就是递归的去构造FP树，然后从FP树中挖掘频繁项集，当FP树节点为空，当前根递归才算结束。
|
||||
|
||||
## 13、PCA 简化数据（片刻）
|
||||
|
||||
1. 、 2017-12-06 20:44:01
|
||||
问：为什么主成分的方向，就是数据方差最大的方向？
|
||||
问: 为什么主成分的方向，就是数据方差最大的方向？
|
||||
|
||||
答：
|
||||
答:
|
||||
|
||||
2. mushroom 2017-12-06 20:58:54
|
||||
问：降维之后会损失有效数据，怎么理解？
|
||||
问: 降维之后会损失有效数据，怎么理解？
|
||||
|
||||
答：
|
||||
答:
|
||||
|
||||
3. cpp 2017-12-06 20:59:35
|
||||
问：为什么会正交？
|
||||
问: 为什么会正交？
|
||||
|
||||
答：正交的一个原因是特征值的特征向量是正交的。（还需要详细说一下）
|
||||
答: 正交的一个原因是特征值的特征向量是正交的。（还需要详细说一下）
|
||||
|
||||
## 14、SVD 简化数据（片刻）
|
||||
|
||||
1. 风风 2017-12-07 21:19:22
|
||||
问：为什么分解后还要还原？或者说，压缩的目的是什么？
|
||||
问: 为什么分解后还要还原？或者说，压缩的目的是什么？
|
||||
|
||||
答：
|
||||
答:
|
||||
|
||||
|
||||
## 15、大数据与 MapReduce（片刻）
|
||||
|
||||
1. HY Serendipity 2017-12-08 20:45:21
|
||||
问：mrjob 和 hadoop 区别是什么？
|
||||
问: mrjob 和 hadoop 区别是什么？
|
||||
|
||||
答：hadoop = HDFS + YARN + MapReduce
|
||||
答: hadoop = HDFS + YARN + MapReduce
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
After Width: | Height: | Size: 236 KiB |
|
|
@ -0,0 +1,47 @@
|
|||
#!/bin/bash
|
||||
loginfo() { echo "[INFO] $@"; }
|
||||
logerror() { echo "[ERROR] $@" 1>&2; }
|
||||
|
||||
python3 src/script.py "home" "book"
|
||||
rm -rf node_modules/gitbook-plugin-tbfed-pagefooter
|
||||
gitbook install
|
||||
python3 src/script.py "home" "powered"
|
||||
python3 src/script.py "home" "gitalk"
|
||||
gitbook build ./ _book
|
||||
|
||||
|
||||
# versions="0.2 0.3 0.4 1.0 1.2 1.4 LatestChanges"
|
||||
# for version in $versions;do
|
||||
# loginfo "==========================================================="
|
||||
# loginfo "开始", ${version}, "版本编译"
|
||||
|
||||
# echo "cp book.json docs/${version}"
|
||||
# cp book.json docs/${version}
|
||||
|
||||
# # 替换 book.json 的编辑地址
|
||||
# echo "python3 src/script.py ${version} book"
|
||||
# python3 src/script.py ${version} "book"
|
||||
|
||||
# echo "cp -r node_modules docs/${version}"
|
||||
# rm -rf docs/${version}/node_modules
|
||||
# cp -r node_modules docs/${version}
|
||||
|
||||
# echo "gitbook install docs/${version}"
|
||||
# gitbook install docs/${version}
|
||||
|
||||
# echo "python3 src/script.py ${version} powered"
|
||||
# python3 src/script.py ${version} "powered"
|
||||
|
||||
# echo "python3 src/script.py ${version} gitalk"
|
||||
# python3 src/script.py ${version} "gitalk"
|
||||
|
||||
# echo "gitbook build docs/${version} _book/docs/${version}"
|
||||
# gitbook build docs/${version} _book/docs/${version}
|
||||
|
||||
# # 注释多余的内容
|
||||
# # echo "python3 src/script.py ${version} index"
|
||||
# # python3 src/script.py ${version} "index"
|
||||
# done
|
||||
|
||||
# # rm -rf /opt/apache-tomcat-9.0.17/webapps/test_book
|
||||
# # cp -r _book /opt/apache-tomcat-9.0.17/webapps/test_book
|
||||
|
|
@ -131,7 +131,7 @@ class Node(object):
|
|||
Returns:
|
||||
None
|
||||
'''
|
||||
# 打印格式：第几层 - 第几个节点，output 是多少，delta 是多少
|
||||
# 打印格式: 第几层 - 第几个节点，output 是多少，delta 是多少
|
||||
node_str = '%u-%u: output: %f delta: %f' % (self.layer_index, self.node_index, self.output, self.delta)
|
||||
# 下游节点
|
||||
downstream_str = reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
|
||||
|
|
@ -348,7 +348,7 @@ class Connection(object):
|
|||
Returns:
|
||||
连接信息进行返回
|
||||
'''
|
||||
# 格式为：上游节点的层的索引+上游节点的节点索引 ---> 下游节点的层的索引+下游节点的节点索引，最后一个数是权重
|
||||
# 格式为: 上游节点的层的索引+上游节点的节点索引 ---> 下游节点的层的索引+下游节点的节点索引，最后一个数是权重
|
||||
return '(%u-%u) -> (%u-%u) = %f' % (
|
||||
self.upstream_node.layer_index,
|
||||
self.upstream_node.node_index,
|
||||
|
|
@ -491,7 +491,7 @@ class Network(object):
|
|||
for i in range(len(label)):
|
||||
# 计算输出层节点的 delta
|
||||
output_nodes[i].calc_output_layer_delta(label[i])
|
||||
# 这个用法就是切片的用法， [-2::-1] 就是将 layers 这个数组倒过来，从没倒过来的时候的倒数第二个元素开始，到翻转过来的倒数第一个数，比如这样：aaa = [1,2,3,4,5,6,7,8,9],bbb = aaa[-2::-1] ==> bbb = [8, 7, 6, 5, 4, 3, 2, 1]
|
||||
# 这个用法就是切片的用法， [-2::-1] 就是将 layers 这个数组倒过来，从没倒过来的时候的倒数第二个元素开始，到翻转过来的倒数第一个数，比如这样: aaa = [1,2,3,4,5,6,7,8,9],bbb = aaa[-2::-1] ==> bbb = [8, 7, 6, 5, 4, 3, 2, 1]
|
||||
# 实际上就是除掉输出层之外的所有层按照相反的顺序进行遍历
|
||||
for layer in self.layers[-2::-1]:
|
||||
# 遍历每层的所有节点
|
||||
|
|
@ -587,7 +587,7 @@ class Network(object):
|
|||
|
||||
# # ------------------------- 至此，基本上我们把 我们的神经网络实现完成，下面还会介绍一下对应的梯度检查相关的算法，现在我们首先回顾一下我们上面写道的类及他们的作用 ------------------------
|
||||
'''
|
||||
1、节点类的实现 Node ：负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算。如下：
|
||||
1、节点类的实现 Node : 负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算。如下:
|
||||
layer_index --- 节点所属的层的编号
|
||||
node_index --- 节点的编号
|
||||
downstream --- 下游节点
|
||||
|
|
@ -595,7 +595,7 @@ upstream ---- 上游节点
|
|||
output ---- 节点的输出值
|
||||
delta ------ 节点的误差项
|
||||
|
||||
2、ConstNode 类，偏置项类的实现：实现一个输出恒为 1 的节点（计算偏置项的时候会用到），如下：
|
||||
2、ConstNode 类，偏置项类的实现: 实现一个输出恒为 1 的节点（计算偏置项的时候会用到），如下:
|
||||
layer_index --- 节点所属层的编号
|
||||
node_index ---- 节点的编号
|
||||
downstream ---- 下游节点
|
||||
|
|
@ -608,7 +608,7 @@ node_count ----- 层所包含的节点的个数
|
|||
def set_ouput() -- 设置层的输出，当层是输入层时会用到
|
||||
def calc_output -- 计算层的输出向量，调用的 Node 类的 计算输出 方法
|
||||
|
||||
4、Connection 类：负责记录连接的权重，以及这个连接所关联的上下游节点，如下：
|
||||
4、Connection 类: 负责记录连接的权重，以及这个连接所关联的上下游节点，如下:
|
||||
upstream_node --- 连接的上游节点
|
||||
downstream_node -- 连接的下游节点
|
||||
weight -------- random.uniform(-0.1, 0.1) 初始化为一个很小的随机数
|
||||
|
|
@ -617,10 +617,10 @@ def calc_gradient() --- 计算梯度，使用的是下游节点的 delta 与上
|
|||
def get_gradient() ---- 获取当前的梯度
|
||||
def update_weight() --- 根据梯度下降算法更新权重
|
||||
|
||||
5、Connections 类：提供对 Connection 集合操作，如下：
|
||||
5、Connections 类: 提供对 Connection 集合操作，如下:
|
||||
def add_connection() --- 添加一个 connection
|
||||
|
||||
6、Network 类：提供相应的 API，如下：
|
||||
6、Network 类: 提供相应的 API，如下:
|
||||
connections --- Connections 对象
|
||||
layers -------- 神经网络的层
|
||||
layer_count --- 神经网络的层数
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ class Filter(object):
|
|||
'''
|
||||
Desc:
|
||||
Filter类保存了卷积层的参数以及梯度，并且实现了用梯度下降算法来更新参数。
|
||||
我们对参数的初始化采用了常用的策略，即：权重随机初始化为一个很小的值，而偏置项初始化为0。
|
||||
我们对参数的初始化采用了常用的策略，即: 权重随机初始化为一个很小的值，而偏置项初始化为0。
|
||||
'''
|
||||
def __init__(self, width, height, depth):
|
||||
self.weights = np.random.uniform(-1e-4, 1e-4,
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ def plot(linear_unit):
|
|||
'''
|
||||
# 引入绘图的库
|
||||
import matplotlib.pyplot as plt
|
||||
# 获取训练数据：特征 input_vecs 与 对应的标签 labels
|
||||
# 获取训练数据: 特征 input_vecs 与 对应的标签 labels
|
||||
input_vecs, labels = get_training_dataset()
|
||||
# figure() 创建一个 Figure 对象，与用户交互的整个窗口，这个 figure 中容纳着 subplots
|
||||
fig = plt.figure()
|
||||
|
|
|
|||
|
|
@ -58,14 +58,14 @@ class Perceptron():
|
|||
# reduce() 函数是 python 2 的内置函数，从 python 3 开始移到了 functools 模块
|
||||
# reduce() 从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值，例如 reduce(lambda x,y: x+y, [1,2,3,4,5]) 计算的就是 ((((1+2)+3)+4)+5)
|
||||
# map() 接收一个函数 f 和一个 list ，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 返回。比如我们的 f 函数是计算平方， map(f, [1,2,3,4,5]) ===> 返回 [1,4,9,16,25]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例：x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例: x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
return self.activator(reduce(lambda a, b: a + b,map(lambda (x, w): x * w, zip(input_vec, self.weights)), 0.0) + self.bias)
|
||||
|
||||
|
||||
def train(self, input_vecs, labels, iteration, rate):
|
||||
'''
|
||||
Desc:
|
||||
输入训练数据：一组向量、与每个向量对应的 label; 以及训练轮数、学习率
|
||||
输入训练数据: 一组向量、与每个向量对应的 label; 以及训练轮数、学习率
|
||||
Args:
|
||||
input_vec —— 输入向量
|
||||
labels —— 数据对应的标签
|
||||
|
|
@ -89,7 +89,7 @@ class Perceptron():
|
|||
Returns:
|
||||
None
|
||||
'''
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例：x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例: x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
samples = zip(input_vecs, labels)
|
||||
# 对每个样本，按照感知器规则更新权重
|
||||
for (input_vec, label) in samples:
|
||||
|
|
@ -113,7 +113,7 @@ class Perceptron():
|
|||
# 利用感知器规则更新权重
|
||||
delta = label - output
|
||||
# map() 接收一个函数 f 和一个 list ，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 返回。比如我们的 f 函数是计算平方， map(f, [1,2,3,4,5]) ===> 返回 [1,4,9,16,25]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例：x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例: x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
self.weights = map(lambda (x, w): w + rate * delta * x, zip(input_vec, self.weights))
|
||||
# 更新 bias
|
||||
self.bias += rate * delta
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ from numpy import random, mat, eye
|
|||
NumPy存在2中不同的数据类型:
|
||||
1. 矩阵 matrix
|
||||
2. 数组 array
|
||||
相似点：
|
||||
相似点:
|
||||
都可以处理行列表示的数字元素
|
||||
不同点：
|
||||
不同点:
|
||||
1. 2个数据类型上执行相同的数据运算可能得到不同的结果。
|
||||
2. NumPy函数库中的 matrix 与 MATLAB中 matrices 等价。
|
||||
'''
|
||||
|
|
@ -30,14 +30,14 @@ randArray = random.rand(4, 4)
|
|||
randMat = mat(randArray)
|
||||
'''
|
||||
.I 表示对矩阵求逆(可以利用矩阵的初等变换)
|
||||
意义：逆矩阵是一个判断相似性的工具。逆矩阵A与列向量p相乘后，将得到列向量q，q的第i个分量表示p与A的第i个列向量的相似度。
|
||||
参考案例链接：
|
||||
意义: 逆矩阵是一个判断相似性的工具。逆矩阵A与列向量p相乘后，将得到列向量q，q的第i个分量表示p与A的第i个列向量的相似度。
|
||||
参考案例链接:
|
||||
https://www.zhihu.com/question/33258489
|
||||
http://blog.csdn.net/vernice/article/details/48506027
|
||||
.T 表示对矩阵转置(行列颠倒)
|
||||
* 等同于: .transpose()
|
||||
.A 返回矩阵基于的数组
|
||||
参考案例链接：
|
||||
参考案例链接:
|
||||
http://blog.csdn.net/qq403977698/article/details/47254539
|
||||
'''
|
||||
invRandMat = randMat.I
|
||||
|
|
|
|||
|
|
@ -153,7 +153,7 @@ def apriori(dataSet, minSupport=0.5):
|
|||
|
||||
# 计算可信度（confidence）
|
||||
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
|
||||
"""calcConf（对两个元素的频繁项，计算可信度，例如： {1,2}/{1} 或者 {1,2}/{2} 看是否满足条件）
|
||||
"""calcConf（对两个元素的频繁项，计算可信度，例如: {1,2}/{1} 或者 {1,2}/{2} 看是否满足条件）
|
||||
|
||||
Args:
|
||||
freqSet 频繁项集中的元素，例如: frozenset([1, 3])
|
||||
|
|
@ -226,7 +226,7 @@ def generateRules(L, supportData, minConf=0.7):
|
|||
for i in range(1, len(L)):
|
||||
# 获取频繁项集中每个组合的所有元素
|
||||
for freqSet in L[i]:
|
||||
# 假设：freqSet= frozenset([1, 3]), H1=[frozenset([1]), frozenset([3])]
|
||||
# 假设: freqSet= frozenset([1, 3]), H1=[frozenset([1]), frozenset([3])]
|
||||
# 组合总的元素并遍历子元素，并转化为 frozenset 集合，再存放到 list 列表中
|
||||
H1 = [frozenset([item]) for item in freqSet]
|
||||
# 2 个的组合，走 else, 2 个以上的组合，走 if
|
||||
|
|
|
|||
|
|
@ -62,16 +62,16 @@ def createInitSet(dataSet):
|
|||
|
||||
# this version does not use recursion
|
||||
def updateHeader(nodeToTest, targetNode):
|
||||
"""updateHeader(更新头指针，建立相同元素之间的关系，例如： 左边的r指向右边的r值，就是后出现的相同元素 指向 已经出现的元素)
|
||||
"""updateHeader(更新头指针，建立相同元素之间的关系，例如: 左边的r指向右边的r值，就是后出现的相同元素 指向 已经出现的元素)
|
||||
|
||||
从头指针的nodeLink开始，一直沿着nodeLink直到到达链表末尾。这就是链表。
|
||||
性能：如果链表很长可能会遇到迭代调用的次数限制。
|
||||
性能: 如果链表很长可能会遇到迭代调用的次数限制。
|
||||
|
||||
Args:
|
||||
nodeToTest 满足minSup {所有的元素+(value, treeNode)}
|
||||
targetNode Tree对象的子节点
|
||||
"""
|
||||
# 建立相同元素之间的关系，例如： 左边的r指向右边的r值
|
||||
# 建立相同元素之间的关系，例如: 左边的r指向右边的r值
|
||||
while (nodeToTest.nodeLink is not None):
|
||||
nodeToTest = nodeToTest.nodeLink
|
||||
nodeToTest.nodeLink = targetNode
|
||||
|
|
@ -114,20 +114,20 @@ def createTree(dataSet, minSup=1):
|
|||
"""createTree(生成FP-tree)
|
||||
|
||||
Args:
|
||||
dataSet dist{行：出现次数}的样本数据
|
||||
dataSet dist{行: 出现次数}的样本数据
|
||||
minSup 最小的支持度
|
||||
Returns:
|
||||
retTree FP-tree
|
||||
headerTable 满足minSup {所有的元素+(value, treeNode)}
|
||||
"""
|
||||
# 支持度>=minSup的dist{所有元素：出现的次数}
|
||||
# 支持度>=minSup的dist{所有元素: 出现的次数}
|
||||
headerTable = {}
|
||||
# 循环 dist{行：出现次数}的样本数据
|
||||
# 循环 dist{行: 出现次数}的样本数据
|
||||
for trans in dataSet:
|
||||
# 对所有的行进行循环，得到行里面的所有元素
|
||||
# 统计每一行中，每个元素出现的总次数
|
||||
for item in trans:
|
||||
# 例如： {'ababa': 3} count(a)=3+3+3=9 count(b)=3+3=6
|
||||
# 例如: {'ababa': 3} count(a)=3+3+3=9 count(b)=3+3=6
|
||||
headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
|
||||
# 删除 headerTable中，元素次数<最小支持度的元素
|
||||
for k in headerTable.keys():
|
||||
|
|
@ -140,12 +140,12 @@ def createTree(dataSet, minSup=1):
|
|||
if len(freqItemSet) == 0:
|
||||
return None, None
|
||||
for k in headerTable:
|
||||
# 格式化： dist{元素key: [元素次数, None]}
|
||||
# 格式化: dist{元素key: [元素次数, None]}
|
||||
headerTable[k] = [headerTable[k], None]
|
||||
|
||||
# create tree
|
||||
retTree = treeNode('Null Set', 1, None)
|
||||
# 循环 dist{行：出现次数}的样本数据
|
||||
# 循环 dist{行: 出现次数}的样本数据
|
||||
for tranSet, count in dataSet.items():
|
||||
# print 'tranSet, count=', tranSet, count
|
||||
# localD = dist{元素key: 元素总出现次数}
|
||||
|
|
@ -304,13 +304,13 @@ if __name__ == "__main__":
|
|||
# load样本数据
|
||||
simpDat = loadSimpDat()
|
||||
# print simpDat, '\n'
|
||||
# frozen set 格式化 并 重新装载 样本数据，对所有的行进行统计求和，格式: {行：出现次数}
|
||||
# frozen set 格式化 并 重新装载 样本数据，对所有的行进行统计求和，格式: {行: 出现次数}
|
||||
initSet = createInitSet(simpDat)
|
||||
print(initSet)
|
||||
|
||||
# 创建FP树
|
||||
# 输入：dist{行：出现次数}的样本数据 和 最小的支持度
|
||||
# 输出：最终的PF-tree，通过循环获取第一层的节点，然后每一层的节点进行递归的获取每一行的字节点，也就是分支。然后所谓的指针，就是后来的指向已存在的
|
||||
# 输入: dist{行: 出现次数}的样本数据 和 最小的支持度
|
||||
# 输出: 最终的PF-tree，通过循环获取第一层的节点，然后每一层的节点进行递归的获取每一行的字节点，也就是分支。然后所谓的指针，就是后来的指向已存在的
|
||||
myFPtree, myHeaderTab = createTree(initSet, 3)
|
||||
myFPtree.disp()
|
||||
|
||||
|
|
@ -334,7 +334,7 @@ if __name__ == "__main__":
|
|||
# for t in listOfTerms:
|
||||
# print t
|
||||
|
||||
# # 2.新闻网站点击流中挖掘，例如：文章1阅读过的人，还阅读过什么？
|
||||
# # 2.新闻网站点击流中挖掘，例如: 文章1阅读过的人，还阅读过什么？
|
||||
# parsedDat = [line.split() for line in open('data/12.FPGrowth/kosarak.dat').readlines()]
|
||||
# initSet = createInitSet(parsedDat)
|
||||
# myFPtree, myHeaderTab = createTree(initSet, 100000)
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
Created on Jun 1, 2011
|
||||
Update on 2017-05-18
|
||||
Author: Peter Harrington/片刻
|
||||
GitHub：https://github.com/apachecn/AiLearning
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
'''
|
||||
from __future__ import print_function
|
||||
from numpy import *
|
||||
|
|
@ -41,9 +41,9 @@ def pca(dataMat, topNfeat=9999999):
|
|||
|
||||
# cov协方差=[(x1-x均值)*(y1-y均值)+(x2-x均值)*(y2-y均值)+...+(xn-x均值)*(yn-y均值)+]/(n-1)
|
||||
'''
|
||||
方差：（一维）度量两个随机变量关系的统计量
|
||||
协方差： （二维）度量各个维度偏离其均值的程度
|
||||
协方差矩阵：（多维）度量各个维度偏离其均值的程度
|
||||
方差: （一维）度量两个随机变量关系的统计量
|
||||
协方差: （二维）度量各个维度偏离其均值的程度
|
||||
协方差矩阵: （多维）度量各个维度偏离其均值的程度
|
||||
|
||||
当 cov(X, Y)>0时，表明X与Y正相关；(X越大，Y也越大；X越小Y，也越小。这种情况，我们称为“正相关”。)
|
||||
当 cov(X, Y)<0时，表明X与Y负相关；
|
||||
|
|
@ -130,7 +130,7 @@ def analyse_data(dataMat):
|
|||
|
||||
最后，我们可能会注意到有一些小的负值，他们主要源自数值误差应该四舍五入成0.
|
||||
'''
|
||||
print('主成分：%s, 方差占比：%s%%, 累积方差占比：%s%%' % (format(i+1, '2.0f'), format(line_cov_score/cov_all_score*100, '4.2f'), format(sum_cov_score/cov_all_score*100, '4.1f')))
|
||||
print('主成分: %s, 方差占比: %s%%, 累积方差占比: %s%%' % (format(i+1, '2.0f'), format(line_cov_score/cov_all_score*100, '4.2f'), format(sum_cov_score/cov_all_score*100, '4.1f')))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
|||
|
|
@ -240,7 +240,7 @@ def analyse_data(Sigma, loopNum=20):
|
|||
|
||||
通常保留矩阵 80% ～ 90% 的能量，就可以得到重要的特征并取出噪声。
|
||||
'''
|
||||
print('主成分：%s, 方差占比：%s%%' % (format(i+1, '2.0f'), format(SigmaI/SigmaSum*100, '4.2f')))
|
||||
print('主成分: %s, 方差占比: %s%%' % (format(i+1, '2.0f'), format(SigmaI/SigmaSum*100, '4.2f')))
|
||||
|
||||
|
||||
# 图像压缩函数
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ class MRmean(MRJob):
|
|||
"""
|
||||
step方法定义执行的步骤。
|
||||
执行顺序不必完全遵循map-reduce模式。
|
||||
例如：
|
||||
例如:
|
||||
1. map-reduce-reduce-reduce
|
||||
2. map-reduce-map-reduce-map-reduce
|
||||
在step方法里，需要为mrjob指定mapper和reducer的名称。如果没有，它将默认调用mapper和reducer方法。
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ from numpy import mat, mean, power
|
|||
这个mapper文件按行读取所有的输入并创建一组对应的浮点数，然后得到数组的长度并创建NumPy矩阵。
|
||||
再对所有的值进行平方，最后将均值和平方后的均值发送出去。这些值将用来计算全局的均值和方差。
|
||||
|
||||
Args：
|
||||
Args:
|
||||
file 输入数据
|
||||
Return：
|
||||
Return:
|
||||
'''
|
||||
|
||||
|
||||
|
|
@ -36,6 +36,6 @@ sqInput = power(input, 2) # 将矩阵的数据分别求 平方，
|
|||
# 输出 数据的个数，n个数据的均值，n个数据平方之后的均值
|
||||
# 第一行是标准输出，也就是reducer的输出
|
||||
# 第二行识标准错误输出，即对主节点作出的响应报告，表明本节点工作正常。
|
||||
# 【这不就是面试的装逼重点吗？如何设计监听架构细节】注意：一个好的习惯是想标准错误输出发送报告。如果某任务10分钟内没有报告输出，则将被Hadoop中止。
|
||||
# 【这不就是面试的装逼重点吗？如何设计监听架构细节】注意: 一个好的习惯是想标准错误输出发送报告。如果某任务10分钟内没有报告输出，则将被Hadoop中止。
|
||||
print("%d\t%f\t%f" % (numInputs, mean(input), mean(sqInput))) # 计算均值
|
||||
print("map report: still alive", file=sys.stderr)
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ import sys
|
|||
'''
|
||||
mapper 接受原始的输入并产生中间值传递给 reducer。
|
||||
很多的mapper是并行执行的，所以需要将这些mapper的输出合并成一个值。
|
||||
即：将中间的 key/value 对进行组合。
|
||||
即: 将中间的 key/value 对进行组合。
|
||||
'''
|
||||
|
||||
|
||||
|
|
@ -43,5 +43,5 @@ for instance in mapperOut:
|
|||
mean_ = cumVal/cumN
|
||||
varSum = (cumSumSq - 2*mean_*cumVal + cumN*mean_*mean_)/cumN
|
||||
# 输出 数据总量，均值，平方的均值（方差）
|
||||
print ("数据总量：%d\t均值：%f\t方差：%f" % (cumN, mean_, varSum))
|
||||
print ("数据总量: %d\t均值: %f\t方差: %f" % (cumN, mean_, varSum))
|
||||
print("reduce report: still alive", file=sys.stderr)
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ def classify0(inX, dataSet, labels, k):
|
|||
dataSet: 输入的训练样本集
|
||||
labels: 标签向量
|
||||
k: 选择最近邻居的数目
|
||||
注意：labels元素数目和dataSet行数相同；程序使用欧式距离公式.
|
||||
注意: labels元素数目和dataSet行数相同；程序使用欧式距离公式.
|
||||
|
||||
预测数据所在分类可在输入下列命令
|
||||
kNN.classify0([0,0], group, labels, 3)
|
||||
|
|
@ -62,11 +62,11 @@ def classify0(inX, dataSet, labels, k):
|
|||
"""
|
||||
diffMat = tile(inX, (dataSetSize, 1)) - dataSet
|
||||
"""
|
||||
欧氏距离： 点到点之间的距离
|
||||
第一行： 同一个点 到 dataSet的第一个点的距离。
|
||||
第二行： 同一个点 到 dataSet的第二个点的距离。
|
||||
欧氏距离: 点到点之间的距离
|
||||
第一行: 同一个点 到 dataSet的第一个点的距离。
|
||||
第二行: 同一个点 到 dataSet的第二个点的距离。
|
||||
...
|
||||
第N行： 同一个点 到 dataSet的第N个点的距离。
|
||||
第N行: 同一个点 到 dataSet的第N个点的距离。
|
||||
|
||||
[[1,2,3],[1,2,3]]-[[1,2,3],[1,2,0]]
|
||||
(A1-A2)^2+(B1-B2)^2+(c1-c2)^2
|
||||
|
|
@ -79,7 +79,7 @@ def classify0(inX, dataSet, labels, k):
|
|||
distances = sqDistances ** 0.5
|
||||
# 根据距离排序从小到大的排序，返回对应的索引位置
|
||||
# argsort() 是将x中的元素从小到大排列，提取其对应的index（索引），然后输出到y。
|
||||
# 例如：y=array([3,0,2,1,4,5]) 则，x[3]=-1最小，所以y[0]=3;x[5]=9最大，所以y[5]=5。
|
||||
# 例如: y=array([3,0,2,1,4,5]) 则，x[3]=-1最小，所以y[0]=3;x[5]=9最大，所以y[5]=5。
|
||||
# print 'distances=', distances
|
||||
sortedDistIndicies = distances.argsort()
|
||||
# print 'distances.argsort()=', sortedDistIndicies
|
||||
|
|
@ -91,16 +91,16 @@ def classify0(inX, dataSet, labels, k):
|
|||
voteIlabel = labels[sortedDistIndicies[i]]
|
||||
# 在字典中将该类型加一
|
||||
# 字典的get方法
|
||||
# 如：list.get(k,d) 其中 get相当于一条if...else...语句,参数k在字典中，字典将返回list[k];如果参数k不在字典中则返回参数d,如果K在字典中则返回k对应的value值
|
||||
# 如: list.get(k,d) 其中 get相当于一条if...else...语句,参数k在字典中，字典将返回list[k];如果参数k不在字典中则返回参数d,如果K在字典中则返回k对应的value值
|
||||
# l = {5:2,3:4}
|
||||
# print l.get(3,0)返回的值是4；
|
||||
# Print l.get（1,0）返回值是0；
|
||||
classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1
|
||||
# 3. 排序并返回出现最多的那个类型
|
||||
# 字典的 items() 方法，以列表返回可遍历的(键，值)元组数组。
|
||||
# 例如：dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.items() Value : [('Age', 7), ('Name', 'Zara')]
|
||||
# 例如: dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.items() Value : [('Age', 7), ('Name', 'Zara')]
|
||||
# sorted 中的第2个参数 key=operator.itemgetter(1) 这个参数的意思是先比较第几个元素
|
||||
# 例如：a=[('b',2),('a',1),('c',0)] b=sorted(a,key=operator.itemgetter(1)) >>>b=[('c',0),('a',1),('b',2)] 可以看到排序是按照后边的0,1,2进行排序的，而不是a,b,c
|
||||
# 例如: a=[('b',2),('a',1),('c',0)] b=sorted(a,key=operator.itemgetter(1)) >>>b=[('c',0),('a',1),('b',2)] 可以看到排序是按照后边的0,1,2进行排序的，而不是a,b,c
|
||||
# b=sorted(a,key=operator.itemgetter(0)) >>>b=[('a',1),('b',2),('c',0)] 这次比较的是前边的a,b,c而不是0,1,2
|
||||
# b=sorted(a,key=opertator.itemgetter(1,0)) >>>b=[('c',0),('a',1),('b',2)] 这个是先比较第2个元素，然后对第一个元素进行排序，形成多级排序。
|
||||
# sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
|
||||
|
|
@ -115,11 +115,11 @@ def classify0(inX, dataSet, labels, k):
|
|||
# """
|
||||
# 1. 计算距离
|
||||
|
||||
# 欧氏距离： 点到点之间的距离
|
||||
# 第一行： 同一个点 到 dataSet的第一个点的距离。
|
||||
# 第二行： 同一个点 到 dataSet的第二个点的距离。
|
||||
# 欧氏距离: 点到点之间的距离
|
||||
# 第一行: 同一个点 到 dataSet的第一个点的距离。
|
||||
# 第二行: 同一个点 到 dataSet的第二个点的距离。
|
||||
# ...
|
||||
# 第N行： 同一个点 到 dataSet的第N个点的距离。
|
||||
# 第N行: 同一个点 到 dataSet的第N个点的距离。
|
||||
|
||||
# [[1,2,3],[1,2,3]]-[[1,2,3],[1,2,0]]
|
||||
# (A1-A2)^2+(B1-B2)^2+(c1-c2)^2
|
||||
|
|
@ -169,7 +169,7 @@ def file2matrix(filename):
|
|||
# 获得文件中的数据行的行数
|
||||
numberOfLines = len(fr.readlines())
|
||||
# 生成对应的空矩阵
|
||||
# 例如：zeros(2，3)就是生成一个 2*3的矩阵，各个位置上全是 0
|
||||
# 例如: zeros(2，3)就是生成一个 2*3的矩阵，各个位置上全是 0
|
||||
returnMat = zeros((numberOfLines, 3)) # prepare matrix to return
|
||||
classLabelVector = [] # prepare labels return
|
||||
fr = open(filename)
|
||||
|
|
@ -194,7 +194,7 @@ def autoNorm(dataSet):
|
|||
:param dataSet: 数据集
|
||||
:return: 归一化后的数据集normDataSet,ranges和minVals即最小值与范围，并没有用到
|
||||
|
||||
归一化公式：
|
||||
归一化公式:
|
||||
Y = (X-Xmin)/(Xmax-Xmin)
|
||||
其中的 min 和 max 分别是数据集中的最小特征值和最大特征值。该函数可以自动将数字特征值转化为0到1的区间。
|
||||
"""
|
||||
|
|
@ -249,7 +249,7 @@ def img2vector(filename):
|
|||
将图像数据转换为向量
|
||||
:param filename: 图片文件 因为我们的输入数据的图片格式是 32 * 32的
|
||||
:return: 一维矩阵
|
||||
该函数将图像转换为向量：该函数创建 1 * 1024 的NumPy数组，然后打开给定的文件，
|
||||
该函数将图像转换为向量: 该函数创建 1 * 1024 的NumPy数组，然后打开给定的文件，
|
||||
循环读出文件的前32行，并将每行的头32个字符值存储在NumPy数组中，最后返回数组。
|
||||
"""
|
||||
returnVect = zeros((1, 1024))
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-28
|
||||
Updated on 2017-06-28
|
||||
KNN：k近邻算法
|
||||
KNN: k近邻算法
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/python
|
||||
# coding: utf8
|
||||
# 原始链接： http://blog.csdn.net/lsldd/article/details/41223147
|
||||
# 原始链接: http://blog.csdn.net/lsldd/article/details/41223147
|
||||
# GitHub: https://github.com/apachecn/AiLearning
|
||||
from __future__ import print_function
|
||||
import numpy as np
|
||||
|
|
@ -16,7 +16,7 @@ def createDataSet():
|
|||
labels = []
|
||||
with open("data/3.DecisionTree/data.txt") as ifile:
|
||||
for line in ifile:
|
||||
# 特征： 身高 体重 label： 胖瘦
|
||||
# 特征: 身高 体重 label: 胖瘦
|
||||
tokens = line.strip().split(' ')
|
||||
data.append([float(tk) for tk in tokens[:-1]])
|
||||
labels.append(tokens[-1])
|
||||
|
|
@ -36,7 +36,7 @@ def createDataSet():
|
|||
def predict_train(x_train, y_train):
|
||||
'''
|
||||
使用信息熵作为划分标准，对决策树进行训练
|
||||
参考链接： http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier
|
||||
参考链接: http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier
|
||||
'''
|
||||
clf = tree.DecisionTreeClassifier(criterion='entropy')
|
||||
# print(clf)
|
||||
|
|
@ -56,7 +56,7 @@ def predict_train(x_train, y_train):
|
|||
def show_precision_recall(x, y, clf, y_train, y_pre):
|
||||
'''
|
||||
准确率与召回率
|
||||
参考链接： http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve
|
||||
参考链接: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve
|
||||
'''
|
||||
precision, recall, thresholds = precision_recall_curve(y_train, y_pre)
|
||||
# 计算全量的预估结果
|
||||
|
|
@ -68,7 +68,7 @@ def show_precision_recall(x, y, clf, y_train, y_pre):
|
|||
recall 召回率
|
||||
f1-score 准确率和召回率的一个综合得分
|
||||
support 参与比较的数量
|
||||
参考链接：http://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report
|
||||
参考链接: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report
|
||||
'''
|
||||
# target_names 以 y的label分类为准
|
||||
target_names = ['thin', 'fat']
|
||||
|
|
@ -82,9 +82,9 @@ def show_pdf(clf):
|
|||
可视化输出
|
||||
把决策树结构写入文件: http://sklearn.lzjqsdd.com/modules/tree.html
|
||||
|
||||
Mac报错：pydotplus.graphviz.InvocationException: GraphViz's executables not found
|
||||
解决方案：sudo brew install graphviz
|
||||
参考写入： http://www.jianshu.com/p/59b510bafb4d
|
||||
Mac报错: pydotplus.graphviz.InvocationException: GraphViz's executables not found
|
||||
解决方案: sudo brew install graphviz
|
||||
参考写入: http://www.jianshu.com/p/59b510bafb4d
|
||||
'''
|
||||
# with open("testResult/tree.dot", 'w') as f:
|
||||
# from sklearn.externals.six import StringIO
|
||||
|
|
@ -106,7 +106,7 @@ if __name__ == '__main__':
|
|||
|
||||
''' 拆分训练数据与测试数据， 80%做训练 20%做测试 '''
|
||||
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
|
||||
print('拆分数据：', x_train, x_test, y_train, y_test)
|
||||
print('拆分数据: ', x_train, x_test, y_train, y_test)
|
||||
|
||||
# 得到训练的预测结果集
|
||||
y_pre, clf = predict_train(x_train, y_train)
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ def calcShannonEnt(dataSet):
|
|||
# 求list的长度，表示计算参与训练的数据量
|
||||
numEntries = len(dataSet)
|
||||
# 下面输出我们测试的数据集的一些信息
|
||||
# 例如：<type 'list'> numEntries: 5 是下面的代码的输出
|
||||
# 例如: <type 'list'> numEntries: 5 是下面的代码的输出
|
||||
# print type(dataSet), 'numEntries: ', numEntries
|
||||
|
||||
# 计算分类标签label出现的次数
|
||||
|
|
@ -108,7 +108,7 @@ def splitDataSet(dataSet, index, value):
|
|||
# [:index]表示前index行，即若 index 为2，就是取 featVec 的前 index 行
|
||||
reducedFeatVec = featVec[:index]
|
||||
'''
|
||||
请百度查询一下： extend和append的区别
|
||||
请百度查询一下: extend和append的区别
|
||||
list.append(object) 向列表中添加一个对象object
|
||||
list.extend(sequence) 把一个序列seq的内容添加到列表中
|
||||
1、使用append的时候，是将new_media看作一个对象，整体打包添加到music_media对象中。
|
||||
|
|
@ -120,7 +120,7 @@ def splitDataSet(dataSet, index, value):
|
|||
print result
|
||||
result.extend([7,8,9])
|
||||
print result
|
||||
结果：
|
||||
结果:
|
||||
[1, 2, 3]
|
||||
[1, 2, 3, [4, 5, 6]]
|
||||
[1, 2, 3, [4, 5, 6], 7, 8, 9]
|
||||
|
|
@ -230,12 +230,12 @@ def majorityCnt(classList):
|
|||
def createTree(dataSet, labels):
|
||||
classList = [example[-1] for example in dataSet]
|
||||
# 如果数据集的最后一列的第一个值出现的次数=整个集合的数量，也就说只有一个类别，就只直接返回结果就行
|
||||
# 第一个停止条件：所有的类标签完全相同，则直接返回该类标签。
|
||||
# 第一个停止条件: 所有的类标签完全相同，则直接返回该类标签。
|
||||
# count() 函数是统计括号中的值在list中出现的次数
|
||||
if classList.count(classList[0]) == len(classList):
|
||||
return classList[0]
|
||||
# 如果数据集只有1列，那么最初出现label次数最多的一类，作为结果
|
||||
# 第二个停止条件：使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
|
||||
# 第二个停止条件: 使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
|
||||
if len(dataSet[0]) == 1:
|
||||
return majorityCnt(classList)
|
||||
|
||||
|
|
@ -245,7 +245,7 @@ def createTree(dataSet, labels):
|
|||
bestFeatLabel = labels[bestFeat]
|
||||
# 初始化myTree
|
||||
myTree = {bestFeatLabel: {}}
|
||||
# 注：labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
|
||||
# 注: labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
|
||||
# 所以这行代码导致函数外的同名变量被删除了元素，造成例句无法执行，提示'no surfacing' is not in list
|
||||
del(labels[bestFeat])
|
||||
# 取出最优列，然后它的branch做分类
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-29
|
||||
Updated on 2017-06-29
|
||||
DecisionTree：决策树
|
||||
DecisionTree: 决策树
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-29
|
||||
Updated on 2017-06-29
|
||||
DecisionTree：决策树
|
||||
DecisionTree: 决策树
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -144,10 +144,10 @@ def trainNB0(trainMatrix, trainCategory):
|
|||
|
||||
def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
|
||||
"""
|
||||
使用算法：
|
||||
使用算法:
|
||||
# 将乘法转换为加法
|
||||
乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
乘法: P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法: P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
:param vec2Classify: 待测数据[0,1,1,1,1...]，即要分类的向量
|
||||
:param p0Vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
|
||||
:param p1Vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
|
||||
|
|
@ -156,7 +156,7 @@ def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
|
|||
"""
|
||||
# 计算公式 log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
# 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
|
||||
# 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
# 我的理解是: 这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
# 可以理解为 1.单词在词汇表中的条件下，文件是good 类别的概率 也可以理解为 2.在整个空间下，文件既在词汇表中又是good类别的概率
|
||||
p1 = sum(vec2Classify * p1Vec) + log(pClass1)
|
||||
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-28
|
||||
Updated on 2017-06-28
|
||||
NaiveBayes：朴素贝叶斯
|
||||
NaiveBayes: 朴素贝叶斯
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ def sigmoid(inX):
|
|||
|
||||
|
||||
# 正常的处理方案
|
||||
# 两个参数：第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
|
||||
# 两个参数: 第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
|
||||
# 第二个参数==> classLabels 是类别标签，它是一个 1*100 的行向量。为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给labelMat。
|
||||
def gradAscent(dataMatIn, classLabels):
|
||||
'''
|
||||
|
|
@ -80,8 +80,8 @@ def gradAscent(dataMatIn, classLabels):
|
|||
weights = ones((n, 1))
|
||||
for k in range(maxCycles): # heavy on matrix operations
|
||||
# m*3 的矩阵 * 3*1 的单位矩阵 ＝ m*1的矩阵
|
||||
# 那么乘上单位矩阵的意义，就代表：通过公式得到的理论值
|
||||
# 参考地址： 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
|
||||
# 那么乘上单位矩阵的意义，就代表: 通过公式得到的理论值
|
||||
# 参考地址: 矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
|
||||
# print 'dataMatrix====', dataMatrix
|
||||
# print 'weights====', weights
|
||||
# n*3 * 3*1 = n*1
|
||||
|
|
@ -195,7 +195,7 @@ def plotBestFit(dataArr, labelMat, weights):
|
|||
dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
|
||||
w0*x0+w1*x1+w2*x2=f(x)
|
||||
x0最开始就设置为1叻， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了
|
||||
所以： w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2
|
||||
所以: w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2
|
||||
"""
|
||||
y = (-weights[0] - weights[1] * x) / weights[2]
|
||||
ax.plot(x, y)
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Update on 2017-05-18
|
|||
Logistic Regression Working Module
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
scikit-learn的例子地址：http://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
|
||||
scikit-learn的例子地址: http://scikit-learn.org/stable/modules/linear_model.html#logistic-regression
|
||||
'''
|
||||
|
||||
# 逻辑回归中的 L1 惩罚和稀缺性 L1 Penalty and Sparsity in Logistic Regression
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-28
|
||||
Updated on 2017-06-28
|
||||
SVM：最大边距分离超平面
|
||||
SVM: 最大边距分离超平面
|
||||
Author: 片刻
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
sklearn-SVM译文链接: http://cwiki.apachecn.org/pages/viewpage.action?pageId=10031359
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ def loadDataSet(fileName):
|
|||
|
||||
|
||||
def calcEk(oS, k):
|
||||
"""calcEk（求 Ek误差：预测值-真实值的差）
|
||||
"""calcEk（求 Ek误差: 预测值-真实值的差）
|
||||
|
||||
该过程在完整版的SMO算法中陪出现次数较多，因此将其单独作为一个方法
|
||||
Args:
|
||||
|
|
@ -150,10 +150,10 @@ def selectJ(i, oS, Ei): # this is the second choice -heurstic, and calcs Ej
|
|||
# print 'oS.eCache[%s]=%s' % (i, oS.eCache[i])
|
||||
# print 'oS.eCache[:, 0].A=%s' % oS.eCache[:, 0].A.T
|
||||
# """
|
||||
# # 返回非0的：行列值
|
||||
# # 返回非0的: 行列值
|
||||
# nonzero(oS.eCache[:, 0].A)= (
|
||||
# 行： array([ 0, 2, 4, 5, 8, 10, 17, 18, 20, 21, 23, 25, 26, 29, 30, 39, 46,52, 54, 55, 62, 69, 70, 76, 79, 82, 94, 97]),
|
||||
# 列： array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0])
|
||||
# 行: array([ 0, 2, 4, 5, 8, 10, 17, 18, 20, 21, 23, 25, 26, 29, 30, 39, 46,52, 54, 55, 62, 69, 70, 76, 79, 82, 94, 97]),
|
||||
# 列: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0])
|
||||
# )
|
||||
# """
|
||||
# print 'nonzero(oS.eCache[:, 0].A)=', nonzero(oS.eCache[:, 0].A)
|
||||
|
|
@ -166,7 +166,7 @@ def selectJ(i, oS, Ei): # this is the second choice -heurstic, and calcs Ej
|
|||
if k == i:
|
||||
continue # don't calc for i, waste of time
|
||||
|
||||
# 求 Ek误差：预测值-真实值的差
|
||||
# 求 Ek误差: 预测值-真实值的差
|
||||
Ek = calcEk(oS, k)
|
||||
deltaE = abs(Ei - Ek)
|
||||
if (deltaE > maxDeltaE):
|
||||
|
|
@ -178,7 +178,7 @@ def selectJ(i, oS, Ei): # this is the second choice -heurstic, and calcs Ej
|
|||
else: # 如果是第一次循环，则随机选择一个alpha值
|
||||
j = selectJrand(i, oS.m)
|
||||
|
||||
# 求 Ek误差：预测值-真实值的差
|
||||
# 求 Ek误差: 预测值-真实值的差
|
||||
Ej = calcEk(oS, j)
|
||||
return j, Ej
|
||||
|
||||
|
|
@ -192,7 +192,7 @@ def updateEk(oS, k):
|
|||
k 某一列的行号
|
||||
"""
|
||||
|
||||
# 求 误差：预测值-真实值的差
|
||||
# 求 误差: 预测值-真实值的差
|
||||
Ek = calcEk(oS, k)
|
||||
oS.eCache[k] = [1, Ek]
|
||||
|
||||
|
|
@ -225,12 +225,12 @@ def innerL(i, oS):
|
|||
1 找到了最优的值，并且oS.Cache到缓存中
|
||||
"""
|
||||
|
||||
# 求 Ek误差：预测值-真实值的差
|
||||
# 求 Ek误差: 预测值-真实值的差
|
||||
Ei = calcEk(oS, i)
|
||||
|
||||
# 约束条件 (KKT条件是解决最优化问题的时用到的一种方法。我们这里提到的最优化问题通常是指对于给定的某一函数，求其在指定作用域上的全局最小值)
|
||||
# 0<=alphas[i]<=C，但由于0和C是边界值，我们无法进行优化，因为需要增加一个alphas和降低一个alphas。
|
||||
# 表示发生错误的概率：labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
# 表示发生错误的概率: labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
'''
|
||||
# 检验训练样本(xi, yi)是否满足KKT条件
|
||||
yi*f(i) >= 1 and alpha = 0 (outside the boundary)
|
||||
|
|
@ -280,7 +280,7 @@ def innerL(i, oS):
|
|||
|
||||
# 在对alpha[i], alpha[j] 进行优化之后，给这两个alpha值设置一个常数b。
|
||||
# w= Σ[1~n] ai*yi*xi => b = yi- Σ[1~n] ai*yi(xi*xj)
|
||||
# 所以： b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 所以: b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 为什么减2遍？ 因为是 减去Σ[1~n]，正好2个变量i和j，所以减2遍
|
||||
b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alphaIold) * oS.K[i, i] - oS.labelMat[j] * (oS.alphas[j] - alphaJold) * oS.K[i, j]
|
||||
b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alphaIold) * oS.K[i, j] - oS.labelMat[j] * (oS.alphas[j] - alphaJold) * oS.K[j, j]
|
||||
|
|
@ -318,7 +318,7 @@ def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup=('lin', 0)):
|
|||
entireSet = True
|
||||
alphaPairsChanged = 0
|
||||
|
||||
# 循环遍历：循环maxIter次 并且 （alphaPairsChanged存在可以改变 or 所有行遍历一遍）
|
||||
# 循环遍历: 循环maxIter次 并且 （alphaPairsChanged存在可以改变 or 所有行遍历一遍）
|
||||
while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):
|
||||
alphaPairsChanged = 0
|
||||
|
||||
|
|
@ -383,7 +383,7 @@ def testRbf(k1=1.3):
|
|||
for i in range(m):
|
||||
kernelEval = kernelTrans(sVs, datMat[i, :], ('rbf', k1))
|
||||
|
||||
# 和这个svm-simple类似： fXi = float(multiply(alphas, labelMat).T*(dataMatrix*dataMatrix[i, :].T)) + b
|
||||
# 和这个svm-simple类似: fXi = float(multiply(alphas, labelMat).T*(dataMatrix*dataMatrix[i, :].T)) + b
|
||||
predict = kernelEval.T * multiply(labelSV, alphas[svInd]) + b
|
||||
if sign(predict) != sign(labelArr[i]):
|
||||
errorCount += 1
|
||||
|
|
@ -466,7 +466,7 @@ def testDigits(kTup=('rbf', 10)):
|
|||
|
||||
def plotfig_SVM(xArr, yArr, ws, b, alphas):
|
||||
"""
|
||||
参考地址：
|
||||
参考地址:
|
||||
http://blog.csdn.net/maoersong/article/details/24315633
|
||||
http://www.cnblogs.com/JustForCS/p/5283489.html
|
||||
http://blog.csdn.net/kkxgx/article/details/6951959
|
||||
|
|
@ -527,7 +527,7 @@ if __name__ == "__main__":
|
|||
testRbf(0.8)
|
||||
|
||||
# # 项目实战
|
||||
# # 示例：手写识别问题回顾
|
||||
# # 示例: 手写识别问题回顾
|
||||
# testDigits(('rbf', 0.1))
|
||||
# testDigits(('rbf', 5))
|
||||
# testDigits(('rbf', 10))
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ def clipAlpha(aj, H, L):
|
|||
|
||||
|
||||
def calcEk(oS, k):
|
||||
"""calcEk（求 Ek误差：预测值-真实值的差）
|
||||
"""calcEk（求 Ek误差: 预测值-真实值的差）
|
||||
|
||||
该过程在完整版的SMO算法中陪出现次数较多，因此将其单独作为一个方法
|
||||
Args:
|
||||
|
|
@ -116,10 +116,10 @@ def selectJ(i, oS, Ei): # this is the second choice -heurstic, and calcs Ej
|
|||
# print 'oS.eCache[%s]=%s' % (i, oS.eCache[i])
|
||||
# print 'oS.eCache[:, 0].A=%s' % oS.eCache[:, 0].A.T
|
||||
# """
|
||||
# # 返回非0的：行列值
|
||||
# # 返回非0的: 行列值
|
||||
# nonzero(oS.eCache[:, 0].A)= (
|
||||
# 行： array([ 0, 2, 4, 5, 8, 10, 17, 18, 20, 21, 23, 25, 26, 29, 30, 39, 46,52, 54, 55, 62, 69, 70, 76, 79, 82, 94, 97]),
|
||||
# 列： array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0])
|
||||
# 行: array([ 0, 2, 4, 5, 8, 10, 17, 18, 20, 21, 23, 25, 26, 29, 30, 39, 46,52, 54, 55, 62, 69, 70, 76, 79, 82, 94, 97]),
|
||||
# 列: array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0])
|
||||
# )
|
||||
# """
|
||||
# print 'nonzero(oS.eCache[:, 0].A)=', nonzero(oS.eCache[:, 0].A)
|
||||
|
|
@ -132,7 +132,7 @@ def selectJ(i, oS, Ei): # this is the second choice -heurstic, and calcs Ej
|
|||
if k == i:
|
||||
continue # don't calc for i, waste of time
|
||||
|
||||
# 求 Ek误差：预测值-真实值的差
|
||||
# 求 Ek误差: 预测值-真实值的差
|
||||
Ek = calcEk(oS, k)
|
||||
deltaE = abs(Ei - Ek)
|
||||
if (deltaE > maxDeltaE):
|
||||
|
|
@ -143,7 +143,7 @@ def selectJ(i, oS, Ei): # this is the second choice -heurstic, and calcs Ej
|
|||
else: # 如果是第一次循环，则随机选择一个alpha值
|
||||
j = selectJrand(i, oS.m)
|
||||
|
||||
# 求 Ek误差：预测值-真实值的差
|
||||
# 求 Ek误差: 预测值-真实值的差
|
||||
Ej = calcEk(oS, j)
|
||||
return j, Ej
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ def updateEk(oS, k): # after any alpha has changed update the new value in the
|
|||
k 某一列的行号
|
||||
"""
|
||||
|
||||
# 求 误差：预测值-真实值的差
|
||||
# 求 误差: 预测值-真实值的差
|
||||
Ek = calcEk(oS, k)
|
||||
oS.eCache[k] = [1, Ek]
|
||||
|
||||
|
|
@ -174,12 +174,12 @@ def innerL(i, oS):
|
|||
1 找到了最优的值，并且oS.Cache到缓存中
|
||||
"""
|
||||
|
||||
# 求 Ek误差：预测值-真实值的差
|
||||
# 求 Ek误差: 预测值-真实值的差
|
||||
Ei = calcEk(oS, i)
|
||||
|
||||
# 约束条件 (KKT条件是解决最优化问题的时用到的一种方法。我们这里提到的最优化问题通常是指对于给定的某一函数，求其在指定作用域上的全局最小值)
|
||||
# 0<=alphas[i]<=C，但由于0和C是边界值，我们无法进行优化，因为需要增加一个alphas和降低一个alphas。
|
||||
# 表示发生错误的概率：labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
# 表示发生错误的概率: labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
'''
|
||||
# 检验训练样本(xi, yi)是否满足KKT条件
|
||||
yi*f(i) >= 1 and alpha = 0 (outside the boundary)
|
||||
|
|
@ -229,7 +229,7 @@ def innerL(i, oS):
|
|||
|
||||
# 在对alpha[i], alpha[j] 进行优化之后，给这两个alpha值设置一个常数b。
|
||||
# w= Σ[1~n] ai*yi*xi => b = yj Σ[1~n] ai*yi(xi*xj)
|
||||
# 所以： b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 所以: b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 为什么减2遍？ 因为是 减去Σ[1~n]，正好2个变量i和j，所以减2遍
|
||||
b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alphaIold) * oS.X[i, :] * oS.X[i, :].T - oS.labelMat[j] * (oS.alphas[j] - alphaJold) * oS.X[i, :] * oS.X[j, :].T
|
||||
b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alphaIold) * oS.X[i, :] * oS.X[j, :].T - oS.labelMat[j] * (oS.alphas[j] - alphaJold) * oS.X[j, :] * oS.X[j, :].T
|
||||
|
|
@ -266,7 +266,7 @@ def smoP(dataMatIn, classLabels, C, toler, maxIter):
|
|||
entireSet = True
|
||||
alphaPairsChanged = 0
|
||||
|
||||
# 循环遍历：循环maxIter次 并且 （alphaPairsChanged存在可以改变 or 所有行遍历一遍）
|
||||
# 循环遍历: 循环maxIter次 并且 （alphaPairsChanged存在可以改变 or 所有行遍历一遍）
|
||||
# 循环迭代结束 或者 循环遍历所有alpha后，alphaPairs还是没变化
|
||||
while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):
|
||||
alphaPairsChanged = 0
|
||||
|
|
@ -319,7 +319,7 @@ def calcWs(alphas, dataArr, classLabels):
|
|||
|
||||
def plotfig_SVM(xArr, yArr, ws, b, alphas):
|
||||
"""
|
||||
参考地址：
|
||||
参考地址:
|
||||
http://blog.csdn.net/maoersong/article/details/24315633
|
||||
http://www.cnblogs.com/JustForCS/p/5283489.html
|
||||
http://blog.csdn.net/kkxgx/article/details/6951959
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
|
||||
# 约束条件 (KKT条件是解决最优化问题的时用到的一种方法。我们这里提到的最优化问题通常是指对于给定的某一函数，求其在指定作用域上的全局最小值)
|
||||
# 0<=alphas[i]<=C，但由于0和C是边界值，我们无法进行优化，因为需要增加一个alphas和降低一个alphas。
|
||||
# 表示发生错误的概率：labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
# 表示发生错误的概率: labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
|
||||
'''
|
||||
# 检验训练样本(xi, yi)是否满足KKT条件
|
||||
yi*f(i) >= 1 and alpha = 0 (outside the boundary)
|
||||
|
|
@ -155,7 +155,7 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
|
|||
alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
|
||||
# 在对alpha[i], alpha[j] 进行优化之后，给这两个alpha值设置一个常数b。
|
||||
# w= Σ[1~n] ai*yi*xi => b = yj- Σ[1~n] ai*yi(xi*xj)
|
||||
# 所以： b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 所以: b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
|
||||
# 为什么减2遍？ 因为是 减去Σ[1~n]，正好2个变量i和j，所以减2遍
|
||||
b1 = b - Ei- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i, :]*dataMatrix[i, :].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[i, :]*dataMatrix[j, :].T
|
||||
b2 = b - Ej- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i, :]*dataMatrix[j, :].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[j, :]*dataMatrix[j, :].T
|
||||
|
|
@ -199,7 +199,7 @@ def calcWs(alphas, dataArr, classLabels):
|
|||
|
||||
def plotfig_SVM(xMat, yMat, ws, b, alphas):
|
||||
"""
|
||||
参考地址：
|
||||
参考地址:
|
||||
http://blog.csdn.net/maoersong/article/details/24315633
|
||||
http://www.cnblogs.com/JustForCS/p/5283489.html
|
||||
http://blog.csdn.net/kkxgx/article/details/6951959
|
||||
|
|
|
|||
|
|
@ -94,8 +94,8 @@ def buildStump(dataArr, labelArr, D):
|
|||
# print 'rangeMin=%s, rangeMax=%s' % (rangeMin, rangeMax)
|
||||
# 计算每一份的元素个数
|
||||
stepSize = (rangeMax-rangeMin)/numSteps
|
||||
# 例如： 4=(10-1)/2 那么 1-4(-1次) 1(0次) 1+1*4(1次) 1+2*4(2次)
|
||||
# 所以： 循环 -1/0/1/2
|
||||
# 例如: 4=(10-1)/2 那么 1-4(-1次) 1(0次) 1+1*4(1次) 1+2*4(2次)
|
||||
# 所以: 循环 -1/0/1/2
|
||||
for j in range(-1, int(numSteps)+1):
|
||||
# go over less than and greater than
|
||||
for inequal in ['lt', 'gt']:
|
||||
|
|
@ -108,7 +108,7 @@ def buildStump(dataArr, labelArr, D):
|
|||
# 正确为0，错误为1
|
||||
errArr[predictedVals == labelMat] = 0
|
||||
# 计算 平均每个特征的概率0.2*错误概率的总和为多少，就知道错误率多高
|
||||
# 例如： 一个都没错，那么错误率= 0.2*0=0 ， 5个都错，那么错误率= 0.2*5=1， 只错3个，那么错误率= 0.2*3=0.6
|
||||
# 例如: 一个都没错，那么错误率= 0.2*0=0 ， 5个都错，那么错误率= 0.2*5=1， 只错3个，那么错误率= 0.2*3=0.6
|
||||
weightedError = D.T*errArr
|
||||
'''
|
||||
dim 表示 feature列
|
||||
|
|
@ -157,8 +157,8 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
|
|||
weakClassArr.append(bestStump)
|
||||
|
||||
# print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)
|
||||
# 分类正确：乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
|
||||
# 分类错误：乘积为 -1，结果会受影响，所以也乘以 -1
|
||||
# 分类正确: 乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
|
||||
# 分类错误: 乘积为 -1，结果会受影响，所以也乘以 -1
|
||||
expon = multiply(-1*alpha*mat(labelArr).T, classEst)
|
||||
# print '\n'
|
||||
# print 'labelArr=', labelArr
|
||||
|
|
@ -168,18 +168,18 @@ def adaBoostTrainDS(dataArr, labelArr, numIt=40):
|
|||
# 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式。
|
||||
# print '(-1取反)预测值expon=', expon.T
|
||||
# 计算e的expon次方，然后计算得到一个综合的概率的值
|
||||
# 结果发现： 判断错误的样本，D对于的样本权重值会变大。
|
||||
# 结果发现: 判断错误的样本，D对于的样本权重值会变大。
|
||||
D = multiply(D, exp(expon))
|
||||
D = D/D.sum()
|
||||
# print "D: ", D.T
|
||||
# print '\n'
|
||||
|
||||
# 预测的分类结果值，在上一轮结果的基础上，进行加和操作
|
||||
# print '当前的分类结果：', alpha*classEst.T
|
||||
# print '当前的分类结果: ', alpha*classEst.T
|
||||
aggClassEst += alpha*classEst
|
||||
# print "叠加后的分类结果aggClassEst: ", aggClassEst.T
|
||||
# sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
|
||||
# 结果为：错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
|
||||
# 结果为: 错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
|
||||
aggErrors = multiply(sign(aggClassEst) != mat(labelArr).T, ones((m, 1)))
|
||||
errorRate = aggErrors.sum()/m
|
||||
# print "total error=%s " % (errorRate)
|
||||
|
|
@ -196,7 +196,7 @@ def adaClassify(datToClass, classifierArr):
|
|||
|
||||
# 循环 多个分类器
|
||||
for i in range(len(classifierArr)):
|
||||
# 前提： 我们已经知道了最佳的分类器的实例
|
||||
# 前提: 我们已经知道了最佳的分类器的实例
|
||||
# 通过分类器来核算每一次的分类结果，然后通过alpha*每一次的结果 得到最后的权重加和的值。
|
||||
classEst = stumpClassify(dataMat, classifierArr[i]['dim'], classifierArr[i]['thresh'], classifierArr[i]['ineq'])
|
||||
aggClassEst += classifierArr[i]['alpha']*classEst
|
||||
|
|
@ -258,7 +258,7 @@ def plotROC(predStrengths, classLabels):
|
|||
ax.axis([0, 1, 0, 1])
|
||||
plt.show()
|
||||
'''
|
||||
参考说明：http://blog.csdn.net/wenyusuran/article/details/39056013
|
||||
参考说明: http://blog.csdn.net/wenyusuran/article/details/39056013
|
||||
为了计算 AUC ，我们需要对多个小矩形的面积进行累加。
|
||||
这些小矩形的宽度是xStep，因此可以先对所有矩形的高度进行累加，最后再乘以xStep得到其总面积。
|
||||
所有高度的和(ySum)随着x轴的每次移动而渐次增加。
|
||||
|
|
@ -272,7 +272,7 @@ if __name__ == "__main__":
|
|||
# print 'dataArr', dataArr, 'labelArr', labelArr
|
||||
|
||||
# # D表示最初值，对1进行均分为5份，平均每一个初始的概率都为0.2
|
||||
# # D的目的是为了计算错误概率： weightedError = D.T*errArr
|
||||
# # D的目的是为了计算错误概率: weightedError = D.T*errArr
|
||||
# D = mat(ones((5, 1))/5)
|
||||
# print 'D=', D.T
|
||||
|
||||
|
|
@ -281,18 +281,18 @@ if __name__ == "__main__":
|
|||
# # print 'minError=', minError
|
||||
# # print 'bestClasEst=', bestClasEst.T
|
||||
|
||||
# # 分类器：weakClassArr
|
||||
# # 分类器: weakClassArr
|
||||
# # 历史累计的分类结果集
|
||||
# weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, labelArr, 9)
|
||||
# print '\nweakClassArr=', weakClassArr, '\naggClassEst=', aggClassEst.T
|
||||
|
||||
# """
|
||||
# 发现:
|
||||
# 分类的权重值：最大的值，为alpha的加和，最小值为-最大值
|
||||
# 特征的权重值：如果一个值误判的几率越小，那么D的特征权重越少
|
||||
# 分类的权重值: 最大的值，为alpha的加和，最小值为-最大值
|
||||
# 特征的权重值: 如果一个值误判的几率越小，那么D的特征权重越少
|
||||
# """
|
||||
|
||||
# # 测试数据的分类结果, 观测：aggClassEst分类的最终权重
|
||||
# # 测试数据的分类结果, 观测: aggClassEst分类的最终权重
|
||||
# print adaClassify([0, 0], weakClassArr).T
|
||||
# print adaClassify([[5, 5], [0, 0]], weakClassArr).T
|
||||
|
||||
|
|
@ -308,5 +308,5 @@ if __name__ == "__main__":
|
|||
m = shape(dataArrTest)[0]
|
||||
predicting10 = adaClassify(dataArrTest, weakClassArr)
|
||||
errArr = mat(ones((m, 1)))
|
||||
# 测试：计算总样本数，错误样本数，错误率
|
||||
# 测试: 计算总样本数，错误样本数，错误率
|
||||
print(m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10 != mat(labelArrTest).T].sum()/m)
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ Random Forest Algorithm on Sonar Dataset
|
|||
Author: Flying_sfeng/片刻
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
---
|
||||
源代码网址：http://www.tuicool.com/articles/iiUfeim
|
||||
Flying_sfeng博客地址：http://blog.csdn.net/flying_sfeng/article/details/64133822 (感谢作者贡献)
|
||||
源代码网址: http://www.tuicool.com/articles/iiUfeim
|
||||
Flying_sfeng博客地址: http://blog.csdn.net/flying_sfeng/article/details/64133822 (感谢作者贡献)
|
||||
'''
|
||||
from __future__ import print_function
|
||||
from random import seed, randrange, random
|
||||
|
|
@ -46,7 +46,7 @@ def cross_validation_split(dataset, n_folds):
|
|||
dataset 原始数据集
|
||||
n_folds 数据集dataset分成n_flods份
|
||||
Returns:
|
||||
dataset_split list集合，存放的是：将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
|
||||
dataset_split list集合，存放的是: 将数据集进行抽重抽样 n_folds 份，数据可以重复重复抽取，每一次list的元素是无重复的
|
||||
"""
|
||||
dataset_split = list()
|
||||
dataset_copy = list(dataset) # 复制一份 dataset,防止 dataset 的内容改变
|
||||
|
|
@ -79,14 +79,14 @@ def test_split(index, value, dataset):
|
|||
'''
|
||||
Gini指数的计算问题，假如将原始数据集D切割两部分，分别为D1和D2，则
|
||||
Gini(D|切割) = (|D1|/|D| ) * Gini(D1) + (|D2|/|D|) * Gini(D2)
|
||||
学习地址：
|
||||
学习地址:
|
||||
http://bbs.pinggu.org/thread-5986969-1-1.html
|
||||
http://www.cnblogs.com/pinard/p/6053344.html
|
||||
而原文中 计算方式为：
|
||||
而原文中 计算方式为:
|
||||
Gini(D|切割) = Gini(D1) + Gini(D2)
|
||||
|
||||
# Calculate the Gini index for a split dataset
|
||||
def gini_index(groups, class_values): # 个人理解：计算代价，分类越准确，则 gini 越小
|
||||
def gini_index(groups, class_values): # 个人理解: 计算代价，分类越准确，则 gini 越小
|
||||
gini = 0.0
|
||||
for class_value in class_values: # class_values = [0, 1]
|
||||
for group in groups: # groups = (left, right)
|
||||
|
|
@ -94,12 +94,12 @@ def gini_index(groups, class_values): # 个人理解：计算代价，分类
|
|||
if size == 0:
|
||||
continue
|
||||
proportion = [row[-1] for row in group].count(class_value) / float(size)
|
||||
gini += (proportion * (1.0 - proportion)) # 个人理解：计算代价，分类越准确，则 gini 越小
|
||||
gini += (proportion * (1.0 - proportion)) # 个人理解: 计算代价，分类越准确，则 gini 越小
|
||||
return gini
|
||||
'''
|
||||
|
||||
|
||||
def gini_index(groups, class_values): # 个人理解：计算代价，分类越准确，则 gini 越小
|
||||
def gini_index(groups, class_values): # 个人理解: 计算代价，分类越准确，则 gini 越小
|
||||
gini = 0.0
|
||||
D = len(groups[0]) + len(groups[1])
|
||||
for class_value in class_values: # class_values = [0, 1]
|
||||
|
|
@ -108,7 +108,7 @@ def gini_index(groups, class_values): # 个人理解：计算代价，分类
|
|||
if size == 0:
|
||||
continue
|
||||
proportion = [row[-1] for row in group].count(class_value) / float(size)
|
||||
gini += float(size)/D * (proportion * (1.0 - proportion)) # 个人理解：计算代价，分类越准确，则 gini 越小
|
||||
gini += float(size)/D * (proportion * (1.0 - proportion)) # 个人理解: 计算代价，分类越准确，则 gini 越小
|
||||
return gini
|
||||
|
||||
|
||||
|
|
@ -181,7 +181,7 @@ def build_tree(train, max_depth, min_size, n_features):
|
|||
root = get_split(train, n_features)
|
||||
|
||||
# 对左右2边的数据 进行递归的调用，由于最优特征使用过，所以在后面进行使用的时候，就没有意义了
|
||||
# 例如： 性别-男女，对男使用这一特征就没任何意义了
|
||||
# 例如: 性别-男女，对男使用这一特征就没任何意义了
|
||||
split(root, max_depth, min_size, n_features, 1)
|
||||
return root
|
||||
|
||||
|
|
|
|||
|
|
@ -15,9 +15,9 @@ import matplotlib.pylab as plt
|
|||
def loadDataSet(fileName):
|
||||
""" 加载数据
|
||||
解析以tab键分隔的文件中的浮点数
|
||||
Returns：
|
||||
dataMat ： feature 对应的数据集
|
||||
labelMat ： feature 对应的分类标签，即类别标签
|
||||
Returns:
|
||||
dataMat : feature 对应的数据集
|
||||
labelMat : feature 对应的分类标签，即类别标签
|
||||
"""
|
||||
# 获取样本特征的总数，不算最后的目标变量
|
||||
numFeat = len(open(fileName).readline().split('\t')) - 1
|
||||
|
|
@ -42,13 +42,13 @@ def loadDataSet(fileName):
|
|||
|
||||
def standRegres(xArr, yArr):
|
||||
'''
|
||||
Description：
|
||||
Description:
|
||||
线性回归
|
||||
Args:
|
||||
xArr ：输入的样本数据，包含每个样本数据的 feature
|
||||
yArr ：对应于输入数据的类别标签，也就是每个样本对应的目标变量
|
||||
xArr : 输入的样本数据，包含每个样本数据的 feature
|
||||
yArr : 对应于输入数据的类别标签，也就是每个样本对应的目标变量
|
||||
Returns:
|
||||
ws：回归系数
|
||||
ws: 回归系数
|
||||
'''
|
||||
|
||||
# mat()函数将xArr，yArr转换为矩阵 mat().T 代表的是对矩阵进行转置操作
|
||||
|
|
@ -71,20 +71,20 @@ def standRegres(xArr, yArr):
|
|||
# 局部加权线性回归
|
||||
def lwlr(testPoint, xArr, yArr, k=1.0):
|
||||
'''
|
||||
Description：
|
||||
Description:
|
||||
局部加权线性回归，在待预测点附近的每个点赋予一定的权重，在子集上基于最小均方差来进行普通的回归。
|
||||
Args：
|
||||
testPoint：样本点
|
||||
xArr：样本的特征数据，即 feature
|
||||
yArr：每个样本对应的类别标签，即目标变量
|
||||
Args:
|
||||
testPoint: 样本点
|
||||
xArr: 样本的特征数据，即 feature
|
||||
yArr: 每个样本对应的类别标签，即目标变量
|
||||
k:关于赋予权重矩阵的核的一个参数，与权重的衰减速率有关
|
||||
Returns:
|
||||
testPoint * ws：数据点与具有权重的系数相乘得到的预测点
|
||||
testPoint * ws: 数据点与具有权重的系数相乘得到的预测点
|
||||
Notes:
|
||||
这其中会用到计算权重的公式，w = e^((x^((i))-x) / -2k^2)
|
||||
理解：x为某个预测点，x^((i))为样本点，样本点距离预测点越近，贡献的误差越大（权值越大），越远则贡献的误差越小（权值越小）。
|
||||
理解: x为某个预测点，x^((i))为样本点，样本点距离预测点越近，贡献的误差越大（权值越大），越远则贡献的误差越小（权值越小）。
|
||||
关于预测点的选取，在我的代码中取的是样本点。其中k是带宽参数，控制w（钟形函数）的宽窄程度，类似于高斯函数的标准差。
|
||||
算法思路：假设预测点取样本点中的第i个样本点（共m个样本点），遍历1到m个样本点（含第i个），算出每一个样本点与预测点的距离，
|
||||
算法思路: 假设预测点取样本点中的第i个样本点（共m个样本点），遍历1到m个样本点（含第i个），算出每一个样本点与预测点的距离，
|
||||
也就可以计算出每个样本贡献误差的权值，可以看出w是一个有m个元素的向量（写成对角阵形式）。
|
||||
'''
|
||||
# mat() 函数是将array转换为矩阵的函数， mat().T 是转换为矩阵之后，再进行转置操作
|
||||
|
|
@ -112,15 +112,15 @@ def lwlr(testPoint, xArr, yArr, k=1.0):
|
|||
|
||||
def lwlrTest(testArr, xArr, yArr, k=1.0):
|
||||
'''
|
||||
Description：
|
||||
Description:
|
||||
测试局部加权线性回归，对数据集中每个点调用 lwlr() 函数
|
||||
Args：
|
||||
testArr：测试所用的所有样本点
|
||||
xArr：样本的特征数据，即 feature
|
||||
yArr：每个样本对应的类别标签，即目标变量
|
||||
k：控制核函数的衰减速率
|
||||
Returns：
|
||||
yHat：预测点的估计值
|
||||
Args:
|
||||
testArr: 测试所用的所有样本点
|
||||
xArr: 样本的特征数据，即 feature
|
||||
yArr: 每个样本对应的类别标签，即目标变量
|
||||
k: 控制核函数的衰减速率
|
||||
Returns:
|
||||
yHat: 预测点的估计值
|
||||
'''
|
||||
# 得到样本点的总数
|
||||
m = shape(testArr)[0]
|
||||
|
|
@ -137,13 +137,13 @@ def lwlrTestPlot(xArr, yArr, k=1.0):
|
|||
'''
|
||||
Description:
|
||||
首先将 X 排序，其余的都与lwlrTest相同，这样更容易绘图
|
||||
Args：
|
||||
xArr：样本的特征数据，即 feature
|
||||
yArr：每个样本对应的类别标签，即目标变量，实际值
|
||||
k：控制核函数的衰减速率的有关参数，这里设定的是常量值 1
|
||||
Return：
|
||||
yHat：样本点的估计值
|
||||
xCopy：xArr的复制
|
||||
Args:
|
||||
xArr: 样本的特征数据，即 feature
|
||||
yArr: 每个样本对应的类别标签，即目标变量，实际值
|
||||
k: 控制核函数的衰减速率的有关参数，这里设定的是常量值 1
|
||||
Return:
|
||||
yHat: 样本点的估计值
|
||||
xCopy: xArr的复制
|
||||
'''
|
||||
# 生成一个与目标变量数目相同的 0 向量
|
||||
yHat = zeros(shape(yArr))
|
||||
|
|
@ -162,8 +162,8 @@ def rssError(yArr, yHatArr):
|
|||
Desc:
|
||||
计算分析预测误差的大小
|
||||
Args:
|
||||
yArr：真实的目标变量
|
||||
yHatArr：预测得到的估计值
|
||||
yArr: 真实的目标变量
|
||||
yHatArr: 预测得到的估计值
|
||||
Returns:
|
||||
计算真实值和估计值得到的值的平方和作为最后的返回值
|
||||
'''
|
||||
|
|
@ -172,16 +172,16 @@ def rssError(yArr, yHatArr):
|
|||
|
||||
def ridgeRegres(xMat, yMat, lam=0.2):
|
||||
'''
|
||||
Desc：
|
||||
Desc:
|
||||
这个函数实现了给定 lambda 下的岭回归求解。
|
||||
如果数据的特征比样本点还多，就不能再使用上面介绍的的线性回归和局部线性回归了，因为计算 (xTx)^(-1)会出现错误。
|
||||
如果特征比样本点还多（n > m），也就是说，输入数据的矩阵x不是满秩矩阵。非满秩矩阵在求逆时会出现问题。
|
||||
为了解决这个问题，我们下边讲一下：岭回归，这是我们要讲的第一种缩减方法。
|
||||
Args：
|
||||
xMat：样本的特征数据，即 feature
|
||||
yMat：每个样本对应的类别标签，即目标变量，实际值
|
||||
lam：引入的一个λ值，使得矩阵非奇异
|
||||
Returns：
|
||||
为了解决这个问题，我们下边讲一下: 岭回归，这是我们要讲的第一种缩减方法。
|
||||
Args:
|
||||
xMat: 样本的特征数据，即 feature
|
||||
yMat: 每个样本对应的类别标签，即目标变量，实际值
|
||||
lam: 引入的一个λ值，使得矩阵非奇异
|
||||
Returns:
|
||||
经过岭回归公式计算得到的回归系数
|
||||
'''
|
||||
|
||||
|
|
@ -198,13 +198,13 @@ def ridgeRegres(xMat, yMat, lam=0.2):
|
|||
|
||||
def ridgeTest(xArr, yArr):
|
||||
'''
|
||||
Desc：
|
||||
Desc:
|
||||
函数 ridgeTest() 用于在一组 λ 上测试结果
|
||||
Args：
|
||||
xArr：样本数据的特征，即 feature
|
||||
yArr：样本数据的类别标签，即真实数据
|
||||
Returns：
|
||||
wMat：将所有的回归系数输出到一个矩阵并返回
|
||||
Args:
|
||||
xArr: 样本数据的特征，即 feature
|
||||
yArr: 样本数据的类别标签，即真实数据
|
||||
Returns:
|
||||
wMat: 将所有的回归系数输出到一个矩阵并返回
|
||||
'''
|
||||
|
||||
xMat = mat(xArr)
|
||||
|
|
@ -372,7 +372,7 @@ gt56 trainY.append(yArr[indexList[j]])
|
|||
|
||||
# ----------------------------------------------------------------------------
|
||||
# 预测乐高玩具套装的价格 可运行版本，我们把乐高数据存储到了我们的 input 文件夹下，使用 beautifulSoup 爬去一下内容
|
||||
# 前提：安装 BeautifulSoup 第三方爬虫库，步骤如下
|
||||
# 前提: 安装 BeautifulSoup 第三方爬虫库，步骤如下
|
||||
# 在这个页面 https://www.crummy.com/software/BeautifulSoup/bs4/download/4.4/ 下载，beautifulsoup4-4.4.1.tar.gz
|
||||
# 将下载文件解压，使用 windows 版本的 cmd 命令行，进入解压的包，输入以下两行命令即可完成安装
|
||||
# python setup.py build
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ from numpy import *
|
|||
# general function to parse tab -delimited floats
|
||||
def loadDataSet(fileName):
|
||||
"""loadDataSet(解析每一行，并转化为float类型)
|
||||
Desc：该函数读取一个以 tab 键为分隔符的文件，然后将每行的内容保存成一组浮点数
|
||||
Desc: 该函数读取一个以 tab 键为分隔符的文件，然后将每行的内容保存成一组浮点数
|
||||
Args:
|
||||
fileName 文件名
|
||||
Returns:
|
||||
|
|
@ -39,7 +39,7 @@ def loadDataSet(fileName):
|
|||
|
||||
def binSplitDataSet(dataSet, feature, value):
|
||||
"""binSplitDataSet(将数据集，按照feature列的value进行 二元切分)
|
||||
Description：在给定特征和特征值的情况下，该函数通过数组过滤方式将上述数据集合切分得到两个子集并返回。
|
||||
Description: 在给定特征和特征值的情况下，该函数通过数组过滤方式将上述数据集合切分得到两个子集并返回。
|
||||
Args:
|
||||
dataMat 数据集
|
||||
feature 待切分的特征列
|
||||
|
|
@ -63,13 +63,13 @@ def binSplitDataSet(dataSet, feature, value):
|
|||
|
||||
# 返回每一个叶子结点的均值
|
||||
# returns the value used for each leaf
|
||||
# 我的理解是：regLeaf 是产生叶节点的函数，就是求均值，即用聚类中心点来代表这类数据
|
||||
# 我的理解是: regLeaf 是产生叶节点的函数，就是求均值，即用聚类中心点来代表这类数据
|
||||
def regLeaf(dataSet):
|
||||
return mean(dataSet[:, -1])
|
||||
|
||||
|
||||
# 计算总方差=方差*样本数
|
||||
# 我的理解是：求这组数据的方差，即通过决策树划分，可以让靠近的数据分到同一类中去
|
||||
# 我的理解是: 求这组数据的方差，即通过决策树划分，可以让靠近的数据分到同一类中去
|
||||
def regErr(dataSet):
|
||||
# shape(dataSet)[0] 表示行数
|
||||
return var(dataSet[:, -1]) * shape(dataSet)[0]
|
||||
|
|
@ -142,7 +142,7 @@ def chooseBestSplit(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
|||
# 假设 dataSet 是 NumPy Mat 类型的，那么我们可以进行 array 过滤
|
||||
def createTree(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
||||
"""createTree(获取回归树)
|
||||
Description：递归函数：如果构建的是回归树，该模型是一个常数，如果是模型树，其模型师一个线性方程。
|
||||
Description: 递归函数: 如果构建的是回归树，该模型是一个常数，如果是模型树，其模型师一个线性方程。
|
||||
Args:
|
||||
dataSet 加载的原始数据集
|
||||
leafType 建立叶子点的函数
|
||||
|
|
@ -151,7 +151,7 @@ def createTree(dataSet, leafType=regLeaf, errType=regErr, ops=(1, 4)):
|
|||
Returns:
|
||||
retTree 决策树最后的结果
|
||||
"""
|
||||
# 选择最好的切分方式： feature索引值，最优切分值
|
||||
# 选择最好的切分方式: feature索引值，最优切分值
|
||||
# choose the best split
|
||||
feat, val = chooseBestSplit(dataSet, leafType, errType, ops)
|
||||
# if the splitting hit a stop condition return val
|
||||
|
|
@ -234,7 +234,7 @@ def prune(tree, testData):
|
|||
# 1. 如果正确
|
||||
# * 那么计算一下总方差 和 该结果集的本身不分枝的总方差比较
|
||||
# * 如果 合并的总方差 < 不合并的总方差，那么就进行合并
|
||||
# 注意返回的结果： 如果可以合并，原来的dict就变为了 数值
|
||||
# 注意返回的结果: 如果可以合并，原来的dict就变为了 数值
|
||||
if not isTree(tree['left']) and not isTree(tree['right']):
|
||||
lSet, rSet = binSplitDataSet(testData, tree['spInd'], tree['spVal'])
|
||||
# power(x, y)表示x的y次方；这时tree['left']和tree['right']都是具体数值
|
||||
|
|
@ -252,7 +252,7 @@ def prune(tree, testData):
|
|||
return tree
|
||||
|
||||
|
||||
# 得到模型的ws系数：f(x) = x0 + x1*featrue1+ x2*featrue2 ...
|
||||
# 得到模型的ws系数: f(x) = x0 + x1*featrue1+ x2*featrue2 ...
|
||||
# create linear model and return coeficients
|
||||
def modelLeaf(dataSet):
|
||||
"""
|
||||
|
|
@ -419,13 +419,13 @@ if __name__ == "__main__":
|
|||
# myTree = createTree(myMat)
|
||||
# print myTree
|
||||
|
||||
# # 1. 预剪枝就是：提起设置最大误差数和最少元素数
|
||||
# # 1. 预剪枝就是: 提起设置最大误差数和最少元素数
|
||||
# myDat = loadDataSet('data/9.RegTrees/data3.txt')
|
||||
# myMat = mat(myDat)
|
||||
# myTree = createTree(myMat, ops=(0, 1))
|
||||
# print myTree
|
||||
|
||||
# # 2. 后剪枝就是：通过测试数据，对预测模型进行合并判断
|
||||
# # 2. 后剪枝就是: 通过测试数据，对预测模型进行合并判断
|
||||
# myDatTest = loadDataSet('data/9.RegTrees/data3test.txt')
|
||||
# myMat2Test = mat(myDatTest)
|
||||
# myFinalTree = prune(myTree, myMat2Test)
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-07-13
|
||||
Updated on 2017-07-13
|
||||
RegressionTree：树回归
|
||||
RegressionTree: 树回归
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ class Node(object):
|
|||
Returns:
|
||||
None
|
||||
'''
|
||||
# 打印格式：第几层 - 第几个节点，output 是多少，delta 是多少
|
||||
# 打印格式: 第几层 - 第几个节点，output 是多少，delta 是多少
|
||||
node_str = '%u-%u: output: %f delta: %f' % (self.layer_index, self.node_index, self.output, self.delta)
|
||||
# 下游节点
|
||||
downstream_str = reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
|
||||
|
|
@ -348,7 +348,7 @@ class Connection(object):
|
|||
Returns:
|
||||
连接信息进行返回
|
||||
'''
|
||||
# 格式为：上游节点的层的索引+上游节点的节点索引 ---> 下游节点的层的索引+下游节点的节点索引，最后一个数是权重
|
||||
# 格式为: 上游节点的层的索引+上游节点的节点索引 ---> 下游节点的层的索引+下游节点的节点索引，最后一个数是权重
|
||||
return '(%u-%u) -> (%u-%u) = %f' % (
|
||||
self.upstream_node.layer_index,
|
||||
self.upstream_node.node_index,
|
||||
|
|
@ -491,7 +491,7 @@ class Network(object):
|
|||
for i in range(len(label)):
|
||||
# 计算输出层节点的 delta
|
||||
output_nodes[i].calc_output_layer_delta(label[i])
|
||||
# 这个用法就是切片的用法， [-2::-1] 就是将 layers 这个数组倒过来，从没倒过来的时候的倒数第二个元素开始，到翻转过来的倒数第一个数，比如这样：aaa = [1,2,3,4,5,6,7,8,9],bbb = aaa[-2::-1] ==> bbb = [8, 7, 6, 5, 4, 3, 2, 1]
|
||||
# 这个用法就是切片的用法， [-2::-1] 就是将 layers 这个数组倒过来，从没倒过来的时候的倒数第二个元素开始，到翻转过来的倒数第一个数，比如这样: aaa = [1,2,3,4,5,6,7,8,9],bbb = aaa[-2::-1] ==> bbb = [8, 7, 6, 5, 4, 3, 2, 1]
|
||||
# 实际上就是除掉输出层之外的所有层按照相反的顺序进行遍历
|
||||
for layer in self.layers[-2::-1]:
|
||||
# 遍历每层的所有节点
|
||||
|
|
@ -587,7 +587,7 @@ class Network(object):
|
|||
|
||||
# # ------------------------- 至此，基本上我们把 我们的神经网络实现完成，下面还会介绍一下对应的梯度检查相关的算法，现在我们首先回顾一下我们上面写道的类及他们的作用 ------------------------
|
||||
'''
|
||||
1、节点类的实现 Node ：负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算。如下：
|
||||
1、节点类的实现 Node : 负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算。如下:
|
||||
layer_index --- 节点所属的层的编号
|
||||
node_index --- 节点的编号
|
||||
downstream --- 下游节点
|
||||
|
|
@ -595,7 +595,7 @@ upstream ---- 上游节点
|
|||
output ---- 节点的输出值
|
||||
delta ------ 节点的误差项
|
||||
|
||||
2、ConstNode 类，偏置项类的实现：实现一个输出恒为 1 的节点（计算偏置项的时候会用到），如下：
|
||||
2、ConstNode 类，偏置项类的实现: 实现一个输出恒为 1 的节点（计算偏置项的时候会用到），如下:
|
||||
layer_index --- 节点所属层的编号
|
||||
node_index ---- 节点的编号
|
||||
downstream ---- 下游节点
|
||||
|
|
@ -608,7 +608,7 @@ node_count ----- 层所包含的节点的个数
|
|||
def set_ouput() -- 设置层的输出，当层是输入层时会用到
|
||||
def calc_output -- 计算层的输出向量，调用的 Node 类的 计算输出 方法
|
||||
|
||||
4、Connection 类：负责记录连接的权重，以及这个连接所关联的上下游节点，如下：
|
||||
4、Connection 类: 负责记录连接的权重，以及这个连接所关联的上下游节点，如下:
|
||||
upstream_node --- 连接的上游节点
|
||||
downstream_node -- 连接的下游节点
|
||||
weight -------- random.uniform(-0.1, 0.1) 初始化为一个很小的随机数
|
||||
|
|
@ -617,10 +617,10 @@ def calc_gradient() --- 计算梯度，使用的是下游节点的 delta 与上
|
|||
def get_gradient() ---- 获取当前的梯度
|
||||
def update_weight() --- 根据梯度下降算法更新权重
|
||||
|
||||
5、Connections 类：提供对 Connection 集合操作，如下：
|
||||
5、Connections 类: 提供对 Connection 集合操作，如下:
|
||||
def add_connection() --- 添加一个 connection
|
||||
|
||||
6、Network 类：提供相应的 API，如下：
|
||||
6、Network 类: 提供相应的 API，如下:
|
||||
connections --- Connections 对象
|
||||
layers -------- 神经网络的层
|
||||
layer_count --- 神经网络的层数
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ def plot(linear_unit):
|
|||
'''
|
||||
# 引入绘图的库
|
||||
import matplotlib.pyplot as plt
|
||||
# 获取训练数据：特征 input_vecs 与 对应的标签 labels
|
||||
# 获取训练数据: 特征 input_vecs 与 对应的标签 labels
|
||||
input_vecs, labels = get_training_dataset()
|
||||
# figure() 创建一个 Figure 对象，与用户交互的整个窗口，这个 figure 中容纳着 subplots
|
||||
fig = plt.figure()
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class Perceptron(object):
|
|||
# reduce() 函数是 python 2 的内置函数，从 python 3 开始移到了 functools 模块
|
||||
# reduce() 从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值，例如 reduce(lambda x,y: x+y, [1,2,3,4,5]) 计算的就是 ((((1+2)+3)+4)+5)
|
||||
# map() 接收一个函数 f 和一个 list ，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 返回。比如我们的 f 函数是计算平方， map(f, [1,2,3,4,5]) ===> 返回 [1,4,9,16,25]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例：x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例: x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
|
||||
pack = zip(input_vec,self.weights)
|
||||
multi = []
|
||||
|
|
@ -73,7 +73,7 @@ class Perceptron(object):
|
|||
def train(self,input_vecs,labels,iteration,rate):
|
||||
'''
|
||||
Desc:
|
||||
输入训练数据：一组向量、与每个向量对应的 label; 以及训练轮数、学习率
|
||||
输入训练数据: 一组向量、与每个向量对应的 label; 以及训练轮数、学习率
|
||||
Args:
|
||||
input_vec —— 输入向量
|
||||
labels —— 数据对应的标签
|
||||
|
|
@ -96,7 +96,7 @@ class Perceptron(object):
|
|||
Returns:
|
||||
None
|
||||
'''
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例：x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例: x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
samples = zip(input_vecs, labels)
|
||||
# 对每个样本，按照感知器规则更新权重
|
||||
for (input_vec, label) in samples:
|
||||
|
|
@ -121,7 +121,7 @@ class Perceptron(object):
|
|||
|
||||
delta = labels -output
|
||||
# map() 接收一个函数 f 和一个 list ，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 返回。比如我们的 f 函数是计算平方， map(f, [1,2,3,4,5]) ===> 返回 [1,4,9,16,25]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例：x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# zip() 接收任意多个（包括 0 个和 1个）序列作为参数，返回一个 tuple 列表。例: x = [1,2,3] y = [4,5,6] z = [7,8,9] xyz = zip(x, y, z) ===> [(1,4,7), (2,5,8), (3,6,9)]
|
||||
# 此处python3必须对map函数进行list操作，不然 self.weights为map类型，最后无法打印出具体数值
|
||||
pack = zip(input_vecs,self.weights)
|
||||
tmp = []
|
||||
|
|
|
|||
|
|
@ -15,9 +15,9 @@ from numpy import random, mat, eye
|
|||
NumPy存在2中不同的数据类型:
|
||||
1. 矩阵 matrix
|
||||
2. 数组 array
|
||||
相似点：
|
||||
相似点:
|
||||
都可以处理行列表示的数字元素
|
||||
不同点：
|
||||
不同点:
|
||||
1. 2个数据类型上执行相同的数据运算可能得到不同的结果。
|
||||
2. NumPy函数库中的 matrix 与 MATLAB中 matrices 等价。
|
||||
'''
|
||||
|
|
@ -29,14 +29,14 @@ randArray = random.rand(4, 4)
|
|||
randMat = mat(randArray)
|
||||
'''
|
||||
.I 表示对矩阵求逆(可以利用矩阵的初等变换)
|
||||
意义：逆矩阵是一个判断相似性的工具。逆矩阵A与列向量p相乘后，将得到列向量q，q的第i个分量表示p与A的第i个列向量的相似度。
|
||||
参考案例链接：
|
||||
意义: 逆矩阵是一个判断相似性的工具。逆矩阵A与列向量p相乘后，将得到列向量q，q的第i个分量表示p与A的第i个列向量的相似度。
|
||||
参考案例链接:
|
||||
https://www.zhihu.com/question/33258489
|
||||
http://blog.csdn.net/vernice/article/details/48506027
|
||||
.T 表示对矩阵转置(行列颠倒)
|
||||
* 等同于: .transpose()
|
||||
.A 返回矩阵基于的数组
|
||||
参考案例链接：
|
||||
参考案例链接:
|
||||
http://blog.csdn.net/qq403977698/article/details/47254539
|
||||
'''
|
||||
invRandMat = randMat.I
|
||||
|
|
|
|||
|
|
@ -151,7 +151,7 @@ def apriori(dataSet, minSupport=0.5):
|
|||
|
||||
# 计算可信度（confidence）
|
||||
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
|
||||
"""calcConf（对两个元素的频繁项，计算可信度，例如： {1,2}/{1} 或者 {1,2}/{2} 看是否满足条件）
|
||||
"""calcConf（对两个元素的频繁项，计算可信度，例如: {1,2}/{1} 或者 {1,2}/{2} 看是否满足条件）
|
||||
|
||||
Args:
|
||||
freqSet 频繁项集中的元素，例如: frozenset([1, 3])
|
||||
|
|
@ -224,7 +224,7 @@ def generateRules(L, supportData, minConf=0.7):
|
|||
for i in range(1, len(L)):
|
||||
# 获取频繁项集中每个组合的所有元素
|
||||
for freqSet in L[i]:
|
||||
# 假设：freqSet= frozenset([1, 3]), H1=[frozenset([1]), frozenset([3])]
|
||||
# 假设: freqSet= frozenset([1, 3]), H1=[frozenset([1]), frozenset([3])]
|
||||
# 组合总的元素并遍历子元素，并转化为 frozenset 集合，再存放到 list 列表中
|
||||
H1 = [frozenset([item]) for item in freqSet]
|
||||
# 2 个的组合，走 else, 2 个以上的组合，走 if
|
||||
|
|
|
|||
|
|
@ -61,16 +61,16 @@ def createInitSet(dataSet):
|
|||
|
||||
# this version does not use recursion
|
||||
def updateHeader(nodeToTest, targetNode):
|
||||
"""updateHeader(更新头指针，建立相同元素之间的关系，例如： 左边的r指向右边的r值，就是后出现的相同元素 指向 已经出现的元素)
|
||||
"""updateHeader(更新头指针，建立相同元素之间的关系，例如: 左边的r指向右边的r值，就是后出现的相同元素 指向 已经出现的元素)
|
||||
|
||||
从头指针的nodeLink开始，一直沿着nodeLink直到到达链表末尾。这就是链表。
|
||||
性能：如果链表很长可能会遇到迭代调用的次数限制。
|
||||
性能: 如果链表很长可能会遇到迭代调用的次数限制。
|
||||
|
||||
Args:
|
||||
nodeToTest 满足minSup {所有的元素+(value, treeNode)}
|
||||
targetNode Tree对象的子节点
|
||||
"""
|
||||
# 建立相同元素之间的关系，例如： 左边的r指向右边的r值
|
||||
# 建立相同元素之间的关系，例如: 左边的r指向右边的r值
|
||||
while (nodeToTest.nodeLink is not None):
|
||||
nodeToTest = nodeToTest.nodeLink
|
||||
nodeToTest.nodeLink = targetNode
|
||||
|
|
@ -113,20 +113,20 @@ def createTree(dataSet, minSup=1):
|
|||
"""createTree(生成FP-tree)
|
||||
|
||||
Args:
|
||||
dataSet dist{行：出现次数}的样本数据
|
||||
dataSet dist{行: 出现次数}的样本数据
|
||||
minSup 最小的支持度
|
||||
Returns:
|
||||
retTree FP-tree
|
||||
headerTable 满足minSup {所有的元素+(value, treeNode)}
|
||||
"""
|
||||
# 支持度>=minSup的dist{所有元素：出现的次数}
|
||||
# 支持度>=minSup的dist{所有元素: 出现的次数}
|
||||
headerTable = {}
|
||||
# 循环 dist{行：出现次数}的样本数据
|
||||
# 循环 dist{行: 出现次数}的样本数据
|
||||
for trans in dataSet:
|
||||
# 对所有的行进行循环，得到行里面的所有元素
|
||||
# 统计每一行中，每个元素出现的总次数
|
||||
for item in trans:
|
||||
# 例如： {'ababa': 3} count(a)=3+3+3=9 count(b)=3+3=6
|
||||
# 例如: {'ababa': 3} count(a)=3+3+3=9 count(b)=3+3=6
|
||||
headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
|
||||
# 删除 headerTable中，元素次数<最小支持度的元素
|
||||
for k in list(headerTable.keys()): # python3中.keys()返回的是迭代器不是list,不能在遍历时对其改变。
|
||||
|
|
@ -139,12 +139,12 @@ def createTree(dataSet, minSup=1):
|
|||
if len(freqItemSet) == 0:
|
||||
return None, None
|
||||
for k in headerTable:
|
||||
# 格式化： dist{元素key: [元素次数, None]}
|
||||
# 格式化: dist{元素key: [元素次数, None]}
|
||||
headerTable[k] = [headerTable[k], None]
|
||||
|
||||
# create tree
|
||||
retTree = treeNode('Null Set', 1, None)
|
||||
# 循环 dist{行：出现次数}的样本数据
|
||||
# 循环 dist{行: 出现次数}的样本数据
|
||||
for tranSet, count in dataSet.items():
|
||||
# print('tranSet, count=', tranSet, count)
|
||||
# localD = dist{元素key: 元素总出现次数}
|
||||
|
|
@ -305,13 +305,13 @@ if __name__ == "__main__":
|
|||
# load样本数据
|
||||
simpDat = loadSimpDat()
|
||||
# print(simpDat, '\n')
|
||||
# frozen set 格式化 并 重新装载 样本数据，对所有的行进行统计求和，格式: {行：出现次数}
|
||||
# frozen set 格式化 并 重新装载 样本数据，对所有的行进行统计求和，格式: {行: 出现次数}
|
||||
initSet = createInitSet(simpDat)
|
||||
print(initSet)
|
||||
|
||||
# 创建FP树
|
||||
# 输入：dist{行：出现次数}的样本数据 和 最小的支持度
|
||||
# 输出：最终的PF-tree，通过循环获取第一层的节点，然后每一层的节点进行递归的获取每一行的字节点，也就是分支。然后所谓的指针，就是后来的指向已存在的
|
||||
# 输入: dist{行: 出现次数}的样本数据 和 最小的支持度
|
||||
# 输出: 最终的PF-tree，通过循环获取第一层的节点，然后每一层的节点进行递归的获取每一行的字节点，也就是分支。然后所谓的指针，就是后来的指向已存在的
|
||||
myFPtree, myHeaderTab = createTree(initSet, 3)
|
||||
myFPtree.disp()
|
||||
|
||||
|
|
@ -335,7 +335,7 @@ if __name__ == "__main__":
|
|||
# for t in listOfTerms:
|
||||
# print(t)
|
||||
|
||||
# # 2.新闻网站点击流中挖掘，例如：文章1阅读过的人，还阅读过什么？
|
||||
# # 2.新闻网站点击流中挖掘，例如: 文章1阅读过的人，还阅读过什么？
|
||||
# parsedDat = [line.split() for line in open('data/12.FPGrowth/kosarak.dat').readlines()]
|
||||
# initSet = createInitSet(parsedDat)
|
||||
# myFPtree, myHeaderTab = createTree(initSet, 100000)
|
||||
|
|
|
|||
|
|
@ -41,9 +41,9 @@ def pca(dataMat, topNfeat=9999999):
|
|||
|
||||
# cov协方差=[(x1-x均值)*(y1-y均值)+(x2-x均值)*(y2-y均值)+...+(xn-x均值)*(yn-y均值)+]/(n-1)
|
||||
'''
|
||||
方差：（一维）度量两个随机变量关系的统计量
|
||||
协方差： （二维）度量各个维度偏离其均值的程度
|
||||
协方差矩阵：（多维）度量各个维度偏离其均值的程度
|
||||
方差: （一维）度量两个随机变量关系的统计量
|
||||
协方差: （二维）度量各个维度偏离其均值的程度
|
||||
协方差矩阵: （多维）度量各个维度偏离其均值的程度
|
||||
|
||||
当 cov(X, Y)>0时，表明X与Y正相关；(X越大，Y也越大；X越小Y，也越小。这种情况，我们称为“正相关”。)
|
||||
当 cov(X, Y)<0时，表明X与Y负相关；
|
||||
|
|
@ -130,7 +130,7 @@ def analyse_data(dataMat):
|
|||
|
||||
最后，我们可能会注意到有一些小的负值，他们主要源自数值误差应该四舍五入成0.
|
||||
'''
|
||||
print('主成分：%s, 方差占比：%s%%, 累积方差占比：%s%%' % (format(i+1, '2.0f'), format(line_cov_score/cov_all_score*100, '4.2f'), format(sum_cov_score/cov_all_score*100, '4.1f')))
|
||||
print('主成分: %s, 方差占比: %s%%, 累积方差占比: %s%%' % (format(i+1, '2.0f'), format(line_cov_score/cov_all_score*100, '4.2f'), format(sum_cov_score/cov_all_score*100, '4.1f')))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ def analyse_data(Sigma, loopNum=20):
|
|||
根据自己的业务情况，就行处理，设置对应的 Singma 次数
|
||||
通常保留矩阵 80% ～ 90% 的能量，就可以得到重要的特征并取出噪声。
|
||||
'''
|
||||
print('主成分：%s, 方差占比：%s%%' % (format(i+1, '2.0f'), format(SigmaI/SigmaSum*100, '4.2f')))
|
||||
print('主成分: %s, 方差占比: %s%%' % (format(i+1, '2.0f'), format(SigmaI/SigmaSum*100, '4.2f')))
|
||||
|
||||
|
||||
# 图像压缩函数
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ class MRmean(MRJob):
|
|||
"""
|
||||
step方法定义执行的步骤。
|
||||
执行顺序不必完全遵循map-reduce模式。
|
||||
例如：
|
||||
例如:
|
||||
1. map-reduce-reduce-reduce
|
||||
2. map-reduce-map-reduce-map-reduce
|
||||
在step方法里，需要为mrjob指定mapper和reducer的名称。如果没有，它将默认调用mapper和reducer方法。
|
||||
|
|
|
|||
|
|
@ -17,9 +17,9 @@ from numpy import mat, mean, power
|
|||
这个mapper文件按行读取所有的输入并创建一组对应的浮点数，然后得到数组的长度并创建NumPy矩阵。
|
||||
再对所有的值进行平方，最后将均值和平方后的均值发送出去。这些值将用来计算全局的均值和方差。
|
||||
|
||||
Args：
|
||||
Args:
|
||||
file 输入数据
|
||||
Return：
|
||||
Return:
|
||||
'''
|
||||
|
||||
|
||||
|
|
@ -37,6 +37,6 @@ sqInput = power(input, 2) # 将矩阵的数据分别求 平方，
|
|||
# 输出 数据的个数，n个数据的均值，n个数据平方之后的均值
|
||||
# 第一行是标准输出，也就是reducer的输出
|
||||
# 第二行识标准错误输出，即对主节点作出的响应报告，表明本节点工作正常。
|
||||
# 【这不就是面试的装逼重点吗？如何设计监听架构细节】注意：一个好的习惯是想标准错误输出发送报告。如果某任务10分钟内没有报告输出，则将被Hadoop中止。
|
||||
# 【这不就是面试的装逼重点吗？如何设计监听架构细节】注意: 一个好的习惯是想标准错误输出发送报告。如果某任务10分钟内没有报告输出，则将被Hadoop中止。
|
||||
print("%d\t%f\t%f" % (numInputs, mean(input), mean(sqInput))) # 计算均值
|
||||
print("map report: still alive", file=sys.stderr)
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ import sys
|
|||
'''
|
||||
mapper 接受原始的输入并产生中间值传递给 reducer。
|
||||
很多的mapper是并行执行的，所以需要将这些mapper的输出合并成一个值。
|
||||
即：将中间的 key/value 对进行组合。
|
||||
即: 将中间的 key/value 对进行组合。
|
||||
'''
|
||||
|
||||
|
||||
|
|
@ -43,5 +43,5 @@ for instance in mapperOut:
|
|||
mean_ = cumVal/cumN
|
||||
varSum = (cumSumSq - 2*mean_*cumVal + cumN*mean_*mean_)/cumN
|
||||
# 输出 数据总量，均值，平方的均值（方差）
|
||||
print("数据总量：%d\t均值：%f\t方差：%f" % (cumN, mean_, varSum))
|
||||
print("数据总量: %d\t均值: %f\t方差: %f" % (cumN, mean_, varSum))
|
||||
print("reduce report: still alive", file=sys.stderr)
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ Created on 2015-06-22
|
|||
Update on 2017-05-16
|
||||
Author: Lockvictor/片刻
|
||||
《推荐系统实践》协同过滤算法源代码
|
||||
参考地址：https://github.com/Lockvictor/MovieLens-RecSys
|
||||
更新地址：https://github.com/apachecn/AiLearning
|
||||
参考地址: https://github.com/Lockvictor/MovieLens-RecSys
|
||||
更新地址: https://github.com/apachecn/AiLearning
|
||||
'''
|
||||
from __future__ import print_function
|
||||
import sys
|
||||
|
|
@ -14,7 +14,7 @@ import math
|
|||
import random
|
||||
from operator import itemgetter
|
||||
|
||||
# 作用：使得随机数据可预测
|
||||
# 作用: 使得随机数据可预测
|
||||
random.seed(0)
|
||||
|
||||
|
||||
|
|
@ -153,7 +153,7 @@ class ItemBasedCF():
|
|||
|
||||
# 计算top K 电影的相似度
|
||||
# rating=电影评分, w=不同电影出现的次数
|
||||
# 耗时分析：98.2%的时间在 line-154行
|
||||
# 耗时分析: 98.2%的时间在 line-154行
|
||||
for movie, rating in watched_movies.iteritems():
|
||||
for related_movie, w in sorted(
|
||||
self.movie_sim_mat[movie].items(),
|
||||
|
|
@ -183,7 +183,7 @@ class ItemBasedCF():
|
|||
popular_sum = 0
|
||||
|
||||
# enumerate将其组成一个索引序列，利用它可以同时获得索引和值
|
||||
# 参考地址：http://blog.csdn.net/churximi/article/details/51648388
|
||||
# 参考地址: http://blog.csdn.net/churximi/article/details/51648388
|
||||
for i, user in enumerate(self.trainset):
|
||||
if i > 0 and i % 500 == 0:
|
||||
print('recommended for %d users' % i, file=sys.stderr)
|
||||
|
|
@ -215,7 +215,7 @@ if __name__ == '__main__':
|
|||
|
||||
# 创建ItemCF对象
|
||||
itemcf = ItemBasedCF()
|
||||
# 将数据按照 7:3的比例，拆分成：训练集和测试集，存储在usercf的trainset和testset中
|
||||
# 将数据按照 7:3的比例，拆分成: 训练集和测试集，存储在usercf的trainset和testset中
|
||||
itemcf.generate_dataset(ratingfile, pivot=0.7)
|
||||
# 计算用户之间的相似度
|
||||
itemcf.calc_movie_sim()
|
||||
|
|
|
|||
|
|
@ -25,12 +25,12 @@ def splitData(dataFile, test_size):
|
|||
print('Number of users = ' + str(n_users) + ' | Number of movies = ' +
|
||||
str(n_items))
|
||||
train_data, test_data = cv.train_test_split(df, test_size=test_size)
|
||||
print("数据量：", len(train_data), len(test_data))
|
||||
print("数据量: ", len(train_data), len(test_data))
|
||||
return df, n_users, n_items, train_data, test_data
|
||||
|
||||
|
||||
def calc_similarity(n_users, n_items, train_data, test_data):
|
||||
# 创建用户产品矩阵，针对测试数据和训练数据，创建两个矩阵：
|
||||
# 创建用户产品矩阵，针对测试数据和训练数据，创建两个矩阵:
|
||||
train_data_matrix = np.zeros((n_users, n_items))
|
||||
for line in train_data.itertuples():
|
||||
train_data_matrix[line[1] - 1, line[2] - 1] = line[3]
|
||||
|
|
@ -39,8 +39,8 @@ def calc_similarity(n_users, n_items, train_data, test_data):
|
|||
test_data_matrix[line[1] - 1, line[2] - 1] = line[3]
|
||||
|
||||
# 使用sklearn的pairwise_distances函数来计算余弦相似性。
|
||||
print("1:", np.shape(train_data_matrix)) # 行：人，列：电影
|
||||
print("2:", np.shape(train_data_matrix.T)) # 行：电影，列：人
|
||||
print("1:", np.shape(train_data_matrix)) # 行: 人，列: 电影
|
||||
print("2:", np.shape(train_data_matrix.T)) # 行: 电影，列: 人
|
||||
|
||||
user_similarity = pairwise_distances(train_data_matrix, metric="cosine")
|
||||
item_similarity = pairwise_distances(train_data_matrix.T, metric="cosine")
|
||||
|
|
@ -80,7 +80,7 @@ def predict(rating, similarity, type='user'):
|
|||
pred = mean_user_rating[:, np.newaxis] + similarity.dot(
|
||||
rating_diff) / np.array([np.abs(similarity).sum(axis=1)]).T
|
||||
elif type == 'item':
|
||||
# 综合打分： 人-电影-评分(943, 1682)*电影-电影-距离(1682, 1682)=结果-人-电影(各个电影对同一电影的综合得分)(943, 1682) ／ 再除以 电影与其他电影总的距离 = 人-电影综合得分
|
||||
# 综合打分: 人-电影-评分(943, 1682)*电影-电影-距离(1682, 1682)=结果-人-电影(各个电影对同一电影的综合得分)(943, 1682) ／ 再除以 电影与其他电影总的距离 = 人-电影综合得分
|
||||
pred = rating.dot(similarity) / np.array(
|
||||
[np.abs(similarity).sum(axis=1)])
|
||||
return pred
|
||||
|
|
@ -135,8 +135,8 @@ def recommend(u_index, prediction):
|
|||
reverse=True)[:10]
|
||||
test_items = np.where(test_data_matrix[u_index, :] != 0)[0]
|
||||
|
||||
print('原始结果：', test_items)
|
||||
print('推荐结果：', [key for key, value in pre_items])
|
||||
print('原始结果: ', test_items)
|
||||
print('推荐结果: ', [key for key, value in pre_items])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
@ -156,7 +156,7 @@ if __name__ == "__main__":
|
|||
item_prediction = predict(train_data_matrix, item_similarity, type='item')
|
||||
user_prediction = predict(train_data_matrix, user_similarity, type='user')
|
||||
|
||||
# 评估：均方根误差
|
||||
# 评估: 均方根误差
|
||||
print(
|
||||
'Item based CF RMSE: ' + str(rmse(item_prediction, test_data_matrix)))
|
||||
print(
|
||||
|
|
@ -177,7 +177,7 @@ if __name__ == "__main__":
|
|||
'Model based CF RMSE: ' + str(rmse(svd_prediction, test_data_matrix)))
|
||||
"""
|
||||
在信息量相同的情况下，矩阵越小，那么携带的信息越可靠。
|
||||
所以：user-cf 推荐效果高于 item-cf； 而svd分解后，发现15个维度效果就能达到90%以上，所以信息更可靠，效果也更好。
|
||||
所以: user-cf 推荐效果高于 item-cf； 而svd分解后，发现15个维度效果就能达到90%以上，所以信息更可靠，效果也更好。
|
||||
item-cf: 1682
|
||||
user-cf: 943
|
||||
svd: 15
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ Created on 2015-06-22
|
|||
Update on 2017-05-16
|
||||
Author: Lockvictor/片刻
|
||||
《推荐系统实践》协同过滤算法源代码
|
||||
参考地址：https://github.com/Lockvictor/MovieLens-RecSys
|
||||
更新地址：https://github.com/apachecn/AiLearning
|
||||
参考地址: https://github.com/Lockvictor/MovieLens-RecSys
|
||||
更新地址: https://github.com/apachecn/AiLearning
|
||||
'''
|
||||
from __future__ import print_function
|
||||
import sys
|
||||
|
|
@ -14,7 +14,7 @@ import math
|
|||
import random
|
||||
from operator import itemgetter
|
||||
print(__doc__)
|
||||
# 作用：使得随机数据可预测
|
||||
# 作用: 使得随机数据可预测
|
||||
random.seed(0)
|
||||
|
||||
|
||||
|
|
@ -161,7 +161,7 @@ class UserBasedCF():
|
|||
|
||||
# 计算top K 用户的相似度
|
||||
# v=similar user, wuv=不同用户同时出现的次数，根据wuv倒序从大到小选出K个用户进行排列
|
||||
# 耗时分析：50.4%的时间在 line-160行
|
||||
# 耗时分析: 50.4%的时间在 line-160行
|
||||
for v, wuv in sorted(
|
||||
self.user_sim_mat[user].items(), key=itemgetter(1),
|
||||
reverse=True)[0:K]:
|
||||
|
|
@ -198,7 +198,7 @@ class UserBasedCF():
|
|||
popular_sum = 0
|
||||
|
||||
# enumerate将其组成一个索引序列，利用它可以同时获得索引和值
|
||||
# 参考地址：http://blog.csdn.net/churximi/article/details/51648388
|
||||
# 参考地址: http://blog.csdn.net/churximi/article/details/51648388
|
||||
for i, user in enumerate(self.trainset):
|
||||
if i > 0 and i % 500 == 0:
|
||||
print('recommended for %d users' % i, file=sys.stderr)
|
||||
|
|
@ -230,7 +230,7 @@ if __name__ == '__main__':
|
|||
|
||||
# 创建UserCF对象
|
||||
usercf = UserBasedCF()
|
||||
# 将数据按照 7:3的比例，拆分成：训练集和测试集，存储在usercf的trainset和testset中
|
||||
# 将数据按照 7:3的比例，拆分成: 训练集和测试集，存储在usercf的trainset和testset中
|
||||
usercf.generate_dataset(ratingfile, pivot=0.7)
|
||||
# 计算用户之间的相似度
|
||||
usercf.calc_user_sim()
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ Created on 2015-06-22
|
|||
Update on 2017-05-16
|
||||
Author: Lockvictor/片刻
|
||||
《推荐系统实践》协同过滤算法源代码
|
||||
参考地址：https://github.com/Lockvictor/MovieLens-RecSys
|
||||
更新地址：https://github.com/apachecn/AiLearning
|
||||
参考地址: https://github.com/Lockvictor/MovieLens-RecSys
|
||||
更新地址: https://github.com/apachecn/AiLearning
|
||||
'''
|
||||
from __future__ import print_function
|
||||
import math
|
||||
|
|
@ -19,7 +19,7 @@ import pandas as pd
|
|||
from sklearn import cross_validation as cv
|
||||
from sklearn.metrics.pairwise import pairwise_distances
|
||||
|
||||
# 作用：使得随机数据可预测
|
||||
# 作用: 使得随机数据可预测
|
||||
random.seed(0)
|
||||
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ class ItemBasedCF():
|
|||
print('Number of users = ' + str(self.n_users) +
|
||||
' | Number of items = ' + str(self.n_items))
|
||||
|
||||
# 拆分数据集： 用户+电影
|
||||
# 拆分数据集: 用户+电影
|
||||
self.train_data, self.test_data = cv.train_test_split(
|
||||
df, test_size=test_size)
|
||||
print('分离训练集和测试集成功', file=sys.stderr)
|
||||
|
|
@ -66,7 +66,7 @@ class ItemBasedCF():
|
|||
print('len(test) = %s' % np.shape(self.test_data)[0], file=sys.stderr)
|
||||
|
||||
def calc_similarity(self):
|
||||
# 创建用户产品矩阵，针对测试数据和训练数据，创建两个矩阵：
|
||||
# 创建用户产品矩阵，针对测试数据和训练数据，创建两个矩阵:
|
||||
self.train_mat = np.zeros((self.n_users, self.n_items))
|
||||
for line in self.train_data.itertuples():
|
||||
self.train_mat[int(line.user_id) - 1,
|
||||
|
|
@ -78,7 +78,7 @@ class ItemBasedCF():
|
|||
int(line.item_id) - 1] = float(line.rating)
|
||||
|
||||
# 使用sklearn的pairwise_distances函数来计算余弦相似性。
|
||||
print("1:", np.shape(np.mat(self.train_mat).T)) # 行：电影，列：人
|
||||
print("1:", np.shape(np.mat(self.train_mat).T)) # 行: 电影，列: 人
|
||||
# 电影-电影-距离(1682, 1682)
|
||||
self.item_mat_similarity = pairwise_distances(
|
||||
np.mat(self.train_mat).T, metric='cosine')
|
||||
|
|
@ -117,7 +117,7 @@ class ItemBasedCF():
|
|||
|
||||
# 计算top K 电影的相似度
|
||||
# rating=电影评分, w=不同电影出现的次数
|
||||
# 耗时分析：98.2%的时间在 line-154行
|
||||
# 耗时分析: 98.2%的时间在 line-154行
|
||||
for i_item, rating in watched_items.items():
|
||||
i_other_items = np.where(
|
||||
self.item_mat_similarity[i_item, :] != 0)[0]
|
||||
|
|
@ -150,7 +150,7 @@ class ItemBasedCF():
|
|||
popular_sum = 0
|
||||
|
||||
# enumerate 将其组成一个索引序列，利用它可以同时获得索引和值
|
||||
# 参考地址：http://blog.csdn.net/churximi/article/details/51648388
|
||||
# 参考地址: http://blog.csdn.net/churximi/article/details/51648388
|
||||
for u_index in range(50):
|
||||
if u_index > 0 and u_index % 10 == 0:
|
||||
print('recommended for %d users' % u_index, file=sys.stderr)
|
||||
|
|
@ -190,7 +190,7 @@ if __name__ == '__main__':
|
|||
|
||||
# 创建ItemCF对象
|
||||
itemcf = ItemBasedCF()
|
||||
# 将数据按照 7:3的比例，拆分成：训练集和测试集，存储在usercf的trainset和testset中
|
||||
# 将数据按照 7:3的比例，拆分成: 训练集和测试集，存储在usercf的trainset和testset中
|
||||
itemcf.splitData(dataFile, test_size=0.3)
|
||||
# 计算用户之间的相似度
|
||||
itemcf.calc_similarity()
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ nmf = NMF(n_components=2) # 设有2个隐主题
|
|||
user_distribution = nmf.fit_transform(RATE_MATRIX)
|
||||
item_distribution = nmf.components_
|
||||
|
||||
print('用户的主题分布：')
|
||||
print('用户的主题分布: ')
|
||||
print(user_distribution)
|
||||
print('物品的主题分布：')
|
||||
print('物品的主题分布: ')
|
||||
print(item_distribution)
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ def classify0(inX, dataSet, labels, k):
|
|||
Returns:
|
||||
sortedClassCount[0][0] -- 输入向量的预测分类 labels
|
||||
|
||||
注意：labels元素数目和dataSet行数相同；程序使用欧式距离公式.
|
||||
注意: labels元素数目和dataSet行数相同；程序使用欧式距离公式.
|
||||
|
||||
预测数据所在分类可在输入下列命令
|
||||
kNN.classify0([0,0], group, labels, 3)
|
||||
|
|
@ -71,11 +71,11 @@ def classify0(inX, dataSet, labels, k):
|
|||
"""
|
||||
diffMat = tile(inX, (dataSetSize, 1)) - dataSet
|
||||
"""
|
||||
欧氏距离： 点到点之间的距离
|
||||
第一行： 同一个点 到 dataSet 的第一个点的距离。
|
||||
第二行： 同一个点 到 dataSet 的第二个点的距离。
|
||||
欧氏距离: 点到点之间的距离
|
||||
第一行: 同一个点 到 dataSet 的第一个点的距离。
|
||||
第二行: 同一个点 到 dataSet 的第二个点的距离。
|
||||
...
|
||||
第N行： 同一个点 到 dataSet 的第N个点的距离。
|
||||
第N行: 同一个点 到 dataSet 的第N个点的距离。
|
||||
|
||||
[[1,2,3],[1,2,3]]-[[1,2,3],[1,2,0]]
|
||||
(A1-A2)^2+(B1-B2)^2+(c1-c2)^2
|
||||
|
|
@ -88,7 +88,7 @@ def classify0(inX, dataSet, labels, k):
|
|||
distances = sqDistances ** 0.5
|
||||
# 根据距离排序从小到大的排序，返回对应的索引位置
|
||||
# argsort() 是将x中的元素从小到大排列，提取其对应的index（索引），然后输出到y。
|
||||
# 例如：y=array([3,0,2,1,4,5]) 则，x[3]=1最小，所以y[0]=3;x[5]=5最大，所以y[5]=5。
|
||||
# 例如: y=array([3,0,2,1,4,5]) 则，x[3]=1最小，所以y[0]=3;x[5]=5最大，所以y[5]=5。
|
||||
# print 'distances=', distances
|
||||
sortedDistIndicies = distances.argsort()
|
||||
# print 'distances.argsort()=', sortedDistIndicies
|
||||
|
|
@ -100,16 +100,16 @@ def classify0(inX, dataSet, labels, k):
|
|||
voteIlabel = labels[sortedDistIndicies[i]]
|
||||
# 在字典中将该类型加一
|
||||
# 字典的get方法
|
||||
# 如：list.get(k,d) 其中 get相当于一条if...else...语句,参数k在字典中，字典将返回list[k];如果参数k不在字典中则返回参数d,如果K在字典中则返回k对应的value值
|
||||
# 如: list.get(k,d) 其中 get相当于一条if...else...语句,参数k在字典中，字典将返回list[k];如果参数k不在字典中则返回参数d,如果K在字典中则返回k对应的value值
|
||||
# l = {5:2,3:4}
|
||||
# print l.get(3,0)返回的值是4；
|
||||
# Print l.get（1,0）返回值是0；
|
||||
classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1
|
||||
# 3. 排序并返回出现最多的那个类型
|
||||
# 字典的 items() 方法，以列表返回可遍历的(键，值)元组数组。
|
||||
# 例如：dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.items() Value : [('Age', 7), ('Name', 'Zara')]
|
||||
# 例如: dict = {'Name': 'Zara', 'Age': 7} print "Value : %s" % dict.items() Value : [('Age', 7), ('Name', 'Zara')]
|
||||
# sorted 中的第2个参数 key=operator.itemgetter(1) 这个参数的意思是先比较第几个元素
|
||||
# 例如：a=[('b',2),('a',1),('c',0)] b=sorted(a,key=operator.itemgetter(1)) >>>b=[('c',0),('a',1),('b',2)] 可以看到排序是按照后边的0,1,2进行排序的，而不是a,b,c
|
||||
# 例如: a=[('b',2),('a',1),('c',0)] b=sorted(a,key=operator.itemgetter(1)) >>>b=[('c',0),('a',1),('b',2)] 可以看到排序是按照后边的0,1,2进行排序的，而不是a,b,c
|
||||
# b=sorted(a,key=operator.itemgetter(0)) >>>b=[('a',1),('b',2),('c',0)] 这次比较的是前边的a,b,c而不是0,1,2
|
||||
# b=sorted(a,key=opertator.itemgetter(1,0)) >>>b=[('c',0),('a',1),('b',2)] 这个是先比较第2个元素，然后对第一个元素进行排序，形成多级排序。
|
||||
sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
|
||||
|
|
@ -121,11 +121,11 @@ def classify0(inX, dataSet, labels, k):
|
|||
# """
|
||||
# 1. 计算距离
|
||||
|
||||
# 欧氏距离： 点到点之间的距离
|
||||
# 第一行： 同一个点 到 dataSet的第一个点的距离。
|
||||
# 第二行： 同一个点 到 dataSet的第二个点的距离。
|
||||
# 欧氏距离: 点到点之间的距离
|
||||
# 第一行: 同一个点 到 dataSet的第一个点的距离。
|
||||
# 第二行: 同一个点 到 dataSet的第二个点的距离。
|
||||
# ...
|
||||
# 第N行： 同一个点 到 dataSet的第N个点的距离。
|
||||
# 第N行: 同一个点 到 dataSet的第N个点的距离。
|
||||
|
||||
# [[1,2,3],[1,2,3]]-[[1,2,3],[1,2,0]]
|
||||
# (A1-A2)^2+(B1-B2)^2+(c1-c2)^2
|
||||
|
|
@ -175,7 +175,7 @@ def file2matrix(filename):
|
|||
# 获得文件中的数据行的行数
|
||||
numberOfLines = len(fr.readlines())
|
||||
# 生成对应的空矩阵
|
||||
# 例如：zeros(2，3)就是生成一个 2*3 的矩阵，各个位置上全是 0
|
||||
# 例如: zeros(2，3)就是生成一个 2*3 的矩阵，各个位置上全是 0
|
||||
returnMat = zeros((numberOfLines, 3)) # prepare matrix to return
|
||||
classLabelVector = [] # prepare labels return
|
||||
fr = open(filename, 'r')
|
||||
|
|
@ -196,16 +196,16 @@ def file2matrix(filename):
|
|||
|
||||
def autoNorm(dataSet):
|
||||
"""
|
||||
Desc：
|
||||
Desc:
|
||||
归一化特征值，消除属性之间量级不同导致的影响
|
||||
Args：
|
||||
Args:
|
||||
dataSet -- 需要进行归一化处理的数据集
|
||||
Returns：
|
||||
Returns:
|
||||
normDataSet -- 归一化处理后得到的数据集
|
||||
ranges -- 归一化处理的范围
|
||||
minVals -- 最小值
|
||||
|
||||
归一化公式：
|
||||
归一化公式:
|
||||
Y = (X-Xmin)/(Xmax-Xmin)
|
||||
其中的 min 和 max 分别是数据集中的最小特征值和最大特征值。该函数可以自动将数字特征值转化为0到1的区间。
|
||||
"""
|
||||
|
|
@ -231,11 +231,11 @@ def autoNorm(dataSet):
|
|||
|
||||
def datingClassTest():
|
||||
"""
|
||||
Desc：
|
||||
Desc:
|
||||
对约会网站的测试方法，并将分类错误的数量和分类错误率打印出来
|
||||
Args：
|
||||
Args:
|
||||
None
|
||||
Returns：
|
||||
Returns:
|
||||
None
|
||||
"""
|
||||
# 设置测试数据的的一个比例（训练数据集比例=1-hoRatio）
|
||||
|
|
@ -261,14 +261,14 @@ def datingClassTest():
|
|||
|
||||
def img2vector(filename):
|
||||
"""
|
||||
Desc：
|
||||
Desc:
|
||||
将图像数据转换为向量
|
||||
Args：
|
||||
Args:
|
||||
filename -- 图片文件 因为我们的输入数据的图片格式是 32 * 32的
|
||||
Returns:
|
||||
returnVect -- 图片文件处理完成后的一维矩阵
|
||||
|
||||
该函数将图像转换为向量：该函数创建 1 * 1024 的NumPy数组，然后打开给定的文件，
|
||||
该函数将图像转换为向量: 该函数创建 1 * 1024 的NumPy数组，然后打开给定的文件，
|
||||
循环读出文件的前32行，并将每行的头32个字符值存储在NumPy数组中，最后返回数组。
|
||||
"""
|
||||
returnVect = zeros((1, 1024))
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-28
|
||||
Updated on 2017-06-28
|
||||
KNN：k近邻算法
|
||||
KNN: k近邻算法
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#!/usr/bin/python
|
||||
# -*- coding: UTF-8 -*-
|
||||
# 原始链接： http://blog.csdn.net/lsldd/article/details/41223147
|
||||
# 原始链接: http://blog.csdn.net/lsldd/article/details/41223147
|
||||
# GitHub: https://github.com/apachecn/AiLearning
|
||||
import numpy as np
|
||||
from sklearn import tree
|
||||
|
|
@ -15,7 +15,7 @@ def createDataSet():
|
|||
labels = []
|
||||
with open("data/3.DecisionTree/data.txt") as ifile:
|
||||
for line in ifile:
|
||||
# 特征： 身高 体重 label： 胖瘦
|
||||
# 特征: 身高 体重 label: 胖瘦
|
||||
tokens = line.strip().split(' ')
|
||||
data.append([float(tk) for tk in tokens[:-1]])
|
||||
labels.append(tokens[-1])
|
||||
|
|
@ -35,7 +35,7 @@ def createDataSet():
|
|||
def predict_train(x_train, y_train):
|
||||
'''
|
||||
使用信息熵作为划分标准，对决策树进行训练
|
||||
参考链接： http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier
|
||||
参考链接: http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier
|
||||
'''
|
||||
clf = tree.DecisionTreeClassifier(criterion='entropy')
|
||||
# print(clf)
|
||||
|
|
@ -55,7 +55,7 @@ def predict_train(x_train, y_train):
|
|||
def show_precision_recall(x, y, clf, y_train, y_pre):
|
||||
'''
|
||||
准确率与召回率
|
||||
参考链接： http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve
|
||||
参考链接: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_curve.html#sklearn.metrics.precision_recall_curve
|
||||
'''
|
||||
precision, recall, thresholds = precision_recall_curve(y_train, y_pre)
|
||||
# 计算全量的预估结果
|
||||
|
|
@ -67,7 +67,7 @@ def show_precision_recall(x, y, clf, y_train, y_pre):
|
|||
recall 召回率
|
||||
f1-score 准确率和召回率的一个综合得分
|
||||
support 参与比较的数量
|
||||
参考链接：http://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report
|
||||
参考链接: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html#sklearn.metrics.classification_report
|
||||
'''
|
||||
# target_names 以 y的label分类为准
|
||||
target_names = ['thin', 'fat']
|
||||
|
|
@ -81,9 +81,9 @@ def show_pdf(clf):
|
|||
可视化输出
|
||||
把决策树结构写入文件: http://sklearn.lzjqsdd.com/modules/tree.html
|
||||
|
||||
Mac报错：pydotplus.graphviz.InvocationException: GraphViz's executables not found
|
||||
解决方案：sudo brew install graphviz
|
||||
参考写入： http://www.jianshu.com/p/59b510bafb4d
|
||||
Mac报错: pydotplus.graphviz.InvocationException: GraphViz's executables not found
|
||||
解决方案: sudo brew install graphviz
|
||||
参考写入: http://www.jianshu.com/p/59b510bafb4d
|
||||
'''
|
||||
# with open("testResult/tree.dot", 'w') as f:
|
||||
# from sklearn.externals.six import StringIO
|
||||
|
|
@ -105,7 +105,7 @@ if __name__ == '__main__':
|
|||
|
||||
''' 拆分训练数据与测试数据， 80%做训练 20%做测试 '''
|
||||
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
|
||||
print('拆分数据：', x_train, x_test, y_train, y_test)
|
||||
print('拆分数据: ', x_train, x_test, y_train, y_test)
|
||||
|
||||
# 得到训练的预测结果集
|
||||
y_pre, clf = predict_train(x_train, y_train)
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ def createDataSet():
|
|||
# ['no'],
|
||||
# ['no'],
|
||||
# ['no']]
|
||||
# labels 露出水面 脚蹼，注意：这里的labels是写的 dataSet 中特征的含义，并不是对应的分类标签或者说目标变量
|
||||
# labels 露出水面 脚蹼，注意: 这里的labels是写的 dataSet 中特征的含义，并不是对应的分类标签或者说目标变量
|
||||
labels = ['no surfacing', 'flippers']
|
||||
# 返回
|
||||
return dataSet, labels
|
||||
|
|
@ -43,7 +43,7 @@ def createDataSet():
|
|||
|
||||
def calcShannonEnt(dataSet):
|
||||
"""
|
||||
Desc：
|
||||
Desc:
|
||||
calculate Shannon entropy -- 计算给定数据集的香农熵
|
||||
Args:
|
||||
dataSet -- 数据集
|
||||
|
|
@ -54,7 +54,7 @@ def calcShannonEnt(dataSet):
|
|||
# 求list的长度，表示计算参与训练的数据量
|
||||
numEntries = len(dataSet)
|
||||
# 下面输出我们测试的数据集的一些信息
|
||||
# 例如：<type 'list'> numEntries: 5 是下面的代码的输出
|
||||
# 例如: <type 'list'> numEntries: 5 是下面的代码的输出
|
||||
# print(type(dataSet), 'numEntries: ', numEntries)
|
||||
|
||||
# 计算分类标签label出现的次数
|
||||
|
|
@ -93,7 +93,7 @@ def calcShannonEnt(dataSet):
|
|||
|
||||
def splitDataSet(dataSet, index, value):
|
||||
"""
|
||||
Desc：
|
||||
Desc:
|
||||
划分数据集
|
||||
splitDataSet(通过遍历dataSet数据集，求出index对应的colnum列的值为value的行)
|
||||
就是依据index列进行分类，如果index列的数据等于 value的时候，就要将 index 划分到我们创建的新的数据集中
|
||||
|
|
@ -114,7 +114,7 @@ def splitDataSet(dataSet, index, value):
|
|||
# [:index]表示前index行，即若 index 为2，就是取 featVec 的前 index 行
|
||||
reducedFeatVec = featVec[:index]
|
||||
'''
|
||||
请百度查询一下： extend和append的区别
|
||||
请百度查询一下: extend和append的区别
|
||||
list.append(object) 向列表中添加一个对象object
|
||||
list.extend(sequence) 把一个序列seq的内容添加到列表中
|
||||
1、使用append的时候，是将new_media看作一个对象，整体打包添加到music_media对象中。
|
||||
|
|
@ -126,7 +126,7 @@ def splitDataSet(dataSet, index, value):
|
|||
print(result)
|
||||
result.extend([7,8,9])
|
||||
print(result)
|
||||
结果：
|
||||
结果:
|
||||
[1, 2, 3]
|
||||
[1, 2, 3, [4, 5, 6]]
|
||||
[1, 2, 3, [4, 5, 6], 7, 8, 9]
|
||||
|
|
@ -247,12 +247,12 @@ def createTree(dataSet, labels):
|
|||
"""
|
||||
classList = [example[-1] for example in dataSet]
|
||||
# 如果数据集的最后一列的第一个值出现的次数=整个集合的数量，也就说只有一个类别，就只直接返回结果就行
|
||||
# 第一个停止条件：所有的类标签完全相同，则直接返回该类标签。
|
||||
# 第一个停止条件: 所有的类标签完全相同，则直接返回该类标签。
|
||||
# count() 函数是统计括号中的值在list中出现的次数
|
||||
if classList.count(classList[0]) == len(classList):
|
||||
return classList[0]
|
||||
# 如果数据集只有1列，那么最初出现label次数最多的一类，作为结果
|
||||
# 第二个停止条件：使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
|
||||
# 第二个停止条件: 使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组。
|
||||
if len(dataSet[0]) == 1:
|
||||
return majorityCnt(classList)
|
||||
|
||||
|
|
@ -262,7 +262,7 @@ def createTree(dataSet, labels):
|
|||
bestFeatLabel = labels[bestFeat]
|
||||
# 初始化myTree
|
||||
myTree = {bestFeatLabel: {}}
|
||||
# 注：labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
|
||||
# 注: labels列表是可变对象，在PYTHON函数中作为参数时传址引用，能够被全局修改
|
||||
# 所以这行代码导致函数外的同名变量被删除了元素，造成例句无法执行，提示'no surfacing' is not in list
|
||||
del(labels[bestFeat])
|
||||
# 取出最优列，然后它的branch做分类
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-29
|
||||
Updated on 2017-06-29
|
||||
DecisionTree：决策树
|
||||
DecisionTree: 决策树
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
"""
|
||||
Created on 2017-06-29
|
||||
Updated on 2017-06-29
|
||||
DecisionTree：决策树
|
||||
DecisionTree: 决策树
|
||||
Author: 小瑶
|
||||
GitHub: https://github.com/apachecn/AiLearning
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -148,10 +148,10 @@ def train_naive_bayes(train_mat, train_category):
|
|||
|
||||
def classify_naive_bayes(vec2classify, p0vec, p1vec, p_class1):
|
||||
"""
|
||||
使用算法：
|
||||
使用算法:
|
||||
# 将乘法转换为加法
|
||||
乘法：P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法：P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
乘法: P(C|F1F2...Fn) = P(F1F2...Fn|C)P(C)/P(F1F2...Fn)
|
||||
加法: P(F1|C)*P(F2|C)....P(Fn|C)P(C) -> log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
:param vec2classify: 待测数据[0,1,1,1,1...]，即要分类的向量
|
||||
:param p0vec: 类别0，即正常文档的[log(P(F1|C0)),log(P(F2|C0)),log(P(F3|C0)),log(P(F4|C0)),log(P(F5|C0))....]列表
|
||||
:param p1vec: 类别1，即侮辱性文档的[log(P(F1|C1)),log(P(F2|C1)),log(P(F3|C1)),log(P(F4|C1)),log(P(F5|C1))....]列表
|
||||
|
|
@ -160,7 +160,7 @@ def classify_naive_bayes(vec2classify, p0vec, p1vec, p_class1):
|
|||
"""
|
||||
# 计算公式 log(P(F1|C))+log(P(F2|C))+....+log(P(Fn|C))+log(P(C))
|
||||
# 使用 NumPy 数组来计算两个向量相乘的结果，这里的相乘是指对应元素相乘，即先将两个向量中的第一个元素相乘，然后将第2个元素相乘，以此类推。
|
||||
# 我的理解是：这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
# 我的理解是: 这里的 vec2Classify * p1Vec 的意思就是将每个词与其对应的概率相关联起来
|
||||
# 可以理解为 1.单词在词汇表中的条件下，文件是good 类别的概率 也可以理解为 2.在整个空间下，文件既在词汇表中又是good类别的概率
|
||||
p1 = np.sum(vec2classify * p1vec) + np.log(p_class1)
|
||||
p0 = np.sum(vec2classify * p0vec) + np.log(1 - p_class1)
|
||||
|
|
@ -243,8 +243,8 @@ def spam_test():
|
|||
# 这里其实还可以 :
|
||||
# import os
|
||||
# 然后检查 os.system(' file {}.txt'.format(i))，看一下返回的是什么
|
||||
# 如果正常能读返回的都是： ASCII text
|
||||
# 对于except需要处理的都是返回： Non-ISO extended-ASCII text, with very long lines
|
||||
# 如果正常能读返回的都是: ASCII text
|
||||
# 对于except需要处理的都是返回: Non-ISO extended-ASCII text, with very long lines
|
||||
try:
|
||||
words = text_parse(open('data/4.NaiveBayes/email/spam/{}.txt'.format(i)).read())
|
||||
except:
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue