学习笔记之Python全栈开发/人工智能公开课_腾讯课堂

Python全栈开发/人工智能公开课_腾讯课堂

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') # 保存模型

Python — 爬虫、数据分析

python — 数据分析之旅，Numpy

python — 数据分析之旅，pandas

python — 数据分析之旅，matplotlib

Python – 人工智能

全方位认识python

全面解读人工智能

机器学习实例

基于CNN的手写体数字识别

个人收藏笔记记录

开通VIP