https://ke.qq.com/course/190378
https://github.com/haoran119/ke.qq.com.python/tree/master/src/python-fullstack
Python — 爬虫、数据分析
python — 数据分析之旅，Numpy
数据获取
公开数据集（Mnist），爬虫
数据存储
数据库SQL
数据预处理
噪声，重复，缺失，空值，异常值，分组，合并，随机取样（pandas）
数据建模、分析
找一个合适的模型，统计学，概率论，机器学习，聚类，回归（sklearn）
数据可视化
matplotlib
# coding: utf-8 # In[1]: import numpy as np # In[2]: # 创建数组 list1 = [ 1, 3, 5, -2, 0, -9 ]
list2 = [ 2, 4, -3, -7, 1, -7 ]
list3 = [ [2, 5, 0], [11, 3, 4] ]
list4 = [ [3, -1, 8], [9, -3, 9] ] # In[3]: arr1 = np.array( list1 ) #[ 1 3 5 -2 0 -9]
print(arr1) # In[4]: arr4 = np.array( list3 ) #[[ 2 5 0]
# [11 3 4]]
print(arr4) # In[5]: arr2 = np.arange( 1, 10, 2 ) #[1 3 5 7 9]
print(arr2) # In[6]: arr3 = np.linspace( 1, 10, 4 ) #[ 1. 4. 7. 10.]
print(arr3) # In[7]: arr_zero = np.zeros( (3, 4)) # zeros参数是元组() #[[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]
print(arr_zero) # In[8]: arr_one = np.ones( (3, 3) ) #[[1. 1. 1.]
# [1. 1. 1.]
# [1. 1. 1.]]
#[[100. 100. 100.]
# [100. 100. 100.]
# [100. 100. 100.]]
print(arr_one)
print(arr_one * 100) # In[9]: arr_eye = np.eye( 4, 4 ) # 对角线上元素为1，其他为0 #[[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
print(arr_eye) # In[10]: arr_eye2 = np.eye( 4, 5 ) #[[1. 0. 0. 0. 0.]
# [0. 1. 0. 0. 0.]
# [0. 0. 1. 0. 0.]
# [0. 0. 0. 1. 0.]]
print(arr_eye2) # In[11]: # 数组的索引和切片 #[ 5 -2 0]
#[[3 4]]
print(arr1[2:5]) # 左闭右开
print(arr4[1:2, 1:3]) # In[12]: # 通用的函数 #sqrt :
# [[1.41421356 2.23606798 0. ]
# [3.31662479 1.73205081 2. ]]
#exp :
# [[7.38905610e+00 1.48413159e+02 1.00000000e+00]
# [5.98741417e+04 2.00855369e+01 5.45981500e+01]]
print("sqrt : \n", np.sqrt(arr4))
print("exp : \n", np.exp(arr4)) # In[13]: arr2 = np.array( list2 )
new_arr = np.maximum( arr1, arr2 ) #[ 2 4 5 -2 1 -7]
print(new_arr) # In[14]: # ReLU >0 保留原值，<0 取0
new_arr = np.maximum(0, arr1) #[1 3 5 0 0 0]
print(new_arr) # In[15]: #(array([[0.41421356, 0.23606798, 0. ],
# [0.31662479, 0.73205081, 0. ]]), array([[1., 2., 0.],
# [3., 1., 2.]]))
print( np.modf( np.sqrt( arr4 ) ) ) # 把整数部分和小数部分，生成两个独立的数组 # In[16]: new_arr1 = np.where( arr2>0, 'True', 'False' ) # if condition: x, y #['True' 'True' 'False' 'False' 'True' 'False']
print(new_arr1) # In[17]: #[-7 -3 1 2 4]
#[ 0 2 3 4 5 11]
print( np.unique( arr2 ) )
print( np.unique( arr4 ) ) # In[18]: # 数组作为文件来输入和输出 np.save( 'myarr', arr2 ) # 把数组保存为文件 .npy # In[19]: new_arr2 = np.load( 'myarr.npy' ) #[ 2 4 -3 -7 1 -7]
print(new_arr2) # In[20]: np.savez( 'myarrzip', a1=arr1, a2=arr2, a3=arr3 )
arr = np.load( 'myarrzip.npz' ) #[ 1 3 5 -2 0 -9]
print(arr['a1']) # In[21]: # 线性代数 矩阵
# 矩阵的合并 arr5 = np.array( list3 )
arr6 = np.array( list4 ) #[[ 2 5 0 3 -1 8]
# [11 3 4 9 -3 9]]
#[[ 2 5 0]
# [11 3 4]
# [ 3 -1 8]
# [ 9 -3 9]]
print( np.hstack( [arr5, arr6] ) )
print( np.vstack( [arr5, arr6] ) ) # In[22]: # 点乘 arr6 = np.array( list4 ).reshape( 3, 2 ) #[[ 3 -1]
# [ 8 9]
# [-3 9]]
#[[ -5 12 -4]
# [115 67 36]
# [ 93 12 36]]
print( arr6 )
print( arr6.dot( arr5 ) ) # In[23]: #[[ 3 8 -3]
# [-1 9 9]]
print( np.transpose(arr6) ) # 转置
python — 数据分析之旅，pandas
数据处理
不干净的数据
干净数据，随机采样
表格数据
时间序列数据
矩阵数据
观测数据
统计数据
数据清洗
空值（缺失值）
pandas常用操作
大小可变
数据自动对齐
Series（一维），Dataframe（二维）
分组的功能
Numpy
切片，索引
列表和字符串
数据集的形状
# coding: utf-8 # In[1]: import pandas as pd
import numpy as np # In[2]: data = pd.DataFrame(pd.read_excel('originalData.xlsx')) # date hour pressure wind_direction temperature
#0 2016-07-01 0.0 1000.4 225.0 26.4
#1 2016-07-01 NaN NaN NaN NaN
#2 2016-07-01 6.0 998.9 212.0 31.7
#3 2016-07-01 235.0 998.7 244.0 NaN
#4 2016-07-01 12.0 999.7 222.0 NaN
#5 2016-07-01 15.0 1000.0 102.0 NaN
#6 2016-07-01 NaN 998.8 202.0 26.0
#7 2016-07-01 NaN 1000.2 334.0 25.5
#8 2016-07-01 NaN 1000.2 334.0 25.5
#9 2016-07-02 3.0 1002.4 46.0 30.0
#10 2016-07-02 6.0 1001.3 37.0 29.3
#11 2016-07-02 9.0 1001.9 345.0 25.9
#12 2016-07-02 12.0 1003.6 113.0 25.1
#13 2016-07-02 12.0 1003.6 113.0 25.1
#14 2016-07-02 15.0 1002.4 138.0 25.3
# hour pressure wind_direction temperature
#count 11.000000 14.000000 14.000000 11.000000
#mean 29.545455 1000.864286 190.500000 26.890909
#std 68.313049 1.685963 102.932951 2.311473
#min 0.000000 998.700000 37.000000 25.100000
#25% 6.000000 999.775000 113.000000 25.400000
#50% 12.000000 1000.300000 207.000000 25.900000
#75% 13.500000 1002.275000 239.250000 27.850000
#max 235.000000 1003.600000 345.000000 31.700000
print(data)
print(data.describe()) # In[3]: #RangeIndex(start=0, stop=15, step=1)
#Index(['date', 'hour', 'pressure', 'wind_direction', 'temperature'], dtype='object')
print(data.index)
print(data.columns) # In[4]: # date hour pressure wind_direction temperature
#0 2016-07-01 0.0 1000.4 225.0 26.4
#1 2016-07-01 NaN NaN NaN NaN
#2 2016-07-01 6.0 998.9 212.0 31.7
#3 2016-07-01 235.0 998.7 244.0 NaN
#4 2016-07-01 12.0 999.7 222.0 NaN
#5 2016-07-01 15.0 1000.0 102.0 NaN
# date hour pressure wind_direction temperature
#9 2016-07-02 3.0 1002.4 46.0 30.0
#10 2016-07-02 6.0 1001.3 37.0 29.3
#11 2016-07-02 9.0 1001.9 345.0 25.9
#12 2016-07-02 12.0 1003.6 113.0 25.1
#13 2016-07-02 12.0 1003.6 113.0 25.1
#14 2016-07-02 15.0 1002.4 138.0 25.3
print(data.head(6))
print(data.tail(6)) # In[5]: # 1. 删掉空白值超过3的行
data.dropna(axis=0, thresh=3, inplace=True)
data.reset_index(drop=True, inplace=True) # date hour pressure wind_direction temperature
#0 2016-07-01 0.0 1000.4 225.0 26.4
#1 2016-07-01 6.0 998.9 212.0 31.7
#2 2016-07-01 235.0 998.7 244.0 NaN
#3 2016-07-01 12.0 999.7 222.0 NaN
#4 2016-07-01 15.0 1000.0 102.0 NaN
#5 2016-07-01 NaN 998.8 202.0 26.0
#6 2016-07-01 NaN 1000.2 334.0 25.5
#7 2016-07-01 NaN 1000.2 334.0 25.5
#8 2016-07-02 3.0 1002.4 46.0 30.0
#9 2016-07-02 6.0 1001.3 37.0 29.3
#10 2016-07-02 9.0 1001.9 345.0 25.9
#11 2016-07-02 12.0 1003.6 113.0 25.1
#12 2016-07-02 12.0 1003.6 113.0 25.1
#13 2016-07-02 15.0 1002.4 138.0 25.3
print(data) # In[6]: # 2. 填充空白，hour填充10，temperature填充25.5
data.fillna({'hour':10, 'temperature':25.5}, inplace=True) # date hour pressure wind_direction temperature
#0 2016-07-01 0.0 1000.4 225.0 26.4
#1 2016-07-01 6.0 998.9 212.0 31.7
#2 2016-07-01 235.0 998.7 244.0 25.5
#3 2016-07-01 12.0 999.7 222.0 25.5
#4 2016-07-01 15.0 1000.0 102.0 25.5
#5 2016-07-01 10.0 998.8 202.0 26.0
#6 2016-07-01 10.0 1000.2 334.0 25.5
#7 2016-07-01 10.0 1000.2 334.0 25.5
#8 2016-07-02 3.0 1002.4 46.0 30.0
#9 2016-07-02 6.0 1001.3 37.0 29.3
#10 2016-07-02 9.0 1001.9 345.0 25.9
#11 2016-07-02 12.0 1003.6 113.0 25.1
#12 2016-07-02 12.0 1003.6 113.0 25.1
#13 2016-07-02 15.0 1002.4 138.0 25.3
print(data) # In[7]: # 3. 删掉hour>24的行
num = data.index.max() for i in range(num):
if data.loc[i, 'hour'] > 24:
data.drop([i], inplace=True)
print('hour > 24, deleted') data.reset_index(drop=True, inplace=True) #hour > 24, deleted
# date hour pressure wind_direction temperature
#0 2016-07-01 0.0 1000.4 225.0 26.4
#1 2016-07-01 6.0 998.9 212.0 31.7
#2 2016-07-01 12.0 999.7 222.0 25.5
#3 2016-07-01 15.0 1000.0 102.0 25.5
#4 2016-07-01 10.0 998.8 202.0 26.0
#5 2016-07-01 10.0 1000.2 334.0 25.5
#6 2016-07-01 10.0 1000.2 334.0 25.5
#7 2016-07-02 3.0 1002.4 46.0 30.0
#8 2016-07-02 6.0 1001.3 37.0 29.3
#9 2016-07-02 9.0 1001.9 345.0 25.9
#10 2016-07-02 12.0 1003.6 113.0 25.1
#11 2016-07-02 12.0 1003.6 113.0 25.1
#12 2016-07-02 15.0 1002.4 138.0 25.3
print(data) # In[8]: # 4. 删掉重复的数据行，保留出现的第一行（全部删掉？保留最后一行？）
data.drop_duplicates(keep='first', inplace=True)
data.reset_index(drop=True, inplace=True) # date hour pressure wind_direction temperature
#0 2016-07-01 0.0 1000.4 225.0 26.4
#1 2016-07-01 6.0 998.9 212.0 31.7
#2 2016-07-01 12.0 999.7 222.0 25.5
#3 2016-07-01 15.0 1000.0 102.0 25.5
#4 2016-07-01 10.0 998.8 202.0 26.0
#5 2016-07-01 10.0 1000.2 334.0 25.5
#6 2016-07-02 3.0 1002.4 46.0 30.0
#7 2016-07-02 6.0 1001.3 37.0 29.3
#8 2016-07-02 9.0 1001.9 345.0 25.9
#9 2016-07-02 12.0 1003.6 113.0 25.1
#10 2016-07-02 15.0 1002.4 138.0 25.3
print(data) # In[9]: # 5. 数据重排
randnum = np.random.permutation(data.index.size) #[ 4 0 10 3 1 5 8 9 7 2 6]
print(randnum) # In[10]: data2 = data.take(randnum) # date hour pressure wind_direction temperature
#4 2016-07-01 10.0 998.8 202.0 26.0
#0 2016-07-01 0.0 1000.4 225.0 26.4
#10 2016-07-02 15.0 1002.4 138.0 25.3
#3 2016-07-01 15.0 1000.0 102.0 25.5
#1 2016-07-01 6.0 998.9 212.0 31.7
#5 2016-07-01 10.0 1000.2 334.0 25.5
#8 2016-07-02 9.0 1001.9 345.0 25.9
#9 2016-07-02 12.0 1003.6 113.0 25.1
#7 2016-07-02 6.0 1001.3 37.0 29.3
#2 2016-07-01 12.0 999.7 222.0 25.5
#6 2016-07-02 3.0 1002.4 46.0 30.0
print(data2) # In[11]: # 6. 随机采样
data3 = data.sample(8) # date hour pressure wind_direction temperature
#4 2016-07-01 10.0 998.8 202.0 26.0
#0 2016-07-01 0.0 1000.4 225.0 26.4
#2 2016-07-01 12.0 999.7 222.0 25.5
#1 2016-07-01 6.0 998.9 212.0 31.7
#5 2016-07-01 10.0 1000.2 334.0 25.5
#9 2016-07-02 12.0 1003.6 113.0 25.1
#7 2016-07-02 6.0 1001.3 37.0 29.3
#8 2016-07-02 9.0 1001.9 345.0 25.9
print(data3)
data3.to_csv('data3.csv')
python — 数据分析之旅，matplotlib
Numpy
科学计算
pandas
数据清洗 / 去重 / 修改删除异常值 / 随机采样 / 重排
数据分析的流程
数据建模
学习规律，指导将来的决策 - 机器学习
数据 图
数据可视化
Python开发
语法简洁
丰富的库
标准库
第三方库
numpy / pandas / matplotlib
PyPI.org
构建快速原型
AI主流的编程语言
# coding: utf-8 # In[1]: import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D # In[2]: # 1. 线形图 y = ax + b
x = np.linspace(1, 21, 20)
y = 2 * x + 3
y2 = np.sin(x) plt.plot(x, y, 'm^:', x, y2) plt.show() # In[3]: # 2. 散点图
n = 1024
x = np.random.normal(0, 1, n) #1024个符合高斯分布的值
y = np.random.normal(0, 1, n) plt.scatter(x, y, s=np.random.rand(n)*50, c=np.random.rand(n), alpha=0.7) plt.show() # In[4]: # 3. 柱状图
n = 10
x = np.arange(n)
y1 = (1 - x / float(n)) * np.random.uniform(0.5, 1.0, n)
y2 = (1 - x / float(n)) * np.random.uniform(0.5, 1.0, n) plt.bar(x, y1, facecolor='red', edgecolor='white')
plt.bar(x, -y2, facecolor='blue', edgecolor='black') for xx, y in zip(x, y1):
plt.text(xx, y + 0.1, '%0.2f'%y, ha='center', va='bottom') for xx, y in zip(x, -y2):
plt.text(xx, y - 0.1, '%0.2f'%y, ha='center', va='bottom') plt.ylim(-1.5, 1.5) plt.show() # In[5]: # 4. 3D
fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)
x = np.arange(-4, 4, 0.25)
y = np.arange(-4, 4, 0.25) x, y = np.meshgrid(x, y)
#[[-4. -3.75 -3.5 ... 3.25 3.5 3.75]
# [-4. -3.75 -3.5 ... 3.25 3.5 3.75]
# [-4. -3.75 -3.5 ... 3.25 3.5 3.75]
# ...
# [-4. -3.75 -3.5 ... 3.25 3.5 3.75]
# [-4. -3.75 -3.5 ... 3.25 3.5 3.75]
# [-4. -3.75 -3.5 ... 3.25 3.5 3.75]]
print(x)
#[[-4. -4. -4. ... -4. -4. -4. ]
# [-3.75 -3.75 -3.75 ... -3.75 -3.75 -3.75]
# [-3.5 -3.5 -3.5 ... -3.5 -3.5 -3.5 ]
# ...
# [ 3.25 3.25 3.25 ... 3.25 3.25 3.25]
# [ 3.5 3.5 3.5 ... 3.5 3.5 3.5 ]
# [ 3.75 3.75 3.75 ... 3.75 3.75 3.75]]
print(y) z = np.sin(np.sqrt(x**2 + y**2)) ax.plot_surface(x, y, z, cmap=plt.get_cmap('autumn')) plt.show() # In[6]: # 5. 一图多画
x = np.linspace(0, 5, 5)
y1 = x**2
y2 = 2 * x
y3 = np.sin(x)
y4 = np.cos(x) ax1 = plt.subplot(221)
plt.plot(x, y1)
ax2 = plt.subplot(2, 2, 2)
plt.plot(x, y2)
ax3 = plt.subplot(223)
plt.plot(x, y3)
ax4 = plt.subplot(2, 2, 4)
#plt.plot(x, y4) plt.show()
Python - 人工智能
全方位认识python
Python大器晚成原因
1990那个年代，计算机性能比现在差很多，程序执行速度和效率更重要，快速开发不是第一要务，压榨机器性能才是。
Python非大企业出身
Python语言特点
简单易学、明确优雅、开发速度快
跨平台、可移植、可扩展、交互式、解释型面向对象的动态语言
解释型：Python语言在执行过程中由解释器逐行分析，逐行运行并输出结果
“自带电池”，大量的标准库和第三方库
社区活跃，贡献者多，互帮互助
开源语言，发展动力巨大
Python的缺点
运行速度相对慢点。
GIL（Global Interpreter Lock）全局解释器锁 。
Python的应用方向
常规软件开发
科学计算
WEB开发
网络爬虫
数据分析
人工智能
全面解读人工智能
人工智能 / 机器学习 / 深度学习
人工智能（Artificial Intelligence）
人工智能类型
弱人工智能
包含基础的、特定场景下角色型的任务，如Siri，ALphaGo等
通用人工智能
包含人类水平的任务，涉及机器的持续学习
强人工智能
比人类更聪明的机器
手机中的AI
智能美图
智能搜索排序
自动驾驶
智能会话
机器翻译
智能物流
新一代AI应用
理论与基础技术
大数据智能
技术研究
语言识别
自然语言理解
图像识别
应用研发
聊天界面（小冰）
语音助手（Siri）
语音记录（讯飞）
翻译（谷歌）
智能音箱（亚马逊Echo）
延展性和渗透性：智能音箱
人工智能的技术架构
应用层
智能产品
应用平台
技术层
通用技术
算法模型
基础框架
基础层
数据资源
软件设施
硬件设施
机器学习
计算机从数据中学习出规律和模式，以应用在新数据上做预测的任务
互联网大数据中挖掘出有用的价值
机器学习算法分类、解决什么问题
监督学习
需要用已知结果的数据做训练
输入的数据有相对应的标签
分类问题
根据数据样本上抽取的特征，判定其属于有限个类别中的哪一个
回归问题
根据数据样本上抽取的特征，预测一个连续值的结果
非监督学习
不需要已知标签
输入的信息不知道是什么分类，不知道规则，没有输出，结果就是寻找数据中的规则
聚类问题
根据数据样本上抽取的特征，让样本抱团（相近/相关的样本在一团内）
半监督学习
近几年新起的介于监督学习与非监督学习之间。先少量标注一部分数据，然后寻找这部分数据的特征，自动给剩下的数据标注标签。
强化学习
强调如何基于环境而行动，以取得最大化的预期收益。有机体如何在环境给予的奖励或惩罚的刺激下，逐步形成对刺激的预期，产生能获得最大利益的习惯性行为。常被应用在机器人、无人机等领域。
机器学习的应用
数据挖掘
计算机视觉
自然语言处理
生物特征识别
搜索引擎
医学诊断
检测信用卡欺诈
证券市场分析
语音和手写识别
机器人
机器学习的学习路径
数学基础
微积分
机器学习中大多数算法的求解过程的核心
线性代数
矩阵的各种运算
概率与统计
朴素贝叶斯
隐式马尔可夫
机器学习典型方法
分类问题
决策树、支持向量机（SVM）、随机森林、朴素贝叶斯、深度神经网络
回归问题
线性回归、普通最小二乘回归、逐步回归
聚类问题
K均值（K-means）、基于密度聚类
降维
主成分分析（PCA）、奇异值分解（SVD）
其他算法
Adaboost、EM等
编程基础
Python有全品类的数据科学工具
Scrapy：网页爬虫
Pandas：数据浏览与预处理
numpy：数组运算
scipy：高效的科学计算
matplotlib：非常方便的数据可视化工具
scikit-learn：远近闻名的机器学习package，接口封装好，几乎所有的机器学习算法输入输出格式都一致。支持文档可以直接当教程来学习。
libsvm：高效的svm模型实现
keras/TensorFlow：深度学习，方便搭建自己的神经网络
nltk：自然语言处理相关功能做的非常全面，有典型语料库，上手容易
R - 开源，有许多可用的包
C++ - mlpack，Shark
Java - WEKA Machine Learning Workbench
机器学习实施过程
原始样本集
特征提取
特征样本集
预处理
训练集 - 训练 / 验证集 - 预测
机器学习算法
输出
验证集 / 预测目标
评价 / 改进
深度学习
一类算法集合，机器学习的一个分支，尝试为数据的高层次摘要进行建模
人工神经网络
深度神经网络
CNN、RNN、FCN
人工智能、机器学习、深度学习三者的关系
人工智能
让机器像人一样思考
国际跳棋程序
机器学习
人工智能的分支，研究机器模拟或实现人类的学习行为，以获取新的知识技能，并改善自身性能
垃圾邮件过滤
深度学习
一种机器学习方法，模拟人脑机制解释数据，通过组合低层特征形成更抽象的高层属性类别或特征
谷歌视频寻猫
深度学习必备基础
Python
公开论文 / 代码都是python为主流
开源框架基本都是python接口
线性代数、微积分
矩阵计算和梯度求导运算
主流深度学习框架
TensorFlow
Caffe
Keras
CNTK
MXNet
Torch7
Theano
Deeplearning4J
Leaf
Lasagne
Neon
深度学习的应用
人脸识别
通用物体检测
图像分割
光学字符识别 - OCR
语音识别
机器翻译
情感识别
机器学习实例
KNN分类算法的分类预测过程
对于一个需要预测的输入向量x，只需要在训练数据集中寻找k个与向量x最近的向量的集合，然后把x的类标预测为这k个样本中类标数最多的那一类。
机器学习的主要步骤
- 准备数据集（量要大，模型才够精确。数据要全面，模型才全面）
数据清洗，数据预处理（噪声，缺失值，乱码，特征的提取，分为训练集和测试集）
选择一个模型（算法）
训练（训练集训练模型）
模型（分类，预测）- 测试集（验证集）
评估
模型的优化
调参，e.g. KNN（k）
换模型
迭代4-6
基于KNN的手写体数字识别
# coding: utf-8 # In[1]: from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
from sklearn import datasets # In[2]: """
手写体数字，监督学习
1、样本集：一批手写体数字的图片，带标签（0-9），10类
样本数据量为1797，存在sklearn的datasets里。
每一个数据样本都是由image, target两部分组成。
image是一个尺寸为8*8的图像（手写的数字0-9），
target是图像的类别（数字0-9）。
2、划分训练集和测试集
3、选一个算法，构建模型，KNN
4、训练模型
5、预测、验证
6、模型优化（SVM, 决策树）
7、保存模型（.model, load, predict）
8、新建多张手写体图片，让模型来识别新的图片
"""
sample_data = datasets.load_digits()
images = sample_data.data
labels = sample_data.target # In[3]: #划分训练集和测试集
train_data, test_data, train_labels, test_labels = train_test_split(images, labels, test_size=0.1) # In[4]: #选择模型
model_knn = KNeighborsClassifier(n_neighbors=4, algorithm='auto', weights='distance') # In[5]: #训练模型
model_knn.fit(train_data, train_labels)
#KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
# metric_params=None, n_jobs=1, n_neighbors=4, p=2,
# weights='distance') # In[6]: #预测、验证
pred = model_knn.predict(test_data)
print("pred : \n", pred)
print("test_labels : \n", test_labels)
#pred :
# [3 4 1 4 4 0 0 8 2 9 8 9 6 1 3 3 7 8 5 1 3 2 1 2 7 4 8 5 7 1 0 2 4 0 7 3 1
# 5 3 4 6 2 5 1 6 3 4 5 4 9 3 6 5 0 0 4 5 2 0 7 7 6 5 1 2 9 9 2 7 6 3 2 3 8
# 6 7 6 4 0 2 2 8 8 8 5 0 2 0 4 2 2 0 6 6 6 0 9 8 9 5 3 8 5 7 9 6 3 0 3 9 5
# 1 0 9 6 7 0 1 5 3 0 3 4 9 2 3 8 2 2 5 7 2 6 2 7 3 1 4 5 9 9 6 6 9 7 1 3 7
# 1 9 8 6 9 9 6 5 0 5 6 9 7 7 5 0 3 8 5 9 2 0 9 3 1 2 9 3 7 6 9 6]
#test_labels :
# [3 4 1 4 4 0 0 8 2 9 8 9 6 1 3 3 7 8 5 1 3 2 1 2 7 4 8 5 7 1 0 2 4 0 7 3 1
# 5 3 4 6 2 5 1 6 3 4 5 4 9 3 6 5 0 0 4 5 2 0 7 7 6 5 1 2 9 9 2 7 6 3 2 3 8
# 6 7 6 4 0 2 2 8 8 8 5 0 2 0 4 2 2 0 6 6 6 0 9 8 7 5 3 8 5 7 9 6 3 0 3 9 5
# 1 0 9 6 7 0 1 5 3 0 3 4 9 2 3 8 2 2 5 7 2 6 2 7 3 1 4 5 9 9 6 6 9 7 1 3 7
# 1 9 8 6 9 9 6 5 0 5 6 9 7 7 5 0 3 8 5 9 2 0 9 3 1 2 9 3 7 6 9 6] # In[7]: #查看准确率
acc = accuracy_score(pred, test_labels)
print("Accuracy rate : %.3f" % acc)
#Accuracy rate : 0.994
基于CNN的手写体数字识别
手写体数字识别 - 机器学习的HelloWorld
MNIST数据集
MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges
http://yann.lecun.com/exdb/mnist/
Keras
纯python编写的基于theano/tensorflow的深度学习框架。一个高度模块化的神经网络库，支持GPU和CPU。
一致而简洁的API，极大减少一般应用下用户的工作量
Keras搭建神经网络的过程
CNN - 卷积神经网络
CNN的建造灵感来自于人类对视觉信息的识别过程：点 -> 线 -> 面。
卷积层
卷是席卷，积为乘积。卷积实质上是用一个叫kernel的矩阵，从图像的小块上一一贴过去，每次和图像块的每一个像素乘积得到一个output值，扫过之后就得到一个新图像。
池化层
下采样（subsampling），分为最大值池化和平均值池化。
为什么池化
图像经过下采样尺寸缩小
增强了旋转不定性，池化操作可以看作是一种强制性的模糊策略
核的大小 / 步长
CNN的过程
我们将输入图像传递到第一个卷积层，卷积后以激活图形式输出。图片在卷积层中过滤后的特征会被输出，并传递下去。
每个过滤器都会给出不同的特征，以帮助进行正确的类预测。
随后加入池化层进一步减少参数的数量。
在预测最终提出前，数据会经过多个卷积层和池化层的处理。卷积层会帮助提取特征，越深的卷积神经网络会提取越具体的特征，越浅的神经网络提取越浅显的特征。
CNN中的输出层是全连接层，其中来自其他层的输入在这里被平化和发送，以便将输出转换为网络所需的参数。
随后输出层会产生输出，这些信息会互相比较排除错误。损失函数是全连接输出层计算的均方根损失。随后我们会计算梯度错误。
错误会进行反向传播，以不断改进过滤器（权重）和偏差值。
一个训练周期由单次正向和反向传递完成。
# coding: utf-8 # In[1]: """
基于CNN的手写体数字识别 迭代一轮 80s
"""
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K # In[2]: # 设置初始参数
batch_size = 128 # 一批喂给模型多少张图片 60000
num_classes = 10 # 分类 0 - 9
epochs = 12 # 迭代次数 img_rows, img_cols = 28, 28 # 28 * 28 # In[3]: # 加载数据
(x_train, y_train), (x_test, y_test) = mnist.load_data() # 加载数据集，第一次运行慢 # 判断backend theano, tensorflow
# 彩色图片 RGB 3 通道，灰度图 1 通道
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) # (60000, 1, 28, 28)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
intput_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1) # In[4]: # 数据处理 # image处理
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255 #x_train shape: (60000, 28, 28, 1)
#60000 train samples
#10000 test samples
print('x_train shape: ', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples') # labels处理
# 5 -> [0000010000] 2 -> [0010000000]
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes) # In[5]: # 1. 选择模型
model = Sequential() # 序贯模型 # In[6]: # 2. 构建网络层
# CNN的参数 权重（卷积核的构成），卷积核大小，数量，池化大小，步长，dropout rate
model.add(Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape)) # 卷积层1 model.add(Conv2D(64,
(3, 3),
activation='relu')) # 卷积层2 model.add(MaxPooling2D(pool_size=(2, 2))) # 池化, 默认步长1 model.add(Dropout(0.25)) # 防止过拟合：训练集特征提取太细致，不适用于测试集 model.add(Flatten()) # 压平 model.add(Dense(128,
activation='relu')) # 全连接：所有神经元之间都是互相连接的 model.add(Dropout(0.5)) # 扔掉50% model.add(Dense(num_classes,
activation='softmax')) # 全连接，多分类 # In[7]: # 3. 编译
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy']) # In[8]: # 4. 训练
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test)) # 开始训练 #Train on 60000 samples, validate on 10000 samples
#Epoch 1/12
#60000/60000 [==============================] - 79s 1ms/step - loss: 0.2630 - acc: 0.9195 - val_loss: 0.0574 - val_acc: 0.9825
#Epoch 2/12
#60000/60000 [==============================] - 77s 1ms/step - loss: 0.0900 - acc: 0.9730 - val_loss: 0.0437 - val_acc: 0.9855
#Epoch 3/12
#60000/60000 [==============================] - 78s 1ms/step - loss: 0.0663 - acc: 0.9810 - val_loss: 0.0387 - val_acc: 0.9874
#Epoch 4/12
#60000/60000 [==============================] - 76s 1ms/step - loss: 0.0555 - acc: 0.9836 - val_loss: 0.0321 - val_acc: 0.9881
#Epoch 5/12
#60000/60000 [==============================] - 76s 1ms/step - loss: 0.0462 - acc: 0.9862 - val_loss: 0.0287 - val_acc: 0.9907
#Epoch 6/12
#60000/60000 [==============================] - 81s 1ms/step - loss: 0.0418 - acc: 0.9873 - val_loss: 0.0318 - val_acc: 0.9893
#Epoch 7/12
#60000/60000 [==============================] - 81s 1ms/step - loss: 0.0364 - acc: 0.9885 - val_loss: 0.0291 - val_acc: 0.9907
#Epoch 8/12
#60000/60000 [==============================] - 80s 1ms/step - loss: 0.0338 - acc: 0.9898 - val_loss: 0.0260 - val_acc: 0.9922
#Epoch 9/12
#60000/60000 [==============================] - 80s 1ms/step - loss: 0.0319 - acc: 0.9903 - val_loss: 0.0266 - val_acc: 0.9918
#Epoch 10/12
#60000/60000 [==============================] - 79s 1ms/step - loss: 0.0290 - acc: 0.9908 - val_loss: 0.0271 - val_acc: 0.9919
#Epoch 11/12
#60000/60000 [==============================] - 79s 1ms/step - loss: 0.0281 - acc: 0.9911 - val_loss: 0.0247 - val_acc: 0.9928
#Epoch 12/12
#60000/60000 [==============================] - 82s 1ms/step - loss: 0.0256 - acc: 0.9920 - val_loss: 0.0251 - val_acc: 0.9926
#<keras.callbacks.History at 0x182f48b128> # In[9]: # 5. 预测
score = model.evaluate(x_test, y_test, verbose=0) # 在测试集上测试 #Test loss: 0.025120523367086936
#Test accuracy: 0.9926
print('Test loss: ', score[0])
print('Test accuracy: ', score[1]) # In[10]: model.save('.\model\HandwritingRecUsingCNN.model') # 保存模型
