├── Articles
├── README
├── 机器学习001-数据预处理技术.md
├── 机器学习002-标记编码方法.md
├── 机器学习003-简单线性回归器.md
├── 机器学习004-岭回归器.md
├── 机器学习005-多项式回归器.md
├── 机器学习006-用决策树回归器构建房价评估模型.md
├── 机器学习007-用随机森林构建共享单车需求预测模型.md
├── 机器学习008-简单线性分类器解决二分类问题.md
├── 机器学习009-用逻辑回归分类器解决多分类问题.md
├── 机器学习010-用朴素贝叶斯分类器解决多分类问题.md
├── 机器学习011-分类模型的评估-精确率，召回率，F值.md
├── 机器学习012-用随机森林构建汽车评估模型及模型的优化提升方法.md
├── 机器学习013-用朴素贝叶斯分类器估算个人收入阶层.md
├── 机器学习014-用SVM构建非线性分类模型.md
├── 机器学习015-如何处理样本数差别较大的数据集.md
├── 机器学习016-如何知道SVM模型输出类别的置信度.md
├── 机器学习017-使用GridSearch搜索最佳参数组合.md
├── 机器学习018-根据大楼进出人数预测是否举办活动.md
├── 机器学习019-使用SVM回归器估算交通流量.md
├── 机器学习020-使用K-means算法对数据进行聚类分析.md
├── 机器学习021-使用K-means进行图片的矢量量化.md
├── 机器学习022-使用均值漂移聚类算法构建模型.md
├── 机器学习023-使用凝聚层次聚类算法构建模型.md
├── 机器学习024-无监督学习模型的性能评估.md
├── 机器学习025-自动估算集群数量-DBSCAN.md
├── 机器学习026-股票数据聚类分析-近邻传播算法.md
├── 机器学习027-建立客户细分聚类模型.md
├── 机器学习028-五分钟教你打造机器学习流水线.md
├── 机器学习029-找到离你最近的邻居.md
├── 机器学习030-KNN分类器模型的构建.md
├── 机器学习031-KNN回归器模型的构建.md
├── 机器学习032-数据点之间相似度的计算.md
├── 机器学习033-构建电影推荐系统.md
├── 机器学习034-NLP对文本进行分词.md
├── 机器学习035-NLP词干提取.md
├── 机器学习036-NLP词形还原.md
├── 机器学习037-NLP文本分块.md
├── 机器学习038-NLP创建词袋模型.md
├── 机器学习039-NLP文本分类器.md
├── 机器学习040-NLP性别判断分类器.md
├── 机器学习041-NLP句子情感分析.md
├── 机器学习042-NLP文本的主题建模.md
├── 机器学习043-pandas操作时间序列数据.md
├── 机器学习044-创建隐马尔科夫模型.md
├── 机器学习045-对股票数据进行隐马尔科夫建模.md
├── 机器学习046-图像中线条的检测方法.md
├── 机器学习047-图像的直方图均衡化操作.md
├── 机器学习048-Harris检测图像角点.md
├── 机器学习049-提取图像的SIFT特征点.md
├── 机器学习050-提取图像的Star特征.md
├── 机器学习051-视觉词袋模型+极端随机森林建立图像分类器.md
├── 机器学习052-OpenCV构建人脸鼻子眼睛检测器.md
├── 机器学习053-数据降维绝招-PCA和核PCA.md
├── 机器学习054-用ICA做盲源分离.md
└── 机器学习055-使用LBP直方图建立人脸识别器.md
├── DatSets
├── FireAI_051_Fig2.PNG
├── box.png
├── cascade_files
│ ├── haarcascade_eye.xml
│ ├── haarcascade_frontalface_alt.xml
│ └── haarcascade_mcs_nose.xml
├── chair.jpg
├── data_hmm.txt
├── data_multivar.txt
├── data_multivar_2_class.txt
├── data_multivar_imbalance.txt
├── data_nn_classifier.txt
├── data_perf.txt
├── data_single_layer.txt
├── data_timeseries.txt
├── data_topic_modeling.txt
├── face1.jpg
├── face2.jpg
├── face3.jpg
├── faces.tar
├── faces_dataset
│ ├── .DS_Store
│ ├── test
│ │ ├── .DS_Store
│ │ ├── image_0019.jpg
│ │ ├── image_0020.jpg
│ │ ├── image_0021.jpg
│ │ ├── image_0039.jpg
│ │ ├── image_0040.jpg
│ │ ├── image_0041.jpg
│ │ ├── image_0087.jpg
│ │ ├── image_0088.jpg
│ │ ├── image_0089.jpg
│ │ └── timg.jpg
│ └── train
│ │ ├── person1
│ │ ├── .DS_Store
│ │ ├── image_0001.jpg
│ │ ├── image_0002.jpg
│ │ ├── image_0003.jpg
│ │ ├── image_0004.jpg
│ │ ├── image_0005.jpg
│ │ ├── image_0006.jpg
│ │ ├── image_0007.jpg
│ │ ├── image_0008.jpg
│ │ ├── image_0009.jpg
│ │ ├── image_0010.jpg
│ │ ├── image_0011.jpg
│ │ ├── image_0012.jpg
│ │ ├── image_0013.jpg
│ │ ├── image_0014.jpg
│ │ ├── image_0015.jpg
│ │ ├── image_0016.jpg
│ │ ├── image_0017.jpg
│ │ └── image_0018.jpg
│ │ ├── person2
│ │ ├── .DS_Store
│ │ ├── image_0022.jpg
│ │ ├── image_0023.jpg
│ │ ├── image_0024.jpg
│ │ ├── image_0025.jpg
│ │ ├── image_0026.jpg
│ │ ├── image_0027.jpg
│ │ ├── image_0028.jpg
│ │ ├── image_0029.jpg
│ │ ├── image_0030.jpg
│ │ ├── image_0031.jpg
│ │ ├── image_0032.jpg
│ │ ├── image_0033.jpg
│ │ ├── image_0034.jpg
│ │ ├── image_0035.jpg
│ │ ├── image_0036.jpg
│ │ ├── image_0037.jpg
│ │ └── image_0038.jpg
│ │ └── person3
│ │ ├── .DS_Store
│ │ ├── image_0069.jpg
│ │ ├── image_0070.jpg
│ │ ├── image_0071.jpg
│ │ ├── image_0072.jpg
│ │ ├── image_0073.jpg
│ │ ├── image_0074.jpg
│ │ ├── image_0075.jpg
│ │ ├── image_0076.jpg
│ │ ├── image_0077.jpg
│ │ ├── image_0078.jpg
│ │ ├── image_0079.jpg
│ │ ├── image_0080.jpg
│ │ ├── image_0081.jpg
│ │ ├── image_0082.jpg
│ │ ├── image_0083.jpg
│ │ ├── image_0084.jpg
│ │ ├── image_0085.jpg
│ │ └── image_0086.jpg
├── mixture_of_signals.txt
├── movie_ratings.json
├── sunrise.jpg
├── symbol_map.json
├── table.jpg
├── test0.jpg
├── test1.jpg
├── test2.jpg
└── training_images
│ ├── .DS_Store
│ ├── 0-airplanes
│ ├── .DS_Store
│ ├── 0001.jpg
│ ├── 0002.jpg
│ ├── 0003.jpg
│ ├── 0004.jpg
│ ├── 0005.jpg
│ ├── 0006.jpg
│ ├── 0007.jpg
│ ├── 0008.jpg
│ ├── 0009.jpg
│ ├── 0010.jpg
│ ├── 0011.jpg
│ ├── 0012.jpg
│ ├── 0013.jpg
│ ├── 0014.jpg
│ ├── 0015.jpg
│ ├── 0016.jpg
│ ├── 0017.jpg
│ ├── 0018.jpg
│ ├── 0019.jpg
│ └── 0020.jpg
│ ├── 1-cars
│ ├── .DS_Store
│ ├── image_0001.jpg
│ ├── image_0101.jpg
│ ├── image_0122.jpg
│ ├── image_0134.jpg
│ ├── image_0139.jpg
│ ├── image_0150.jpg
│ ├── image_0161.jpg
│ ├── image_0178.jpg
│ ├── image_0211.jpg
│ ├── image_0253.jpg
│ ├── image_0284.jpg
│ ├── image_0289.jpg
│ ├── image_0294.jpg
│ ├── image_0356.jpg
│ ├── image_0379.jpg
│ ├── image_0445.jpg
│ ├── image_0467.jpg
│ ├── image_0503.jpg
│ ├── image_0508.jpg
│ └── image_0526.jpg
│ └── 2-motorbikes
│ ├── .DS_Store
│ ├── 0001.jpg
│ ├── 0002.jpg
│ ├── 0003.jpg
│ ├── 0004.jpg
│ ├── 0005.jpg
│ ├── 0006.jpg
│ ├── 0007.jpg
│ ├── 0008.jpg
│ ├── 0009.jpg
│ ├── 0010.jpg
│ ├── 0011.jpg
│ ├── 0012.jpg
│ ├── 0013.jpg
│ ├── 0014.jpg
│ ├── 0015.jpg
│ ├── 0016.jpg
│ ├── 0017.jpg
│ ├── 0018.jpg
│ ├── 0019.jpg
│ └── 0020.jpg
├── FireAI_001_FeaturePreprocess.ipynb
├── FireAI_002_LabelEncode.ipynb
├── FireAI_003_LinearRegressor.ipynb
├── FireAI_004_RidgeRegressor.ipynb
├── FireAI_005_PolynomialRegressor.ipynb
├── FireAI_006_BostonHouse.ipynb
├── FireAI_007_SharingBikes.ipynb
├── FireAI_008_SimpleClassifier.ipynb
├── FireAI_009_LogisticRegression.ipynb
├── FireAI_010_NaiveBayersClassifiers.ipynb
├── FireAI_011_ClassifierEvaluation.ipynb
├── FireAI_012_CarEvaluation.ipynb
├── FireAI_013_ClassifyIncome.ipynb
├── FireAI_014_SVMLinearClassifier.ipynb
├── FireAI_015_UnbalancedDataset.ipynb
├── FireAI_016_OutputClassConfidence.ipynb
├── FireAI_017_GridSearchParamOptimization.ipynb
├── FireAI_018_BuildingEvents.ipynb
├── FireAI_019_DodgersTrafficPredict.ipynb
├── FireAI_020_KMeansClustering.ipynb
├── FireAI_021_ImageVectorQuantization.ipynb
├── FireAI_022_MeanShiftAlgorithm.ipynb
├── FireAI_023_HierarchicalClustering.ipynb
├── FireAI_024_ModelEstimation.ipynb
├── FireAI_025_DBSCANAlgorithm.ipynb
├── FireAI_026_AffinityProp.ipynb
├── FireAI_027_Customers.ipynb
├── FireAI_028_SkLearnPipeline.ipynb
├── FireAI_029_FindNearestNeighbors.ipynb
├── FireAI_030_KNNClassifier.ipynb
├── FireAI_031_KNNRegressor.ipynb
├── FireAI_032_SimilarityCalculation.ipynb
├── FireAI_033_MovieReccomendation.ipynb
├── FireAI_034_tokenization.ipynb
├── FireAI_035_GetStems.ipynb
├── FireAI_036_Lemmatisation.ipynb
├── FireAI_037_TextChunking.ipynb
├── FireAI_038_BagOfWords.ipynb
├── FireAI_039_TextClassifier.ipynb
├── FireAI_040_GenderClassify.ipynb
├── FireAI_041_SentimentAnalysis.ipynb
├── FireAI_042_ThemeModelling.ipynb
├── FireAI_043_PandasTimeseries.ipynb
├── FireAI_044_HMMs.ipynb
├── FireAI_045_HMM_Stocks.ipynb
├── FireAI_046_ImgeEdgeDetect.ipynb
├── FireAI_047_HistEqualize.ipynb
├── FireAI_048_HarrisCorner.ipynb
├── FireAI_049_SIFTFeatures.ipynb
├── FireAI_050_StarFeatures.ipynb
├── FireAI_051_ObjectDetector.ipynb
├── FireAI_052_FaceNoseEyeDetector.ipynb
├── FireAI_053_PCA.ipynb
├── FireAI_054_ICA.ipynb
├── FireAI_055_FaceRecognizer.ipynb
└── README.md
/Articles/README:
--------------------------------------------------------------------------------
1 | ##【火炉炼AI】之机器学习系列文章
2 |
3 |
--------------------------------------------------------------------------------
/Articles/机器学习002-标记编码方法.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习002-标记编码方法
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 监督学习中的标记的形式有各种各样，比如对于人脸识别的标记，可能是[“小红”，“小花”，“翠花”。。。]，这些标记对于机器学习来说，如同天书一般，故而为了让机器学习“看懂”这些标记，需要将这些文本类的标记进行一定的编码，形成比如【3,2,4,0，…】等形式.
7 |
8 |
9 |
10 | ## 1. 编码方法
11 |
12 | 有很多python模块可以实现对标记进行编码，此处使用scikit-learn模块中的preprocessing包来进行编码。Talk is cheap, just show me the code….
13 |
14 | ```Python
15 | # *****************对label进行编码********************************
16 | from sklearn import preprocessing
17 |
18 | # 构建编码器
19 | encoder=preprocessing.LabelEncoder() # 先定义一个编码器对象
20 | raw_labels=['翠花','张三','王宝强','芙蓉姐姐','凤姐','王宝强','凤姐']
21 | encoder.fit(raw_labels) # 返回自己的一个实例
22 | print('编码器列表：{}'.format(encoder.classes_)) # 返回编码器中所有类别，已经排除了重复项
23 | for index,item in enumerate(encoder.classes_):
24 | print('{} --> {}'.format(item,index))
25 |
26 | # 使用编码器来编码新样本数据
27 | need_encode_labels=['王宝强','芙蓉姐姐','翠花']
28 | # need_encode_labels=['王宝强','芙蓉姐姐','翠花','无名氏']
29 | # '无名氏'不存在编码器列表中，会报错
30 | encoded_labels=encoder.transform(need_encode_labels)
31 | print('\n编码之前的标记：{}'.format(need_encode_labels))
32 | print('编码之后的标记：{}'.format(encoded_labels))
33 |
34 | # 使用编码器将编码数字解码成原来的文本标记，注意最大值不能超过编码器中的长度
35 | encoded=[1,3,0,4]
36 | # encoded=[1,3,0,4,5] # 5不存在与编码器中，故报错
37 | decoded_labels=encoder.inverse_transform(encoded)
38 | print('\n已经编码的标记代码：{}'.format(encoded))
39 | print('解码后的标记：{}'.format(decoded_labels))
40 | ```
41 |
42 | **-------------------------------------输---------出--------------------------------**
43 |
44 | 编码器列表：['凤姐' '张三' '王宝强' '翠花' '芙蓉姐姐']
45 | 凤姐 --> 0
46 | 张三 --> 1
47 | 王宝强 --> 2
48 | 翠花 --> 3
49 | 芙蓉姐姐 --> 4
50 |
51 | 编码之前的标记：['王宝强', '芙蓉姐姐', '翠花']
52 | 编码之后的标记：[2 4 3]
53 |
54 | 已经编码的标记代码：[1, 3, 0, 4]
55 | 解码后的标记：['张三' '翠花' '凤姐' '芙蓉姐姐']
56 |
57 | **--------------------------------------------完-------------------------------------**
58 |
59 |
60 |
61 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
62 |
63 | **1，使用sklearn的preprocessing模块对标记进行编码是非常简单的，首先构建一个基于所有标记数据的编码器，然后使用该编码器进行编码或解码**
64 |
65 | **2，需要注意，在编码时，如果遇到编码器中没有的标记时会报错，在解码时也一样。**
66 |
67 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
68 |
69 |
70 |
71 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
72 |
73 |
74 |
75 | 参考资料:
76 |
77 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习007-用随机森林构建共享单车需求预测模型.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习007-用随机森林构建共享单车需求预测模型
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 共享单车是最近几年才发展起来的一种便民交通工具，基本上是我等屌丝上班，下班，相亲，泡妞必备神器。本项目拟使用随机森林回归器构建共享单车需求预测模型，从而查看各种不同的条件下，共享单车的需求量。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | 本次使用的数据集来源于加利福尼亚大学欧文分校（UCI）大学的公开数据集：https://archive.ics.uci.edu/ml/datasets/Bike+Sharing+Dataset，关于本次数据集的各种信息可以参考该网站，同时也可以直接从该网站下载和使用数据集。本次共享单车数据集包含有两个文件，一个是按天来统计的共享单车使用量数据，另一个是按照小时数来统计的使用量。
13 |
14 | 说句题外话，这个共享单车数据集是在2011年至2012年间收集的，此处的共享单车是采用固定桩形式的单车，类似于中国的永安行，并不是我们目前所看到的满大街的小黄车，小蓝车，摩拜之类。
15 |
16 | 下载后，将数据集解压到D:\PyProjects\DataSet\SharingBikes中。本数据集总共有17389个样本，每个样本有16列，其中，前两列是样本序号和日期，可以不用考虑，最后三列数据是不同类型的输出结果，最后一列是第十四列和第十五列的和，因此本模型中不考虑第十四列和第十五列。
17 |
18 | 
19 |
20 | 本数据集16列对应的信息分别为：
21 |
22 | 
23 |
24 | 如下为分析数据集的主要代码，此处我没有深入研究数据集各个特征列之间的关系。
25 |
26 |
27 | ```Python
28 | # 首先分析数据集
29 | dataset_path='D:\PyProjects\DataSet\SharingBikes/day.csv' # 首先只分析day 数据
30 | # 首先加载数据集
31 | raw_df=pd.read_csv(dataset_path,index_col=0)
32 | # print(raw_df.shape) # (731, 15)
33 | # print(raw_df.head()) # 查看是否正确加载
34 | # print(raw_df.columns)
35 | # 删除不需要的列，第1列，第12,13列
36 | df=raw_df.drop(['dteday','casual','registered'],axis=1)
37 | # print(df.shape) # (731, 12)
38 | # print(df.head()) # 查看没有问题
39 | print(df.info()) # 没有缺失值 第一列为object,需要进行转换
40 | # print(df.columns)
41 |
42 | # 分隔数据集
43 | dataset=df.as_matrix() # 将pandas转为np.ndarray
44 |
45 | # 将整个数据集分隔成train set和test set
46 | from sklearn.model_selection import train_test_split
47 | train_set,test_set=train_test_split(dataset,test_size=0.1,random_state=37)
48 | # print(train_set.shape) # (657, 12)
49 | # print(test_set.shape) # (74, 12)
50 | # print(dataset[:3])
51 | ```
52 |
53 | **-------------------------------------输---------出--------------------------------**
54 |
55 |
56 | Int64Index: 731 entries, 1 to 731
57 | Data columns (total 12 columns):
58 | season 731 non-null int64
59 | yr 731 non-null int64
60 | mnth 731 non-null int64
61 | holiday 731 non-null int64
62 | weekday 731 non-null int64
63 | workingday 731 non-null int64
64 | weathersit 731 non-null int64
65 | temp 731 non-null float64
66 | atemp 731 non-null float64
67 | hum 731 non-null float64
68 | windspeed 731 non-null float64
69 | cnt 731 non-null int64
70 | dtypes: float64(4), int64(8)
71 | memory usage: 74.2 KB
72 | None
73 |
74 | **--------------------------------------------完-------------------------------------**
75 |
76 |
77 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
78 |
79 | **1，从打印的结果可以看出，这个数据集中没有缺失值，且每一列的数据特征都是一致的，故而不需要再额外做这些处理。**
80 |
81 | **2，数据集中season， yr等有7列是int64类型，代表这些数据需要重新转换为独热编码格式，比如对于season中，1=春，2=夏，3=秋，4=冬，需要改成独热编码形成的稀疏矩阵。**
82 |
83 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
84 |
85 |
86 |
87 | ## 2. 构建随机森林回归模型
88 |
89 | 在第一次尝试时，我没有对原始数据进行任何的特征分析，也没有对数据集进行修改，直接使用随机森林回归模型进行拟合，看看结果怎么样。
90 |
91 | ```Python
92 | # 其次，构建随机森林回归器模型
93 | from sklearn.ensemble import RandomForestRegressor
94 | rf_regressor=RandomForestRegressor()
95 | # rf_regressor=RandomForestRegressor(n_estimators=1000,max_depth=10,min_samples_split=0.5)
96 |
97 | rf_regressor.fit(train_set[:,:-1],train_set[:,-1]) # 训练模型
98 |
99 | # 使用测试集来评价该回归模型
100 | predict_test_y=rf_regressor.predict(test_set[:,:-1])
101 |
102 | import sklearn.metrics as metrics
103 | print('随机森林回归模型的评测结果----->>>')
104 | print('均方误差MSE：{}'.format(
105 | round(metrics.mean_squared_error(predict_test_y,test_set[:,-1]),2)))
106 | print('解释方差分：{}'.format(
107 | round(metrics.explained_variance_score(predict_test_y,test_set[:,-1]),2)))
108 | print('R平方得分：{}'.format(
109 | round(metrics.r2_score(predict_test_y,test_set[:,-1]),2)))
110 | ```
111 |
112 | **-------------------------------------输---------出--------------------------------**
113 |
114 | 随机森林回归模型的评测结果----->>>
115 | 均方误差MSE：291769.31
116 | 解释方差分：0.92
117 | R平方得分：0.92
118 |
119 | **--------------------------------------------完-------------------------------------**
120 |
121 | 然后采用（[【火炉炼AI】机器学习006-用决策树回归器构建房价评估模型](链接)）的方式绘制相对重要性直方图，结果如下：
122 |
123 | 
124 |
125 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
126 |
127 | **1，在没有对数据集进行任何处理的情况下，采用默认的随机森林回归器得到的模型在测试集上的MSE非常大，解释方差分和R2都是0.93，表明模拟的还可以。**
128 |
129 | **2，从相对重要性图中可以看出，温度对共享单车的使用影响最大，这个可以理解，比如冬天太冷，夏天太热时，骑小黄车的人就显著减少。但图中显示年份（yr）是第二个重要因素，这个估计是因为年份只有2011和2012两年所致，要想得到更加可信的结果，还需要更多年份的数据。**
130 |
131 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
132 |
133 |
134 |
135 |
136 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
137 |
138 | 参考资料:
139 |
140 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习008-简单线性分类器解决二分类问题.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习008-简单线性分类器解决二分类问题
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 分类问题，就是将数据点按照不同的类别区分开来，所谓人以类聚，物以群分，就是这个道理。以前的【机器学习001-007】都是讲解的回归问题，两者的不同之处在于：回归输出的结果是实数，并且一般是连续的实数值，而分类问题的输出结果是离散的某一个类别或不同类别的概率。
7 |
8 | 最简单的分类问题是二元分类，将整个样本划分为两个类别，比如将整个人类分为男人和女人（泰国人妖不在考虑范围内，呵呵）。稍微复杂一点的分类问题是多元分类，它将整个样本划分为多个（一般大于两个）不同类别，比如将家禽数据集可以划分为：鸡，鸭，鹅等，将家畜样本划分为：狗，猪，牛，羊等等。
9 |
10 | 下面从一个最简单的二元分类问题入手，看看二元分类器是如何构建的。
11 |
12 |
13 |
14 |
15 | ## 1. 准备数据集
16 |
17 | 由于二元分类问题比较简单，此处我们自己构建了一些数据点，并将这些数据点按照不同类别放入不同变量中，比如把所有第0类别的数据点都放置到class_0中，把所有第1类别的数据点放入class_1中，如下所示。
18 |
19 | ```Python
20 | # 首先准备数据集
21 | # 特征向量
22 | X = np.array([[3,1], [2,5], [1,8], [6,4], [5,2], [3,5], [4,7], [4,-1]]) # 自定义的数据集
23 | # 标记
24 | y = [0, 1, 1, 0, 0, 1, 1, 0]
25 |
26 | # 由于标记中只含有两类，故而将特征向量按照标记分割成两部分
27 | class_0=np.array([feature for (feature,label) in zip(X,y) if label==0])
28 | print(class_0) # 确保没有问题
29 | class_1=np.array([feature for (feature,label) in zip(X,y) if label==1])
30 | print(class_1)
31 |
32 | # 划分也可以采用如下方法：两个打印后结果一样
33 | # class_0=np.array([X[i] for i in range(len(X)) if y[i]==0])
34 | # print(class_0)
35 | # class_1=np.array([X[i] for i in range(len(X)) if y[i]==1])
36 | # print(class_1)
37 | ```
38 |
39 | **-------------------------------------输---------出--------------------------------**
40 |
41 | [[ 3 1]
42 | [ 6 4]
43 | [ 5 2]
44 | [ 4 -1]]
45 | [[2 5]
46 | [1 8]
47 | [3 5]
48 | [4 7]]
49 |
50 | **--------------------------------------------完-------------------------------------**
51 |
52 | 上面虽然构建了数据点，但是难以直观的看清这个二分类问题的数据点有什么特点，所以为了有更加直观的认识，一般会把数据点的散点图画出来，如下所示：
53 |
54 | ```Python
55 | # 在图中画出这两个不同类别的数据集，方便观察不同类别数据的特点
56 | plt.figure()
57 | plt.scatter(class_0[:,0],class_0[:,1],marker='s',label='class_0')
58 | plt.scatter(class_1[:,0],class_1[:,1],marker='x',label='class_1')
59 | plt.legend()
60 | ```
61 |
62 | 
63 |
64 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
65 |
66 | **1，本次研究的二分类问题是极其简单的分类问题，故而构建了8个样本的两个类别的数据点，每个类别有四个点。**
67 |
68 | **2，为了更加直观的查看数据点的分布特点，一般我们要把数据点画在平面上，对数据点的分布情况有一个初步的了解，便于后面我们采用哪种分类器。**
69 |
70 | **3，本次构建的数据集是由8行2列构成的特征矩阵，即8个样本，每个样本有两个features.**
71 |
72 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
73 |
74 |
75 |
76 | ## 2. 构建简单线性分类器
77 |
78 | 所谓线性可分问题，是指在平面上可以通过一条直线（或更高维度上的，一个平面）来将所有数据点划分开来的问题，“可以用直线分开”是线性可分问题的本质。相对应的，“不可以用直线分开”便是线性不可分问题的本质，对于线性不可分问题，需要用曲线或曲面来将这些数据分开，对应的就是非线性问题。比如，上面自己定义的数据集可以用简单的直线划分开来，比如可以采用y=x这条直线分开，如下所示：
79 |
80 | ```Python
81 | # 从上面图中可以看出，可以画一条直线轻松的将class_0和class_1两个数据点分开
82 | # 其实有很多直线可以起到分类器的效果，此处我们只用最简单的y=x作为演示
83 | plt.figure()
84 | plt.scatter(class_0[:,0],class_0[:,1],marker='s',label='class_0')
85 | plt.scatter(class_1[:,0],class_1[:,1],marker='x',label='class_1')
86 | plt.plot(range(10),range(10),label='line_classifier') # 此处x=range(10), y=x
87 | plt.legend()
88 | ```
89 |
90 | 
91 |
92 | 实际上，可以采用非常多的直线来将本数据集的两个类别区分开来，如下图所示，这些直线是在斜率和截距上稍微调整而来。
93 |
94 | 
95 |
96 | 那么，这么多直线都可以解决简单分类问题，肯定会有一条最佳直线，能够达到最佳的分类效果。下面，使用sklearn模块中的SGD分类器构建最佳直线分类器。如下代码：
97 |
98 | ```Python
99 | # 上面虽然随机的选择了一条直线（y=x）作为分类器，但很多时候我们不知道分类
100 | # 下面构建一个SGD分类器，它使用随机梯度下降法来训练
101 | # 训练之前需要对数据进行标准化，保证每个维度的特征数据方差为1，均值为0，避免某个特征值过大而成为影响分类的主因
102 | from sklearn.preprocessing import StandardScaler
103 | ss=StandardScaler()
104 | X_train=ss.fit_transform(X) # 由于本项目数据集太少，故而全部用来train
105 |
106 | # 构建SGD分类器进行训练
107 | from sklearn.linear_model import SGDClassifier
108 | sgdClassifier=SGDClassifier(random_state=42)
109 | sgdClassifier.fit(X_train,y) # y作为label已经是0,1形式，不需进一步处理
110 |
111 | # 使用训练好的SGD分类器对陌生数据进行分类
112 | X_test=np.array([[3,2],[2,3],[2.5,2.4],[2.4,2.5],[5,8],[6.2,5.9]])
113 | X_test=ss.fit_transform(X_test) # test set也要记过同样的处理
114 | test_predicted=sgdClassifier.predict(X_test)
115 | print(test_predicted)
116 | ```
117 |
118 | **-------------------------------------输---------出--------------------------------**
119 |
120 | [0 1 1 1 1 0]
121 |
122 | **--------------------------------------------完-------------------------------------**
123 |
124 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
125 |
126 | **1，使用sklearn中的SGDClassifier可以对数据集进行简单的线性分类，达到比较好的分类效果。**
127 |
128 | **2，在数据集的特征上，貌似x>y时，数据属于class_0, 而x
136 |
137 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
138 |
139 | 参考资料:
140 |
141 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习009-用逻辑回归分类器解决多分类问题.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习009-用逻辑回归分类器解决多分类问题
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 前面的[【火炉炼AI】机器学习008](https://juejin.im/post/5b67cbeb6fb9a04fd6597421)已经讲解了用简单线性分类器解决二分类问题，但是对于多分类问题，我们该怎么办了？
7 |
8 | 此处介绍一种用于解决多分类问题的分类器：逻辑回归。虽然名称中含有回归二字，但逻辑回归不仅可以用来做回归分析，也可以用来做分类问题。逻辑回归是机器学习领域比较常用的算法，用于估计样本所属类别的可能性，关于逻辑回归的更深层次的公式推导，可以参看https://blog.csdn.net/devotion987/article/details/78343834。
9 |
10 |
11 |
12 |
13 | ## 1. 准备数据集
14 |
15 | 此处我们自己构建了一些简单的数据样本作为数据集，首先我们要分析该数据集，做到对数据集的特性了然如胸。
16 |
17 | ```Python
18 | # 首先准备数据集
19 | # 特征向量
20 | X =np.array([[4, 7], [3.5, 8], [3.1, 6.2], [0.5, 1], [1, 2],
21 | [1.2, 1.9], [6, 2], [5.7, 1.5], [5.4, 2.2]]) # 自定义的数据集
22 | # 标记
23 | y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2]) # 三个类别
24 |
25 | # 按照类别将数据点画到散点图中
26 | class_0=np.array([feature for (feature,label) in zip(X,y) if label==0])
27 | # print(class_0) # 确保没有问题
28 | class_1=np.array([feature for (feature,label) in zip(X,y) if label==1])
29 | # print(class_1)
30 | class_2=np.array([feature for (feature,label) in zip(X,y) if label==2])
31 | # print(class_2)
32 |
33 | # 绘图
34 | plt.figure()
35 | plt.scatter(class_0[:,0],class_0[:,1],marker='s',label='class_0')
36 | plt.scatter(class_1[:,0],class_1[:,1],marker='x',label='class_1')
37 | plt.scatter(class_2[:,0],class_2[:,1],marker='o',label='class_2')
38 | plt.legend()
39 | ```
40 |
41 | 
42 |
43 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
44 |
45 | **1，通过将数据集的y label可以看出，整个数据集有三个类别，每个类别的数据点都聚集到一块，这个可以从散点图中看出，故而此处是典型的多分类问题。**
46 |
47 | **2，此处数据集的样本数比较少（每个类别三个样本），且特征向量只有两个，并且从散点图中可以看出，数据集各个类别都区分的比较开，故而相对比较容易分类。**
48 |
49 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
50 |
51 |
52 |
53 | ## 2. 构建逻辑回归分类器
54 |
55 | 逻辑回归分类器的构建非常简单，如下代码所示，首先我们用该分类器的默认参数做一下分类试试。
56 |
57 | ```Python
58 | # 构建逻辑回归分类器
59 | from sklearn.linear_model import LogisticRegression
60 | classifier = LogisticRegression(random_state=37) # 先用默认的参数
61 | classifier.fit(X, y) # 对国际回归分类器进行训练
62 | ```
63 |
64 | 虽然此处我们构建了逻辑回归分类器， 并且用我们的数据集进行了训练，但训练的效果该怎么查看了？此时我们也没有测试集，所以暂时的，我们将该分类器在训练集上的分类效果画到图中，给出一个直观的分类效果。为了在图中看到分类效果，需要定义一个专门绘制分类器效果展示的函数，如下。
65 |
66 | ```Python
67 | # 将分类器绘制到图中
68 | def plot_classifier(classifier, X, y):
69 | x_min, x_max = min(X[:, 0]) - 1.0, max(X[:, 0]) + 1.0 # 计算图中坐标的范围
70 | y_min, y_max = min(X[:, 1]) - 1.0, max(X[:, 1]) + 1.0
71 | step_size = 0.01 # 设置step size
72 | x_values, y_values = np.meshgrid(np.arange(x_min, x_max, step_size), np.arange(y_min, y_max, step_size))
73 | # 构建网格数据
74 | mesh_output = classifier.predict(np.c_[x_values.ravel(), y_values.ravel()])
75 | mesh_output = mesh_output.reshape(x_values.shape)
76 | plt.figure()
77 | plt.pcolormesh(x_values, y_values, mesh_output, cmap=plt.cm.gray)
78 | plt.scatter(X[:, 0], X[:, 1], c=y, s=80, edgecolors='black', linewidth=1, cmap=plt.cm.Paired)
79 | # specify the boundaries of the figure
80 | plt.xlim(x_values.min(), x_values.max())
81 | plt.ylim(y_values.min(), y_values.max())
82 |
83 | # specify the ticks on the X and Y axes
84 | plt.xticks((np.arange(int(min(X[:, 0])-1), int(max(X[:, 0])+1), 1.0)))
85 | plt.yticks((np.arange(int(min(X[:, 1])-1), int(max(X[:, 1])+1), 1.0)))
86 |
87 | plt.show()
88 | ```
89 |
90 | 然后直接调用该绘图函数，查看该逻辑回归分类器在训练集上的分类效果。
91 |
92 | ```Python
93 | plot_classifier(classifier, X, y)
94 | ```
95 |
96 | 
97 |
98 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
99 |
100 | **1，使用sklearn模块中的LogisticRegression函数可以轻松的定义和训练一个逻辑回归分类器模型。**
101 |
102 | **2，由于此处采用分类器的默认参数，而不是最适合参数，故而得到的分类效果并不是最佳，比如从图中可以看出，虽然该分类模型能够将三个类别区分开来，但是其模型明显还可以继续优化。**
103 |
104 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
105 |
106 |
107 |
108 | ## 3. 对分类模型的优化
109 |
110 | 逻辑回归分类器有两个最重要的参数：solver和C，其中参数solver用于设置求解系统方程的算法类型，参数C表示对分类错误的惩罚值，故而C越大，表明该模型对分类错误的惩罚越大，即越不能接受分类发生错误。
111 |
112 | 此处，作为抛砖引玉，可以优化C值对分类效果的影响，如下，我们随机选择几种C值，然后将分类结果图画出来，凭借直观感受来判断哪一个比较好。当然，更科学的做法是，使用测试集结合各种评估指标来综合评价那个参数组合下的模型最好。
113 |
114 |
115 | ```Python
116 | # 优化模型中的参数C
117 | for c in [1,5,20,50,100,200,500]:
118 | classifier = LogisticRegression(C=c,random_state=37)
119 | classifier.fit(X, y)
120 | plot_classifier(classifier, X, y)
121 | # 貌似C越多，分类的效果越好。
122 | ```
123 |
124 | 
125 |
126 | 
127 |
128 | 
129 |
130 |
131 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
132 |
133 | **1，对模型进行优化是一项体力活，也是最能考验机器学习技术功底的工作，此处作为抛砖引玉，我们仅仅优化了逻辑回归分类器的一个参数。**
134 |
135 | **2，逻辑回归分类器的C值越大，得到的分类器模型就越在两个数据集中间区分开来，这也符合我们的预期，那么，是否有必要在一开始时就设置非常大的C值？**
136 |
137 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
138 |
139 |
140 |
141 |
142 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
143 |
144 | 参考资料:
145 |
146 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习015-如何处理样本数差别较大的数据集.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习015-如何处理样本数偏差较大的数据集
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 我们得到的数据集在绝大多数情况下，都不是理想的数据集，都需要经过各种各样的处理，其中的一个处理方式就是，如何处理样本数偏差较大的数据集。比如对于某种疾病的发生概率是1%，即获得的自然状态下的数据集中大约99%的样本都是正常的，那么此时，通过模型进行训练，得到的模型在对新样本进行预测时，也往往偏向于样本数较大的类别，此时或极大的降低小样本类别的召回率。
7 |
8 |
9 |
10 | ## 1. 查看数据集的特征
11 |
12 | 此处所使用的是书本《Python机器学习经典实例》第三章的非平衡数据集，此处我用pandas读取到内存中，通过info()来查看该数据集的基本情况，代码如下：
13 |
14 | ```Python
15 | # 准备数据集
16 | data_path='E:\PyProjects\DataSet\FireAI/data_multivar_imbalance.txt'
17 | df=pd.read_csv(data_path,header=None)
18 | # print(df.head()) # 没有问题
19 | print(df.info()) # 查看数据信息，确保没有错误
20 | dataset_X,dataset_y=df.iloc[:,:-1],df.iloc[:,-1]
21 | # print(dataset_X.head())
22 | # print(dataset_X.info())
23 | # print(dataset_y.head()) # 检查没问题
24 | dataset_X=dataset_X.values
25 | dataset_y=dataset_y.values
26 | ```
27 |
28 | **-------------------------------------输---------出--------------------------------**
29 |
30 |
31 | RangeIndex: 1200 entries, 0 to 1199
32 | Data columns (total 3 columns):
33 | 0 1200 non-null float64
34 | 1 1200 non-null float64
35 | 2 1200 non-null int64
36 | dtypes: float64(2), int64(1)
37 | memory usage: 28.2 KB
38 | None
39 |
40 | **--------------------------------------------完-------------------------------------**
41 |
42 | 可以看出，该数据集只有两个features,一个label,且整个数据集有1200个样本。可以通过查看数据集的2D分布来初步的了解该数据集的样本偏差。如下图所示：
43 |
44 | 
45 |
46 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
47 |
48 | **1. 数据集中不同类别之间样本数偏差比较大，此时需要做进一步处理。**
49 |
50 | **2. 数据集的加载和显示等，在前面的文章中已经讲烂了，此处无需赘言。**
51 |
52 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
53 |
54 |
55 |
56 | ## 2. 用线性SVM分类器构建分类模型
57 |
58 | 从上面的数据集分布图中可以大致看出，这个模型不是简单的线性模型，当然，为了对比效果，此处我仍然使用线性SVM分类器来构建分类模型，看一下效果。
59 |
60 | 代码如下：
61 |
62 | ```Python
63 | # 将整个数据集划分为train set和test set
64 | from sklearn.model_selection import train_test_split
65 | train_X, test_X, train_y, test_y=train_test_split(
66 | dataset_X,dataset_y,test_size=0.25,random_state=42)
67 |
68 | # 如果用线性SVM分类器来进行分类，看看是什么结果
69 | # 使用线性核函数初始化一个SVM对象。
70 | from sklearn.svm import SVC
71 | classifier=SVC(kernel='linear') # 构建线性分类器
72 | classifier.fit(train_X,train_y)
73 | ```
74 |
75 | 然后在通过plot_classifier()函数将这个模型的分类效果画出来。
76 |
77 | ```Python
78 | # 模型在训练集上的性能报告：
79 | from sklearn.metrics import classification_report
80 | plot_classifier(classifier,train_X,train_y) # 分类器在训练集上的分类效果
81 | target_names = ['Class-0', 'Class-1']
82 | y_pred=classifier.predict(train_X)
83 | print(classification_report(train_y, y_pred, target_names=target_names))
84 | ```
85 |
86 | 
87 |
88 | **-------------------------------------输---------出--------------------------------**
89 |
90 | precision recall f1-score support
91 |
92 | Class-0 0.00 0.00 0.00 151
93 | Class-1 0.83 1.00 0.91 749
94 |
95 | avg / total 0.69 0.83 0.76 900
96 |
97 |
98 | **--------------------------------------------完-------------------------------------**
99 |
100 | 可以看出，线性SVM分类器完全没有将class_0区分出来，得到的各种指标都是0，从分类效果图中也可以看到，根本就没有线性平面。
101 |
102 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
103 |
104 | **1. 由于本数据集存在样本数量偏差，故而使用线性SVM分类器没有任何效果。**
105 |
106 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
107 |
108 |
109 |
110 | ## 3. 解决样本数量偏差的方法
111 |
112 | 从上面可以看出，由于样本数量偏差的存在，使用线性SVM分类器没有任何效果，那么我们该怎么处理这种数据集了？
113 |
114 | SVM内部存在一个class_weight参数，我们可以设置该参数为"balanced"，来调节各种类别样本数量的权重，使其达到平衡。如下代码：
115 |
116 | ```Python
117 | # 看来直接使用简单的线性SVM分类器难以将class_0区分出来，故而我们要调整数据集中样本的数量权重
118 | classifier2=SVC(kernel='linear',class_weight='balanced') # 比上面的分类器增加了 class_weight=‘balanced'参数
119 | classifier2.fit(train_X,train_y)
120 |
121 | # 模型在训练集上的性能报告：
122 | plot_classifier(classifier2,train_X,train_y) # 分类器在训练集上的分类效果
123 | target_names = ['Class-0', 'Class-1']
124 | y_pred2=classifier2.predict(train_X)
125 | print(classification_report(train_y, y_pred2, target_names=target_names))
126 | ```
127 |
128 | 
129 |
130 | **-------------------------------------输---------出--------------------------------**
131 |
132 | precision recall f1-score support
133 |
134 | Class-0 0.35 0.86 0.50 151
135 | Class-1 0.96 0.68 0.79 749
136 |
137 | avg / total 0.86 0.71 0.74 900
138 |
139 | **--------------------------------------------完-------------------------------------**
140 |
141 | 从分类效果图中可以看出，此时可以使用线性SVM来对数据集进行训练，并能得到效果还不错的分类模型，从分类结果报告中可以看出，各种指标也还不错，但也存在较大的提升空间。
142 |
143 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
144 |
145 | **1. 在定义SVM分类器时，只需要设置class_weight=balanced即可消除数据集中样本数量偏差的问题。**
146 |
147 | **2. 如果分类器的效果不理想，那么需要考虑是否是数据集存在明显的样本数量偏差问题。**
148 |
149 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
159 |
160 | 参考资料:
161 |
162 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习016-如何知道SVM模型输出类别的置信度.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习016-如何知道SVM模型输出类别的置信度
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 一般的，对于未知样本，我们通过模型预测出来属于某种类别，往往会给出是这种类别的概率。
7 |
8 | 比如通过AI模型识别某一种图片是“狗”的概率是95.8%，是”猫“的概率是4.2%，那用SVM能不能得到类似的属于某种类别的概率值了？
9 |
10 |
11 |
12 | ## 1. 准备数据集
13 |
14 | 本部分代码和上一篇文章（[【火炉炼AI】机器学习014-用SVM构建非线性分类模型](https://juejin.im/post/5b69aef6f265da0f82025693) ）几乎一样，故此不再赘述。
15 |
16 |
17 |
18 | ## 2. 计算新样本的置信度
19 |
20 | 此处，我们自己构建了非线性SVM分类模型，并使用该模型对新样本数据进行类别的分类。如下代码
21 |
22 | ```Python
23 | # 计算某个新样本的置信度
24 | new_samples=np.array([[2,1.5],
25 | [8,9],
26 | [4.8,5.2],
27 | [4,4],
28 | [2.5,7],
29 | [7.6,2],
30 | [5.4,5.9]])
31 | classifier3=SVC(kernel='rbf',probability=True) # 比上面的分类器增加了 probability=True参数
32 | classifier3.fit(train_X,train_y)
33 |
34 | # 使用训练好的SVM分类器classifier3对新样本进行预测，并给出置信度
35 | for sample in new_samples:
36 | print('sample: {}, probs: {}'.format(sample,classifier3.predict_proba([sample])[0]))
37 | ```
38 |
39 | **-------------------------------------输---------出--------------------------------**
40 |
41 | sample: [2. 1.5], probs: [0.08066588 0.91933412]
42 | sample: [8. 9.], probs: [0.08311977 0.91688023]
43 | sample: [4.8 5.2], probs: [0.14367183 0.85632817]
44 | sample: [4. 4.], probs: [0.06178594 0.93821406]
45 | sample: [2.5 7. ], probs: [0.21050117 0.78949883]
46 | sample: [7.6 2. ], probs: [0.07548128 0.92451872]
47 | sample: [5.4 5.9], probs: [0.45817727 0.54182273]
48 |
49 | **--------------------------------------------完-------------------------------------**
50 |
51 | 将该新样本数据点绘制到2D分布图中，可以得到如下结果。
52 |
53 | 
54 |
55 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
56 |
57 | **1. 从中可以看出，如果要输出每一个类别的不同概率，需要设置参数probability=True，同时，需要用classifier.predict_proba()函数来获取类别概率值。**
58 |
59 | **2. 模型输出的样本类别的概率，就是该样本属于这个类别的置信度。**
60 |
61 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
72 |
73 | 参考资料:
74 |
75 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习017-使用GridSearch搜索最佳参数组合.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习017-使用GridSearch搜索最佳参数组合
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 在前面的文章（[【火炉炼AI】机器学习012-用随机森林构建汽车评估模型及模型的优化提升方法](https://juejin.im/post/5b684abbf265da0fa759f463)），我们使用了验证曲线来优化模型的超参数，但是使用验证曲线难以同时优化多个参数的取值，只能一个参数一个参数的优化，从而获取每个参数的最优值，但是有时候，一个非常优秀的模型，可能A参数取最优值时，B参数并不一定是最优值，从而使得验证曲线的方式有其自身的弊端。
7 |
8 | 此处介绍的使用GridSearch来搜索最佳参数组合的方法，可以避免上述弊端，GridSearch可以同时优化多个不同参数的取值。
9 |
10 |
11 |
12 | ## 1. 准备数据集
13 |
14 | 数据集的准备工作和文章（[【火炉炼AI】机器学习014-用SVM构建非线性分类模型](https://juejin.im/post/5b69aef6f265da0f82025693)）中一模一样，此处不再赘述。
15 |
16 |
17 |
18 | ## 2. 使用GridSearch函数来寻找最优参数
19 |
20 | 使用GridSearch函数来寻找最优参数，需要首先定义要搜索的参数候选值，然后定义模型的评价指标，以此来评价模型的优虐。，GridSearch会自动计算各种参数候选值，从而得到最佳的参数组合，使得评价指标最大化。
21 |
22 |
23 | ```Python
24 | from sklearn import svm, grid_search, cross_validation
25 | from sklearn.metrics import classification_report
26 |
27 | parameter_grid = [ {'kernel': ['linear'], 'C': [1, 10, 50, 600]}, # 需要优化的参数及其候选值
28 | {'kernel': ['poly'], 'degree': [2, 3]},
29 | {'kernel': ['rbf'], 'gamma': [0.01, 0.001], 'C': [1, 10, 50, 600]},
30 | ]
31 |
32 | metrics = ['precision', 'recall_weighted'] # 评价指标好坏的标准
33 |
34 | for metric in metrics:
35 | print("Searching optimal hyperparameters for: {}".format(metric))
36 |
37 | classifier = grid_search.GridSearchCV(svm.SVC(C=1),
38 | parameter_grid, cv=5, scoring=metric)
39 | classifier.fit(train_X, train_y)
40 |
41 | print("\nScores across the parameter grid:")
42 | for params, avg_score, _ in classifier.grid_scores_: # 打印出该参数下的模型得分
43 | print('{}: avg_scores: {}'.format(params,round(avg_score,3)))
44 |
45 | print("\nHighest scoring parameter set: {}".format(classifier.best_params_))
46 |
47 | y_pred =classifier.predict(test_X) # 此处自动调用最佳参数？？
48 | print("\nFull performance report:\n {}".format(classification_report(test_y,y_pred)))
49 | ```
50 |
51 | **-------------------------------------输---------出--------------------------------**
52 |
53 | Searching optimal hyperparameters for: precision
54 | Scores across the parameter grid:
55 | {'C': 1, 'kernel': 'linear'}: avg_scores: 0.809
56 | {'C': 10, 'kernel': 'linear'}: avg_scores: 0.809
57 | {'C': 50, 'kernel': 'linear'}: avg_scores: 0.809
58 | {'C': 600, 'kernel': 'linear'}: avg_scores: 0.809
59 | {'degree': 2, 'kernel': 'poly'}: avg_scores: 0.859
60 | {'degree': 3, 'kernel': 'poly'}: avg_scores: 0.852
61 | {'C': 1, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 1.0
62 | {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.0
63 | {'C': 10, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.968
64 | {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.855
65 | {'C': 50, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.946
66 | {'C': 50, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.975
67 | {'C': 600, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.948
68 | {'C': 600, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.968
69 |
70 | Highest scoring parameter set: {'C': 1, 'gamma': 0.01, 'kernel': 'rbf'}
71 |
72 | Full performance report:
73 | precision recall f1-score support
74 |
75 | 0 0.75 1.00 0.86 36
76 | 1 1.00 0.69 0.82 39
77 |
78 | avg / total 0.88 0.84 0.84 75
79 |
80 | Searching optimal hyperparameters for: recall_weighted
81 |
82 | Scores across the parameter grid:
83 | {'C': 1, 'kernel': 'linear'}: avg_scores: 0.653
84 | {'C': 10, 'kernel': 'linear'}: avg_scores: 0.653
85 | {'C': 50, 'kernel': 'linear'}: avg_scores: 0.653
86 | {'C': 600, 'kernel': 'linear'}: avg_scores: 0.653
87 | {'degree': 2, 'kernel': 'poly'}: avg_scores: 0.889
88 | {'degree': 3, 'kernel': 'poly'}: avg_scores: 0.884
89 | {'C': 1, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.76
90 | {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.507
91 | {'C': 10, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.907
92 | {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.658
93 | {'C': 50, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.92
94 | {'C': 50, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.72
95 | {'C': 600, 'gamma': 0.01, 'kernel': 'rbf'}: avg_scores: 0.933
96 | {'C': 600, 'gamma': 0.001, 'kernel': 'rbf'}: avg_scores: 0.902
97 |
98 | Highest scoring parameter set: {'C': 600, 'gamma': 0.01, 'kernel': 'rbf'}
99 |
100 | Full performance report:
101 | precision recall f1-score support
102 |
103 | 0 1.00 0.92 0.96 36
104 | 1 0.93 1.00 0.96 39
105 |
106 | avg / total 0.96 0.96 0.96 75
107 |
108 | **--------------------------------------------完-------------------------------------**
109 |
110 |
111 |
112 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
113 |
114 | **1. 使用GridSearch中的GridSearchCV可以实现最佳参数组合的搜索，但需要指定候选参数和模型的评价指标。**
115 |
116 | **2. 使用classifier.best_params_函数可以直接把最佳的参数组合打印出来，方便以后参数的直接调用**
117 |
118 | **3. classifier.predict函数是自动调用最佳的参数组合来预测，从而得到该模型在测试集或训练集上的预测值。**
119 |
120 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
121 |
122 |
123 | 如果要使用最佳参数来构建SVM模型，可以采用下面的代码来实现：
124 |
125 | ```Python
126 | best_classifier=svm.SVC(C=600,gamma=0.01,kernel='rbf') # 上面的full performance report的确使用的是最佳参数组合
127 | best_classifier.fit(train_X, train_y)
128 | y_pred =best_classifier.predict(test_X)
129 | print("\nFull performance report:\n {}".format(classification_report(test_y,y_pred)))
130 | ```
131 |
132 | 得到的结果和上面full performance report一模一样。
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
142 |
143 | 参考资料:
144 |
145 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习021-使用K-means进行图片的矢量量化.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习021-使用K-means进行图片的矢量量化操作
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 前一篇文章我们讲解了K-means算法的定义方法，并用K-means对数据集进行了简单的聚类分析。此处我们讲解使用k-means对图片进行矢量量化操作。
7 |
8 |
9 |
10 | ## 1. 矢量量化简介
11 |
12 | 矢量量化（Vector Quantization, VQ）是一种非常重要的信号压缩方法，在图片处理，语音信号处理等领域占据十分重要的地位。
13 |
14 | 矢量量化是一种基于块编码规则的有损数据压缩方法，在图片压缩格式JPEG和视频压缩格式MPEG-4中都有矢量量化这一步，其基本思想是：将若干个标量数据组构成一个矢量，然后在矢量空间给以整体量化，从而达到压缩数据的同时但不损失多少信息。
15 |
16 | 矢量量化实际上是一种逼近，其核心思想和“四舍五入”基本一样，就是用一个数来代替其他一个数或者一组数据，比如有很多数据（6.235,6.241,6.238,6.238954,6.24205.。。），这些数据如果用四舍五入的方式，都可以得到一个数据6.24，即用一个数据（6.24）来就可以代表很多个数据。
17 |
18 | 了解了这个基本思想，我们可以看下面的一维矢量量化的例子：
19 |
20 | 
21 |
22 | 在这个数轴上，有很多数据，我们可以用-3来代表所有小于-2的数据，用-1代表-2到0之间的数据，用1代表0到2之间的数据，用3代表大于2的数据，故而整个数轴上的无线多个数据，都可以用这四个数据（-3，-1,1,3）来表示，我们可以对这四个数进行编码，只需要两个bit就可以，如（-3=00，-1=01,1=10,3=11），所以这就是1-dimensional, 2-bit VQ，其量化率rate=2bits/dimension.
23 |
24 | 下面看看稍微复杂一点的二维矢量量化的例子：
25 |
26 | 
27 |
28 | 由于是二维，故而平面上的任意一个点都可以表示为（x,y）这种坐标形式，图中，我们用蓝色实线将整个二维平面划分为16个区域，故而任意一个数据点都会落到这16个区域的某一个。我们可以用平面上的某些点来**代表**这个平面区域，故而得到16个红点，这16个红点的坐标就代表了某一个区域内的所有二维点。
29 |
30 | 更进一步，我们就用4bit二进制码来编码表示这16个数，故而这个问题是2-dimensional, 4-bit VQ， 其量化率也是rate=2bits/dimension.
31 |
32 | 此处图中显示的红星，也就是16个代表，被称为编码矢量（code vectors），而蓝色边界定的区域叫做编码区域（encoding regions)，所有这些编码矢量的集合被称为码书（code book), 所有编码区域的集合称为空间的划分（partition of the space).
33 |
34 | 对于图像而言，可以认为图像中的每个像素点就是一个数据，用k-means对这些数据进行聚类分析，比如将整幅图像聚为K类，那么会得到K个不同的质心（关于质心的理解和直观感受，可以参考我的上一篇文章[【火炉炼AI】机器学习020-使用K-means算法对数据进行聚类分析](https://juejin.im/post/5b8ca7e56fb9a019ef32cdb0))，或者说通俗一点，可以得到K个不同的数据代表，这些数据代表就可以代表整幅图像中的所有点的像素值，故而我们只需要知道这K个数据代表就可以了（想想人大代表就明白这个道理了），从而可以极大的减少图片的存储空间（比如一张bmp的图像可能有2-3M，而压缩成jpg后只有几百K的大小，当然压缩成jpg的过程还有其他压缩方式，不仅仅是矢量量化，但大体意思相同），当然，这个代表的过程会造成一定的图像像素失真，失真的程度就是K的个数了。用图片可以表示为：
35 |
36 | 
37 |
38 | （以上内容部分来源于博客[矢量量化（Vector Quantization）](https://blog.csdn.net/lishuiwang/article/details/78483547)）
39 |
40 |
41 |
42 |
43 | ## 2. 使用K-means对图像进行矢量量化操作
44 |
45 | 根据上面第一部分对矢量量化的介绍，我们可以对某一张图片进行矢量量化压缩，可以从图片中提取K个像素代表，然后用这些代表来表示一张图片。具体的代码为：
46 |
47 | ```Python
48 | from sklearn.cluster import KMeans
49 | # 构建一个函数来完成图像的矢量量化操作
50 | def image_VQ(image,K_nums): # 貌似很花时间。。
51 | # 构建一个KMeans对象
52 | kmeans=KMeans(n_clusters=K_nums,n_init=4)
53 | # 用这个KMeans对象来训练数据集，此处的数据集就是图像
54 | img_data=image.reshape((-1,1))
55 | kmeans.fit(img_data)
56 | centroids=kmeans.cluster_centers_.squeeze() # 每一个类别的质心
57 | labels=kmeans.labels_ # 每一个类别的标记
58 | return np.choose(labels,centroids).reshape(image.shape)
59 | ```
60 |
61 | 上面我们先建立一个函数来完成图像的矢量量化压缩操作，这个操作首先建立一个Kmeans对象，然后用这个KMeans对象来训练图像数据，然后提起分类之后的每个类别的质心和标记，并使用这些质心来直接替换原始图像像素，即可得到压缩之后的图像。
62 |
63 | 为了查看原始图像和压缩后图像，我们将这两幅图都绘制到一行，绘制的函数为：
64 |
65 | ```Python
66 | # 将原图和压缩图都绘制出来，方便对比查看效果
67 | def plot_imgs(raw_img,VQ_img,compress_rate):
68 | assert raw_img.ndim==2 and VQ_img.ndim==2, "only plot gray scale images"
69 | plt.figure(12,figsize=(25,50))
70 | plt.subplot(121)
71 | plt.imshow(raw_img,cmap='gray')
72 | plt.title('raw_img')
73 |
74 | plt.subplot(122)
75 | plt.imshow(VQ_img,cmap='gray')
76 | plt.title('VQ_img compress_rate={:.2f}%'.format(compress_rate))
77 | plt.show()
78 | ```
79 |
80 | 为了使用方便，我们可以直接将压缩图像函数和显示图像函数封装到一个更高级的函数中，方便我们直接调用和运行，如下所示：
81 |
82 | ```Python
83 | import cv2
84 | def compress_plot_img(img_path,num_bits):
85 | assert 1<=num_bits<=8, 'num_bits must be between 1 and 8'
86 | K_nums=np.power(2,num_bits)
87 |
88 | # 计算压缩率
89 | compression_rate=round(100*(8-num_bits)/8,2)
90 | # print('compression rate is {:.2f}%'.format(compression_rate))
91 |
92 | image=cv2.imread(img_path,0) # 读取为灰度图
93 | VQ_img=image_VQ(image,K_nums)
94 | plot_imgs(image,VQ_img,compression_rate)
95 | ```
96 |
97 | 准备好了各种操作函数之后，我们就可以直接调用compress_plot_img()函数来压缩和显示图像，下面是采用三种不同的比特位来压缩得到的图像，可以对比看看效果。
98 |
99 | 
100 |
101 | 
102 |
103 | 
104 |
105 |
106 |
107 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
108 |
109 | **1, 对图像进行矢量量化压缩，其本质就是将图像数据划分为K个不同类比，这种思想和K-means的思想一致，故而对图像进行矢量量化是Ｋ-means算法的一个重要应用。**
110 |
111 | **2, 通过K-means算法得到图像的K个类别的质心后，就可以用着Ｋ个不同质心来代替图像像素，进而得到压缩之后的，有少许失真的图像。**
112 |
113 | **3, 从上述三幅图的比较可以看出，图像压缩率越大，图像失真的越厉害，最后的比特位为1时的图像可以说就是二值化图，其像素值非0即1，非1即0。**
114 |
115 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
116 |
117 |
118 |
119 |
120 |
121 |
122 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
123 |
124 | 参考资料:
125 |
126 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习022-使用均值漂移聚类算法构建模型.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习022-使用均值漂移聚类算法构建模型
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.5, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 无监督学习算法有很多种，前面已经讲解过了K-means聚类算法，并用该算法对图片进行矢量量化压缩。下面我们来学习第二种无监督学习算法----均值漂移算法。
7 |
8 |
9 |
10 | ## 1. 均值漂移算法简介
11 |
12 | 均值漂移算法是一种基于密度梯度上升的非参数方法，它经常被应用在图像识别中的目标跟踪，数据聚类，分类等场景。
13 |
14 | 其核心思想是：首先随便选择一个中心点，然后计算该中心点一定范围之内所有点到中心点的距离向量的平均值，计算该平均值得到一个偏移均值，然后将中心点移动到偏移均值位置，通过这种不断重复的移动，可以使中心点逐步逼近到最佳位置。这种思想类似于梯度下降方法，通过不断的往梯度下降的方向移动，可以到达梯度上的局部最优解或全局最优解。
15 |
16 | 如下是漂移均值算法的思想呈现，首先随机选择一个中心点（绿色点），然后计算该点一定范围内所有点到这个点的距离均值，然后将该中心点移动距离均值，到黄色点处，同理，再计算该黄色点一定范围内的所有点到黄点的距离均值，经过多次计算均值--移动中心点等方式，可以使得中心点逐步逼近最佳中心点位置，即图中红色点处。
17 |
18 | 
19 |
20 | ### 1.1 均值漂移算法的基础公式
21 |
22 | 从上面核心思想可以看出，均值漂移的过程就是不断的重复计算距离均值，移动中心点的过程，故而计算偏移均值和移动距离便是非常关键的两个步骤，如下为计算偏移均值的基础公式。
23 |
24 | 
25 |
26 | 其中Sh:以x为中心点，半径为h的高维球区域； k:包含在Sh范围内点的个数； xi:包含在Sh范围内的点
27 |
28 |
29 | 第二个步骤是计算移动一定距离之后的中心点位置，其计算公式为：
30 |
31 | 
32 |
33 | 其中，Mt为t状态下求得的偏移均值; xt为t状态下的中心
34 |
35 | 很显然，移动之后的中心点位置是移动前位置加上偏移均值。
36 |
37 | ### 1.2 引入核函数的偏移均值算法
38 |
39 | 上述虽然介绍了均值漂移算法的基础公式，但是该公式存在一定的问题，我们知道，高维球区域内的所有样本点对求解的贡献是不一样的，而基础公式却当做贡献一样来处理，即所有点的权重一样，这是不符合逻辑的，那么怎么改进了？我们可以引入核函数，用来求出每个样本点的贡献权重。当然这种求解权重的核函数有很多种，高斯函数就是其中的一种，如下公式是引入高斯核函数后的偏移均值的计算公式：
40 |
41 | 
42 |
43 | 
44 |
45 | 
46 |
47 | 上面就是核函数内部的样子。
48 |
49 | ### 1.3 均值漂移算法的运算步骤
50 |
51 | 均值漂移算法的应用非常广泛，比如在聚类，图像分割，目标跟踪等领域，其运算步骤往往包含有如下几个步骤：
52 |
53 | 1，在数据点中随机选择一个点作为初始中心点。
54 |
55 | 2，找出离该中心点距离在带宽之内的所有点，记做集合M，认为这些点属于簇C.
56 |
57 | 3，计算从中心点开始到集合M中每个元素的向量，将这些向量相加，得到偏移向量。
58 |
59 | 4，将该中心点沿着偏移的方向移动，移动距离就是该偏移向量的模。
60 |
61 | 5，重复上述步骤2,3,4，直到偏移向量的大小满足设定的阈值要求，记住此时的中心点。
62 |
63 | 6，重复上述1,2,3，4，5直到所有的点都被归类。
64 |
65 | 7，分类：根据每个类，对每个点的访问频率，取访问频率最大的那个类，作为当前点集的所属类。
66 |
67 | ### 1.4 均值漂移算法的优势
68 |
69 | 均值漂移算法用于集群数据点时，把数据点的分布看成是概率密度函数，希望在特征空间中根据函数分布特征找出数据点的**模式**，这些模式就对应于一群群局部最密集分布的点。
70 |
71 | 虽然我们前面讲解了K-means算法，但K-means算法在实际应用时，需要知道我们要把数据划分为几个类别，如果类别数量出错，则往往难以得到令人满意的分类结果，而要划分的类别往往很难事先确定。这就是K-means算法的应用难点。
72 |
73 | 而均值漂移算法却不需要事先知道要集群的数量，这种算法可以在我们不知道要寻找多少集群的情况下自动划分最合适的族群，这就是均值漂移算法的一个很明显优势。
74 |
75 | 以上部分内容来源于[博客文章](https://blog.csdn.net/qwerasdf_1_2/article/details/54577336)，在此表示感谢。
76 |
77 |
78 |
79 | ## 2. 构建均值漂移模型来聚类数据
80 |
81 | 本文所使用的数据集和读取数据集的方式与上一篇文章[【火炉炼AI】机器学习020-使用K-means算法对数据进行聚类分析](https://juejin.im/post/5b8ca7e56fb9a019ef32cdb0)一模一样，故而此处省略。
82 |
83 | 下面是构建MeanShift对象的代码，使用MeanShift之前，我们需要评估带宽，带宽就是上面所讲到的距离中心点的一定距离，我们要把所有包含在这个距离之内的点都放入一个集合M中，用于计算偏移向量。
84 |
85 | ```Python
86 | # 构建MeanShift对象，但需要评估带宽
87 | from sklearn.cluster import MeanShift, estimate_bandwidth
88 | bandwidth=estimate_bandwidth(dataset_X,quantile=0.1,
89 | n_samples=len(dataset_X))
90 | meanshift=MeanShift(bandwidth=bandwidth,bin_seeding=True) # 构建对象
91 | meanshift.fit(dataset_X) # 并用MeanShift对象来训练该数据集
92 |
93 | centroids=meanshift.cluster_centers_ # 质心的坐标，对应于feature0, feature1
94 | print(centroids) # 可以看出有4行，即4个质心
95 | labels=meanshift.labels_ # 数据集中每个数据点对应的label
96 | # print(labels)
97 |
98 | cluster_num=len(np.unique(labels)) # label的个数，即自动划分的族群的个数
99 | print('cluster num: {}'.format(cluster_num))
100 | ```
101 |
102 | **-------------------------------------输---------出--------------------------------**
103 |
104 | [[ 8.22338235 1.34779412]
105 | [ 4.10104478 -0.81164179]
106 | [ 1.18820896 2.10716418]
107 | [ 4.995 4.99967742]]
108 | cluster num: 4
109 |
110 | **--------------------------------------------完-------------------------------------**
111 |
112 | 可以看出，此处我们得到了四个质心，这四个质心的坐标位置可以通过meanshift.cluster_centers_获取，而meanshift.labels_ 得到的就是原来样本数据的label，也就是我们通过均值漂移算法自己找到的label，这就是无监督学习的优势所在：虽然没有给样本数据指定label，但是该算法能自己找到其对应的label。
113 |
114 | 同样的，该怎么查看该MeanShift算法的好坏了，可以通过下面的函数直接观察数据集划分的效果。
115 |
116 | ```Python
117 | def visual_meanshift_effect(meanshift,dataset):
118 | assert dataset.shape[1]==2,'only support dataset with 2 features'
119 | X=dataset[:,0]
120 | Y=dataset[:,1]
121 | X_min,X_max=np.min(X)-1,np.max(X)+1
122 | Y_min,Y_max=np.min(Y)-1,np.max(Y)+1
123 | X_values,Y_values=np.meshgrid(np.arange(X_min,X_max,0.01),
124 | np.arange(Y_min,Y_max,0.01))
125 | # 预测网格点的标记
126 | predict_labels=meanshift.predict(np.c_[X_values.ravel(),Y_values.ravel()])
127 | predict_labels=predict_labels.reshape(X_values.shape)
128 | plt.figure()
129 | plt.imshow(predict_labels,interpolation='nearest',
130 | extent=(X_values.min(),X_values.max(),
131 | Y_values.min(),Y_values.max()),
132 | cmap=plt.cm.Paired,
133 | aspect='auto',
134 | origin='lower')
135 |
136 | # 将数据集绘制到图表中
137 | plt.scatter(X,Y,marker='v',facecolors='none',edgecolors='k',s=30)
138 |
139 | # 将中心点绘制到图中
140 | centroids=meanshift.cluster_centers_
141 | plt.scatter(centroids[:,0],centroids[:,1],marker='o',
142 | s=100,linewidths=2,color='k',zorder=5,facecolors='b')
143 | plt.title('MeanShift effect graph')
144 | plt.xlim(X_min,X_max)
145 | plt.ylim(Y_min,Y_max)
146 | plt.xlabel('feature_0')
147 | plt.ylabel('feature_1')
148 | plt.show()
149 |
150 | visual_meanshift_effect(meanshift,dataset_X)
151 | ```
152 |
153 | 
154 |
155 |
156 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
157 |
158 | **1，MeanShift的构建和训练方法和K-means的方式几乎一样，但是MeanShift可以自动计算出数据集的族群数量，而不需要人为事先指定，这使得MeanShift比K-means要好用一些。**
159 |
160 | **2, 训练之后的MeanShift对象中包含有该数据集的质心坐标，数据集的各个样本对应的label信息，这些信息可以很方便的获取。**
161 |
162 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
163 |
164 |
165 |
166 |
167 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
168 |
169 | 参考资料:
170 |
171 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习024-无监督学习模型的性能评估.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习024-无监督学习模型的性能评估--轮廓系数
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 前面我们学习过监督学习模型的性能评估，由于数据集有标记，所以我们可以将模型预测值和真实的标记做比较，计算两者之间的差异，从而来评估监督学习模型的好坏。
7 |
8 | 但是，对于无监督学习模型，由于没有标记数据，我们该怎么样评估一个模型的好坏了？显然，此时我们不能采用和监督学习模型一样的评估方式了，而要另辟蹊径。
9 |
10 |
11 |
12 | ## 1. 度量聚类模型的好坏---轮廓系数
13 |
14 | 有很多种度量聚类模型的算法，其中一个比较好用的算法就是轮廓系数（Silhouette Coefficient）指标。这个指标度量模型将数据集分类的离散程度，即判断数据集是否分离的合理，判断一个集群中的数据点是不是足够紧密（即内聚度），一个集群中的点和其他集群中的点相隔是否足够远（即分离度），故而轮廓系数结合了内聚度和分离度这两种因素，可以用来在相同原始数据的基础上用来评价不同算法，或者算法不同运行方式对聚类结果所产生的影响。
15 |
16 | 以下是百度对轮廓系数的说明，此处我直接搬过来用了。
17 |
18 | 
19 |
20 | 
21 |
22 |
23 |
24 | ## 2. 使用轮廓系数评估K-means模型
25 |
26 | 首先是用pandas加载数据集，查看数据集加载是否正确，这部分可以看我的[具体代码](https://github.com/RayDean/MachineLearning)，此处省略。
27 |
28 | 然后我随机的构建一个K-means模型，用这个模型来训练数据集，并用轮廓系数来评估该模型的优虐，代码如下：
29 |
30 | ```Python
31 | from sklearn.cluster import KMeans
32 | # 构建一个聚类模型，此处用K-means算法
33 | model=KMeans(init='k-means++',n_clusters=3,n_init=10)
34 | # 原始K-means算法最开始随机选取数据集中K个点作为聚类中心，
35 | # 分类结果会因为初始点的选取不同而有所区别
36 | # 而K-means++算法改变这种随机选取方法，能显著的改善分类结果的最终误差
37 | # 此处我随机的指定n_cluster=3，看看评估结果
38 | model.fit(dataset)
39 | ```
40 |
41 | ```Python
42 | # 使用轮廓系数评估模型的优虐
43 | from sklearn.metrics import silhouette_score
44 | si_score=silhouette_score(dataset,model.labels_,
45 | metric='euclidean',sample_size=len(dataset))
46 | print('si_score: {:.4f}'.format(si_score))
47 | ```
48 |
49 | **-------------------------------------输---------出--------------------------------**
50 |
51 | si_score: 0.5572
52 |
53 | **--------------------------------------------完-------------------------------------**
54 |
55 | 从上面的代码可以看出，计算轮廓系数是非常简单的。
56 |
57 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
58 |
59 | **1， sklearn中已经集成了轮廓系数的计算方法，我们只需要调用该函数即可，使用非常简单。**
60 |
61 | **2， 有了模型的评估指标，我们就可以对模型进行一些优化，提升模型的性能，或者用该指标来比较两个不同模型在相同数据集上的效果，从而为我们选择模型提供指导。**
62 |
63 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
64 |
65 |
66 |
67 | ## 3. K-means模型性能的提升方法
68 |
69 | 上面在评价K-means模型时，我们随机指定了划分的族群数量，即Ｋ值，但是有了评估指标之后，我们就可以优化这个K值，其基本思路是：遍历各种可能的K值，计算每种K值之下的轮廓系数，选择轮廓系数最大的K值，即为最优的族群数量。
70 |
71 | 下面我先定义一个函数，专门用来计算K-means算法的最优K值，这个函数具有一定的通用性，也可以用于其它场合。如下为代码：
72 |
73 | ```Python
74 | # K-means模型的提升
75 | # 在定义K-means时，往往我们很难知道最优的簇群数量，即K值，
76 | # 故而可以通过遍历得到最优值
77 | def get_optimal_K(dataset,K_list=None):
78 | k_lists=K_list if K_list else range(2,15)
79 | scores=[]
80 | for k in k_lists:
81 | kmeans=KMeans(init='k-means++',n_clusters=k,n_init=10)
82 | kmeans.fit(dataset)
83 | scores.append(silhouette_score(dataset,kmeans.labels_,
84 | metric='euclidean',
85 | sample_size=len(dataset)))
86 | return k_lists[scores.index(max(scores))],scores
87 | ```
88 |
89 | 有了这个通用性求解最优K值的函数，我们就可以用来获取这个数据集的最佳K值，如下为代码：
90 |
91 | ```Python
92 | optimal_K, scores=get_optimal_K(dataset)
93 | print('optimal_K is: {}, all scores: {}'.format(optimal_K,scores))
94 |
95 | # or:
96 | # optimal_K, scores=get_optimal_K(dataset,[2,4,6,8,10,12])
97 | # print('optimal_K is: {}, all scores: {}'.format(optimal_K,scores))
98 | ```
99 |
100 | **-------------------------------------输---------出--------------------------------**
101 |
102 | optimal_K is: 5, all scores: [0.5290397175472954, 0.5551898802099927, 0.5832757517829593, 0.6582796909760834, 0.5823584119482567, 0.5238070812131604, 0.4674788136779971, 0.38754867890367795, 0.41013511008667664, 0.41972398760085106, 0.41614459998617975, 0.3485105795903397, 0.357222732243728]
103 |
104 | **--------------------------------------------完-------------------------------------**
105 |
106 | 从上面的结果可以看出，函数计算出来的最优Ｋ值为5，即最好的情况是将本数据集划分为5个类别，且在K=5时的轮廓系数为0.6583。
107 |
108 | 下面我们来看一下这个数据集在平面上的分布情况，看看是不是数据集有5种类别，如下所示是使用visual_2D_dataset()函数之后得到的平面分布图。
109 |
110 | 
111 |
112 | 从上图中可以看出，的确数据集中到五个不同的簇群中。那么用最优的参数来聚类这些数据集，得到什么样的效果了？如下是平面的聚类效果图。
113 |
114 | 
115 |
116 |
117 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
118 |
119 | **1， 使用轮廓系数可以对模型进行参数优化，此处我们定义了一个通用性函数，可以直接计算出数据集的最佳Ｋ值。**
120 |
121 | **2， 当然，也可以用轮廓系数来优化其他参数，只要稍微修改一下上面的通用函数即可。**
122 |
123 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
124 |
125 |
126 |
127 |
128 |
129 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
130 |
131 | 参考资料:
132 |
133 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习028-五分钟教你打造机器学习流水线.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习028-五分钟教你打造机器学习流水线
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 现在的社会工业化大生产离不开流水线作业，有了流水线，我们可以轻松的制造出成千上万相同的产品，而且所需要的价格成本极大地下降，所以说，流水线操作，使得工业化生产水平极大的提高。
7 |
8 | 那么有没有可能将这种流水线的处理思想转移到机器学习领域了？我们可不可以将数据清洗-数据规整-数据处理-特征选择-监督学习-模型评估等一整套流程做成一条机器学习的流水线了？如果可以，那就能极大的节省我们打造一个AI模型的时间，极大的提高构建优秀AI的效率。
9 |
10 | 在此，【火炉炼AI】可以十分肯定的告诉你，这是可以的，而且打造这种机器学习流水线非常方便，只需要短短的五分钟即可。
11 |
12 |
13 |
14 | ## 1. 流水线第一步：准备数据集
15 |
16 | 数据集在本项目中反而不是很重要，故而我们用sklearn自带模块samples_generator生成一些示例数据即可。虽然numpy也在random模块中有随机产生数据集的函数，但是numpy比较适合用于产生一些简单的抽样数据。而sklearn中的datasets类却可以用来产生适合机器学习模型的数据集。
17 |
18 | sklearn的datasets中常用的API有：
19 |
20 | 1) 用make_regression 生成回归模型的数据
21 |
22 | 2) 用make_hastie_10_2，make_classification或者make_multilabel_classification生成分类模型数据
23 |
24 | 3) 用make_blobs生成聚类模型数据
25 |
26 | 4) 用make_gaussian_quantiles生成分组多维正态分布的数据
27 |
28 | ```Python
29 | # 准备数据集
30 | from sklearn.datasets import samples_generator
31 | # 使用这个函数产生示例数据
32 | X,y=samples_generator.make_classification(n_informative=4,
33 | n_features=20,
34 | n_redundant=0,
35 | random_state=5)
36 | # 产生一个分类数据集，包含有100个样本，20个features，2个类别，没有冗余特征。
37 | # print(X.shape) # (100, 20)
38 | # print(y.shape) # (100,)
39 | # print(X[:3]) # 查看没有问题
40 | ```
41 |
42 |
43 |
44 | ## 2. 流水线第二步：构建特征选择器
45 |
46 | 在数据集准备完成之后，需要提取数据集中最重要的几个特征，即对我们的分类结果影响最大的几个主要特征，这样做可以减小模型的复杂程度，同时还能保持模型的预测精准度。sklearn框架也为我们准备好了特征选择函数SelectKBest()，我们只需要指定要选择的特征数K即可。如下为代码，非常简单。
47 |
48 | ```Python
49 | # 建立特征选择器
50 | from sklearn.feature_selection import SelectKBest, f_regression
51 | feature_selector=SelectKBest(f_regression,k=10)
52 | # 一共20个特征向量，我们从中选择最重要的10个特征向量
53 | ```
54 |
55 |
56 |
57 | ## 3. 流水线第三步：构建分类器
58 |
59 | 下一步，我们就需要构建分类器模型，前面在我的文章中讲到了很多分类器算法，比如SVM，随机森林，朴素贝叶斯等，此处我们构建一个简单的随机森林分类器作为例子。
60 |
61 | ```Python
62 | # 建立分类器
63 | from sklearn.ensemble import RandomForestClassifier
64 | classifier=RandomForestClassifier(n_estimators=50,max_depth=4)
65 | # 此处构建随机森林分类器作为例子，参数随便指定
66 | ```
67 |
68 |
69 |
70 | ## 4. 流水线第四步：组装完整流水线
71 |
72 | 上面的几个步骤相当于建立各种产品处理模块，这一步我们就需要将这些模块组装起来，构建成一个可以完整运行的机器学习流水线。代码很简单，如下所示。
73 |
74 | ```Python
75 | # 第四步：组装完整流水线
76 | from sklearn.pipeline import Pipeline
77 | pipeline=Pipeline([('selector',feature_selector),
78 | ('rf_classifier',classifier)])
79 | # 修改流水线中参数设置
80 | # 假如我们希望特征选择器不是选择10个特征，而是5个特征，
81 | # 同时分类器中的参数n_estimators也要修改一下，可以采用：
82 | pipeline.set_params(selector__k=5,
83 | rf_classifier__n_estimators=25)
84 | ```
85 |
86 | **-------------------------------------输---------出--------------------------------**
87 |
88 | Pipeline(memory=None,
89 | steps=[('selector', SelectKBest(k=5, score_func=)), ('rf_classifier', RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
90 | max_depth=4, max_features='auto', max_leaf_nodes=None,
91 | min_impurity_decrease=0.0, min...n_jobs=1,
92 | oob_score=False, random_state=None, verbose=0,
93 | warm_start=False))])
94 |
95 | **--------------------------------------------完-------------------------------------**
96 |
97 | 从上面的输出中可以看出，这个流水线中只有两个模块，一个是特征选择器selector，另外一个是分类器rf_classifier，各自分别的参数位于后面。
98 |
99 | 对于模型，最终都是要用数据集进行训练，并且用训练好的模型来对新样本做出预测。如下为代码：
100 |
101 | ```Python
102 | # 将数据输入到流水线中
103 | pipeline.fit(X,y) # 对流水线进行训练
104 |
105 | predict_y=pipeline.predict(X) #用训练好的流水线预测样本
106 | # print(predict_y)
107 |
108 | # 评估该流水线的模型性能
109 | print('pipeline model score: {:.3f}'.format(pipeline.score(X,y)))
110 | ```
111 |
112 | **-------------------------------------输---------出--------------------------------**
113 |
114 | pipeline model score: 0.960
115 |
116 | **--------------------------------------------完-------------------------------------**
117 |
118 | 这个流水线模型在训练集上的得分为0.960，貌似性能还不错。
119 |
120 | 上面我们构建了一个特征选择器，但是怎么知道哪些特征被选择，哪些陪抛弃了？如下代码：
121 |
122 | ```Python
123 | # 查看特征选择器选择的特征：
124 | feature_status=pipeline.named_steps['selector'].get_support()
125 | # get_support()会返回true/false，如果支持该feature，则为true.
126 | selected_features=[]
127 | for count,item in enumerate(feature_status):
128 | if item: selected_features.append(count)
129 | print('selected features by pipeline, (0-indexed): \n{}'.format(
130 | selected_features))
131 | ```
132 |
133 | **-------------------------------------输---------出--------------------------------**
134 |
135 | selected features by pipeline, (0-indexed):
136 | [5, 9, 10, 11, 15]
137 |
138 | **--------------------------------------------完-------------------------------------**
139 |
140 | 由此可以看出，流水线自动选择了五个特征（我们前面指定了k=5),这最重要的五个特征分别是标号为5,9,10,11,15的特征。
141 |
142 |
143 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
144 |
145 | **1，打造机器学习流水线非常简单，只需要先构建机器学习的基本模块即可，然后将这些模块组装起来。**
146 |
147 | **2，前面的特征提取器选择最重要特征的过程是先进行单变量统计测试，然后从特征向量中抽取最优秀的特征。这种测试之后，向量空间中的每个特征将有一个评价分数，基于这些评价分数，选择最好的K个特征，一旦抽取出K个特征，一旦K维的特征向量形成，就可以用这个特征向量用于分类器的输入训练数据。**
148 |
149 | **3，打造这种流水线的优势有很多，可以简单快速的构建机器学习模型，可以方便的提取最重要的K个特征向量，可以快速的评估构建的模型，正所谓，这是个快速进行AI模型构建的必备良器。**
150 |
151 | **4，上面的流水线只是整合了特征选择，分类器部分，唯一让人遗憾的是，怎么把数据处理，数据清洗这部分也整合到流水线中？暂时我还没有找到这部分内容，有哪位朋友找到了这种方法，请联系我啊。。。**
152 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
153 |
154 |
155 |
156 |
157 |
158 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
159 |
160 | 参考资料:
161 |
162 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习029-找到离你最近的邻居.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习029-找到离你最近的邻居
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 最近邻算法的核心思想是：想要判断你属于哪一个类别，先找离你最近的K个邻居，看看这些邻居的大部分属于哪个类别，那么就可以认为你也属于这个类别。
7 |
8 | 所以，根据这种核心思想，有三个重要的因素：距离度量，K的大小和分类规则。在KNN中，当训练数据集和三要素确定后，相当于将特征空间划分为一些子空间。对于距离度量，有很多种方式，常用的是闵可夫斯基距离，其计算公式为：
9 |
10 | 
11 |
12 | 其中P>=1, 当P=2时，是欧式距离，当p=1时，是曼哈顿距离。
13 |
14 | 对于K的大小选择是一个重要的考虑因素，其选择会对算法的结果有重大影响。如果Ｋ太小，就相当于用较小领域中的训练实例进行预测，这样会被噪声所影响，同时方差比较大，也就是模型的过拟合现象会比较严重。如果Ｋ太大，就相当于用很多的邻居来判断，此时会走向另一个极端，使得模型产生欠拟合现象。
15 |
16 | 在具体应用中，一般选择较小Ｋ并且Ｋ是奇数，通常使用交叉验证的方法来获取最合适的Ｋ值。
17 |
18 | 分类规则一般常用多数表决，即大多数实例所属的类别就认为是新样本的类别。这个很容易理解。
19 |
20 |
21 |
22 | ## 1. 查找最近的K个邻居
23 |
24 | 下面我们自己用代码寻找一个新样本的K个最近的邻居，看看这些邻居们都在哪儿。
25 |
26 | ```Python
27 | # 1，寻找最近的K个邻居
28 | from sklearn.neighbors import NearestNeighbors
29 | # 自定义一些数据集
30 | X = np.array([[1, 1], [1, 3], [2, 2], [2.5, 5], [3, 1],
31 | [4, 2], [2, 3.5], [3, 3], [3.5, 4]])
32 | # 画出这些数据集在平面图上的分布情况
33 | plt.scatter(X[:,0],X[:,1],marker='o',color='k')
34 |
35 | # 一个新样本
36 | new_sample=np.array([[2.6,1.7]])
37 | plt.scatter(new_sample[:,0],new_sample[:,1],marker='*',color='r')
38 | ```
39 |
40 | 
41 |
42 | 上面只是将原始数据集和新样本的分布绘制到二维平面上，但是没有计算其最近的距离和邻居。下面代码是计算过程。
43 |
44 | ```Python
45 | # 构建KNN模型，计算最近的K个数据点
46 | K=3
47 | KNN=NearestNeighbors(n_neighbors=K,algorithm='ball_tree').fit(X)
48 | distances,indices=KNN.kneighbors(new_sample)
49 |
50 | # 打印最近的K个邻居
51 | for rank, (indices, distance) in \
52 | enumerate(zip(indices[0][:K],distances[0][:K])):
53 | print('rank: {} --> {}, distance: {:.3f}'.format(rank, X[index],distance))
54 | ```
55 |
56 | **-------------------------------------输---------出--------------------------------**
57 |
58 | rank: 0 --> [2. 2.], distance: 0.671
59 | rank: 1 --> [3. 1.], distance: 0.806
60 | rank: 2 --> [3. 3.], distance: 1.360
61 |
62 | **--------------------------------------------完-------------------------------------**
63 |
64 | 可以看出距离新样本最近的三个邻居分别是【2,2】，【3,1】，【3,3】，而且各自的距离也打印出来了。实际上，KNN.kneighbors(new_sample)返回的indices数组是一个已经排序的数组，我们只需要从中获取下标即可。
65 |
66 | 下面为了方便观察，将最近的K个邻居用别的颜色重点标注出来。
67 |
68 | 
69 |
70 |
71 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
72 |
73 | **1，想要寻找新样本最近的K个邻居，需要首先构建一个KNN模型，然后用数据集训练该模型。**
74 |
75 | **2，然后使用函数KNN.kneighbors(new_sample)即可得到距离的排序，从这些排序中可以计算出最近的Ｋ个邻居。**
76 |
77 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
78 |
79 |
80 |
81 |
82 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
83 |
84 | 参考资料:
85 |
86 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习030-KNN分类器模型的构建.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习030-KNN分类器模型的构建
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | KNN(K-nearest neighbors)是用K个最近邻的训练数据集来寻找未知对象分类的一种算法。其基本的核心思想在我的上一篇文章中介绍过了。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | 此处我的数据集准备包括数据加载和数据可视化，这部分比较简单，以前文章中使用了多次，直接看数据分布图。
13 |
14 | 
15 |
16 |
17 |
18 |
19 | ## 2. 构建KNN分类器模型
20 |
21 | ### 2.1 KNN分类器模型的构建和训练
22 |
23 | 构建KNN分类器模型的方法和SVM，RandomForest的方法类似，代码如下：
24 |
25 | ```Python
26 |
27 | # 构建KNN分类模型
28 | from sklearn.neighbors import KNeighborsClassifier
29 | K=10 # 暂定10个最近样本
30 | KNN=KNeighborsClassifier(K,weights='distance')
31 | KNN.fit(dataset_X,dataset_y) # 使用该数据集训练模型
32 |
33 | ```
34 |
35 | 上面使用数据集训练了这个KNN模型，但是我们怎么知道该模型的训练效果了？下面绘制了分类模型在训练数据集上的分类效果，从边界上来看，该分类器比较清晰的将这个数据集区分开来。
36 |
37 | 
38 |
39 |
40 | ### 2.1 用训练好的KNN分类器预测新样本
41 |
42 | 直接上代码：
43 |
44 | ```Python
45 |
46 | # 用训练好的KNN模型预测新样本
47 | new_sample=np.array([[4.5,3.6]])
48 | predicted=KNN.predict(new_sample)[0]
49 | print("KNN predicted：{}".format(predicted))
50 |
51 | ```
52 |
53 | 得到的结果是2，表示该新样本属于第2类。
54 |
55 | 下面我们将这个新样本绘制到图中，看看它在图中的位置。
56 |
57 | 为了绘制新样本和其周围的K个样本的位置，我修改了上面的plot_classifier函数，如下为代码：
58 |
59 | ```Python
60 | # 为了查看新样本在原数据集中的位置，也为了查看新样本周围最近的K个样本位置，
61 | # 我修改了上面的plot_classifier函数，如下所示：
62 |
63 | def plot_classifier2(KNN_classifier, X, y,new_sample,K):
64 | x_min, x_max = min(X[:, 0]) - 1.0, max(X[:, 0]) + 1.0 # 计算图中坐标的范围
65 | y_min, y_max = min(X[:, 1]) - 1.0, max(X[:, 1]) + 1.0
66 | step_size = 0.01 # 设置step size
67 | x_values, y_values = np.meshgrid(np.arange(x_min, x_max, step_size),
68 | np.arange(y_min, y_max, step_size))
69 | # 构建网格数据
70 | mesh_output = KNN_classifier.predict(np.c_[x_values.ravel(), y_values.ravel()])
71 | mesh_output = mesh_output.reshape(x_values.shape)
72 | plt.figure()
73 | plt.pcolormesh(x_values, y_values, mesh_output, cmap=plt.cm.gray)
74 | plt.scatter(X[:, 0], X[:, 1], c=y, s=80, edgecolors='black',
75 | linewidth=1, cmap=plt.cm.Paired)
76 | # 绘制新样本所在的位置
77 | plt.scatter(new_sample[:,0],new_sample[:,1],marker='*',color='red')
78 | # 绘制新样本周围最近的K个样本，只适用于KNN
79 | # Extract k nearest neighbors
80 | dist, indices = KNN_classifier.kneighbors(new_sample)
81 | plt.scatter(dataset_X[indices][0][:][:,0],dataset_X[indices][0][:][:,1],
82 | marker='x',s=80,color='r')
83 | # specify the boundaries of the figure
84 | plt.xlim(x_values.min(), x_values.max())
85 | plt.ylim(y_values.min(), y_values.max())
86 |
87 | # specify the ticks on the X and Y axes
88 | plt.xticks((np.arange(int(min(X[:, 0])), int(max(X[:, 0])), 1.0)))
89 | plt.yticks((np.arange(int(min(X[:, 1])), int(max(X[:, 1])), 1.0)))
90 |
91 | plt.show()
92 |
93 | ```
94 |
95 | 直接代入运行后得到结果图：
96 |
97 | 
98 |
99 | 从图中可以看出，红色的五角星是我们的新样本，而红色的叉号表示与其最近的K个邻居。可以看出，这些邻居中的大多数都位于第二个类别中，故而新样本也被划分到第二个类比，通过predict得到的结果也是2。
100 |
101 |
102 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
103 |
104 | **1，构建和训练KNN分类器非常简单，只需要用sklearn导入KNNClassifier，然后用fit（）函数即可。**
105 |
106 | **2，KNN分类器存储了所有可用的训练集数据点，在新的数据点需要预测时，首先计算该新数据点和内部存储的所有数据点的相似度（也就是距离），并对该距离排序，获取距离最近的K个数据点，然后判断这K个数据点的大多数属于哪一个类别，就认为该新数据点属于哪一个类别。这也解释了为什么K通常取奇数，要是偶数，得到两个类别的数据点个数都相等，那就尴尬了。**
107 |
108 | **3，KNN分类器的难点是寻找最合适的K值，这个需要用交叉验证来反复尝试，采用具有最大准确率或召回率的K作为最佳Ｋ值，这个过程也可以采用GridSearch或RandomSearch来完成。**
109 |
110 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
111 |
112 |
113 |
114 |
115 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
116 |
117 | 参考资料:
118 |
119 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习031-KNN回归器模型的构建.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习031-KNN回归器模型的构建
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 在上一篇文章中我们学习了构建KNN分类器模型，但是KNN不仅可以用于分类问题，还可以用于回归问题，本章我们来学习KNN回归模型的构建和训练。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | 此处我们使用随机函数构建了序列型数据集，其产生方式是用函数np.sinc()来产生y值。
13 |
14 | ```Python
15 | # 准备数据集，此处用随机的方式生成一些样本数据
16 | amplitute=10
17 | num_points=100
18 | dataset_X=amplitute*np.random.rand(num_points,1)-0.5*amplitute
19 | dataset_y=np.sinc(dataset_X).ravel()
20 | dataset_y+=0.2*(0.5-np.random.rand(dataset_y.size))
21 | print(dataset_X.shape)
22 | print(dataset_y.shape)
23 | ```
24 |
25 | 用plt将该数据集绘制到图表中，可以看到如下结果。
26 |
27 | 
28 |
29 |
30 |
31 | ## 2. KNN回归模型的构建和训练
32 |
33 | 构建和训练KNN回归器与KNN分类器一样简单，如下代码。
34 |
35 | ```Python
36 | # 构建KNN回归模型
37 | from sklearn.neighbors import KNeighborsRegressor
38 | K=8
39 | KNN_regressor=KNeighborsRegressor(K,weights='distance')
40 | KNN_regressor.fit(dataset_X,dataset_y)
41 | ```
42 |
43 | 虽然此处构建了ＫＮＮ回归器并对该回归器进行了训练，可是怎么知道训练结果了？
44 |
45 | 如下我定义了一个绘图函数，可以用散点图的方式来绘制原始的数据集和预测之后的数据集
46 |
47 | ```Python
48 | # 将回归器绘制到图中
49 | def plot_regressor(regressor, X, y):
50 | # 将数据集绘制到图表中看看分布情况
51 | plt.scatter(X,y,color='k',marker='o',label='dataset')
52 | predicted=regressor.predict(X)
53 | plt.scatter(dataset_X,predicted,color='blue',marker='*',label='predicted')
54 | plt.xlim(X.min() - 1, X.max() + 1)
55 | plt.ylim(y.min() - 0.2, y.max() + 0.2)
56 | plt.legend()
57 | plt.show()
58 | ```
59 |
60 | 在本数据集上的表现可以从下图中看出：
61 |
62 | 
63 |
64 |
65 | 上面可以看出该KNN回归器在训练集上的表现貌似还不错，那么怎么用该训练完成的KNN回归器来预测新数据集了？如下我们先构建一序列新样本数据，然后将该样本数据绘制到图中，看看其分布是否符合原来的分布特性。
66 |
67 | ```Python
68 | # 下面用本KNN回归器来预测新样本数据，如下
69 | # 构建了10倍的新数据，并且建立第二个轴，用于KNNregressor.predict
70 | new_samples=np.linspace(-0.5*amplitute, 0.5*amplitute, 10*num_points)[:, np.newaxis]
71 | new_predicted=KNN_regressor.predict(new_samples)
72 |
73 | # 把原始数据也画上来
74 | plt.scatter(dataset_X,dataset_y,color='k',marker='o',label='dataset')
75 | plt.plot(new_samples,new_predicted,color='r',linestyle='-',
76 | label='new_samples')
77 | plt.legend()
78 |
79 | ```
80 |
81 | 得到的结果图貌似有非常严重的过拟合，如下图：
82 |
83 | 
84 |
85 |
86 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
87 |
88 | **1，KNN回归器的构建，训练，预测和KNN分类器基本一致。**
89 |
90 | **2，我在使用KNN回归器对训练集进行预测，得到的预测值竟然和训练集中的Y值完全一致，一模一样，我反复检查了好多遍，还是这个结果，刚开始以为是K值太小导致过拟合，但是修改K后仍然有这种情况，这个现象不知道其他人遇到没有，我找了好久都没找到原因所在。**
91 |
92 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
93 |
94 |
95 |
96 |
97 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
98 |
99 | 参考资料:
100 |
101 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习032-数据点之间相似度的计算.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习032-用户之间相似度的计算
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 在构建推荐引擎时，一般需要计算两个用户之间的相似度，以便找到与数据库中特定用户相似的用户。计算相似度的方法有很多种，其中比较常见的两种是计算欧几里得距离和皮尔逊相关系数，本文分别讲述使用这两种方法来计算用户之间的相似度。
7 |
8 |
9 |
10 | ## 1. 计算两个用户的欧氏距离
11 |
12 | 欧几里得距离是欧几里得空间中两点间的普通距离，即两点组成的直线的距离。其计算公式可以说是数学里的基本公式，如下，其基本含义就是计算两个点之间的空间距离。
13 |
14 | 
15 |
16 | 欧式距离很直观，是常见的一种相似度算法。其基本思路为：根据两用户之间共同评价的项目为维度，建立一个多维空间，用户对单一维度上的评价就可以组成一个数组或向量，一旦这个向量确定，那么就可以确定这个用户在这个多维空间的位置。但我们把多个用户都放置到这个多维空间后，距离非常近的两个用户，可以认为他们之间的相似度非常高，反之，距离较远的用户之间的相似度也较远，故而这种多维空间内的用户之间的欧式距离就标定了他们之间的相似度。
17 |
18 | 但是在日常使用中，我们一般不太习惯数值小反而表示相似度高，故而对这种数值取一个倒数，使得数值都落在0-1之间，即使用 1/（1+Distance(X,Y)）之后，得到的相似度范围为：0<=Similarity(X,y)<=1，越接近1，表示相似度越高，这种表示方式很符合我们的惯性思维。
19 |
20 | 下面用代码来计算两个用户之间的欧式距离，其思想是，计算两个用户在数据集中的所有项目中的平方和，然后在开方，得到两个用户之间的距离，在用倒数法转变一下。
21 |
22 | ```Python
23 | # 定义一个函数来计算两个用户之间的欧式距离
24 | def euclidean_distance(dataset,user1,user2):
25 | # 首先要排除一种情况，如果数据集中不存在同时被两个用户评价过的电影，
26 | # 则表示两个用户之间的没有相似度，直接返回0
27 | both_rated_num=0 # 表示同时被两个用户都评价过的电影的数目
28 | for item in dataset[user1]: # 在user1评价过的电影中
29 | if item in dataset[user2]: # 如果user2也评价过，则+1
30 | both_rated_num+=1
31 | if both_rated_num==0:# 不存在同时被两个用户都评价过的电影
32 | return 0 # 直接返回0，表示两个用户之间相似度为0
33 |
34 | squared_difference=[] # 每一个元素表示同时被两个用户都评价过的电影得分的欧式距离
35 | for item in dataset[user1]:
36 | if item in dataset[user2]:
37 | squared_difference.append(np.square(dataset[user1][item]-dataset[user2][item]))
38 | return 1/(1+np.sqrt(np.sum(squared_difference)))
39 |
40 | ```
41 |
42 | 由于原始的电影评价数据都存放在movie_ratings.json文件中，所以需要用json模块加载数据，并对其进行分析
43 |
44 | ```Python
45 | # 原始的电影评价数据都放置在 movie_ratings.json文件中，我们加载进来看看结果
46 | import json
47 | with open("E:\PyProjects\DataSet\FireAI\movie_ratings.json",'r') as file:
48 | dataset=json.loads(file.read())
49 |
50 | # 现在计算两个随机用户之间的欧式距离
51 | user1='John Carson'
52 | user2='Michelle Peterson'
53 | print(" Euclidean score: ",euclidean_distance(dataset,user1,user2))
54 | ```
55 |
56 | **-------------------------------------输---------出--------------------------------**
57 |
58 | Euclidean score: 0.29429805508554946
59 |
60 | **--------------------------------------------完-------------------------------------**
61 |
62 | 即此处计算出这两个用户之间的欧式距离为0.29，相似度不是很高。
63 |
64 | 欧式距离虽然是比较常用的计算用户相似度的方法，但是它有其内在的缺点，比如：
65 |
66 | 1，由于计算时基于各维度特征的绝对数值，所以欧式距离需要保证各维度指标在相同的刻度级别。
67 |
68 | 2，欧式距离是数据上的直观体现，看似简单，但在处理一些受主观影响很大的评分数据时，效果则不太明显。即评价者的评价相对于平均水平偏离很大的时候欧式距离不能很好地揭示出真实的相似度。
69 |
70 |
71 |
72 | ## 2. 计算两个用户的皮尔逊相关系数
73 |
74 | 在统计学中，皮尔逊相关系数用于度量两个变量之间的线性相关性，其值位于-1到1之间。相关系数为1时，成为完全正相关；当相关系数为-1时，成为完全负相关；相关系数的绝对值越大，相关性越强；相关系数越接近于0，相关度越弱。
75 |
76 | ```Python
77 | # 定义一个函数来计算两个用户之间的皮尔逊相关系数
78 | def pearson_score(dataset,user1,user2):
79 | # 和上面的函数类似，先排除相似度为0的情况
80 | # both_rated_num=0 # 表示同时被两个用户都评价过的电影的数目
81 | # for item in dataset[user1]: # 在user1评价过的电影中
82 | # if item in dataset[user2]: # 如果user2也评价过，则+1
83 | # both_rated_num+=1
84 | # if both_rated_num==0:# 不存在同时被两个用户都评价过的电影
85 | # return 0 # 直接返回0，表示两个用户之间相似度为0
86 |
87 | both_rated={}
88 | for item in dataset[user1]:
89 | if item in dataset[user2]:
90 | both_rated[item]=1
91 | num_ratings=len(both_rated)
92 | if num_ratings==0: # 不存在同时被两个用户都评价过的电影
93 | return 0
94 |
95 | # 计算每个用户对每个相同电影的评价之和
96 | user1_sum=np.sum([dataset[user1][item] for item in both_rated])
97 | user2_sum=np.sum([dataset[user2][item] for item in both_rated])
98 |
99 | # 计算每个用户对每个相同电影的评价的平方和
100 | user1_squared_sum = np.sum([np.square(dataset[user1][item]) for item in both_rated])
101 | user2_squared_sum = np.sum([np.square(dataset[user2][item]) for item in both_rated])
102 |
103 | # 计算两个用户的相同电影的乘积
104 | product_sum=np.sum([dataset[user1][item]*dataset[user2][item] for item in both_rated])
105 |
106 | # 计算Pearson 相关系数
107 | Sxy = product_sum - (user1_sum * user2_sum / num_ratings)
108 | Sxx = user1_squared_sum - np.square(user1_sum) / num_ratings
109 | Syy = user2_squared_sum - np.square(user2_sum) / num_ratings
110 |
111 | if Sxx * Syy == 0:
112 | return 0
113 |
114 | return Sxy / np.sqrt(Sxx * Syy)
115 | ```
116 |
117 | 同理计算得到两个用户的皮尔逊相关系数为： Peason score: 0.396. 相似度不能横向比较，即不能将Pearson得分和欧式距离进行比较，这样比较没有意义，只能用于纵向比较。
118 |
119 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
120 |
121 | **1，用户之间的相似度计算可以采用欧式距离的方式计算，也可以采用皮尔逊相关系数来计算。**
122 |
123 | **2，貌似用皮尔逊相关系数来表示相似度更好一些，在很多时候能够克服欧式距离表示法的一些缺点。**
124 |
125 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
126 |
127 |
128 |
129 |
130 |
131 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
132 |
133 | 参考资料:
134 |
135 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
136 |
--------------------------------------------------------------------------------
/Articles/机器学习034-NLP对文本进行分词.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习034-NLP对文本进行分词
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3， jieba 0.39)
5 |
6 | 分词过程可以认为是自然语言处理（NLP）的第一步，在我们获取了文本数据集后，首先要做的就是将文本句子分割成各种单词，下面介绍各种常用的分词工具。
7 |
8 |
9 |
10 | ## 1. 对英文进行分词
11 |
12 | ### 1.1 对句子进行分割--sent_tokenize
13 |
14 | NLP可以对句子进行分割，也就将一整段文本分割成几句话，经常是以句子结尾符号为标志来分割。这些符号包括有问号，感叹号，句号等。（逗号不会分割。）如下演示代码
15 |
16 |
17 | ```Python
18 | # 对句子进行分割（tokenization)
19 | from nltk.tokenize import sent_tokenize
20 | text = "Are you curious about tokenization? Let's see how it works! We need to analyze, a couple of sentences with punctuations to see it in action."
21 | sent_list=sent_tokenize(text)
22 | print(sent_list) # 句子结尾符号为标志分割
23 | ```
24 |
25 | **-------------------------------------输---------出--------------------------------**
26 |
27 | ['Are you curious about tokenization?', "Let's see how it works!", 'We need to analyze, a couple of sentences with punctuations to see it in action.']
28 |
29 | **--------------------------------------------完-------------------------------------**
30 |
31 | 可以看出sent_tokenize以问号，感叹号，句号来分割，但是中间的逗号却留在原来的句子中，没有分割。
32 |
33 | ### 1.2 对句子进行分词--word_tokenize
34 |
35 | 对句子进行分词，是将一段文本，一句话或者几个单词分割成几个单独的单词，分割的依据是空格，问号，逗号，句号等符号，代码如下：
36 |
37 | ```Python
38 | # 对句子进行分词，即根据语义将一句话分成多个单词
39 | from nltk.tokenize import word_tokenize
40 | text = "Are you curious about tokenization? Let's see how it works! We need to analyze, a couple of sentences with punctuations to see it in action."
41 | word_list=word_tokenize(text)
42 | print(word_list) # 以空格，问号，感叹号，句号等分割成单词
43 | # 分词在NLP中非常重要，经常是NLP的第一步
44 | ```
45 |
46 | **-------------------------------------输---------出--------------------------------**
47 |
48 | ['Are', 'you', 'curious', 'about', 'tokenization', '?', 'Let', "'s", 'see', 'how', 'it', 'works', '!', 'We', 'need', 'to', 'analyze', ',', 'a', 'couple', 'of', 'sentences', 'with', 'punctuations', 'to', 'see', 'it', 'in', 'action', '.']
49 |
50 | **--------------------------------------------完-------------------------------------**
51 |
52 |
53 | ### 1.3 对句子进行分词--WordPunctTokenizer
54 |
55 | WordPunctTokenizer的结果基本和上面的word_tokenize结果一致，不同的地方在于WordPunctTokenizer分词器可以将标点符号保留到不同的句子标记中。代码如下：
56 |
57 | ```Python
58 | # 还有一个分词方法：WordPunct分词器，可以将标点符号保留到不同的句子标记中
59 | from nltk.tokenize import WordPunctTokenizer
60 | text = "Are you curious about tokenization? Let's see how it works! We need to analyze, a couple of sentences with punctuations to see it in action."
61 | word_punct=WordPunctTokenizer()
62 | word_punct_list=word_punct.tokenize(text)
63 | print(word_punct_list)
64 | ```
65 |
66 | **-------------------------------------输---------出--------------------------------**
67 |
68 | ['Are', 'you', 'curious', 'about', 'tokenization', '?', 'Let', "'", 's', 'see', 'how', 'it', 'works', '!', 'We', 'need', 'to', 'analyze', ',', 'a', 'couple', 'of', 'sentences', 'with', 'punctuations', 'to', 'see', 'it', 'in', 'action', '.']
69 |
70 | **--------------------------------------------完-------------------------------------**
71 |
72 | 通过和上面的word_tokenize结果结果进行比较可以发现，唯一的不同就是Let's分割时不同，WordPunctTokenizer将Let's分割为三个单词，而word_tokenize却分割成两个单词。一般情况下，这一点区别意义不大，故而word_tokenize用得跟多一些。
73 |
74 | **（注意：虽然在《Python机器学习经典实例》中提到还有一个分词器PunktWordTokenizer，但是这个分词器已经弃用了，就连import都会出错，故而此处不讲解。）**
75 |
76 | ## 2. 对中文进行分词
77 |
78 | 上面的几个分词器对英文非常好用，但是很遗憾，对中文不能分词成功，我自己尝试过。对英文的分词很简单，因为是以空格作为自然分解符，可是中文却不是的，中文要分成单词而不是汉字。
79 |
80 | 对于中文分词，有很多种分词模块，比如：jieba、SnowNLP（MIT）、pynlpir（大数据搜索挖掘实验室（北京市海量语言信息处理与云计算应用工程技术研究中心））、thulac（清华大学自然语言处理与社会人文计算实验室）等。比较常用的是"jieba"分词器，意思就是像结巴一样结结巴巴的把一个句子分成几个单词。
81 |
82 | jieba分词器需要单独安装，安装也很简单，直接使用pip install jieba即可。
83 |
84 | jieba分词支持说那种分词模式：
85 | 1. 精确模式：试图将句子最精确的切开，适合于文本分析。
86 | 2. 全模式：把句子中所有的可以成词的词语都扫描出来，速度非常快，但不能解决歧义。
87 | 3. 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合于搜索引擎分词，支持繁体分词。
88 |
89 | 下面分别用着三种模式来进行中文分词，比较其异同点。
90 |
91 | ```Python
92 | # 中文分词应该使用jieba等分词模块
93 | import jieba
94 | text = "这是【火炉炼AI】的机器学习系列文章，本文的标题是《【火炉炼AI】机器学习034-NLP对文本进行分词》。"+ \
95 | "你可以从这个系列文章中学习到很多关于机器学习，人工智能方面的基础知识和实战技巧。"+\
96 | "请尽情享受吧！我的AI朋友们。。。"
97 | mode1_list=jieba.cut(text,cut_all=False) # 精确模式（默认为False,精确模式）
98 | print('jieba-精确模式结果：')
99 | print('/'.join(mode1_list))
100 |
101 | mode2_list=jieba.cut(text,cut_all=True) # 全模式
102 | print('jieba-全模式结果：')
103 | print('/'.join(mode2_list))
104 |
105 | mode3_list=jieba.cut_for_search(text) # 搜索引擎模式
106 | print('jieba-搜索引擎模式结果：')
107 | print('/'.join(mode3_list))
108 | ```
109 |
110 | **-------------------------------------输---------出--------------------------------**
111 |
112 | 这是/【/火炉/炼/AI/】/的/机器/学习/系列/文章/，/本文/的/标题/是/《/【/火炉/炼/AI/】/机器/学习/034/-/NLP/对/文本/进行/分词/》/。/你/可以/从/这个/系列/文章/中/学习/到/很多/关于/机器/学习/，/人工智能/方面/的/基础知识/和/实战/技巧/。/请/尽情/享受/吧/！/我/的/AI/朋友/们/。/。/。
113 | jieba-全模式结果：
114 | 这/是///火炉/炼/AI//的/机器/学习/系列/文章///本文/的/标题/是////火炉/炼/AI//机器/学习/034/NLP/对/文本/进行/分词////你/可以/从/这个/系列/文章/中学/学习/到/很多/关于/机器/学习///人工/人工智能/智能/方面/的/基础/基础知识/知识/和/实战/战技/技巧///请/尽情/享受/吧///我/的/AI/朋友/们////
115 | jieba-搜索引擎模式结果：
116 | 这是/【/火炉/炼/AI/】/的/机器/学习/系列/文章/，/本文/的/标题/是/《/【/火炉/炼/AI/】/机器/学习/034/-/NLP/对/文本/进行/分词/》/。/你/可以/从/这个/系列/文章/中/学习/到/很多/关于/机器/学习/，/人工/智能/人工智能/方面/的/基础/知识/基础知识/和/实战/技巧/。/请/尽情/享受/吧/！/我/的/AI/朋友/们/。/。/。
117 |
118 | **--------------------------------------------完-------------------------------------**
119 |
120 | 从上面的输出结果可以看出，这三种方法还是有很多不同点的，比如全模式的结果都没有标点符号，而且有几个地方有重复，比如"文章中学习到"被分割成/文章/中学/学习/到/，而搜索引擎模式则对长词在此切分，所以有些地方重复，比如/人工/智能/人工智能/方面/的/基础/知识/基础知识/等。
121 |
122 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
123 |
124 | **1，如果想对英文进行分词，可以直接使用NLP中自带的sent_tokenize，word_tokenize，WordPunctTokenizer分词器，其中的word_tokenize是应用最频繁的。**
125 |
126 | **2，如果想对中文进行分词，可以使用jieba模块，其中的精确模式（也是其默认模式）已经能够很好的将文本切分开来。其他模式在不同的应用场景中会用到。**
127 |
128 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
129 |
130 |
131 |
132 |
133 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
134 |
135 | 参考资料:
136 |
137 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习035-NLP词干提取.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习035-NLP词干提取
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3)
5 |
6 | 在英语中，经常会有很多单词的变形，记得以前英语老师讲课时，讲到动词的变形，有过去时，将来时，现在进行时等不同场合，动词需要变成相应的形态，而讲到名词时，又提到单数和复数的概念，可数名词要在单词末尾加s等。那么NLP如何处理这些变形之后的词了？有一种方法是提取这些词的词干，所谓万变不离其宗，我们只要抓住这个“宗”就可以应对其他了。
7 |
8 | 本文就是讲解如何用NLP提取单词的词干，抓住这些单词的“宗”。
9 |
10 |
11 |
12 | ## 1. NLP提取词干
13 |
14 | 词干提取的目标是将不同词形的单词都变成其原形，词干提取使用启发式处理的方法来截取单词的尾部，以提取单词的原形。
15 |
16 | NLP主要有说那种词干提取方法：基于Porter的词干提取算法，基于Lancaster的词干提取算法，基于Snowball的词干提取算法。下面分别用这几种方法来提取不同单词的词干。
17 |
18 | ```Python
19 | words = ['table', 'probably', 'wolves', 'playing', 'is',
20 | 'dog', 'the', 'beaches', 'grounded', 'dreamt', 'envision']
21 | # 要提取的单词
22 |
23 | # 三种不同的词干提取器
24 | stemmers = ['PORTER', 'LANCASTER', 'SNOWBALL']
25 | stemmer_porter = PorterStemmer()
26 | stemmer_lancaster = LancasterStemmer()
27 | stemmer_snowball = SnowballStemmer('english')
28 |
29 | formatted_row = '{:>16}' * (len(stemmers) + 1)
30 | print(formatted_row.format('WORD',*stemmers)) # 打印表头
31 |
32 | for word in words: # 每个单词逐一提取
33 | stem=[stemmer_porter.stem(word),
34 | stemmer_lancaster.stem(word), stemmer_snowball.stem(word)]
35 | print(formatted_row.format(word,*stem)) # 对提取后的stem进行拆包
36 | ```
37 |
38 | **-------------------------------------输---------出--------------------------------**
39 |
40 | WORD PORTER LANCASTER SNOWBALL
41 | table tabl tabl tabl
42 | probably probabl prob probabl
43 | wolves wolv wolv wolv
44 | playing play play play
45 | is is is is
46 | dog dog dog dog
47 | the the the the
48 | beaches beach beach beach
49 | grounded ground ground ground
50 | dreamt dreamt dreamt dreamt
51 | envision envis envid envis
52 |
53 | **--------------------------------------------完-------------------------------------**
54 |
55 |
56 |
57 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
58 |
59 | **可以看出说那种词干提取算法都能够提取词干，但是提取的结果却不一样，这主要是因为三种算法的提取严格程度不一样，简单的比较下，Lancaster提取最严格，而Porter最宽松。所以Lancaster得到的词干往往比较模糊，难以理解，但是它的提取速度很快。一般情况下，通常会选择Snowball词干提取器。**
60 |
61 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
62 |
63 |
64 |
65 |
66 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
67 |
68 | 参考资料:
69 |
70 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习036-NLP词形还原.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习036-NLP词形还原
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3)
5 |
6 | 词形还原也是将单词转换为原来的相貌，和上一篇文章中介绍的词干提取不一样，词形还原要难的多，它是一个更加结构化的方法，在上一篇中的词干提取例子中，可以看到将wolves提取为wolv等，这些肯定不是我们所期望的。那么此处我们使用NLP词形还原的方式来将英语单词还原。
7 |
8 |
9 |
10 | ## 1. NLP词形还原
11 |
12 | 词形还原是基于字典的映射，而且，NLTK还要求手动注明词形，否则可能会还原不准确，所以在做自然语言处理的过程中，先对文本进行分词，然后标注词性，最后再进行词形还原。
13 |
14 | ```Python
15 | # 待还原的单词
16 | words = ['table', 'probably', 'wolves', 'playing', 'is',
17 | 'dog', 'the', 'beaches', 'grounded', 'dreamt', 'envision']
18 |
19 | # 由于词形还原需要先标注词性，故而此处我们用名词和动词两种词性进行测试
20 | lemmatizers = ['NOUN LEMMATIZER', 'VERB LEMMATIZER'] # 两种词性
21 | lemmatizer = WordNetLemmatizer()
22 | formatted_row = '{:>24}' * (len(lemmatizers) + 1) # 使其打印格式一致
23 | print(formatted_row.format('WORD',*lemmatizers)) # 打印表头
24 |
25 | for word in words: # # 每个单词逐一变换
26 | lemmatized=[lemmatizer.lemmatize(word, pos='n'), lemmatizer.lemmatize(word, pos='v')]
27 | # 注意里面pos表示词性，分别表示名称和动词
28 | print(formatted_row.format(word,*lemmatized)) # 对提取后的stem进行拆包
29 | ```
30 |
31 | **-------------------------------------输---------出--------------------------------**
32 |
33 | WORD NOUN LEMMATIZER VERB LEMMATIZER
34 | table table table
35 | probably probably probably
36 | wolves wolf wolves
37 | playing playing play
38 | is is be
39 | dog dog dog
40 | the the the
41 | beaches beach beach
42 | grounded grounded ground
43 | dreamt dreamt dream
44 | envision envision envision
45 |
46 | **--------------------------------------------完-------------------------------------**
47 |
48 |
49 | 可以看出，虽然WordNetLemmatizer很有用，但是需要事先判断词性，并且把词性作为一个参数传入到这个函数中，那么有没有可能自动判断词性，不需要我们认为判断了？这是肯定的，NLTK有一个函数pos_tag可以自动判断出某个单词的词性，所以基于此，我们可以编写一个函数，来自动处理一整个句子，输出器词性还原之后的形式。如下代码：
50 |
51 | ```Python
52 | # 定义一个函数来对一个句子中的所有单词进行词形还原
53 | def lemmatize_all(sentence):
54 | wnl = WordNetLemmatizer()
55 | for word, tag in pos_tag(word_tokenize(sentence)):
56 | if tag.startswith('NN'):
57 | yield wnl.lemmatize(word, pos='n')
58 | elif tag.startswith('VB'):
59 | yield wnl.lemmatize(word, pos='v')
60 | elif tag.startswith('JJ'):
61 | yield wnl.lemmatize(word, pos='a')
62 | elif tag.startswith('R'):
63 | yield wnl.lemmatize(word, pos='r')
64 | else:
65 | yield word
66 |
67 | ```
68 |
69 | ```Python
70 | text ='dog runs, cats drunk wines, chicken eat apples, foxes jumped two meters'
71 | print('/'.join(lemmatize_all(text)))
72 | ```
73 |
74 | **-------------------------------------输---------出--------------------------------**
75 |
76 | dog/run/,/cat/drink/wine/,/chicken/eat/apple/,/fox/jump/two/meter
77 |
78 | **--------------------------------------------完-------------------------------------**
79 |
80 | 可以看出，句子中的名词复数都转变为了单数，动词过去式都转变为了现在式等。
81 |
82 | 关于pos_tag()函数，返回的是单词和词性标签，这些词性标签有：
83 |
84 | ```Python
85 | # NLTK 词性标签：
86 | CC 连词 and, or,but, if, while,although
87 | CD 数词 twenty-four, fourth, 1991,14:24
88 | DT 限定词 the, a, some, most,every, no
89 | EX 存在量词 there, there's
90 | FW 外来词 dolce, ersatz, esprit, quo,maitre
91 | IN 介词连词 on, of,at, with,by,into, under
92 | JJ 形容词 new,good, high, special, big, local
93 | JJR 比较级词语 bleaker braver breezier briefer brighter brisker
94 | JJS 最高级词语 calmest cheapest choicest classiest cleanest clearest
95 | LS 标记 A A. B B. C C. D E F First G H I J K
96 | MD 情态动词 can cannot could couldn't
97 | NN 名词 year,home, costs, time, education
98 | NNS 名词复数 undergraduates scotches
99 | NNP 专有名词 Alison,Africa,April,Washington
100 | NNPS 专有名词复数 Americans Americas Amharas Amityvilles
101 | PDT 前限定词 all both half many
102 | POS 所有格标记 ' 's
103 | PRP 人称代词 hers herself him himself hisself
104 | PRP$ 所有格 her his mine my our ours
105 | RB 副词 occasionally unabatingly maddeningly
106 | RBR 副词比较级 further gloomier grander
107 | RBS 副词最高级 best biggest bluntest earliest
108 | RP 虚词 aboard about across along apart
109 | SYM 符号 % & ' '' ''. ) )
110 | TO 词to to
111 | UH 感叹词 Goodbye Goody Gosh Wow
112 | VB 动词 ask assemble assess
113 | VBD 动词过去式 dipped pleaded swiped
114 | VBG 动词现在分词 telegraphing stirring focusing
115 | VBN 动词过去分词 multihulled dilapidated aerosolized
116 | VBP 动词现在式非第三人称时态 predominate wrap resort sue
117 | VBZ 动词现在式第三人称时态 bases reconstructs marks
118 | WDT Wh限定词 who,which,when,what,where,how
119 | WP WH代词 that what whatever
120 | WP$ WH代词所有格 whose
121 | WRB WH副词
122 |
123 | ```
124 |
125 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
126 |
127 | **1，NLP词形还原可以使用WordNetLemmatizer函数，但是这个函数在使用前需要先判断某个单词的词性，然后将词性作为参数输入到这个函数中进行转换。**
128 |
129 | **2，为了简化这种人为判断的过程，NLTK有自带的词性判断函数pos_tag，这个函数可以自动输出某个单词的词性，所以将pos_tag和WordNetLemmatizer函数联合起来，可以自动对某一整段文本进行分词，词形还原等操作。**
130 |
131 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
132 |
133 |
134 |
135 |
136 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
137 |
138 | 参考资料:
139 |
140 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习037-NLP文本分块.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习037-NLP文本分块
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3)
5 |
6 | 文本分块是将一大段文本分割成几段小文本，其目的是比如想获取一段文本中的一小部分，或分割得到固定单词数目的小部分等，经常用于非常大的文本。注意文本分块和分词不一样，分词的目的是把一段文本分割成单词，而文本分块的目的是把一大段文本分割成多个小段文本。
7 |
8 |
9 |
10 | ## 1. NLP文本分块
11 |
12 | 在不用的应用中，可能需要按照不同的规则对大段文本进行分块，此处我们需要得到单词数相等的块，故而可以编写函数来实现这种规则的分块。代码如下。
13 |
14 | ```Python
15 | from nltk.tokenize import word_tokenize
16 | def split(dataset,words_num):
17 | '''
18 | 将dataset这一整段文本分割成N个小块，
19 | 使得每个小块中含有单词的数目等于words_num'''
20 | words=dataset.split(' ') # 此处用空格来区分单词是否合适？
21 | # words=word_tokenize(dataset) # 用分词器来分词是否更合适一些？
22 |
23 | rows=int(np.ceil(len(words)/words_num)) # 即行数
24 | result=[] # 预计里面装的元素是rows行words_num列，最后一行可能少于words_num，故不能用np.array
25 |
26 | # words是list，可以用切片的方式获取
27 | for row in range(rows):
28 | result.append(words[row*words_num:(row+1)*words_num])
29 | return result
30 |
31 | ```
32 |
33 | 然后用简·奥斯丁的《爱玛》中的文本作为数据集，由于这个数据集太大，长度有192427，故而我们此处只获取前面的1000个单词做测试。
34 |
35 | ```Python
36 | # 测试一下
37 | # 数据集暂时用简·奥斯丁的《爱玛》中的文本
38 | dataset=nltk.corpus.gutenberg.words('austen-emma.txt')
39 | print(len(dataset)) # 192427 代表读入正常
40 | result=split(" ".join(dataset[:1000]), 30) # 只取前面的1000个单词，每30个单词分一个块，一共有34个块
41 | print(len(result))
42 | print(result[0])
43 | print(len(result[0]))
44 | print(result[-1])
45 | print(len(result[-1]))
46 | ```
47 | **-------------------------------------输---------出--------------------------------**
48 |
49 | 192427
50 | 34
51 | ['[', 'Emma', 'by', 'Jane', 'Austen', '1816', ']', 'VOLUME', 'I', 'CHAPTER', 'I', 'Emma', 'Woodhouse', ',', 'handsome', ',', 'clever', ',', 'and', 'rich', ',', 'with', 'a', 'comfortable', 'home', 'and', 'happy', 'disposition', ',', 'seemed']
52 | 30
53 | ['its', 'separate', 'lawn', ',', 'and', 'shrubberies', ',', 'and', 'name', ',']
54 | 10
55 |
56 | **--------------------------------------------完-------------------------------------**
57 |
58 | 可以看出split之后的分成了34块，第一个块长度是30，而最后一块的长度是10，并且split函数准确的将文本进行了分块。
59 |
60 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
61 |
62 | **1，本例中文本分块貌似没有用到NLTK模块中的任何函数，只用python字符串处理函数就可以。但在其他应用场景中，可能会需要更复杂的函数来完成特定的分块功能。**
63 |
64 | **2，本例中使用空格来区分一个单词，这种分词方式并不一定准确，可以使用前面讲到的word_tokenize函数来分词，可能更准确一些。**
65 |
66 | **3，如果是中文的分块，可以先用jieba对文本进行分词，然后在获取特定的单词数来进行文本分块，仿照上面的split函数很容易扩展到中文方面，此处省略。**
67 |
68 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
69 |
70 |
71 |
72 |
73 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
74 |
75 | 参考资料:
76 |
77 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
78 |
--------------------------------------------------------------------------------
/Articles/机器学习038-NLP创建词袋模型.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习038-NLP创建词袋模型
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3)
5 |
6 | 词袋模型（Bag Of Words, BOW)和词向量（Word Embedding, 也叫词嵌套等）是自然语言处理和文本分析的两个最常用的模型。
7 |
8 | 词袋模型将一段文本看成一系列单词的集合，由于单词很多，故而这段文本就相当于一个袋子，里面装着一系列单词。故而计算机的NLP分析就是对这个袋子进行分析，但是计算机不认识文本，只认识数字，那么我们需要一种机制将袋子里的文本转换成数字，这种机制可以是一种Dict映射（key为数字，value为文本等），或数组（索引为数字，值为文本），或者还可以用HashCode来计算文本的数字表示，而NLP建模就是使用这些数字来建模。词袋在学习之后，就可以通过构建文档中所有单词的直方图来对每篇文档进行建模。
9 |
10 | 词向量模型是将单个单词映射到一个高维空间（维度可以到几千几万甚至几十万），这个高维空间就用数组，或者成为向量来表示，故而建立一种单词-向量的映射关系，所以成为词向量模型。但是这种模型能表示的仅仅是单个单词，对于有多个单词组成的一句话，那么就需要做进一步处理，比如一个单词就是一个向量，Ｎ个单词组成的一句话就是Ｎ个一维向量了，故而可以用Ｎ个一维向量组成的矩阵来表示一句话，只不过不同长度的句子，该矩阵的行数不一样罢了。
11 |
12 | 下面我们仅仅学习用NLP创建词袋模型，创建过程主要是提取文本的特征，构建特征向量。有两种方法可以构建特征向量，分别是CountVectorizer和TfidfVectorizer。
13 |
14 |
15 |
16 | ## 1. 用CountVectorizer提取文本特征
17 |
18 | sklearn模块中的CountVectorizer方法可以直接提取文本特征，这个函数只考虑词汇在文本中出现的频率，这个函数有一个参数：stop_words，表示是否取出停用词，所谓的停用词是指为了节省空间和提高效率而自动过滤到的词语，比如 the, is, at, which等，对于不同的，默认的stop_words不去除停用词。
19 |
20 | ```Python
21 | # 数据集暂时用简·奥斯丁的《爱玛》中的文本
22 | dataset=nltk.corpus.gutenberg.words('austen-emma.txt')
23 | # print(len(dataset)) # 192427 代表读入正常
24 | chunks=split(" ".join(dataset[:10000]), 2000) # 将前面的10000个单词分成五个词袋，每个袋子装2000个单词
25 |
26 | # 构建一个文档-词矩阵，该矩阵记录了文档中每个单词出现的频次
27 | # 用sk-learn的CountVectorizer函数来实现这种构建过程
28 | from sklearn.feature_extraction.text import CountVectorizer
29 | vectorizer = CountVectorizer(min_df=4, max_df=.99)
30 | # fit_transform函数需要输入一维数组，且数组元素是用空格连起来的文本
31 | chunks=[" ".join(chunk) for chunk in chunks] # 故而需要转换一下
32 | doc_term_matrix = vectorizer.fit_transform(chunks)
33 | feature_names=vectorizer.get_feature_names() # 获取
34 | print(len(feature_names))
35 | print(doc_term_matrix.shape)
36 | # print(doc_term_matrix.T.toarray())
37 | ```
38 |
39 | 上面将简·奥斯丁的《爱玛》中的前面10000个单词分成了五个词袋，每个词袋包含2000个单词，然后用CountVectorizer建立文本特征向量，通过fit_transform后就在CountVectorizer对象内部建立了这种文档-词矩阵，通过print可以看出结果。
40 |
41 | 为了更加明确的看出里面的文档-词矩阵，可以用下面的代码将其打印出来：
42 |
43 | ```Python
44 | # 打印看看doc_term_matrix这个文档-词矩阵里面的内容
45 | print('Document Term Matrix------>>>>')
46 | bag_names=['Bag_'+str(i) for i in range(5)] # 5个词袋
47 | formatted_row='{:>12}'*(1+len(bag_names)) # 每一行第一列是单词，后面是每个词袋中的频率
48 | print(formatted_row.format('Word', *bag_names))
49 | for word, freq in zip(feature_names,doc_term_matrix.T.toarray()): # 需要装置矩阵
50 | # 此处的freq是csr_matrix数据结构
51 | output = [str(x) for x in freq.data]
52 | print(formatted_row.format(word,*output))
53 | ```
54 |
55 |
56 | **-------------------------------------输---------出--------------------------------**
57 |
58 | Document Term Matrix------>>>>
59 | Word Bag_0 Bag_1 Bag_2 Bag_3 Bag_4
60 | about 3 4 0 1 1
61 | among 1 1 1 1 0
62 | because 1 1 0 1 1
63 | believe 0 1 1 1 3
64 | believed 0 1 1 1 2
65 | best 1 2 1 1 0
66 | better 0 3 1 1 2
67 | beyond 1 0 1 2 3
68 |
69 | ...
70 |
71 | **--------------------------------------------完-------------------------------------**
72 |
73 | 以上是部分结果，可以看出about在Bag_0中出现了3次，在Bag_1中出现了4次，以此类推。
74 |
75 | 如果对这种矩阵的出现次数有疑惑，可以看我的[**我的github中代码**](https://github.com/RayDean/MachineLearning)，里面有更详细的解释。
76 |
77 | 值得注意的是，CountVectorizer也可以用于中文特征的提取，但是需要对自定义的split函数进行修改，原来的函数用空格作为分隔符，可以很好的将英文分词，但对中文无效，故而中文的情况需要将split中的分词方式改成jieba分词。
78 |
79 |
80 |
81 | ## 2. 用TfidfVectorizer提取文本特征
82 |
83 | TfidfVectorizer的主要特点是：除了考量某词汇在文本出现的频率，还关注包含这个词汇的所有文本的数量，这个方法能够削减高频没有意义的词汇带来的影响，挖掘更有意义的特征。一般的，当文本条目越多，这个方法的效果越显著。
84 |
85 | 在代码上，用TfidfVectorizer和上面的CountVectorizer几乎一样，只是将类名称替换一下即可。
86 |
87 | ```Python
88 | # 数据集暂时用简·奥斯丁的《爱玛》中的文本
89 | dataset=nltk.corpus.gutenberg.words('austen-emma.txt')
90 | # print(len(dataset)) # 192427 代表读入正常
91 | chunks=split(" ".join(dataset[:10000]), 2000) # 将前面的10000个单词分成五个词袋，每个袋子装2000个单词
92 |
93 | from sklearn.feature_extraction.text import TfidfVectorizer
94 | vectorizer = TfidfVectorizer()
95 | # fit_transform函数需要输入一维数组，且数组元素是用空格连起来的文本
96 | chunks=[" ".join(chunk) for chunk in chunks] # 故而需要转换一下
97 | doc_term_matrix = vectorizer.fit_transform(chunks)
98 | feature_names=vectorizer.get_feature_names() # 获取
99 | print(len(feature_names))
100 | print(doc_term_matrix.shape)
101 | ```
102 |
103 | 打印出来的结果并不是某个单词在词袋中出现的频率，而是tf-idf权重，这个权重有个计算公式，tf-idf=tf*idf，也就是说tf与idf分别是两个不同的东西。其中tf为谋个训练文本中，某个词的出现次数，即词频(Term Frequency)；idf为逆文档频率（Inverse Document Frequency），对于词频的权重调整系数。
104 |
105 |
106 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
107 |
108 | **1，用于词袋模型中提取文本特征主要有两种方法：CountVectorizer和TfidfVectorizer，其中CountVectorizer构建的文档-词矩阵里面是单词在某个词袋中出现的频率，而TfidfVectorizer构建的矩阵中是单词的tf-idf权重。**
109 |
110 | **2，一般情况下，文档的文本都比较长，故而使用TfidfVectorizer更好一些，推荐首选这个方法。**
111 |
112 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
113 |
114 |
115 |
116 |
117 |
118 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
119 |
120 | 参考资料:
121 |
122 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习040-NLP性别判断分类器.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习040-NLP性别判断分类器
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3)
5 |
6 | 本文的目标是构建一个分类器，从名字就判断这个人是男性还是女性。能够建立这种分类器的基本假设是英文名字后面的几个字母带有很明显的性别倾向，比如'la'结尾的一般是女性，以'im'结尾的一般是男性。故而我们认为名字的后面几个字母和性别之间有很强烈的相关性，所以可以建立一个分类模型，从名字中就可以直接判断性别。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | NLTK库中已经有英文姓名的一些文档，此处我们可以直接加载，并将两部分的名字合并组成一个数据集。
13 |
14 | ```py
15 | # 1, 准备数据集，此次数据集来源于nltk.corpus内置的names文件
16 | from nltk.corpus import names
17 | male_names=[(name, 'male') for name in names.words('male.txt')]
18 | female_names=[(name,'female') for name in names.words('female.txt')]
19 | print(len(male_names)) # 2943
20 | print(len(female_names)) # 5001
21 | # 数据集中有2943个男性名字，5001个女性名字
22 |
23 | # 看看男性和女性的名字都是哪些。。。。
24 | print(male_names[:5])
25 | print(female_names[:3])
26 |
27 | # 将这些名字组成的list合并成一个数据集，第一列是名字，即features，第二列是性别，即label
28 | dataset=np.array(male_names+female_names)
29 | print(dataset.shape) # (7944, 2)没错
30 | ```
31 |
32 | **-------------------------------------输---------出--------------------------------**
33 |
34 | 2943
35 | 5001
36 | [('Aamir', 'male'), ('Aaron', 'male'), ('Abbey', 'male'), ('Abbie', 'male'), ('Abbot', 'male')]
37 | [('Abagael', 'female'), ('Abagail', 'female'), ('Abbe', 'female')]
38 | (7944, 2)
39 |
40 | **--------------------------------------------完-------------------------------------**
41 |
42 | 虽然此处我们假设名字的后面几个字母和性别之间有很强烈的相关性，但是我们不确定到底是最后几个字母的相关性最强，我们应该基于最后的几个字母来建模，所以，此处我们就分别取最后的1-4个字母，然后组成数据集的特征列，分别建模，看看哪一种的结果最好。
43 |
44 | ```py
45 | # 处理数据集
46 | # 我们难以确定到底是姓名后面的几个字母才和性别相关性最大，
47 | # 故而此处把后面的1-4个字母都取出来作为一个特征列
48 | # 用pandas 貌似更容易一些
49 | import pandas as pd
50 | dataset_df=pd.DataFrame(dataset,columns=['name','sex'])
51 | # print(dataset_df.info())
52 | # print(dataset_df.head()) # 检查没有问题
53 |
54 | for i in range(1,5): # 分别截取每个名字的后面i个字母
55 | dataset_df['len'+str(i)]=dataset_df.name.map(lambda x: x[-i:].lower())
56 |
57 | print(dataset_df.head())# 检查没有问题
58 | ```
59 |
60 | **-------------------------------------输---------出--------------------------------**
61 |
62 | name sex len1 len2 len3 len4
63 | 0 Aamir male r ir mir amir
64 | 1 Aaron male n on ron aron
65 | 2 Abbey male y ey bey bbey
66 | 3 Abbie male e ie bie bbie
67 | 4 Abbot male t ot bot bbot
68 |
69 | **--------------------------------------------完-------------------------------------**
70 |
71 |
72 |
73 | ## 2. 建立模型，训练特征
74 |
75 | 此处由于我们不知道姓名后面几个字母得到的结果最准确，故而只能都建模看看在测试集上的表现。如下为代码：
76 |
77 | ```py
78 | # 分别构建分类器，并训练后再测试集上看看效果
79 | dataset=dataset_df.values
80 | np.random.shuffle(dataset)
81 | rows=int(len(dataset)*0.7) # 70%为train set
82 | train_set,test_set=dataset[:rows],dataset[rows:]
83 |
84 | from nltk import NaiveBayesClassifier
85 | from nltk.classify import accuracy as nltk_accuracy
86 | for i in range(1,5): # 对每一列特征分别建模并训练
87 | train_X,train_y=train_set[:,i+1],train_set[:,1]
88 | train=[({'feature':feature},label) for (feature,label) in zip(train_X,train_y)]
89 | # 后面的NaiveBayesClassifier 在train的时候需要()组成的list
90 | clf=NaiveBayesClassifier.train(train)
91 |
92 | # 查看该模型在test set上的表现
93 | test_X,test_y=test_set[:,i+1],test_set[:,1]
94 | test=[({'feature':feature},label) for (feature,label) in zip(test_X,test_y)]
95 | acc=nltk_accuracy(clf,test)
96 |
97 | print('Number of suffix: {}, accuracy on test set: {:.2f}%'
98 | .format(i, 100*acc))
99 | ```
100 |
101 | **-------------------------------------输---------出--------------------------------**
102 |
103 | Number of suffix: 1, accuracy on test set: 76.05%
104 | Number of suffix: 2, accuracy on test set: 77.89%
105 | Number of suffix: 3, accuracy on test set: 75.80%
106 | Number of suffix: 4, accuracy on test set: 71.56%
107 |
108 | **--------------------------------------------完-------------------------------------**
109 |
110 | 由此可以看出，最准确的是只需要两个字母的情况，其次是只需要一个字母。在测试集上的准确率为77%左右。
111 |
112 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
113 |
114 | **1，本项目对数据集的准备需要花费一番功夫，需要分别取出名字的后面N个字母作为一个新的特征列。然后用这个特征列在训练模型**
115 |
116 | **2，nltk模块中继承的分类器可以不需要对特征进行文本转数字操作，故而此处我们没必要用传统机器学习的String转int的读热编码方式来转换，估计nltk这些分类器内部已经集成了这些转换操作。**
117 |
118 | **3，NaiveBaysClassifier在调用train方法时，需要注意输入变量的形式，必须是(特征dict，label)组成的list，否则很多情况下会出错。**
119 |
120 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
121 |
122 |
123 |
124 |
125 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
126 |
127 | 参考资料:
128 |
129 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习041-NLP句子情感分析.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习041-NLP句子情感分析
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 在NLP中有一个非常实用的应用领域--情感分析，情感分析是用NLP技术分析一段给定文本的情感类型，是积极的还是消极的，是乐观的还是悲观的等。比如在股市中，我们知道，往往大众最悲观的时候往往是股市的大底，而最乐观的时候却是股市的顶部，所以，如果我们能够掌握大众的心里情感状况，那么也就能大概知道股市的底和顶，换言之，也就能够在股市上挣得大把大把的银子了。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | 本项目所使用的数据集也是由nltk内部提供，其中的corpus模块中有movies_reviews，可以给我们提供“积极”和“消极”的语句文本。
13 |
14 | ```py
15 | # 1, 准备数据集
16 | from nltk.corpus import movie_reviews
17 | pos_fileIds=movie_reviews.fileids('pos') # 加载积极文本文件
18 | neg_fileIds=movie_reviews.fileids('neg') # 消极文本文件
19 |
20 | print(len(pos_fileIds)) # 1000
21 | print(len(neg_fileIds)) # 1000
22 |
23 | print(pos_fileIds[:5])
24 | print(neg_fileIds[:5])
25 |
26 | # 由此可看出，movie_reviews.fileids是加载各种类别文本的文件，
27 | # 并返回该文件名组成的list
28 |
29 | # 如果想要查看某个文本文件的内容，可以使用
30 | print(movie_reviews.words(fileids=['pos/cv000_29590.txt']))
31 | ```
32 |
33 | **-------------------------------------输---------出--------------------------------**
34 |
35 | 1000
36 | 1000
37 | ['pos/cv000_29590.txt', 'pos/cv001_18431.txt', 'pos/cv002_15918.txt', 'pos/cv003_11664.txt', 'pos/cv004_11636.txt']
38 | ['neg/cv000_29416.txt', 'neg/cv001_19502.txt', 'neg/cv002_17424.txt', 'neg/cv003_12683.txt', 'neg/cv004_12641.txt']
39 | ['films', 'adapted', 'from', 'comic', 'books', 'have', ...]
40 |
41 | **--------------------------------------------完-------------------------------------**
42 |
43 | 虽然上面把文本文件的名称提取出来，但是我们还需要从这些txt文件中提取出所需要的特征，使用这些特征才能进行后续的分类器建模。
44 |
45 | ```py
46 | # 2, 处理数据集
47 | def extract_features(word_list):
48 | '''专门一个函数来提取特征'''
49 | return dict([(word,True) for word in word_list]) # 此处加True的作用是构成dict,实质意义不大
50 |
51 | pos_features=[(extract_features(movie_reviews.words(fileids=[f])),'Pos')
52 | for f in pos_fileIds]
53 | neg_features=[(extract_features(movie_reviews.words(fileids=[f])),'Neg')
54 | for f in neg_fileIds]
55 | print(pos_features[:3]) # 打印下看看内容是否正确
56 |
57 | dataset=pos_features+neg_features # 将两部分结合起来作为一个dataset
58 | ```
59 |
60 | 打印出来的结果很长，可以参考[**我的github**](https://github.com/RayDean/MachineLearning)里面的代码。
61 |
62 |
63 |
64 | ## 2. 建立模型，训练特征
65 |
66 | ```py
67 | # 构建模型，训练模型
68 | from nltk import NaiveBayesClassifier
69 | from nltk.classify import accuracy as nltk_accuracy
70 |
71 | np.random.shuffle(dataset)
72 | rows=int(len(dataset)*0.8) # 80%为train set
73 | train_set,test_set=dataset[:rows],dataset[rows:]
74 | print('Num of train_set: ',len(train_set),
75 | '/nNum of test_set: ',len(test_set))
76 | clf=NaiveBayesClassifier.train(train_set)
77 |
78 | # 查看该模型在test set上的表现
79 | acc=nltk_accuracy(clf,test_set)
80 | print('Accuracy: {:.2f}%'.format(acc*100))
81 | ```
82 |
83 | **-------------------------------------输---------出--------------------------------**
84 |
85 | Num of train_set: 1600
86 | Num of test_set: 400
87 | Accuracy: 70.75%
88 |
89 | **--------------------------------------------完-------------------------------------**
90 |
91 | 由此可以看出该模型在测试集上的表现为：准确率70.75%
92 |
93 | ```py
94 | # 查看模型内部信息
95 | # 该分类器是分析某段文本中哪些单词与“积极”的关联最大，
96 | # 哪些与“消极”的关联最大，进而分析这些关键词的出现来判断某句话是积极或消极
97 |
98 | # 打印这些关键词
99 | for key_word in clf.most_informative_features()[:10]:
100 | print(key_word[0])
101 | ```
102 |
103 |
104 | **-------------------------------------输---------出--------------------------------**
105 |
106 | outstanding
107 | insulting
108 | ludicrous
109 | affecting
110 | magnificent
111 | breathtaking
112 | avoids
113 | strongest
114 | fascination
115 | slip
116 |
117 | **--------------------------------------------完-------------------------------------**
118 |
119 | 可以看出，这些关键词对于区分一个句子是积极还是消极有着至关重要的作用，或者说，如果某个句子中有了这些关键词，就可以区分这个句子的情感是积极还是消极，这些单词越多，模型预测的准确率就越高。
120 |
121 |
122 |
123 | ## 3. 用成熟模型预测新样本
124 |
125 | ```py
126 | # 用该模型来预测新样本，查看新句子的情感是积极还是消极
127 | new_samples = [
128 | "It is an amazing movie",
129 | "This is a dull movie. I would never recommend it to anyone.",
130 | "The cinematography is pretty great in this movie",
131 | "The direction was terrible and the story was all over the place"
132 | ]
133 |
134 | for sample in new_samples:
135 | predict_P=clf.prob_classify(extract_features(sample.split()))
136 | pred_sentiment=predict_P.max()
137 | print('Sample: {}, Type: {}, Probability: {:.2f}%'.format(
138 | sample,pred_sentiment,predict_P.prob(pred_sentiment)*100))
139 | ```
140 |
141 | **-------------------------------------输---------出--------------------------------**
142 |
143 | Sample: It is an amazing movie, Type: Pos, Probability: 61.45%
144 | Sample: This is a dull movie. I would never recommend it to anyone., Type: Neg, Probability: 80.12%
145 | Sample: The cinematography is pretty great in this movie, Type: Pos, Probability: 63.63%
146 | Sample: The direction was terrible and the story was all over the place, Type: Neg, Probability: 63.89%
147 |
148 | **--------------------------------------------完-------------------------------------**
149 |
150 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
151 |
152 | **1，NLTK中所使用的分类器需要用dict类型的数据作为features来数据，故而我们需要自定义一个extract_features函数，来将单词转变为dict类型。**
153 |
154 | **2，NLTK中已经集成了很多分类器，比如NaiveBayesClassifier，这些分类器已经集成了字符串处理方面的各种细节，使用起来很方便。**
155 |
156 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
157 |
158 |
159 |
160 |
161 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
162 |
163 | 参考资料:
164 |
165 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习042-NLP文本的主题建模.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习042-NLP文本的主题建模
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2， NLTK 3.3)
5 |
6 | 文本的主题建模时用NLP来识别文本文档中隐藏的某种模式的过程，可以发现该文档的隐藏主题，以便对文档进行分析。主题建模的实现过程是，识别出某文本文档中最有意义，最能表征主题的词来实现主题分类，即寻找文本文档中的关键词，通过关键词就可以识别出某文档的隐藏主题。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | 本次所用的数据集存放在一个txt文档中，故而需要从txt文档中加载该文本内容，然后再对这些文本进行预处理。由于预处理的步骤比较多，故而此处建立一个class来完成数据的加载和预处理过程，也使得代码看起来更简洁，更通用。
13 |
14 |
15 | ```py
16 | # 准备数据集，建一个class来加载数据集，对数据进行预处理
17 | from nltk.tokenize import RegexpTokenizer
18 | from nltk.corpus import stopwords
19 | from nltk.stem.snowball import SnowballStemmer
20 | from gensim import models, corpora
21 |
22 | class DataSet:
23 |
24 | def __init__(self,txt_file_path):
25 | self.__txt_file=txt_file_path
26 |
27 | def __load_txt(self): # 从txt文档中加载文本内容，逐行读入
28 | with open(self.__txt_file,'r') as file:
29 | content=file.readlines() # 一次性将所有的行都读入
30 | return [line[:-1] for line in content] # 去掉每一行末尾的\n
31 |
32 | def __tokenize(self,lines_list): # 预处理之一：对每一行文本进行分词
33 | tokenizer=RegexpTokenizer('\w+')
34 | # 此处用正则表达式分词器而不用word_tokenize的原因是：排除带有标点的单词
35 | return [tokenizer.tokenize(line.lower()) for line in lines_list]
36 |
37 | def __remove_stops(self,lines_list): # 预处理之二：对每一行取出停用词
38 | # 我们要删除一些停用词，避免这些词的噪声干扰，故而需要一个停用词表
39 | stop_words_list=stopwords.words('english') # 获取英文停用词表
40 | return [[token for token in line if token not in stop_words_list]
41 | for line in lines_list]
42 | # 这儿有点难以理解，lines_list含有的元素也是list，这一个list就是一行文本，
43 | # 而一行文本内部有N个分词组成，故而lines_list可以看出二维数组，需要用两层generator
44 |
45 | def __word_stemm(self,lines_list): # 预处理之三：对每个分词进行词干提取
46 | stemmer=SnowballStemmer('english')
47 | return [[stemmer.stem(word) for word in line] for line in lines_list]
48 |
49 | def prepare(self):
50 | '''供外部调用的函数，用于准备数据集'''
51 | # 先从txt文件中加载文本内容，再进行分词，再去除停用词，再进行词干提取
52 | stemmed_words=self.__word_stemm(self.__remove_stops(self.__tokenize(self.__load_txt())))
53 | # 后面的建模需要用到基于dict的词矩阵，故而先用corpora构建dict在建立词矩阵
54 | dict_words=corpora.Dictionary(stemmed_words)
55 | matrix_words=[dict_words.doc2bow(text) for text in stemmed_words]
56 | return dict_words, matrix_words
57 |
58 | # 以下函数主要用于测试上面的几个函数是否运行正常
59 | def get_content(self):
60 | return self.__load_txt()
61 |
62 | def get_tokenize(self):
63 | return self.__tokenize(self.__load_txt())
64 |
65 | def get_remove_stops(self):
66 | return self.__remove_stops(self.__tokenize(self.__load_txt()))
67 |
68 | def get_word_stemm(self):
69 | return self.__word_stemm(self.__remove_stops(self.__tokenize(self.__load_txt())))
70 | ```
71 |
72 | 这个类是否运行正常，是否能够得到我们预期的结果了？可以用下面的代码来测试
73 |
74 | ```py
75 | # 检验上述DataSet类是否运行正常
76 | dataset=DataSet("E:\PyProjects\DataSet\FireAI\data_topic_modeling.txt")
77 |
78 | # 以下测试load_txt()函数是否正常
79 | content=dataset.get_content()
80 | print(len(content))
81 | print(content[:3])
82 |
83 | # 以下测试__tokenize()函数是否正常
84 | tokenized=dataset.get_tokenize()
85 | print(tokenized)
86 |
87 | # 一下测试__remove_stops()函数是否正常
88 | removed=dataset.get_remove_stops()
89 | print(removed)
90 |
91 | # 以下测试__word_stemm()函数是否正常
92 | stemmed=dataset.get_word_stemm()
93 | print(stemmed)
94 |
95 | # 以下测试prepare函数是否正常
96 | _,prepared=dataset.prepare()
97 | print(prepared)
98 | ```
99 |
100 | 输出的运行结果比较长，可以看我的github源代码。
101 |
102 |
103 |
104 | ## 2. 构建模型，训练数据集
105 |
106 | 我们用LDA模型（Latent Dirichlet Allocation， LDA）做主题建模，如下：
107 |
108 | ```py
109 | # 获取数据集
110 | dataset=DataSet("E:\PyProjects\DataSet\FireAI\data_topic_modeling.txt")
111 | dict_words, matrix_words =dataset.prepare()
112 |
113 | # 使用LDAModel建模
114 | lda_model=models.ldamodel.LdaModel(matrix_words,num_topics=2,
115 | id2word=dict_words,passes=25)
116 | # 此处假设原始文档有两个主题
117 | ```
118 |
119 | 上面的代码会建立LDAModel并对模型进行训练，需要注意，LDAModel位于gensim模块中，这个模块需要自己用pip install gensim来安装，安装之后才能使用。
120 |
121 | LDAModel会计算每个单词的重要性，然后建立重要性计算方程，依靠此方程来给出预测主题。
122 |
123 | 如下代码可以打印出该重要性方程：
124 |
125 | ```py
126 | # 查看模型中最重要的N个单词
127 | print('Most important words to topics: ')
128 | for item in lda_model.print_topics(num_topics=2,num_words=5):
129 | # 此处只打印最重要的5个单词
130 | print('Topic: {}, words: {}'.format(item[0],item[1]))
131 | ```
132 |
133 | **-------------------------------------输---------出--------------------------------**
134 |
135 | Most important words to topics:
136 | Topic: 0, words: 0.075*"need" + 0.053*"order" + 0.032*"system" + 0.032*"encrypt" + 0.032*"work"
137 | Topic: 1, words: 0.037*"younger" + 0.037*"develop" + 0.037*"promot" + 0.037*"talent" + 0.037*"train"
138 |
139 | **--------------------------------------------完-------------------------------------**
140 |
141 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
142 |
143 | **1，一般机器学习项目需要我们自己处理的内容都是数据集方面，可以将数据集处理过程写成一个专门的class，比如上面我把文本预处理过程写在class里面，每一个函数代表一种预处理方式，这样条理清楚，具有一定通用性。**
144 |
145 | **2，此处我们使用gensim模块中的LDAModel来做主题建模，gensim模块是一个非常有用的NLP处理工具，在文本内容分析中应用较多。**
146 |
147 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
148 |
149 |
150 |
151 |
152 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
153 |
154 | 参考资料:
155 |
156 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习043-pandas操作时间序列数据.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习043-pandas操作时间序列数据
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 时间序列数据分析是机器学习领域中的一个重要领域，时间序列数据是随着时间变化而不断变化的数据，最典型的一个例子就是股价数据，随着日期的不同而不同，还有一年四季的温度变化，台风运行轨迹等等领域。这个领域的一个重要点是收集到的样本数据在时间是相关的，我们不能像以前那样打乱样本数据之间的顺序，故而这各领域需要特别的研究方式。
7 |
8 |
9 |
10 | ## 1. 准备时间序列数据
11 |
12 | 本章用到的时间序列数据来源于文件data_timeseries.txt，这个文件中第一列是年份，从1940到2015，第二列是月份，第三列和第四列是数据。
13 |
14 | ### 1.1 数据转换为时间序列格式
15 |
16 | 我们可以将第一列和第二列合并，然后在用一个函数将合并后的字符串转换为Date类型，但是此处的数据很有规律性，时间上没有遗漏，故而我们可以借助pandas的date_range()函数来构建时间序列，并将该时间序列作为DataFrame数据集的index
17 |
18 | 第一步：用pandas加载数据集
19 |
20 | ```py
21 | # 加载数据集
22 | data_path='E:\PyProjects\DataSet\FireAI/data_timeseries.txt'
23 | df=pd.read_csv(data_path,header=None)
24 | print(df.info()) # 查看数据信息，确保没有错误
25 | print(df.head())
26 | print(df.tail())
27 | ```
28 |
29 | 第二步：用pd.date_range()建立时间序列数据
30 |
31 | ```py
32 | start=str(df.iloc[0,0])+'-'+str(df.iloc[0,1]) # 1940-1
33 | if df.iloc[-1,1] %12 ==0: # 如果是12月结尾，需要转为第二年1月
34 | end=str(int(df.iloc[-1,0])+1)+'-01'
35 | else:
36 | end=str(df.iloc[-1,0])+'-'+str(int(df.iloc[-1,1])+1)
37 | print(end)
38 |
39 | dates=pd.date_range(start,end,freq='M') # 构建以月为间隔的日期数据
40 | print(dates[0])
41 | print(dates[-1]) # 最后一个是2015-12 没有错误
42 | print(len(dates))
43 | ```
44 |
45 | 注意上面有一个判断最后一个月是否是12月，因为date_range在freq为月的时候得到的结果不包含end所在的月份，故而此处我们要加上一个月份，使得最终日期的个数相同。
46 |
47 | **-------------------------------------输---------出--------------------------------**
48 |
49 | 2016-01
50 | 1940-01-31 00:00:00
51 | 2015-12-31 00:00:00
52 | 912
53 |
54 | **--------------------------------------------完-------------------------------------**
55 |
56 | 第三步：将时间序列数据设置为df的index
57 |
58 | ```py
59 | df.set_axis(dates)
60 | print(df.info())
61 | print(df.head())
62 | ```
63 |
64 | 从结果中可以看出，上面得到的dates日期数据已经变成了df这个数据集的index.
65 |
66 | ### 1.2 时间序列数据的绘图
67 |
68 | pandas内部本来就集成了matplotlib这个函数的多种画图功能，故而我们可以直接画图，比如对所有的第二列数据画图，代码为：
69 |
70 | ```py
71 | # 画图
72 | df.iloc[:,2].plot() # 画出第2列的时序数据
73 | ```
74 |
75 | 
76 |
77 | 上面图中数据量太大，导致密密麻麻看不清楚，故而我们需要只绘制一部分图来看清楚某一个时间段内的数据走势，可以用下列方法：
78 |
79 | ```py
80 | # 上面的图中数据太密集了，我们需要查看部分时间段的数据
81 | start='2008-2'
82 | end='2010-3'
83 | df.iloc[:,2][start:end].plot()
84 | # 注意这种写法，先获取第二列数据为Series，然后对Series进行时间范围切片即可
85 | ```
86 |
87 | 
88 |
89 | 也可以选择某几年的数据来绘图
90 |
91 | ```py
92 | start='2008' # 给定年份来获取数据
93 | end='2010'
94 | df.iloc[:,2][start:end].plot()
95 |
96 | ```
97 |
98 | 
99 |
100 |
101 | 上面每次只绘制一列数据，其实可以同时绘制多列数据，如下：
102 |
103 | ```py
104 | # 上面每次只绘制一列数据，下面同时绘制两列数据
105 | start='2008' # 给定年份来获取数据
106 | end='2010'
107 | df.iloc[:,2:4][start:end].plot() # 同时绘制第二列和第三列的数据
108 | ```
109 |
110 | 
111 |
112 |
113 | 还可以绘制这两列数据之间的差，或和，或min，max等如下：
114 |
115 | ```py
116 | # 也可以绘制两列数据的差异
117 | start='2008' # 给定年份来获取数据
118 | end='2010'
119 | temp_df=df.iloc[:,2][start:end]-df.iloc[:,3][start:end]
120 | temp_df.plot()
121 | ```
122 |
123 | 
124 |
125 | 还可以绘制出某一列大于某值且另一列小于某值的一部分数据。
126 |
127 | ```py
128 | # 还可以筛选出第一个大于某个值，同时第二列小于某个值的数据来绘图
129 | temp_df2=df[df.iloc[:,2]>60][df.iloc[:,3]<20].iloc[:,2:4]
130 | temp_df2.plot()
131 | ```
132 |
133 | 
134 |
135 |
136 | ### 1.3 获取统计数据
137 |
138 | ### 1.3.1 获取Max,Min，Mean等
139 |
140 | ```py
141 | # 获取数据集的统计数据
142 | part_df=df.iloc[:,2:4] # 只取第二和第三列进行统计
143 | print('Max: \n{}'.format(part_df.max()))
144 | print('Min: \n{}'.format(part_df.min()))
145 | print('Mean: \n{}'.format(part_df.mean()))
146 | # 上面这个方法虽然可以获取Max，Min，Mean值，但是还不如下面这个函数好用
147 |
148 | print(part_df.describe()) # 这个可以从整体上看出数据的分布情况
149 |
150 | ```
151 |
152 | 上面几个函数很简单，就不贴打印结果了。
153 |
154 |
155 | ### 1.3.2 计算移动平均值
156 |
157 | 移动平均值的意义主要是消除噪声，使得信号看起来更加的平滑，计算方法就是计算前面N个数据的平均值，然后在移动一位，始终计算最近N个数据的平均值。如果你会炒股，那么对移动平均线的意义和计算方法应该会了然于胸。
158 |
159 | ```py
160 | # 计算移动平均值MAn
161 | N=20
162 | MAn=part_df.rolling(N).mean()
163 | MAn.plot()
164 | ```
165 |
166 | 
167 |
168 |
169 | ### 1.3.3 计算移动平均值的相关系数
170 |
171 | 移动平均值的相关系数可以理解为：两列数据的相关性，如果相关性很强，那么这两列数据具有很强的关联，用股票数据来说明的话，移动平均值的相关性就是这两只股票的股价走势相关性，如果相关性很强，那么这两只股票会表现出同步的“同涨共跌”的走势，如果相关性很小，说明两个股票的价格走势没有太大关系。
172 |
173 | ```py
174 | # 计算移动平均值MAn的相关系数
175 | N=20
176 | MAn=part_df.rolling(N).mean()
177 | corr=MAn.iloc[:,0].rolling(window=40).corr(MAn.iloc[:,1])
178 | corr.plot()
179 | ```
180 |
181 | 
182 |
183 |
184 |
185 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
186 |
187 | **1，这部分很多都是Pandas模块的基本方法，所以也没有太多要讲解的内容。**
188 |
189 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
190 |
191 |
192 |
193 |
194 |
195 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
196 |
197 | 参考资料:
198 |
199 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习045-对股票数据进行隐马尔科夫建模.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习045-对股票数据进行隐马尔科夫建模
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 股票数据是非常非常典型的时序数据，数据都是按照日期排列好，而且股价就是我们所能观察到的观测序列，而股价背后隐藏的变动机理就是我们难以看到的隐藏状态和状态转移概率，所以完全可以用隐马尔科夫对股票进行建模，并预测出股票后续的变动情况，如果在股票数据研究上有点突破，那么，银子就大把大把的到口袋中来。
7 |
8 |
9 |
10 | ## 1. 准备数据集
11 |
12 | 此处我用tushare提取某只股票数据，然后用该股票的每日涨幅和成交量来建模，看看能预测出什么结果。
13 |
14 | ```py
15 | # 1， 准备数据集，使用tushare来获取股票数据
16 | import tushare as ts
17 | stock_df=ts.get_k_data('600123',start='2008-10-01',end='2018-10-01') # 获取600123这只股票的近十年数据
18 | print(stock_df.info()) # 查看没有错误
19 | print(stock_df.head())
20 | ```
21 |
22 | 上面只是下载了600123这只股票的最近十年的日数据，但是我们要得到的是收盘价的涨幅，所还需要对数据做进一步处理。
23 |
24 | ```py
25 | # 准备数据集，此次我们用两个指标来计算HMM模型，股价涨幅和成交量
26 | close=stock_df.close.values
27 | feature1=100*np.diff(close)/close[:-1] # 股票涨幅的计算
28 | print(close[:10])
29 | print(feature1[:10]) # 查看涨幅计算有没问题
30 | ```
31 |
32 | **-------------------------------------输---------出--------------------------------**
33 |
34 | [6.775 6.291 6.045 5.899 5.361 5.436 5.299 4.994 4.494 4.598]
35 | [ -7.14391144 -3.91034812 -2.41521919 -9.12018986 1.39899273
36 | -2.52023547 -5.75580298 -10.01201442 2.31419671 9.98260113]
37 |
38 | **--------------------------------------------完-------------------------------------**
39 |
40 |
41 | ```py
42 | # 由于计算涨幅之后的序列比原来的收盘价序列少一个（最开始的股价没法计算涨幅），故而需要减去一个
43 | feature2=stock_df.volume.values[1:]
44 | dataset_X=np.c_[feature1,feature2]
45 | print(dataset_X[:5]) # 检查没错
46 | ```
47 |
48 |
49 |
50 | ## 2. 创建HMM模型
51 |
52 | 关于HMM模型，我已经在我前面的文章中进行了详细的讲解，请参考[【火炉炼AI】机器学习044-创建隐马尔科夫模型](https://www.cnblogs.com/RayDean/p/9816280.html)
53 |
54 | ```py
55 | # 创建HMM模型，并训练
56 | from hmmlearn.hmm import GaussianHMM
57 | model=GaussianHMM(n_components=5,n_iter=1000) # 暂时假设该股票有5个隐含状态
58 | model.fit(dataset_X)
59 | ```
60 |
61 | 在使用HMM模型建模之后，我们怎么知道这个模型的好坏了？那么就需要将其预测的结果和实际的结果进行比较，看看是否一致。
62 |
63 | ```py
64 | # 使用该模型查看一下效果
65 | N=500
66 | samples,_=model.sample(N)
67 | # 由于此处我使用涨幅作为第一个特征，成交量作为第二个特征进行建模，
68 | # 故而得到的模型第一列就是预测的涨幅，第二列就是成交量
69 | plt.plot(feature1[:N],c='red',label='Rise%') # 将实际涨幅和预测的涨幅绘制到一幅图中方便比较
70 | plt.plot(samples[:,0],c='blue',label='Predicted%')
71 | plt.legend()
72 | ```
73 |
74 | 
75 |
76 | 貌似匹配结果不怎么样，再来看看对于成交量的预测：
77 |
78 | ```py
79 | plt.plot(feature2[:N],c='red',label='volume')
80 | plt.plot(samples[:,1],c='blue',label='Predicted')
81 | plt.legend()
82 | ```
83 |
84 | 
85 |
86 | 这两个结果都不怎么样，预测值和实际值都相差比较大，说明模型难以解决这个项目。我们换个角度来想，如果这么简单就能预测股票的走势，那每个人都会从股市捞钱，最终股市只能关门了。读者有兴趣可以优化一下HMM模型的隐含状态数，可能会得到比较好的匹配结果，但是也有可能发生过拟合，所以我觉得优化的用处不大。
87 |
88 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
89 |
90 | **1，此处只是简单的做了一个用HMM模型来分析股票数据的例子，虽然实用价值不大，但可以给其他复杂的算法提供一点思路。**
91 |
92 | **2，还是那句话，远离股市，远离伤害。**
93 |
94 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
95 |
96 |
97 |
98 |
99 |
100 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
101 |
102 | 参考资料:
103 |
104 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习046-图像中线条的检测方法.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习046-图像边缘的检测方法
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 图像中各种形状的检测时计算机视觉领域中非常常见的技术之一，特别是图像中直线的检测，圆的检测，图像边缘的检测等，下面我们来研究一下如何快速检测图像边缘。
7 |
8 | 边缘是不同区域的分界线，是周围（局部）像素有显著变化的像素的集合，有幅值与方向两个属性。这个不是绝对的定义，主要记住边缘是局部特征以及周围像素显著变化产生边缘。
9 |
10 | 常见边缘检测算子：Roberts 、Sobel 、Prewitt、Laplacian、Log/Marr、Canny、Kirsch、Nevitia
11 |
12 |
13 |
14 | ## 1. Sobel算子
15 |
16 | Sobel算子是图像边缘检测中最重要的算子之一，在机器学习中占有举足轻重的作用，在技术上，它是一个离散的一阶差分算子，用来计算图像亮度函数的一阶梯度之近似值。在图像的任何一点使用此算子，将会得到该点对应的梯度矢量或法矢量。
17 |
18 | 在计算公式上，Sobel算子包含有两组3*3的矩阵，分别为横向及纵向，将这两个矩阵与图像做平面卷积，即可分别得到横向及纵向的亮度差分近似值。所以这两个算子，一个是检测水平边缘的，另一个是检测垂直边缘的，与Prewitt算子相比，Sobel算子对于像素的位置的影响做了加权，可以降低边缘模糊程度，因此效果更好。
19 |
20 | Sobel算子算法的优点是计算简单，速度快，但是由于只采用了两个方向的模板，只能检测水平和垂直方向的边缘，因此这种算法对于纹理较为复杂的图像，其边缘检测效果就不是很理想。该算法认为：凡灰度新值大于或等于阈值的像素点都是边缘点，这种判断不太合理，会造成边缘点的误判，因为许多噪声点的灰度值也很大。
21 |
22 | ```py
23 | import cv2
24 | image=cv2.imread('E:\PyProjects\DataSet\FireAI/chair.jpg')
25 | # Sobel 算子进行图像边缘检测
26 | sobel_h=cv2.Sobel(image,cv2.CV_64F,1,0,ksize=3)
27 | sobel_v=cv2.Sobel(image,cv2.CV_64F,0,1,ksize=3)
28 | plt.figure(13,figsize=(15,30))
29 |
30 | plt.subplot(131)
31 | plt.imshow(image,cmap='gray') # 彩色图像显示异常，plt采用RGB模式，而cv2采用BGR模式
32 | plt.title('raw_img')
33 |
34 | plt.subplot(132)
35 | plt.imshow(sobel_h,cmap='gray')
36 | plt.title('sobel_h')
37 |
38 | plt.subplot(133)
39 | plt.imshow(sobel_v,cmap='gray')
40 | plt.title('sobel_v')
41 | ```
42 |
43 | 
44 |
45 |
46 | Sobel算子需要优化的地方可能只有ksize一个参数了。ksize只能去1，3,5,7这四个数字。
47 |
48 |
49 |
50 | ## 2. Laplacian算子
51 |
52 | Laplacian算子是N维欧几里得空间中的一个二阶微分算子，定义为梯度grad的散度div。此处不讲解这个算子的计算和原理，只讲解使用方法和效果
53 |
54 | ```py
55 | # Laplacian算子进行图像边缘检测
56 | lap=cv2.Laplacian(image, cv2.CV_64F)
57 | plt.figure(12,figsize=(10,30))
58 |
59 | plt.subplot(121)
60 | plt.imshow(image,cmap='gray') # 彩色图像显示异常，plt采用RGB模式，而cv2采用BGR模式
61 | plt.title('raw_img')
62 |
63 | plt.subplot(122)
64 | plt.imshow(lap,cmap='gray')
65 | plt.title('Laplacian')
66 | ```
67 |
68 | 
69 |
70 |
71 |
72 |
73 | ## 3. Canny算子
74 |
75 | Canny的目标是找到一个最优的边缘检测算法，最有边缘检测的含义是：
76 |
77 | 1，好的检测：算法能够尽可能多的标识出图像中的实际边缘。
78 |
79 | 2，好的定位：标识出的边缘要与实际图像中的实际边缘尽可能接近。
80 |
81 | 3，最小相应：图像中的边缘只能标识一次，并可能存在的图像噪声不应标识为边缘
82 |
83 | 为了满足这些要求，Canny使用了变分法，这是一种寻找满足特定功能的函数的方法，最优检测使用四个指数函数项的和表示，但是它非常近似于高斯函数的一阶导数。
84 |
85 | Canny算法的步骤可以分为：降噪，寻找梯度，跟踪边缘。降噪是对原始图像与高斯平滑模板做卷积，得到的图像与原始图像相比有些轻微的模糊，这样做的目的是单独的像素噪声在经过高斯平滑处理后就变得几乎没有影响。
86 |
87 | 寻找梯度：Canny算子使用4个mask检测水平，垂直以及对角线方向的边缘，原始图像与每个mask所作的卷积都存储起来。对于每个点我们都标识在这个点上的最大值以及生成的边缘方向。这样我们就从原始图像生成了图像中每个点亮度梯度图以及亮度梯度的方向。
88 |
89 | 跟踪边缘：较高的亮度梯度比较有可能是边缘，但是没有一个确切的值来限定多大的亮度梯度是边缘，所以canny使用滞后阈值--高阈值和低阈值。
90 |
91 | 上述步骤完成之后，我们就得到了一个二值图，每点表示是否是一个边缘点。
92 |
93 | ```py
94 | # Canny算子
95 | canny = cv2.Canny(image, 50, 240)
96 | plt.figure(12,figsize=(10,30))
97 |
98 | plt.subplot(121)
99 | plt.imshow(image,cmap='gray') # 彩色图像显示异常，plt采用RGB模式，而cv2采用BGR模式
100 | plt.title('raw_img')
101 |
102 | plt.subplot(122)
103 | plt.imshow(canny,cmap='gray')
104 | plt.title('Canny')
105 | ```
106 |
107 | 
108 |
109 | Canny算子使用的一个难点在于高阈值和低阈值的选择，其实对于任何阈值的选择，都面临一个两难问题，设置的太高，可能会漏掉部分信息，设置的过低，会把噪声当做重要信号来处理，这一点，倒是很像机器学习中的准确率和召回率的关系。
110 |
111 | Canny算子适用于不同的场合，它的参数允许根据不同实现的特定要求进行调整以识别不同的边缘特性。
112 |
113 |
114 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
115 |
116 | **1，此处讲解的三个边缘检测算子，使用起来都比较简单，比较难的是理解其内在本质含义。**
117 |
118 | **2，从效果上来看，我个人比较倾向于Canny算子，因为从图片中可以看出，其噪声最少，得到的边缘效果最好。**
119 |
120 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
121 |
122 |
123 |
124 |
125 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
126 |
127 | 参考资料:
128 |
129 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习047-图像的直方图均衡化操作.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习047-图像的直方图均衡化操作
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 图像的直方图是指图像中每一像素范围内像素频率的统计关系图，直方图能够给出图像灰度范围，每个灰度的频度和灰度的分布，整幅图的平均明暗，对比度等概貌性描述。灰度直方图是灰度级的函数，反映的是图像中具有该灰度级像素的个数。如果大部分像素都集中在低灰度区域，图像会呈现暗的特性，反之，如果大部分图像都集中在高灰度区域，图像呈现出亮的特性。
7 |
8 | 直方图均衡化是指，将随机分布的图像直方图修改成均匀分布的直方图，基本思想是对原始图像的像素灰度做某种映射变换，使得变换后的图像灰度的概率密度呈均匀分布，这就意味着图像灰度的动态范围得到扩大，提高了图像的对比度。
9 |
10 |
11 |
12 |
13 | ## 1. 获取图像直方图
14 |
15 | 图像直方图有灰度直方图和彩色直方图的区别，如果输入图像是灰度图，则得到灰度直方图，如果输入图像是BGR图像，得到的则是某个颜色通道的直方图。
16 |
17 | ```py
18 | # 获取灰度直方图
19 | gray_hist=cv2.calcHist([gray], [0], None, [256], [0, 256])
20 | plt.plot(gray_hist)
21 | ```
22 |
23 | 
24 |
25 |
26 | 取得图像的灰度直方图，只需要调用cv2.calcHist()函数即可，这个函数的参数为：
27 |
28 | 第一个参数为输入的图像，可以是灰度图也可以是彩色图。
29 |
30 | 第二个参数是用于计算直方图的通道，这里使用灰度图计算直方图，所以就直接使用第一个通道；
31 |
32 | 第三个参数是Mask，这里没有使用，所以用None。
33 |
34 | 第四个参数是histSize，表示这个直方图分成多少份（即多少个直方柱）。
35 |
36 | 第五个参数是表示直方图中各个像素的值，[0.0, 256.0]表示直方图能表示像素值从0.0到256的像素。
37 |
38 | 最后是两个可选参数，由于直方图作为函数结果返回，所以第六个hist就没有意义了（待确定）
39 |
40 | 最后一个accumulate是一个布尔值，用来表示直方图是否叠加。
41 |
42 | ```py
43 | # 获取彩色图的各个通道直方图
44 | hist_B=cv2.calcHist([img],[0],None,[256],[0,256])
45 | plt.plot(hist_B,'b',label='B') # Blue color
46 |
47 | hist_G=cv2.calcHist([img],[1],None,[256],[0,256])
48 | plt.plot(hist_G,'g',label='G') # green color
49 |
50 | hist_R=cv2.calcHist([img],[2],None,[256],[0,256])
51 | plt.plot(hist_R,'r',label='R')# red color
52 | plt.title('histogram of Color Chanel')
53 | plt.legend()
54 | ```
55 |
56 | 
57 |
58 |
59 |
60 | ## 2. 直方图均衡化
61 |
62 | ### 2.1 灰度图的直方图均衡化
63 |
64 | 为了方便对比，我将直方图均衡化前后的图像都绘制到同一个图片中。如下：
65 |
66 | ```py
67 | # 灰度图的直方图均衡化：
68 | # 先显示均衡化前后的图像
69 | plt.figure(12,figsize=(15,30))
70 | plt.subplot(121)
71 | plt.imshow(gray,cmap='gray')
72 | plt.title('GrayImg before Equalization')
73 |
74 | equalize = cv2.equalizeHist(gray)
75 | plt.subplot(122)
76 | plt.imshow(equalize,cmap='gray')
77 | plt.title('GrayImg after Equalization')
78 | ```
79 |
80 | 
81 |
82 | ```py
83 | plt.plot(gray_hist,c='b',label='raw_Hist')
84 |
85 | gray_equalized_hist=cv2.calcHist([equalize], [0], None, [256], [0, 256])
86 | plt.plot(gray_equalized_hist,c='r',label='Equalized')
87 |
88 | plt.legend()
89 | plt.title('Histogram comparison')
90 | ```
91 |
92 | 
93 |
94 | 话说，经过直方图均衡化之后的直方图怎么长的这么丑？
95 |
96 | 直方图均衡化只需要一个函数cv2.equalizeHist()即可，但是需要注意：cv2.equalizeHist()只提供灰度值图片的处理，当把上面的图片换成RGB图片时，就会报错了。
97 |
98 | ### 2.2 彩色图的直方图均衡化
99 |
100 | 彩色图的直方图均衡化需要借助YUV空间，如下代码：
101 |
102 | ```py
103 | # 彩色直方图均衡化需要借助YUV空间
104 | img_yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
105 | img_yuv[:,:,0] = cv2.equalizeHist(img_yuv[:,:,0])
106 | img_histeq = cv2.cvtColor(img_yuv, cv2.COLOR_YUV2BGR)
107 |
108 | # 显示均衡化前后的图像
109 | plt.figure(12,figsize=(15,30))
110 | plt.subplot(121)
111 | img_rgb=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
112 | plt.imshow(img_rgb)
113 | plt.title('ColorImg before Equalization')
114 |
115 | plt.subplot(122)
116 | img_hist_rgb=cv2.cvtColor(img_histeq,cv2.COLOR_BGR2RGB)
117 | plt.imshow(img_hist_rgb)
118 | plt.title('ColorImg after Equalization')
119 | ```
120 |
121 | 
122 |
123 | ```py
124 | # 显示均衡化前后的直方图情况
125 | plt.figure(12)
126 |
127 | plt.subplot(121)
128 | hist_B=cv2.calcHist([img],[0],None,[256],[0,256])
129 | plt.plot(hist_B,'b',label='B') # Blue color
130 |
131 | hist_G=cv2.calcHist([img],[1],None,[256],[0,256])
132 | plt.plot(hist_G,'g',label='G') # green color
133 |
134 | hist_R=cv2.calcHist([img],[2],None,[256],[0,256])
135 | plt.plot(hist_R,'r',label='R')# red color
136 | plt.title('Color Histogram before Equalization')
137 | plt.legend()
138 |
139 | plt.subplot(122)
140 | hist_B=cv2.calcHist([img_histeq],[0],None,[256],[0,256])
141 | plt.plot(hist_B,'b',label='B') # Blue color
142 |
143 | hist_G=cv2.calcHist([img_histeq],[1],None,[256],[0,256])
144 | plt.plot(hist_G,'g',label='G') # green color
145 |
146 | hist_R=cv2.calcHist([img_histeq],[2],None,[256],[0,256])
147 | plt.plot(hist_R,'r',label='R')# red color
148 | plt.title('Color Histogram after Equalization')
149 | plt.legend()
150 | ```
151 |
152 | 
153 |
154 | 同样的，经过对比可以看出，经过直方图均衡化之后的图像直方图都比较丑。。。。
155 |
156 |
157 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
158 |
159 | **1，对于图像直方图进行操作可以比较明显的改变图像的对比度和明暗度。**
160 |
161 |
162 | **2，使用cv2.equalizeHist函数可以直接改变灰度图的直方图，但是却不能直接改变彩色图的直方图，对于彩色图如果想要均衡化，需要先转变到YUV空间再进行转换。**
163 |
164 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
165 |
166 |
167 |
168 |
169 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
170 |
171 | 参考资料:
172 |
173 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习048-Harris检测图像角点.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习048-Harris检测图像角点
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 角点检测算法大致有三类：基于灰度图像的角点检测，基于二值图像的角点检测，基于轮廓曲线的角点检测。基于灰度图像的角点检测又可分为基于梯度、基于模板和基于模板梯度组合3类方法，其中基于模板的方法主要考虑像素领域点的灰度变化，即图像亮度的变化，将与邻点亮度对比足够大的点定义为角点。常见的基于模板的角点检测算法有Kitchen-Rosenfeld角点检测算法，Harris角点检测算法、KLT角点检测算法及SUSAN角点检测算法。
7 |
8 |
9 |
10 | ## 1. Harris角点检测器
11 |
12 | Harris角点检测主要经过以下步骤：
13 |
14 | 1，对图像进行高斯滤波
15 |
16 | 2，对每个像素，估计其垂直方向的梯度大小值，使用近似于导数的核做两次一维卷积。
17 |
18 | 3，对每一像素核给定的邻域窗口：计算局部结构矩阵和响应函数。
19 |
20 | 4，选取响应函数的一个阈值，以选择最佳候选角点并完成非极大值抑制。
21 |
22 | 关于Harris角点检测器的具体算法，可以参考这篇博文：[harris角点检测器](https://www.cnblogs.com/hfutemg/p/5611329.html)
23 |
24 | 下面我们来一步一步的使用Harris来检测图像中的角点
25 |
26 | ```py
27 | # Harris 角点检测器
28 | img_gray = np.float32(gray) # Harris角点检测器需要float型数据
29 | img_harris = cv2.cornerHarris(img_gray, 7, 5, 0.04) # 使用角点检测
30 | plt.imshow(img_harris,cmap='gray')
31 | ```
32 |
33 | 
34 |
35 | 上面使用cv2.cornerHarris()函数检测到了图片中的角点，但是从图中可以看出，也检测出了很多边缘线条，故而我们要想办法去掉这些边缘线条而保留角点。
36 |
37 | ```py
38 | # 为了图像更加平滑，使用膨胀来将图像边缘减小，使得角点更突出
39 | img_harris = cv2.dilate(img_harris, None)
40 | plt.imshow(img_harris,cmap='gray')
41 | ```
42 |
43 | 
44 |
45 | 从图片中可以看出，经过膨胀操作之后，边缘线条的宽度变小，而角点几乎不变。
46 |
47 | 但是我们要确定一个角点定义方法，此处我们定义像素值为最大值的1%以上为角点，从代码中可以看出：
48 |
49 | ```py
50 | # 确定角点的方法：此处我们定义角点为：其像素值为最大值的1%以上为角点，如下：
51 | is_corner=img_harris > 0.01 * img_harris.max()
52 | plt.imshow(is_corner,cmap='gray') # 将角点绘制出来看一下
53 | ```
54 |
55 | 
56 |
57 | 上面的二值化图可以很明显的判断出哪些是角点，那么将这些角点绘制到原图中是怎么样了？
58 |
59 | ```py
60 | img[is_corner]=[0, 0, 255] # 用红色标注这些角点
61 | img2=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
62 | plt.imshow(img2)
63 | ```
64 |
65 | 
66 |
67 | 可以从图中看出，角点检测的还是比较准确的。
68 |
69 |
70 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
71 |
72 | **1，角点的检测有一个难点在于cv2.cornerHarris的参数的选择，这个可能要多次尝试看效果。**
73 |
74 | **2，本项目检测的角点比较准确，有一个重要原因是图片的背景是纯白，背景颜色简单，图片物体前景只是一个箱子，角点非常明显，故而检测比较容易，在其他很多情况下，可能难以简单的获得比较满意的结果。**
75 |
76 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
77 |
78 |
79 |
80 |
81 |
82 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
83 |
84 | 参考资料:
85 |
86 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习049-提取图像的SIFT特征点.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习049-提取图像的SIFT特征点
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 图像中的特征点，就是某一幅图像区别于其他图像的关键点位，在进行这些关键点位的检测时，我们要考虑几个问题，即1，不管怎么旋转目标，要保持目标的特征点不变（即旋转不变性），2，不管这个目标是变大还是变小，其特征点也要保持不变（即尺度不变性），还有比如要求光照不变性等等。
7 |
8 | 目前对于特征点位的描述有很多种方法和算子，常见的有SIFT特征描述算子、SURF特征描述算子、ORB特征描述算子、HOG特征描述、LBP特征描述以及Harr特征描述。关于这几种算子和特征描述的区别，可以参考博文：[图像特征检测描述(一):SIFT、SURF、ORB、HOG、LBP特征的原理概述及OpenCV代码实现](http://lib.csdn.net/article/opencv/41913)
9 |
10 | SIFT特征点，即尺度不变特征变换（Scale-invariant feature transform，SIFT），是用于图像处理领域的一种描述。SIFT特征点在图像处理和计算机视觉领域有着很重要的作用。
11 |
12 | SIFT特征点具有很多优点：
13 |
14 | 1.SIFT特征是图像的局部特征，其对旋转、尺度缩放、亮度变化保持不变性，对视角变化、仿射变换、噪声也保持一定程度的稳定性；
15 |
16 | 2.区分性好，信息量丰富，适用于在海量特征数据库中进行快速、准确的匹配；
17 |
18 | 3.多量性，即使少数的几个物体也可以产生大量的SIFT特征向量；
19 |
20 | 4.高速性，经优化的SIFT匹配算法甚至可以达到实时的要求；
21 |
22 | 5.可扩展性，可以很方便的与其他形式的特征向量进行联合。
23 |
24 | 对SIFT特征点的提取主要包括以下四个步骤：
25 |
26 | 1.尺度空间极值检测：搜索所有尺度上的图像位置。通过高斯微分函数来识别潜在的对于尺度和旋转不变的兴趣点。
27 |
28 | 2.关键点定位：在每个候选的位置上，通过一个拟合精细的模型来确定位置和尺度。关键点的选择依据于它们的稳定程度。
29 |
30 | 3.方向确定：基于图像局部的梯度方向，分配给每个关键点位置一个或多个方向。所有后面的对图像数据的操作都相对于关键点的方向、尺度和位置进行变换，从而提供对于这些变换的不变性。
31 |
32 | 4.关键点描述：在每个关键点周围的邻域内，在选定的尺度上测量图像局部的梯度。这些梯度被变换成一种表示，这种表示允许比较大的局部形状的变形和光照变化。
33 |
34 | 关于SIFT的数学推导和具体含义，可以参考这篇博文：[SIFT特征详解](https://www.cnblogs.com/wangguchangqing/p/4853263.html)
35 |
36 |
37 |
38 | ## 1. 提取SIFT特征点
39 |
40 | ### 1.1 安装opencv-contrib-python模块
41 |
42 | 一般我们使用的是opencv-python模块，但是这个模块中没有xfeatures2d这个方法，因为SIFT算法已经被申请专利，故而从opencv-python中剔除了。
43 |
44 | 关于这个模块的安装，网上有很多个版本，我也踩了好几个坑，最后发现下面的方法是可用的，先卸载原先的opencv-python模块（如果原先的opencv-python模块的版本号是3.4.2.16，则不需要卸载）。然后安装3.4.2.16这个版本的opencv-python和 opencv-contrib-python即可。
45 |
46 | 安装方法：
47 |
48 | pip install opencv-python==3.4.2.16
49 |
50 | pip install opencv-contrib-python==3.4.2.16
51 |
52 |
53 | ### 1.2 提取SIFT特征点
54 |
55 | 首先构建SIFT特征点检测器对象，然后用这个检测器对象来检测灰度图中的特征点
56 |
57 | ```py
58 | sift = cv2.xfeatures2d.SIFT_create() # 构建SIFT特征点检测器对象
59 | keypoints = sift.detect(gray, None) # 用SIFT特征点检测器对象检测灰度图中的特征点
60 | ```
61 |
62 | ```py
63 | # 将keypoints绘制到原图中
64 | img_sift = np.copy(img)
65 | cv2.drawKeypoints(img, keypoints, img_sift, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
66 |
67 | # 显示绘制有特征点的图像
68 | plt.figure(12,figsize=(15,30))
69 | plt.subplot(121)
70 | img_rgb=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
71 | plt.imshow(img_rgb)
72 | plt.title('Raw Img')
73 |
74 | plt.subplot(122)
75 | img_sift_rgb=cv2.cvtColor(img_sift,cv2.COLOR_BGR2RGB)
76 | plt.imshow(img_sift_rgb)
77 | plt.title('Img with SIFT features')
78 | ```
79 |
80 | 
81 |
82 |
83 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
84 |
85 | **1, SIFT特征点的提取只需要使用cv2.xfeatures2d.SIFT_create().detect()函数即可，但是要事先安装opencv-contrib-python模块。**
86 |
87 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
88 |
89 |
90 |
91 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
92 |
93 | 参考资料:
94 |
95 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习050-提取图像的Star特征.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习050-提取图像的Star特征
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 对于图像的特征点，前面我们讨论过边缘检测方法，Harris角点检测算法等，这些检测算法检测的都是图像的轮廓边缘，而不是内部细节，如果要进一步提取图像内部细节方面的特征，需要用到SIFT特征提取器和Star特征提取器。上一篇我们讲解了SIFT特征提取器，下面我们来介绍Star特征提取器。
7 |
8 | 在博文[特征点的基本概念和如何找到它们](https://www.cnblogs.com/jsxyhelu/p/7520047.html)中提到，OpenCV中具有以下特征点模型：（这些函数的使用也同样适用于OpenCV-Python）
9 |
10 | 1、Harris-Shi-Tomasi特征检测器和cv :: GoodFeaturesToTrackDetector
11 |
12 | 最常用的角点定义是由哈里斯[Harris88]提出的， 这些角点，被称为哈尔角点，可以被认为是原始的关键点；而后被Shi和Tomasi [Shi94]进行了进一步扩展，后者被证明对于大多数跟踪应用来说是优越的。由于历史原因，在OpenCV中叫做”GoodFeatures";
13 |
14 | 2、简单的blob检测器和cv :: SimpleBlobDetector
15 |
16 | 提出“斑点”的概念。斑点本质上没有那么明确的局部化，而是表示可能预期随时间具有一定稳定性的感兴趣区域。
17 |
18 | 3、FAST特征检测器和cv :: FastFeatureDetector
19 |
20 | 最初由Rosten和Drummond [Rosten06]提出的FAST（加速段测试的特征），其基本思想是，如果附近的几个点与P类似，那么P将成为一个很好的关键点。
21 |
22 | 4、SIFT特征检测器和cv :: xfeatures2d :: SIFT
23 |
24 | 由David Lowe最初于2004年提出的SIFT特征（尺度不变特征变换）[Lowe04]被广泛使用，是许多随后开发的特征的基础；SIFT特征计算花销很大，但是具有高度的表达能力。
25 |
26 | 5、SURF特征检测器和cv :: xfeatures2d :: SURF
27 |
28 | SURF特征（加速鲁棒特征）最初由Bay等人于2006年提出[Bay06，Bay08]，并且在许多方面是我们刚刚讨论的SIFT特征的演变。SURF所产生的特征不仅计算速度快得多，并且在许多情况下，它对SIFT特征观察到的方向或照明变化的鲁棒性也更强。
29 |
30 | 6、Star / CenSurE特征检测器和cv :: xfeatures2d :: StarDetector
31 |
32 | Star特征，也被称为中心环绕极值（或CenSurE）功能，试图解决提供哈尔角点或FAST特征的局部化水平的问题，同时还提供尺度不变性。
33 |
34 | 7、BRIEF描述符提取器和cv :: BriefDescriptorExtractor
35 |
36 | BRIEF，即二进制鲁棒独立基本特征，是一种相对较新的算法，BRIEF不找到关键点；相反，它用于生成可通过任何其他可用的特征检测器算法定位的关键点的描述符。
37 |
38 | 8、BRISK算法
39 |
40 | Leutenegger等人介绍的BRISK40描述符,试图以两种不同的方式改进Brief（Leutenegger11）。 首先，BRISK引入了自己的一个特征检测器（回想一下，Brief只是一种计算描述符的方法）。 其次，BRISK的特征本身虽然与BRIEF原则相似，却尝试以提高整体功能的鲁棒性的方式进行二值比较。
41 |
42 | 9、ORB特征检测器和cv :: ORB
43 |
44 | 创建了ORB功能[Rublee11]，其目标是为SIFT或SURF提供更高速的替代品。ORB功能使用非常接近于FAST（我们在本章前面看到的）的关键点检测器，但是使用了基本上不同的描述符，主要基于BRIEF。
45 |
46 | 10、FREAK描述符提取器和cv :: xfeatures2d :: FREAK
47 |
48 | FREAK描述符最初是作为Brief，BRISK和ORB的改进引入的，它是一个生物启发式的描述符，其功能非常类似于BRIEF，主要在于它计算二进制比较的领域的方式[Alahi12]。
49 |
50 | 11、稠密特征网格和cv :: DenseFeatureDetector类
51 |
52 | cv :: DenseFeatureDetector class53的目的只是在图像中的网格中生成一个规则的特征数组。
53 |
54 |
55 |
56 | ## 1. 使用Star提取图像特征点
57 |
58 | 具体代码和我上一篇文章很类似，可以先看看[【火炉炼AI】机器学习049-提取图像的SIFT特征点](https://www.cnblogs.com/RayDean/p/9831163.html)
59 |
60 | ```py
61 | star = cv2.xfeatures2d.StarDetector_create() # 构建Star特征点检测器对象
62 | keypoints = star.detect(gray, None) # 用Star特征点检测器对象检测灰度图中的特征点
63 | ```
64 |
65 | ```py
66 | # 将keypoints绘制到原图中
67 | img_sift = np.copy(img)
68 | cv2.drawKeypoints(img, keypoints, img_sift, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
69 | #画在原图上，第一个是原图，第二个image是目标图，这个flags既包括位置又包括方向，也有只有位置的flags
70 | #圆圈的大小表示特征的重要性大小，主要在桌子腿上，腿上边缘和棱角比较多，更有代表性
71 |
72 | # 显示绘制有特征点的图像
73 | plt.figure(12,figsize=(15,30))
74 | plt.subplot(121)
75 | img_rgb=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
76 | plt.imshow(img_rgb)
77 | plt.title('Raw Img')
78 |
79 | plt.subplot(122)
80 | img_sift_rgb=cv2.cvtColor(img_sift,cv2.COLOR_BGR2RGB)
81 | plt.imshow(img_sift_rgb)
82 | plt.title('Img with Star features')
83 | ```
84 |
85 | 
86 |
87 |
88 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
89 |
90 | **1，Star特征点的提取方法在代码上很容易实现，cv2.xfeatures2d.StarDetector_create()这个函数就可以构建Star检测器并用detect方法就可以实现。**
91 |
92 | **2，Star特征点提取器和SIFT特征点提取器的结果有很多相似之处，都是在桌腿附近有很多特征点。**
93 |
94 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
95 |
96 |
97 |
98 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
99 |
100 | 参考资料:
101 |
102 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/Articles/机器学习054-用ICA做盲源分离.md:
--------------------------------------------------------------------------------
1 | 【火炉炼AI】机器学习054-用ICA做盲源分离
2 | -
3 |
4 | (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 )
5 |
6 | 盲源分离是指在信号的理论模型和源信号无法精确获知的情况下，如何从混叠信号中分离出各源信号的过程。盲源分离的目的是求得源信号的最佳估计。说的通俗一点，就相当于，假如有十个人同时说话，我用录音机把他们说的话都录下来，得到的肯定是10种声音的混杂，那么怎么将这种混杂声音分离成单个人的说话声音？解决类似这种问题就是盲源分离。
7 |
8 | 独立成分分析（Independent Components Analysis, ICA)解决的是原始数据分解的问题，常常用于盲源分离问题中。在我上一篇文章[【火炉炼AI】机器学习053-数据降维绝招-PCA和核PCA](https://www.cnblogs.com/RayDean/p/9882023.html)中提到PCA虽然具有各种优点，但是也有几个缺点，比如不能对非线性组织的数据集降维，针对这个缺点解决方法是用核PCA代替PCA，另外一个缺点是不能用于解决数据集不满足高斯分布的情况，这种情况的数据降维要用独立成分分析ICA来完成。
9 |
10 | 独立成分分析师从多维统计数据中寻找潜在因子或成分的一种方法，ICA与PCA等降维方法的区别在于，它寻找满足统计独立和非高斯的成分。其数学原理和逻辑可以参考博文：[独立成分分析ICA系列2：概念、应用和估计原理](https://blog.csdn.net/shenziheng1/article/details/53637907)
11 |
12 |
13 |
14 |
15 | ## 1. 加载数据集
16 |
17 | 首先加载数据集，本次所用的数据集位于文件mixture_of_signals.txt中，这个文件中有四列数据，代表四个不同的信号源，共2000个样本
18 |
19 | ```py
20 | data_path="E:\PyProjects\DataSet\FireAI\mixture_of_signals.txt"
21 | df=pd.read_csv(data_path,header=None,sep=' ')
22 | print(df.info()) # 查看数据信息，确保没有错误
23 | print(df.head())
24 | print(df.tail())
25 | dataset_X=df.values
26 | print(dataset_X.shape)
27 | ```
28 |
29 | 绘图后，可以看出这些数据的分布情况：
30 |
31 | 
32 |
33 |
34 |
35 |
36 | ## 2. 用传统PCA来分离信号
37 |
38 | 假如我们用PCA来进行盲源分离，可以看看效果怎么样，代码为：
39 |
40 | ```py
41 | # 如果用PCA来进行分离，看看结果如何
42 | from sklearn.decomposition import PCA
43 | pca = PCA(n_components=4)
44 | pca_dataset_X = pca.fit_transform(dataset_X)
45 | pd.DataFrame(pca_dataset_X).plot(title='PCA_dataset')
46 | ```
47 |
48 | 
49 |
50 | 上面虽然绘制了PCA分离之后的各种信号，但是信号夹杂在一起难以分辨，故而我编写了一个函数将其分开显示
51 |
52 | ```py
53 | def plot_dataset_X(dataset_X):
54 | rows,cols=dataset_X.shape
55 | plt.figure(figsize=(15,20))
56 | for i in range(cols):
57 | plt.subplot(cols,1,i+1)
58 | plt.title('Signal_'+str(i))
59 | plt.plot(dataset_X[:,i])
60 |
61 | ```
62 |
63 | 
64 |
65 |
66 |
67 |
68 | ## 3. 用ICA来分离信号
69 |
70 | 下面看看用独立成分分析方法得到的分离后信号：
71 |
72 | ```py
73 | # 如果用ICA进行信号分离
74 | from sklearn.decomposition import FastICA
75 | ica = FastICA(n_components=4)
76 | ica_dataset_X = ica.fit_transform(dataset_X)
77 | pd.DataFrame(ica_dataset_X).plot(title='ICA_dataset')
78 | ```
79 |
80 | 
81 |
82 | 同理，为了显示方便，将各种信号单独画图，如下：
83 |
84 | 
85 |
86 | 可以看出，经过ICA分离之后得到的信号非常有规律，而PCA分离后的信号有些杂乱，表面ICA的盲源分离效果较好。
87 |
88 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#小\*\*\*\*\*\*\*\*\*\*结\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
89 |
90 | **1，用ICA可以解决盲源分离问题，所得到的分离效果要比PCA要好得多。**
91 |
92 | **2，实际上，生活中的真实数据集大部分都不是服从高斯分布，它们一般服从超高斯分布或亚高斯分布，故而很多问题用PCA得到的效果不太理想，返回用ICA能够得到比较好的结果。**
93 |
94 | **\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#**
95 |
96 |
97 |
98 |
99 | 注：本部分代码已经全部上传到（[**我的github**](https://github.com/RayDean/MachineLearning)）上，欢迎下载。
100 |
101 | 参考资料:
102 |
103 | 1, Python机器学习经典实例，Prateek Joshi著，陶俊杰，陈小莉译
--------------------------------------------------------------------------------
/DatSets/FireAI_051_Fig2.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/FireAI_051_Fig2.PNG
--------------------------------------------------------------------------------
/DatSets/box.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/box.png
--------------------------------------------------------------------------------
/DatSets/chair.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/chair.jpg
--------------------------------------------------------------------------------
/DatSets/data_multivar_2_class.txt:
--------------------------------------------------------------------------------
1 | 5.35,4.48,0
2 | 6.72,5.37,0
3 | 3.57,5.25,0
4 | 4.77,7.65,1
5 | 2.25,4.07,1
6 | 6.08,3.01,1
7 | 4.91,5.52,0
8 | 5.79,4.09,0
9 | 5.03,5.92,0
10 | 5.51,7.32,1
11 | 3.49,4.08,1
12 | 7.32,2.71,1
13 | 4.5,4.76,0
14 | 5.35,4.94,0
15 | 5.18,4.91,0
16 | 4.77,9.15,1
17 | 2.5,4.35,1
18 | 7.94,2.91,1
19 | 5.5,4.64,0
20 | 5.62,3.42,0
21 | 4.15,5.95,0
22 | 5.04,8.56,1
23 | 2.22,4.78,1
24 | 7.77,4.21,1
25 | 5.36,4.24,0
26 | 4.82,5.52,0
27 | 4.23,5.83,0
28 | 3.74,8.74,1
29 | 1.7,4.53,1
30 | 7.0,2.86,1
31 | 4.73,4.12,0
32 | 6.4,4.21,0
33 | 4.4,6.27,0
34 | 5.72,8.75,1
35 | 3.0,3.56,1
36 | 6.48,3.14,1
37 | 4.33,4.09,0
38 | 5.16,4.34,0
39 | 5.67,5.67,0
40 | 3.88,7.5,1
41 | 3.41,4.62,1
42 | 6.76,3.71,1
43 | 4.02,5.46,0
44 | 6.18,5.67,0
45 | 4.9,5.3,0
46 | 5.82,9.13,1
47 | 2.43,2.87,1
48 | 6.12,3.68,1
49 | 5.61,3.98,0
50 | 5.76,5.96,0
51 | 4.82,5.41,0
52 | 4.59,7.28,1
53 | 2.51,2.99,1
54 | 6.92,2.62,1
55 | 4.47,5.88,0
56 | 6.01,5.51,0
57 | 3.65,6.05,0
58 | 5.13,7.98,1
59 | 2.43,4.81,1
60 | 6.68,2.32,1
61 | 5.6,4.7,0
62 | 6.01,5.51,0
63 | 4.97,5.89,0
64 | 5.15,7.59,1
65 | 3.1,3.83,1
66 | 6.83,3.8,1
67 | 4.87,5.65,0
68 | 6.63,5.24,0
69 | 3.93,5.2,0
70 | 4.88,8.49,1
71 | 1.0,4.36,1
72 | 6.82,2.77,1
73 | 4.45,4.57,0
74 | 4.36,4.85,0
75 | 5.45,5.62,0
76 | 5.0,8.02,1
77 | 2.16,4.23,1
78 | 8.02,3.3,1
79 | 5.31,5.46,0
80 | 6.03,5.47,0
81 | 4.57,4.2,0
82 | 4.22,8.34,1
83 | 1.8,3.69,1
84 | 7.49,2.87,1
85 | 5.99,5.15,0
86 | 5.86,4.67,0
87 | 5.71,5.63,0
88 | 5.05,7.84,1
89 | 3.1,3.02,1
90 | 6.46,2.71,1
91 | 4.9,4.71,0
92 | 5.95,4.45,0
93 | 4.17,5.91,0
94 | 5.33,7.41,1
95 | 3.26,3.86,1
96 | 7.59,3.27,1
97 | 5.39,6.14,0
98 | 4.86,4.99,0
99 | 5.01,6.54,0
100 | 4.12,8.27,1
101 | 1.74,6.65,1
102 | 6.61,2.62,1
103 | 5.08,4.85,0
104 | 6.08,4.47,0
105 | 4.31,6.89,0
106 | 5.12,6.69,1
107 | 2.64,4.62,1
108 | 6.71,3.43,1
109 | 5.31,6.93,0
110 | 5.89,5.53,0
111 | 4.25,6.34,0
112 | 5.32,8.82,1
113 | 3.36,4.69,1
114 | 7.04,2.77,1
115 | 6.08,5.5,0
116 | 5.71,4.76,0
117 | 4.93,4.77,0
118 | 4.91,6.46,1
119 | 3.3,3.92,1
120 | 5.89,2.2,1
121 | 4.6,6.67,0
122 | 5.81,4.58,0
123 | 5.52,6.0,0
124 | 5.34,6.91,1
125 | 2.68,3.65,1
126 | 6.93,4.01,1
127 | 4.97,5.46,0
128 | 4.68,4.49,0
129 | 5.27,5.23,0
130 | 4.36,7.91,1
131 | 3.32,3.68,1
132 | 6.61,3.35,1
133 | 4.2,5.43,0
134 | 4.94,5.94,0
135 | 5.19,5.85,0
136 | 5.43,9.2,1
137 | 1.37,4.77,1
138 | 5.99,4.41,1
139 | 5.13,5.88,0
140 | 7.53,3.77,0
141 | 4.78,6.04,0
142 | 4.54,9.24,1
143 | 3.59,4.94,1
144 | 5.5,3.24,1
145 | 3.88,5.42,0
146 | 4.95,5.04,0
147 | 5.52,5.43,0
148 | 5.29,8.61,1
149 | 2.75,4.86,1
150 | 6.74,3.77,1
151 | 3.85,5.23,0
152 | 6.29,4.87,0
153 | 4.65,5.22,0
154 | 5.14,8.14,1
155 | 3.1,3.89,1
156 | 7.2,2.93,1
157 | 5.44,4.57,0
158 | 5.41,4.79,0
159 | 3.76,5.03,0
160 | 5.14,8.09,1
161 | 1.69,4.37,1
162 | 7.94,3.33,1
163 | 5.62,3.92,0
164 | 5.45,4.29,0
165 | 5.86,4.73,0
166 | 5.31,7.79,1
167 | 3.47,4.09,1
168 | 7.24,2.83,1
169 | 4.34,4.89,0
170 | 5.67,5.54,0
171 | 4.67,6.11,0
172 | 4.26,8.28,1
173 | 3.91,2.55,1
174 | 6.6,3.94,1
175 | 5.22,4.52,0
176 | 5.19,4.75,0
177 | 4.57,5.29,0
178 | 4.34,7.11,1
179 | 1.6,4.96,1
180 | 6.53,2.48,1
181 | 5.13,4.84,0
182 | 5.74,4.98,0
183 | 5.65,4.36,0
184 | 4.87,8.14,1
185 | 1.85,1.94,1
186 | 7.14,2.15,1
187 | 5.23,4.19,0
188 | 4.67,3.44,0
189 | 5.21,5.97,0
190 | 5.85,8.11,1
191 | 2.28,4.06,1
192 | 8.13,3.0,1
193 | 4.42,4.59,0
194 | 6.8,6.22,0
195 | 4.51,4.75,0
196 | 6.07,9.27,1
197 | 1.61,4.72,1
198 | 7.57,3.6,1
199 | 4.1,4.22,0
200 | 5.06,5.06,0
201 | 4.79,4.44,0
202 | 4.55,7.86,1
203 | 4.23,4.02,1
204 | 6.78,3.97,1
205 | 5.36,5.5,0
206 | 4.26,5.45,0
207 | 5.42,5.91,0
208 | 5.04,6.63,1
209 | 1.9,3.9,1
210 | 6.49,3.44,1
211 | 4.82,5.5,0
212 | 4.63,5.81,0
213 | 4.61,5.83,0
214 | 3.48,8.51,1
215 | 2.5,3.4,1
216 | 9.08,3.6,1
217 | 3.66,4.79,0
218 | 5.75,5.18,0
219 | 4.98,5.88,0
220 | 4.97,8.14,1
221 | 3.43,3.76,1
222 | 7.68,1.68,1
223 | 4.36,4.51,0
224 | 5.75,3.53,0
225 | 4.19,7.12,0
226 | 4.63,7.92,1
227 | 3.05,3.18,1
228 | 7.15,3.57,1
229 | 5.09,5.33,0
230 | 6.38,5.72,0
231 | 5.33,4.11,0
232 | 4.04,7.74,1
233 | 2.94,4.11,1
234 | 7.85,3.28,1
235 | 4.86,5.34,0
236 | 5.62,5.49,0
237 | 4.36,5.98,0
238 | 5.55,7.76,1
239 | 1.78,4.1,1
240 | 6.46,3.08,1
241 | 3.69,4.58,0
242 | 4.69,4.47,0
243 | 5.99,5.42,0
244 | 4.16,6.91,1
245 | 2.66,4.41,1
246 | 7.33,2.29,1
247 | 4.82,5.4,0
248 | 5.79,4.5,0
249 | 4.74,5.34,0
250 | 5.44,7.57,1
251 | 1.75,4.89,1
252 | 6.36,3.08,1
253 | 4.65,4.63,0
254 | 5.62,5.0,0
255 | 4.63,5.71,0
256 | 5.1,7.09,1
257 | 0.74,3.85,1
258 | 7.56,3.07,1
259 | 5.16,5.58,0
260 | 4.62,4.56,0
261 | 4.58,5.61,0
262 | 5.02,7.74,1
263 | 2.5,4.2,1
264 | 6.52,2.86,1
265 | 5.04,4.87,0
266 | 5.86,5.25,0
267 | 5.57,5.08,0
268 | 4.35,8.51,1
269 | 2.64,3.11,1
270 | 6.92,2.87,1
271 | 5.04,5.73,0
272 | 5.91,5.52,0
273 | 4.59,5.66,0
274 | 4.51,8.37,1
275 | 1.51,3.92,1
276 | 6.99,2.29,1
277 | 6.33,4.35,0
278 | 5.69,5.07,0
279 | 4.57,4.85,0
280 | 5.09,7.95,1
281 | 1.59,4.34,1
282 | 6.7,1.66,1
283 | 5.26,5.59,0
284 | 4.98,6.17,0
285 | 4.36,7.11,0
286 | 5.05,7.91,1
287 | 3.31,3.92,1
288 | 7.63,1.86,1
289 | 5.46,5.2,0
290 | 5.32,5.76,0
291 | 5.12,5.43,0
292 | 4.45,7.6,1
293 | 2.67,3.39,1
294 | 9.66,2.51,1
295 | 6.36,3.76,0
296 | 5.24,4.92,0
297 | 5.14,5.14,0
298 | 5.28,8.66,1
299 | 2.68,2.49,1
300 | 7.28,2.63,1
301 |
--------------------------------------------------------------------------------
/DatSets/data_nn_classifier.txt:
--------------------------------------------------------------------------------
1 | 1.82,2.04,0
2 | 3.31,6.78,1
3 | 6.33,2.55,2
4 | 2.05,2.47,0
5 | 4.3,5.25,1
6 | 5.67,2.93,2
7 | 1.14,2.99,0
8 | 3.28,5.6,1
9 | 7.14,1.74,2
10 | 1.67,0.77,0
11 | 3.65,7.09,1
12 | 5.36,-0.52,2
13 | 1.51,2.53,0
14 | 4.02,6.96,1
15 | 5.99,2.66,2
16 | 2.19,1.74,0
17 | 3.84,6.27,1
18 | 5.23,0.46,2
19 | 0.91,2.02,0
20 | 4.16,6.41,1
21 | 6.27,2.91,2
22 | 2.07,0.94,0
23 | 2.94,5.84,1
24 | 5.5,4.16,2
25 | 2.9,3.14,0
26 | 2.84,6.3,1
27 | 5.93,2.44,2
28 | 0.68,1.85,0
29 | 3.11,6.82,1
30 | 5.69,1.31,2
31 | 2.49,3.47,0
32 | 3.55,6.21,1
33 | 6.61,2.62,2
34 | 1.09,2.18,0
35 | 4.37,6.11,1
36 | 6.7,3.17,2
37 | 1.51,1.73,0
38 | 4.68,5.73,1
39 | 6.4,3.83,2
40 | 2.77,1.34,0
41 | 2.83,5.81,1
42 | 5.64,2.19,2
43 | 3.15,2.56,0
44 | 4.7,5.67,1
45 | 5.57,3.92,2
46 | 2.42,0.83,0
47 | 3.7,5.97,1
48 | 4.06,2.15,2
49 | 2.45,2.1,0
50 | 4.37,5.23,1
51 | 5.88,2.01,2
52 | 2.38,2.78,0
53 | 3.0,6.13,1
54 | 5.14,2.05,2
55 | 0.94,1.02,0
56 | 4.03,5.88,1
57 | 6.19,3.16,2
58 | 1.66,0.78,0
59 | 5.62,6.84,1
60 | 6.15,3.16,2
61 | 2.34,2.23,0
62 | 5.01,5.93,1
63 | 5.77,2.77,2
64 | 2.75,3.27,0
65 | 4.04,4.41,1
66 | 6.03,3.12,2
67 | 0.13,2.2,0
68 | 5.13,6.96,1
69 | 6.6,4.03,2
70 | 1.78,3.22,0
71 | 4.25,5.83,1
72 | 7.81,0.06,2
73 | 1.32,0.7,0
74 | 4.11,6.72,1
75 | 7.17,2.6,2
76 | 1.86,1.37,0
77 | 3.0,6.84,1
78 | 5.58,3.29,2
79 | 1.74,1.86,0
80 | 4.06,4.21,1
81 | 6.49,1.94,2
82 | 2.19,2.01,0
83 | 2.73,6.73,1
84 | 4.92,2.49,2
85 | 1.19,0.75,0
86 | 4.07,6.62,1
87 | 5.67,1.78,2
88 | 2.79,2.01,0
89 | 3.58,6.0,1
90 | 6.03,2.86,2
91 | 2.32,2.22,0
92 | 2.86,6.13,1
93 | 4.72,3.09,2
94 | 2.86,3.26,0
95 | 4.23,6.96,1
96 | 4.25,2.2,2
97 | 2.6,1.4,0
98 | 3.13,5.43,1
99 | 5.94,1.21,2
100 | 2.0,2.69,0
101 | 2.82,4.82,1
102 | 6.17,3.65,2
103 | 2.97,1.64,0
104 | 4.59,6.0,1
105 | 5.13,1.56,2
106 | 2.69,2.89,0
107 | 1.33,5.88,1
108 | 6.62,2.51,2
109 | 2.8,2.66,0
110 | 4.31,5.41,1
111 | 6.9,2.95,2
112 | 3.07,2.02,0
113 | 4.84,5.08,1
114 | 6.61,3.9,2
115 | 2.36,2.44,0
116 | 4.5,5.55,1
117 | 6.37,2.82,2
118 | 2.82,2.65,0
119 | 2.87,6.51,1
120 | 5.14,3.15,2
121 | 2.48,1.25,0
122 | 4.9,4.74,1
123 | 6.34,2.94,2
124 | 2.07,2.58,0
125 | 2.08,6.93,1
126 | 6.29,1.84,2
127 | 2.61,3.16,0
128 | 5.14,7.11,1
129 | 5.34,3.07,2
130 | 1.98,1.35,0
131 | 4.63,7.45,1
132 | 5.6,3.43,2
133 | 3.19,1.94,0
134 | 4.88,5.27,1
135 | 6.29,2.52,2
136 | 0.76,1.38,0
137 | 3.76,5.02,1
138 | 6.01,1.27,2
139 | 2.71,1.97,0
140 | 2.69,6.14,1
141 | 4.6,1.89,2
142 | 1.95,1.69,0
143 | 2.76,6.76,1
144 | 5.29,1.97,2
145 | 2.22,1.16,0
146 | 5.54,5.95,1
147 | 6.1,2.82,2
148 | 2.4,2.5,0
149 | 3.74,7.24,1
150 | 5.5,2.26,2
151 |
--------------------------------------------------------------------------------
/DatSets/data_perf.txt:
--------------------------------------------------------------------------------
1 | 1.65,1.91
2 | 2.77,4.98
3 | 5.82,2.56
4 | 7.24,5.24
5 | -0.3,4.06
6 | 1.13,2.0
7 | 2.83,5.31
8 | 5.62,2.19
9 | 6.76,5.87
10 | 0.61,3.95
11 | 2.55,1.8
12 | 3.21,4.9
13 | 6.07,3.1
14 | 7.18,5.48
15 | -0.04,3.84
16 | 2.53,1.33
17 | 3.93,5.03
18 | 5.22,2.66
19 | 7.88,5.37
20 | -0.79,3.77
21 | 2.03,1.87
22 | 3.82,6.21
23 | 6.97,0.65
24 | 6.78,4.9
25 | 0.5,3.3
26 | 2.04,3.62
27 | 3.8,4.66
28 | 5.55,3.17
29 | 7.66,5.05
30 | -0.14,4.09
31 | 0.86,2.38
32 | 3.03,5.18
33 | 6.1,2.26
34 | 7.36,6.59
35 | -0.01,3.48
36 | 2.29,1.95
37 | 2.7,4.85
38 | 5.98,1.64
39 | 6.15,5.38
40 | -0.4,3.68
41 | 1.1,2.03
42 | 3.27,4.1
43 | 6.04,1.24
44 | 7.73,5.35
45 | -0.04,3.54
46 | 1.74,2.02
47 | 3.13,5.21
48 | 5.2,2.32
49 | 7.58,4.13
50 | -0.03,3.82
51 | 3.69,1.57
52 | 3.46,6.57
53 | 5.93,1.37
54 | 7.39,5.6
55 | 0.58,3.68
56 | 2.66,2.32
57 | 2.44,4.84
58 | 6.25,2.59
59 | 7.62,6.08
60 | -0.15,3.35
61 | 1.19,2.52
62 | 2.63,3.22
63 | 6.29,1.48
64 | 6.05,4.92
65 | 0.3,3.79
66 | 0.76,1.54
67 | 2.81,4.39
68 | 5.79,2.15
69 | 7.09,4.78
70 | 0.05,3.98
71 | 2.63,2.05
72 | 3.69,5.93
73 | 5.81,1.96
74 | 7.85,4.95
75 | 0.16,4.05
76 | 1.8,2.55
77 | 3.17,5.77
78 | 6.25,1.78
79 | 7.41,5.86
80 | -0.57,3.68
81 | 3.18,2.74
82 | 3.38,5.19
83 | 6.59,0.86
84 | 6.1,5.98
85 | -0.03,3.7
86 | 1.4,2.02
87 | 2.99,4.64
88 | 6.11,3.22
89 | 7.47,4.85
90 | -0.67,4.32
91 | 1.45,1.92
92 | 3.5,5.85
93 | 5.66,2.04
94 | 6.3,5.38
95 | -0.27,4.38
96 | 1.85,2.64
97 | 2.13,5.57
98 | 5.98,1.68
99 | 5.49,4.85
100 | 0.07,4.2
101 | 2.29,2.19
102 | 2.71,4.32
103 | 5.8,1.08
104 | 7.1,5.72
105 | 0.11,3.47
106 | 1.59,1.72
107 | 3.36,4.72
108 | 5.94,2.79
109 | 6.93,6.25
110 | -0.5,4.07
111 | 2.24,2.95
112 | 2.51,4.96
113 | 5.65,2.35
114 | 6.74,5.03
115 | -0.41,2.6
116 | 2.56,2.3
117 | 4.04,5.32
118 | 5.5,1.94
119 | 7.53,5.63
120 | 0.05,4.02
121 | 1.31,2.77
122 | 3.06,4.92
123 | 6.08,1.58
124 | 6.73,5.73
125 | 0.23,3.64
126 | 1.83,1.27
127 | 3.65,4.65
128 | 6.25,1.63
129 | 7.03,4.91
130 | 0.38,3.65
131 | 1.32,1.73
132 | 3.62,6.01
133 | 6.78,1.93
134 | 7.96,6.12
135 | -0.61,3.86
136 | 2.7,1.28
137 | 2.41,4.81
138 | 6.47,1.71
139 | 7.16,5.48
140 | 0.04,3.09
141 | 2.71,2.58
142 | 1.86,5.28
143 | 5.3,1.55
144 | 6.96,5.33
145 | 1.49,3.89
146 | 1.98,2.27
147 | 3.27,4.54
148 | 6.51,1.8
149 | 6.02,5.68
150 | 0.38,4.06
151 | 0.48,2.02
152 | 2.79,5.06
153 | 6.27,2.48
154 | 6.86,5.55
155 | 0.45,4.29
156 | 1.4,3.06
157 | 2.89,4.63
158 | 6.85,1.87
159 | 6.77,5.87
160 | -0.8,4.49
161 | 1.75,2.19
162 | 3.14,4.16
163 | 7.11,2.94
164 | 7.06,5.83
165 | -0.02,5.43
166 | 1.86,2.36
167 | 4.25,5.19
168 | 7.56,1.42
169 | 7.39,5.6
170 | 0.18,3.76
171 | 2.57,1.73
172 | 3.43,4.85
173 | 5.21,1.61
174 | 5.99,5.34
175 | 0.06,4.44
176 | 2.04,1.43
177 | 3.77,5.07
178 | 5.88,0.88
179 | 7.42,6.18
180 | 0.48,4.46
181 | 1.77,0.83
182 | 3.73,5.09
183 | 6.68,1.7
184 | 7.62,4.71
185 | -1.14,4.71
186 | 2.47,2.24
187 | 2.98,5.28
188 | 5.71,1.72
189 | 7.27,5.13
190 | -0.27,4.17
191 | 2.24,1.9
192 | 2.43,4.98
193 | 6.3,2.11
194 | 8.14,5.21
195 | -0.14,4.38
196 | 2.88,0.69
197 | 2.52,4.59
198 | 5.63,1.59
199 | 5.94,5.99
200 | 0.36,3.64
201 | 1.55,2.55
202 | 1.64,5.02
203 | 5.7,1.41
204 | 7.21,5.85
205 | -0.25,3.13
206 | 1.76,3.12
207 | 2.71,5.63
208 | 5.95,1.41
209 | 7.24,6.61
210 | -0.59,3.69
211 | 2.72,3.21
212 | 2.41,5.3
213 | 5.7,1.75
214 | 5.84,5.28
215 | 0.27,3.56
216 | 1.1,1.96
217 | 2.98,4.05
218 | 5.09,1.39
219 | 7.95,7.02
220 | 0.81,4.06
221 | 1.11,1.4
222 | 2.43,5.89
223 | 5.93,2.1
224 | 6.53,4.97
225 | 0.59,4.75
226 | 1.75,1.74
227 | 3.31,5.12
228 | 5.9,3.07
229 | 7.38,4.15
230 | 0.71,4.79
231 | 2.0,2.22
232 | 2.83,5.45
233 | 5.62,1.48
234 | 7.19,5.89
235 | -0.27,3.96
236 | 1.87,2.32
237 | 3.47,4.91
238 | 5.3,2.44
239 | 7.14,5.5
240 | -0.02,3.59
241 | 2.3,1.87
242 | 3.27,4.12
243 | 5.04,1.71
244 | 7.16,5.49
245 | 0.71,4.12
246 | 2.87,1.59
247 | 2.54,5.37
248 | 5.69,1.46
249 | 6.8,6.01
250 | 0.39,3.14
251 |
--------------------------------------------------------------------------------
/DatSets/data_single_layer.txt:
--------------------------------------------------------------------------------
1 | 1.0 4.0 0 0
2 | 1.1 3.9 0 0
3 | 1.2 4.1 0 0
4 | 0.9 3.7 0 0
5 | 7.0 4.0 0 1
6 | 7.2 4.1 0 1
7 | 6.9 3.9 0 1
8 | 7.1 4.2 0 1
9 | 4.0 1.0 1 0
10 | 4.1 0.9 1 0
11 | 4.2 1.1 1 0
12 | 3.9 0.8 1 0
13 | 4.0 7.0 1 1
14 | 4.2 7.2 1 1
15 | 3.9 7.1 1 1
16 | 4.1 6.8 1 1
17 |
--------------------------------------------------------------------------------
/DatSets/data_topic_modeling.txt:
--------------------------------------------------------------------------------
1 | He spent a lot of time studying cryptography.
2 | You need to have a very good understanding of modern encryption systems in order to work there.
3 | If their team doesn't win this match, they will be out of the competition.
4 | Those codes are generated by a specialized machine.
5 | The club needs to develop a policy of training and promoting younger talent.
6 | His movement off the ball is really great.
7 | In order to evade the defenders, he needs to move swiftly.
8 | We need to make sure only the authorized parties can read the message.
--------------------------------------------------------------------------------
/DatSets/face1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/face1.jpg
--------------------------------------------------------------------------------
/DatSets/face2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/face2.jpg
--------------------------------------------------------------------------------
/DatSets/face3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/face3.jpg
--------------------------------------------------------------------------------
/DatSets/faces.tar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces.tar
--------------------------------------------------------------------------------
/DatSets/faces_dataset/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/.DS_Store
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/.DS_Store
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0019.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0019.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0020.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0020.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0021.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0021.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0039.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0039.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0040.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0040.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0041.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0041.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0087.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0087.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0088.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0088.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/image_0089.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/image_0089.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/test/timg.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/test/timg.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/.DS_Store
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0001.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0001.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0002.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0002.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0003.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0003.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0004.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0004.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0005.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0005.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0006.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0006.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0007.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0007.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0008.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0008.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0009.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0009.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0010.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0010.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0011.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0011.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0012.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0012.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0013.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0013.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0014.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0014.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0015.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0015.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0016.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0016.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0017.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0017.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person1/image_0018.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person1/image_0018.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/.DS_Store
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0022.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0022.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0023.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0023.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0024.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0024.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0025.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0025.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0026.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0026.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0027.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0027.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0028.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0028.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0029.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0029.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0030.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0030.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0031.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0031.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0032.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0032.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0033.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0033.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0034.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0034.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0035.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0035.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0036.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0036.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0037.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0037.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person2/image_0038.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person2/image_0038.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/.DS_Store
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0069.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0069.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0070.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0070.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0071.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0071.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0072.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0072.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0073.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0073.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0074.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0074.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0075.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0075.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0076.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0076.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0077.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0077.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0078.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0078.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0079.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0079.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0080.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0080.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0081.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0081.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0082.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0082.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0083.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0083.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0084.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0084.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0085.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0085.jpg
--------------------------------------------------------------------------------
/DatSets/faces_dataset/train/person3/image_0086.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/faces_dataset/train/person3/image_0086.jpg
--------------------------------------------------------------------------------
/DatSets/movie_ratings.json:
--------------------------------------------------------------------------------
1 | {
2 | "John Carson":
3 | {
4 | "Inception": 2.5,
5 | "Pulp Fiction": 3.5,
6 | "Anger Management": 3.0,
7 | "Fracture": 3.5,
8 | "Serendipity": 2.5,
9 | "Jerry Maguire": 3.0
10 | },
11 | "Michelle Peterson":
12 | {
13 | "Inception": 3.0,
14 | "Pulp Fiction": 3.5,
15 | "Anger Management": 1.5,
16 | "Fracture": 5.0,
17 | "Jerry Maguire": 3.0,
18 | "Serendipity": 3.5
19 | },
20 | "William Reynolds":
21 | {
22 | "Inception": 2.5,
23 | "Pulp Fiction": 3.0,
24 | "Fracture": 3.5,
25 | "Jerry Maguire": 4.0
26 | },
27 | "Jillian Hobart":
28 | {
29 | "Pulp Fiction": 3.5,
30 | "Anger Management": 3.0,
31 | "Jerry Maguire": 4.5,
32 | "Fracture": 4.0,
33 | "Serendipity": 2.5
34 | },
35 | "Melissa Jones":
36 | {
37 | "Inception": 3.0,
38 | "Pulp Fiction": 4.0,
39 | "Anger Management": 2.0,
40 | "Fracture": 3.0,
41 | "Jerry Maguire": 3.0,
42 | "Serendipity": 2.0
43 | },
44 | "Alex Roberts":
45 | {
46 | "Inception": 3.0,
47 | "Pulp Fiction": 4.0,
48 | "Jerry Maguire": 3.0,
49 | "Fracture": 5.0,
50 | "Serendipity": 3.5
51 | },
52 | "Michael Henry":
53 | {
54 | "Pulp Fiction": 4.5,
55 | "Serendipity": 1.0,
56 | "Fracture": 4.0
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/DatSets/sunrise.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/sunrise.jpg
--------------------------------------------------------------------------------
/DatSets/symbol_map.json:
--------------------------------------------------------------------------------
1 | {
2 | "TOT": "Total",
3 | "XOM": "Exxon",
4 | "CVX": "Chevron",
5 | "COP": "ConocoPhillips",
6 | "VLO": "Valero Energy",
7 | "MSFT": "Microsoft",
8 | "IBM": "IBM",
9 | "TWX": "Time Warner",
10 | "CMCSA": "Comcast",
11 | "CVC": "Cablevision",
12 | "YHOO": "Yahoo",
13 | "DELL": "Dell",
14 | "HPQ": "HP",
15 | "AMZN": "Amazon",
16 | "TM": "Toyota",
17 | "CAJ": "Canon",
18 | "MTU": "Mitsubishi",
19 | "SNE": "Sony",
20 | "F": "Ford",
21 | "HMC": "Honda",
22 | "NAV": "Navistar",
23 | "NOC": "Northrop Grumman",
24 | "BA": "Boeing",
25 | "KO": "Coca Cola",
26 | "MMM": "3M",
27 | "MCD": "Mc Donalds",
28 | "PEP": "Pepsi",
29 | "MDLZ": "Kraft Foods",
30 | "K": "Kellogg",
31 | "UN": "Unilever",
32 | "MAR": "Marriott",
33 | "PG": "Procter Gamble",
34 | "CL": "Colgate-Palmolive",
35 | "GE": "General Electrics",
36 | "WFC": "Wells Fargo",
37 | "JPM": "JPMorgan Chase",
38 | "AIG": "AIG",
39 | "AXP": "American express",
40 | "BAC": "Bank of America",
41 | "GS": "Goldman Sachs",
42 | "AAPL": "Apple",
43 | "SAP": "SAP",
44 | "CSCO": "Cisco",
45 | "TXN": "Texas instruments",
46 | "XRX": "Xerox",
47 | "LMT": "Lookheed Martin",
48 | "WMT": "Wal-Mart",
49 | "WBA": "Walgreen",
50 | "HD": "Home Depot",
51 | "GSK": "GlaxoSmithKline",
52 | "PFE": "Pfizer",
53 | "SNY": "Sanofi-Aventis",
54 | "NVS": "Novartis",
55 | "KMB": "Kimberly-Clark",
56 | "R": "Ryder",
57 | "GD": "General Dynamics",
58 | "RTN": "Raytheon",
59 | "CVS": "CVS",
60 | "CAT": "Caterpillar",
61 | "DD": "DuPont de Nemours"
62 | }
63 |
--------------------------------------------------------------------------------
/DatSets/table.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/table.jpg
--------------------------------------------------------------------------------
/DatSets/test0.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/test0.jpg
--------------------------------------------------------------------------------
/DatSets/test1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/test1.jpg
--------------------------------------------------------------------------------
/DatSets/test2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/test2.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/.DS_Store
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/.DS_Store
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0001.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0001.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0002.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0002.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0003.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0003.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0004.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0004.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0005.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0005.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0006.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0006.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0007.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0007.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0008.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0008.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0009.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0009.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0010.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0010.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0011.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0011.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0012.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0012.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0013.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0013.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0014.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0014.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0015.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0015.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0016.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0016.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0017.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0017.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0018.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0018.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0019.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0019.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/0-airplanes/0020.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/0-airplanes/0020.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/.DS_Store
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0001.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0001.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0101.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0101.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0122.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0122.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0134.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0134.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0139.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0139.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0150.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0150.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0161.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0161.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0178.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0178.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0211.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0211.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0253.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0253.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0284.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0284.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0289.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0289.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0294.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0294.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0356.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0356.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0379.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0379.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0445.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0445.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0467.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0467.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0503.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0503.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0508.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0508.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/1-cars/image_0526.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/1-cars/image_0526.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/.DS_Store
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0001.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0001.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0002.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0002.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0003.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0003.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0004.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0004.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0005.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0005.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0006.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0006.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0007.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0007.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0008.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0008.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0009.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0009.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0010.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0010.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0011.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0011.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0012.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0012.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0013.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0013.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0014.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0014.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0015.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0015.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0016.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0016.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0017.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0017.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0018.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0018.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0019.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0019.jpg
--------------------------------------------------------------------------------
/DatSets/training_images/2-motorbikes/0020.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RayDean/MachineLearning/24fbcb8059c8ee922a1167a22057d012eb4c5a26/DatSets/training_images/2-motorbikes/0020.jpg
--------------------------------------------------------------------------------
/FireAI_002_LabelEncode.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [
8 | {
9 | "name": "stdout",
10 | "output_type": "stream",
11 | "text": [
12 | "编码器列表：['凤姐' '张三' '王宝强' '翠花' '芙蓉姐姐']\n",
13 | "凤姐 --> 0\n",
14 | "张三 --> 1\n",
15 | "王宝强 --> 2\n",
16 | "翠花 --> 3\n",
17 | "芙蓉姐姐 --> 4\n",
18 | "\n",
19 | "编码之前的标记：['王宝强', '芙蓉姐姐', '翠花']\n",
20 | "编码之后的标记：[2 4 3]\n",
21 | "\n",
22 | "已经编码的标记代码：[1, 3, 0, 4]\n",
23 | "解码后的标记：['张三' '翠花' '凤姐' '芙蓉姐姐']\n"
24 | ]
25 | },
26 | {
27 | "name": "stderr",
28 | "output_type": "stream",
29 | "text": [
30 | "c:\\users\\dingr\\appdata\\local\\programs\\python\\python35\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
31 | " if diff:\n"
32 | ]
33 | }
34 | ],
35 | "source": [
36 | "# *****************对label进行编码********************************\n",
37 | "from sklearn import preprocessing\n",
38 | "\n",
39 | "# 构建编码器\n",
40 | "encoder=preprocessing.LabelEncoder() # 先定义一个编码器对象\n",
41 | "raw_labels=['翠花','张三','王宝强','芙蓉姐姐','凤姐','王宝强','凤姐']\n",
42 | "encoder.fit(raw_labels) # 返回自己的一个实例\n",
43 | "print('编码器列表：{}'.format(encoder.classes_)) # 返回编码器中所有类别，已经排除了重复项\n",
44 | "for index,item in enumerate(encoder.classes_):\n",
45 | " print('{} --> {}'.format(item,index))\n",
46 | " \n",
47 | "# 使用编码器来编码新样本数据\n",
48 | "need_encode_labels=['王宝强','芙蓉姐姐','翠花']\n",
49 | "# need_encode_labels=['王宝强','芙蓉姐姐','翠花','无名氏'] \n",
50 | "# '无名氏'不存在编码器列表中，会报错\n",
51 | "encoded_labels=encoder.transform(need_encode_labels)\n",
52 | "print('\\n编码之前的标记：{}'.format(need_encode_labels))\n",
53 | "print('编码之后的标记：{}'.format(encoded_labels))\n",
54 | "\n",
55 | "# 使用编码器将编码数字解码成原来的文本标记，注意最大值不能超过编码器中的长度\n",
56 | "encoded=[1,3,0,4]\n",
57 | "# encoded=[1,3,0,4,5] # 5不存在与编码器中，故报错\n",
58 | "decoded_labels=encoder.inverse_transform(encoded)\n",
59 | "print('\\n已经编码的标记代码：{}'.format(encoded))\n",
60 | "print('解码后的标记：{}'.format(decoded_labels))\n"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": null,
66 | "metadata": {},
67 | "outputs": [],
68 | "source": []
69 | }
70 | ],
71 | "metadata": {
72 | "kernelspec": {
73 | "display_name": "Python 3",
74 | "language": "python",
75 | "name": "python3"
76 | },
77 | "language_info": {
78 | "codemirror_mode": {
79 | "name": "ipython",
80 | "version": 3
81 | },
82 | "file_extension": ".py",
83 | "mimetype": "text/x-python",
84 | "name": "python",
85 | "nbconvert_exporter": "python",
86 | "pygments_lexer": "ipython3",
87 | "version": "3.5.2"
88 | }
89 | },
90 | "nbformat": 4,
91 | "nbformat_minor": 2
92 | }
93 |
--------------------------------------------------------------------------------
/FireAI_028_SkLearnPipeline.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "import numpy as np\n",
10 | "import pandas as pd\n",
11 | "import matplotlib.pyplot as plt\n",
12 | "%matplotlib inline\n",
13 | "np.random.seed(37) # 使得每次运行得到的随机数都一样"
14 | ]
15 | },
16 | {
17 | "cell_type": "code",
18 | "execution_count": 2,
19 | "metadata": {},
20 | "outputs": [],
21 | "source": [
22 | "# 第一步：准备数据集\n",
23 | "from sklearn.datasets import samples_generator\n",
24 | "# 使用这个函数产生示例数据\n",
25 | "X,y=samples_generator.make_classification(n_informative=4,\n",
26 | " n_features=20,\n",
27 | " n_redundant=0,\n",
28 | " random_state=5)\n",
29 | "# 产生一个分类数据集，包含有100个样本，20个features，2个类别，没有冗余特征。\n",
30 | "# print(X.shape) # (100, 20)\n",
31 | "# print(y.shape) # (100,)\n",
32 | "# print(X[:3]) # 查看没有问题"
33 | ]
34 | },
35 | {
36 | "cell_type": "code",
37 | "execution_count": 3,
38 | "metadata": {},
39 | "outputs": [],
40 | "source": [
41 | "# 第二步：建立特征选择器\n",
42 | "from sklearn.feature_selection import SelectKBest, f_regression\n",
43 | "feature_selector=SelectKBest(f_regression,k=10) \n",
44 | "# 一共20个特征向量，我们从中选择最重要的10个特征向量\n"
45 | ]
46 | },
47 | {
48 | "cell_type": "code",
49 | "execution_count": 4,
50 | "metadata": {},
51 | "outputs": [],
52 | "source": [
53 | "# 第三步：建立分类器\n",
54 | "from sklearn.ensemble import RandomForestClassifier\n",
55 | "classifier=RandomForestClassifier(n_estimators=50,max_depth=4)\n",
56 | "# 此处构建随机森林分类器作为例子，参数随便指定"
57 | ]
58 | },
59 | {
60 | "cell_type": "code",
61 | "execution_count": 5,
62 | "metadata": {},
63 | "outputs": [
64 | {
65 | "data": {
66 | "text/plain": [
67 | "Pipeline(memory=None,\n",
68 | " steps=[('selector', SelectKBest(k=5, score_func=)), ('rf_classifier', RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
69 | " max_depth=4, max_features='auto', max_leaf_nodes=None,\n",
70 | " min_impurity_decrease=0.0, min...n_jobs=1,\n",
71 | " oob_score=False, random_state=None, verbose=0,\n",
72 | " warm_start=False))])"
73 | ]
74 | },
75 | "execution_count": 5,
76 | "metadata": {},
77 | "output_type": "execute_result"
78 | }
79 | ],
80 | "source": [
81 | "# 第四步：组装完整流水线\n",
82 | "from sklearn.pipeline import Pipeline\n",
83 | "pipeline=Pipeline([('selector',feature_selector),\n",
84 | " ('rf_classifier',classifier)])\n",
85 | "# 修改流水线中参数设置\n",
86 | "# 假如我们希望特征选择器不是选择10个特征，而是5个特征，\n",
87 | "# 同时分类器中的参数n_estimators也要修改一下，可以采用：\n",
88 | "pipeline.set_params(selector__k=5,\n",
89 | " rf_classifier__n_estimators=25)\n"
90 | ]
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": 6,
95 | "metadata": {},
96 | "outputs": [
97 | {
98 | "name": "stdout",
99 | "output_type": "stream",
100 | "text": [
101 | "pipeline model score: 0.930\n"
102 | ]
103 | }
104 | ],
105 | "source": [
106 | "# 将数据输入到流水线中\n",
107 | "pipeline.fit(X,y) # 对流水线进行训练\n",
108 | "\n",
109 | "predict_y=pipeline.predict(X) #用训练好的流水线预测样本\n",
110 | "# print(predict_y)\n",
111 | "\n",
112 | "# 评估该流水线的模型性能\n",
113 | "print('pipeline model score: {:.3f}'.format(pipeline.score(X,y)))"
114 | ]
115 | },
116 | {
117 | "cell_type": "code",
118 | "execution_count": 7,
119 | "metadata": {},
120 | "outputs": [
121 | {
122 | "name": "stdout",
123 | "output_type": "stream",
124 | "text": [
125 | "selected features by pipeline, (0-indexed): \n",
126 | "[5, 9, 10, 11, 15]\n"
127 | ]
128 | }
129 | ],
130 | "source": [
131 | "# 查看特征选择器选择的特征：\n",
132 | "feature_status=pipeline.named_steps['selector'].get_support()\n",
133 | "# get_support()会返回true/false，如果支持该feature，则为true.\n",
134 | "selected_features=[]\n",
135 | "for count,item in enumerate(feature_status):\n",
136 | " if item: selected_features.append(count)\n",
137 | "print('selected features by pipeline, (0-indexed): \\n{}'.format(\n",
138 | " selected_features))"
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": null,
144 | "metadata": {},
145 | "outputs": [],
146 | "source": []
147 | }
148 | ],
149 | "metadata": {
150 | "kernelspec": {
151 | "display_name": "Python 3",
152 | "language": "python",
153 | "name": "python3"
154 | },
155 | "language_info": {
156 | "codemirror_mode": {
157 | "name": "ipython",
158 | "version": 3
159 | },
160 | "file_extension": ".py",
161 | "mimetype": "text/x-python",
162 | "name": "python",
163 | "nbconvert_exporter": "python",
164 | "pygments_lexer": "ipython3",
165 | "version": "3.6.6"
166 | }
167 | },
168 | "nbformat": 4,
169 | "nbformat_minor": 2
170 | }
171 |
--------------------------------------------------------------------------------
/FireAI_032_SimilarityCalculation.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "import numpy as np\n",
10 | "import pandas as pd\n",
11 | "import matplotlib.pyplot as plt\n",
12 | "%matplotlib inline\n",
13 | "np.random.seed(37) "
14 | ]
15 | },
16 | {
17 | "cell_type": "code",
18 | "execution_count": 2,
19 | "metadata": {},
20 | "outputs": [],
21 | "source": [
22 | "# 定义一个函数来计算两个用户之间的欧式距离\n",
23 | "def euclidean_distance(dataset,user1,user2):\n",
24 | " # 首先要排除一种情况，如果数据集中不存在同时被两个用户评价过的电影，\n",
25 | " # 则表示两个用户之间的没有相似度，直接返回0\n",
26 | " both_rated_num=0 # 表示同时被两个用户都评价过的电影的数目\n",
27 | " for item in dataset[user1]: # 在user1评价过的电影中\n",
28 | " if item in dataset[user2]: # 如果user2也评价过，则+1\n",
29 | " both_rated_num+=1\n",
30 | " if both_rated_num==0:# 不存在同时被两个用户都评价过的电影\n",
31 | " return 0 # 直接返回0，表示两个用户之间相似度为0\n",
32 | " \n",
33 | " squared_difference=[] # 每一个元素表示同时被两个用户都评价过的电影得分的欧式距离\n",
34 | " for item in dataset[user1]:\n",
35 | " if item in dataset[user2]:\n",
36 | " squared_difference.append(np.square(dataset[user1][item]-dataset[user2][item]))\n",
37 | " return 1/(1+np.sqrt(np.sum(squared_difference)))\n"
38 | ]
39 | },
40 | {
41 | "cell_type": "code",
42 | "execution_count": 3,
43 | "metadata": {},
44 | "outputs": [
45 | {
46 | "name": "stdout",
47 | "output_type": "stream",
48 | "text": [
49 | " Euclidean score: 0.29429805508554946\n"
50 | ]
51 | }
52 | ],
53 | "source": [
54 | "# 原始的电影评价数据都放置在 movie_ratings.json文件中，我们加载进来看看结果\n",
55 | "import json\n",
56 | "with open(\"E:\\PyProjects\\DataSet\\FireAI\\movie_ratings.json\",'r') as file:\n",
57 | " dataset=json.loads(file.read())\n",
58 | " \n",
59 | "# 现在计算两个随机用户之间的欧式距离\n",
60 | "user1='John Carson'\n",
61 | "user2='Michelle Peterson'\n",
62 | "print(\" Euclidean score: \",euclidean_distance(dataset,user1,user2))"
63 | ]
64 | },
65 | {
66 | "cell_type": "code",
67 | "execution_count": 4,
68 | "metadata": {},
69 | "outputs": [],
70 | "source": [
71 | "# 定义一个函数来计算两个用户之间的皮尔逊相关系数\n",
72 | "def pearson_score(dataset,user1,user2):\n",
73 | " # 和上面的函数类似，先排除相似度为0的情况\n",
74 | "# both_rated_num=0 # 表示同时被两个用户都评价过的电影的数目\n",
75 | "# for item in dataset[user1]: # 在user1评价过的电影中\n",
76 | "# if item in dataset[user2]: # 如果user2也评价过，则+1\n",
77 | "# both_rated_num+=1\n",
78 | "# if both_rated_num==0:# 不存在同时被两个用户都评价过的电影\n",
79 | "# return 0 # 直接返回0，表示两个用户之间相似度为0\n",
80 | "\n",
81 | " both_rated={}\n",
82 | " for item in dataset[user1]:\n",
83 | " if item in dataset[user2]:\n",
84 | " both_rated[item]=1\n",
85 | " num_ratings=len(both_rated)\n",
86 | " if num_ratings==0: # 不存在同时被两个用户都评价过的电影\n",
87 | " return 0\n",
88 | " \n",
89 | " # 计算每个用户对每个相同电影的评价之和\n",
90 | " user1_sum=np.sum([dataset[user1][item] for item in both_rated])\n",
91 | " user2_sum=np.sum([dataset[user2][item] for item in both_rated])\n",
92 | " \n",
93 | " # 计算每个用户对每个相同电影的评价的平方和\n",
94 | " user1_squared_sum = np.sum([np.square(dataset[user1][item]) for item in both_rated])\n",
95 | " user2_squared_sum = np.sum([np.square(dataset[user2][item]) for item in both_rated])\n",
96 | "\n",
97 | " # 计算两个用户的相同电影的乘积\n",
98 | " product_sum=np.sum([dataset[user1][item]*dataset[user2][item] for item in both_rated])\n",
99 | " \n",
100 | " # 计算Pearson 相关系数\n",
101 | " Sxy = product_sum - (user1_sum * user2_sum / num_ratings)\n",
102 | " Sxx = user1_squared_sum - np.square(user1_sum) / num_ratings\n",
103 | " Syy = user2_squared_sum - np.square(user2_sum) / num_ratings\n",
104 | " \n",
105 | " if Sxx * Syy == 0:\n",
106 | " return 0\n",
107 | "\n",
108 | " return Sxy / np.sqrt(Sxx * Syy)"
109 | ]
110 | },
111 | {
112 | "cell_type": "code",
113 | "execution_count": 5,
114 | "metadata": {},
115 | "outputs": [
116 | {
117 | "name": "stdout",
118 | "output_type": "stream",
119 | "text": [
120 | " Peason score: 0.39605901719066977\n"
121 | ]
122 | }
123 | ],
124 | "source": [
125 | "# 原始的电影评价数据都放置在 movie_ratings.json文件中，我们加载进来看看结果\n",
126 | "import json\n",
127 | "with open(\"E:\\PyProjects\\DataSet\\FireAI\\movie_ratings.json\",'r') as file:\n",
128 | " dataset=json.loads(file.read())\n",
129 | " \n",
130 | "# 现在计算两个随机用户之间的欧式距离\n",
131 | "user1='John Carson'\n",
132 | "user2='Michelle Peterson'\n",
133 | "print(\" Peason score: \",pearson_score(dataset,user1,user2))"
134 | ]
135 | },
136 | {
137 | "cell_type": "code",
138 | "execution_count": null,
139 | "metadata": {},
140 | "outputs": [],
141 | "source": []
142 | }
143 | ],
144 | "metadata": {
145 | "kernelspec": {
146 | "display_name": "Python 3",
147 | "language": "python",
148 | "name": "python3"
149 | },
150 | "language_info": {
151 | "codemirror_mode": {
152 | "name": "ipython",
153 | "version": 3
154 | },
155 | "file_extension": ".py",
156 | "mimetype": "text/x-python",
157 | "name": "python",
158 | "nbconvert_exporter": "python",
159 | "pygments_lexer": "ipython3",
160 | "version": "3.6.6"
161 | }
162 | },
163 | "nbformat": 4,
164 | "nbformat_minor": 2
165 | }
166 |
--------------------------------------------------------------------------------
/FireAI_035_GetStems.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "# 英语单词的词干提取\n",
10 | "from nltk.stem.porter import PorterStemmer\n",
11 | "from nltk.stem.lancaster import LancasterStemmer\n",
12 | "from nltk.stem.snowball import SnowballStemmer"
13 | ]
14 | },
15 | {
16 | "cell_type": "code",
17 | "execution_count": 2,
18 | "metadata": {},
19 | "outputs": [
20 | {
21 | "name": "stdout",
22 | "output_type": "stream",
23 | "text": [
24 | " WORD PORTER LANCASTER SNOWBALL\n",
25 | " table tabl tabl tabl\n",
26 | " probably probabl prob probabl\n",
27 | " wolves wolv wolv wolv\n",
28 | " playing play play play\n",
29 | " is is is is\n",
30 | " dog dog dog dog\n",
31 | " the the the the\n",
32 | " beaches beach beach beach\n",
33 | " grounded ground ground ground\n",
34 | " dreamt dreamt dreamt dreamt\n",
35 | " envision envis envid envis\n"
36 | ]
37 | }
38 | ],
39 | "source": [
40 | "words = ['table', 'probably', 'wolves', 'playing', 'is', \n",
41 | " 'dog', 'the', 'beaches', 'grounded', 'dreamt', 'envision'] \n",
42 | "# 要提取的单词\n",
43 | "\n",
44 | "# 三种不同的词干提取器\n",
45 | "stemmers = ['PORTER', 'LANCASTER', 'SNOWBALL']\n",
46 | "stemmer_porter = PorterStemmer()\n",
47 | "stemmer_lancaster = LancasterStemmer()\n",
48 | "stemmer_snowball = SnowballStemmer('english')\n",
49 | "\n",
50 | "formatted_row = '{:>16}' * (len(stemmers) + 1)\n",
51 | "print(formatted_row.format('WORD',*stemmers)) # 打印表头\n",
52 | "\n",
53 | "for word in words: # 每个单词逐一提取\n",
54 | " stem=[stemmer_porter.stem(word), \n",
55 | " stemmer_lancaster.stem(word), stemmer_snowball.stem(word)]\n",
56 | " print(formatted_row.format(word,*stem)) # 对提取后的stem进行拆包"
57 | ]
58 | },
59 | {
60 | "cell_type": "code",
61 | "execution_count": null,
62 | "metadata": {},
63 | "outputs": [],
64 | "source": []
65 | }
66 | ],
67 | "metadata": {
68 | "kernelspec": {
69 | "display_name": "Python 3",
70 | "language": "python",
71 | "name": "python3"
72 | },
73 | "language_info": {
74 | "codemirror_mode": {
75 | "name": "ipython",
76 | "version": 3
77 | },
78 | "file_extension": ".py",
79 | "mimetype": "text/x-python",
80 | "name": "python",
81 | "nbconvert_exporter": "python",
82 | "pygments_lexer": "ipython3",
83 | "version": "3.6.6"
84 | }
85 | },
86 | "nbformat": 4,
87 | "nbformat_minor": 2
88 | }
89 |
--------------------------------------------------------------------------------
/FireAI_037_TextChunking.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "import numpy as np\n",
10 | "import nltk"
11 | ]
12 | },
13 | {
14 | "cell_type": "code",
15 | "execution_count": 2,
16 | "metadata": {},
17 | "outputs": [],
18 | "source": [
19 | "from nltk.tokenize import word_tokenize\n",
20 | "def split(dataset,words_num):\n",
21 | " '''\n",
22 | " 将dataset这一整段文本分割成N个小块，\n",
23 | " 使得每个小块中含有单词的数目等于words_num'''\n",
24 | " words=dataset.split(' ') # 此处用空格来区分单词是否合适？\n",
25 | " # words=word_tokenize(dataset) # 用分词器来分词是否更合适一些？\n",
26 | " \n",
27 | " rows=int(np.ceil(len(words)/words_num)) # 即行数\n",
28 | " result=[] # 预计里面装的元素是rows行words_num列，最后一行可能少于words_num，故不能用np.array\n",
29 | "\n",
30 | " # words是list，可以用切片的方式获取\n",
31 | " for row in range(rows):\n",
32 | " result.append(words[row*words_num:(row+1)*words_num])\n",
33 | " return result\n"
34 | ]
35 | },
36 | {
37 | "cell_type": "code",
38 | "execution_count": 3,
39 | "metadata": {},
40 | "outputs": [
41 | {
42 | "name": "stdout",
43 | "output_type": "stream",
44 | "text": [
45 | "192427\n",
46 | "34\n",
47 | "['[', 'Emma', 'by', 'Jane', 'Austen', '1816', ']', 'VOLUME', 'I', 'CHAPTER', 'I', 'Emma', 'Woodhouse', ',', 'handsome', ',', 'clever', ',', 'and', 'rich', ',', 'with', 'a', 'comfortable', 'home', 'and', 'happy', 'disposition', ',', 'seemed']\n",
48 | "30\n",
49 | "['its', 'separate', 'lawn', ',', 'and', 'shrubberies', ',', 'and', 'name', ',']\n",
50 | "10\n"
51 | ]
52 | }
53 | ],
54 | "source": [
55 | "# 测试一下\n",
56 | "# 数据集暂时用简·奥斯丁的《爱玛》中的文本\n",
57 | "dataset=nltk.corpus.gutenberg.words('austen-emma.txt')\n",
58 | "print(len(dataset)) # 192427 代表读入正常\n",
59 | "result=split(\" \".join(dataset[:1000]), 30) # 只取前面的1000个单词，每30个单词分一个块，一共有34个块\n",
60 | "print(len(result))\n",
61 | "print(result[0])\n",
62 | "print(len(result[0]))\n",
63 | "print(result[-1])\n",
64 | "print(len(result[-1]))"
65 | ]
66 | },
67 | {
68 | "cell_type": "code",
69 | "execution_count": null,
70 | "metadata": {},
71 | "outputs": [],
72 | "source": []
73 | }
74 | ],
75 | "metadata": {
76 | "kernelspec": {
77 | "display_name": "Python 3",
78 | "language": "python",
79 | "name": "python3"
80 | },
81 | "language_info": {
82 | "codemirror_mode": {
83 | "name": "ipython",
84 | "version": 3
85 | },
86 | "file_extension": ".py",
87 | "mimetype": "text/x-python",
88 | "name": "python",
89 | "nbconvert_exporter": "python",
90 | "pygments_lexer": "ipython3",
91 | "version": "3.6.6"
92 | }
93 | },
94 | "nbformat": 4,
95 | "nbformat_minor": 2
96 | }
97 |
--------------------------------------------------------------------------------
/FireAI_040_GenderClassify.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "import numpy as np\n",
10 | "np.random.seed(37) # 使得每次运行得到的随机数都一样"
11 | ]
12 | },
13 | {
14 | "cell_type": "code",
15 | "execution_count": 2,
16 | "metadata": {},
17 | "outputs": [
18 | {
19 | "name": "stdout",
20 | "output_type": "stream",
21 | "text": [
22 | "2943\n",
23 | "5001\n",
24 | "[('Aamir', 'male'), ('Aaron', 'male'), ('Abbey', 'male'), ('Abbie', 'male'), ('Abbot', 'male')]\n",
25 | "[('Abagael', 'female'), ('Abagail', 'female'), ('Abbe', 'female')]\n",
26 | "(7944, 2)\n"
27 | ]
28 | }
29 | ],
30 | "source": [
31 | "# 1, 准备数据集，此次数据集来源于nltk.corpus内置的names文件\n",
32 | "from nltk.corpus import names\n",
33 | "male_names=[(name, 'male') for name in names.words('male.txt')]\n",
34 | "female_names=[(name,'female') for name in names.words('female.txt')]\n",
35 | "print(len(male_names)) # 2943\n",
36 | "print(len(female_names)) # 5001\n",
37 | "# 数据集中有2943个男性名字，5001个女性名字\n",
38 | "\n",
39 | "# 看看男性和女性的名字都是哪些。。。。\n",
40 | "print(male_names[:5])\n",
41 | "print(female_names[:3])\n",
42 | "\n",
43 | "# 将这些名字组成的list合并成一个数据集，第一列是名字，即features，第二列是性别，即label\n",
44 | "dataset=np.array(male_names+female_names)\n",
45 | "print(dataset.shape) # (7944, 2)没错"
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": 3,
51 | "metadata": {},
52 | "outputs": [
53 | {
54 | "name": "stdout",
55 | "output_type": "stream",
56 | "text": [
57 | " name sex len1 len2 len3 len4\n",
58 | "0 Aamir male r ir mir amir\n",
59 | "1 Aaron male n on ron aron\n",
60 | "2 Abbey male y ey bey bbey\n",
61 | "3 Abbie male e ie bie bbie\n",
62 | "4 Abbot male t ot bot bbot\n"
63 | ]
64 | }
65 | ],
66 | "source": [
67 | "# 处理数据集\n",
68 | "# 我们难以确定到底是姓名后面的几个字母才和性别相关性最大，\n",
69 | "# 故而此处把后面的1-4个字母都取出来作为一个特征列\n",
70 | "# 用pandas 貌似更容易一些\n",
71 | "import pandas as pd\n",
72 | "dataset_df=pd.DataFrame(dataset,columns=['name','sex'])\n",
73 | "# print(dataset_df.info())\n",
74 | "# print(dataset_df.head()) # 检查没有问题\n",
75 | "\n",
76 | "for i in range(1,5): # 分别截取每个名字的后面i个字母\n",
77 | " dataset_df['len'+str(i)]=dataset_df.name.map(lambda x: x[-i:].lower())\n",
78 | " \n",
79 | "print(dataset_df.head())# 检查没有问题"
80 | ]
81 | },
82 | {
83 | "cell_type": "code",
84 | "execution_count": 4,
85 | "metadata": {},
86 | "outputs": [
87 | {
88 | "name": "stdout",
89 | "output_type": "stream",
90 | "text": [
91 | "Number of suffix: 1, accuracy on test set: 76.05%\n",
92 | "Number of suffix: 2, accuracy on test set: 77.89%\n",
93 | "Number of suffix: 3, accuracy on test set: 75.80%\n",
94 | "Number of suffix: 4, accuracy on test set: 71.56%\n"
95 | ]
96 | }
97 | ],
98 | "source": [
99 | "# 分别构建分类器，并训练后再测试集上看看效果\n",
100 | "dataset=dataset_df.values\n",
101 | "np.random.shuffle(dataset)\n",
102 | "rows=int(len(dataset)*0.7) # 70%为train set\n",
103 | "train_set,test_set=dataset[:rows],dataset[rows:]\n",
104 | "\n",
105 | "from nltk import NaiveBayesClassifier\n",
106 | "from nltk.classify import accuracy as nltk_accuracy\n",
107 | "for i in range(1,5): # 对每一列特征分别建模并训练\n",
108 | " train_X,train_y=train_set[:,i+1],train_set[:,1]\n",
109 | " train=[({'feature':feature},label) for (feature,label) in zip(train_X,train_y)] \n",
110 | " # 后面的NaiveBayesClassifier 在train的时候需要()组成的list\n",
111 | " clf=NaiveBayesClassifier.train(train)\n",
112 | " \n",
113 | " # 查看该模型在test set上的表现\n",
114 | " test_X,test_y=test_set[:,i+1],test_set[:,1]\n",
115 | " test=[({'feature':feature},label) for (feature,label) in zip(test_X,test_y)] \n",
116 | " acc=nltk_accuracy(clf,test)\n",
117 | " \n",
118 | " print('Number of suffix: {}, accuracy on test set: {:.2f}%'\n",
119 | " .format(i, 100*acc))"
120 | ]
121 | },
122 | {
123 | "cell_type": "code",
124 | "execution_count": null,
125 | "metadata": {},
126 | "outputs": [],
127 | "source": []
128 | },
129 | {
130 | "cell_type": "code",
131 | "execution_count": null,
132 | "metadata": {},
133 | "outputs": [],
134 | "source": []
135 | }
136 | ],
137 | "metadata": {
138 | "kernelspec": {
139 | "display_name": "Python 3",
140 | "language": "python",
141 | "name": "python3"
142 | },
143 | "language_info": {
144 | "codemirror_mode": {
145 | "name": "ipython",
146 | "version": 3
147 | },
148 | "file_extension": ".py",
149 | "mimetype": "text/x-python",
150 | "name": "python",
151 | "nbconvert_exporter": "python",
152 | "pygments_lexer": "ipython3",
153 | "version": "3.6.6"
154 | }
155 | },
156 | "nbformat": 4,
157 | "nbformat_minor": 2
158 | }
159 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 【火炉炼AI】-机器学习系列文章
2 |
3 |
4 | 说明：
5 |
6 | 1，本部分是【火炉炼AI】系列之机器学习部分的内容。
7 |
8 | 2，对于每一篇文章分为两部分：文章和代码，其中的文章发布在Articles文件夹下，而代码位于本文件夹下。
9 |
10 | 3，我所有的文章都同时发布在[我的掘金页面](https://juejin.im/user/5b6441cfe51d455d6825feec/posts)和[我的简书页面](https://www.jianshu.com/u/fdeeaeacad7f)
11 |
12 | 4，如果有任何问题想联系我，请在我的掘金或简书主页下留言即可。
13 |
--------------------------------------------------------------------------------