天天看點
傳回

學習筆記之Python全棧開發/人工智能公開課_騰訊課堂

Python全棧開發/人工智能公開課_騰訊課堂

https://ke.qq.com/course/190378

python/ke.qq.com.python at main · haoran119/python (github.com)

Python — 爬蟲、資料分析

python — 資料分析之旅，Numpy

  • 資料擷取
    • 公開資料集（Mnist），爬蟲
  • 資料存儲
    • 資料庫SQL
  • 資料預處理
    • 噪聲，重複，缺失，空值，異常值，分組，合并，随機取樣（pandas）
  • 資料模組化、分析
    • 找一個合适的模型，統計學，機率論，機器學習，聚類，回歸（sklearn）
  • 資料可視化
    • matplotlib 
1 # coding: utf-8
  2 
  3 # In[1]:
  4 
  5 
  6 import numpy as np
  7 
  8 
  9 # In[2]:
 10 
 11 
 12 # 建立數組
 13 
 14 list1 = [ 1, 3, 5, -2, 0, -9 ]
 15 list2 = [ 2, 4, -3, -7, 1, -7 ]
 16 list3 = [ [2, 5, 0], [11, 3, 4] ]
 17 list4 = [ [3, -1, 8], [9, -3, 9] ]
 18 
 19 
 20 # In[3]:
 21 
 22 
 23 arr1 = np.array( list1 )
 24 
 25 #[ 1  3  5 -2  0 -9]
 26 print(arr1)
 27 
 28 
 29 # In[4]:
 30 
 31 
 32 arr4 = np.array( list3 )
 33 
 34 #[[ 2  5  0]
 35 # [11  3  4]]
 36 print(arr4)
 37 
 38 
 39 # In[5]:
 40 
 41 
 42 arr2 = np.arange( 1, 10, 2 )
 43 
 44 #[1 3 5 7 9]
 45 print(arr2)
 46 
 47 
 48 # In[6]:
 49 
 50 
 51 arr3 = np.linspace( 1, 10, 4 )
 52 
 53 #[ 1.  4.  7. 10.]
 54 print(arr3)
 55 
 56 
 57 # In[7]:
 58 
 59 
 60 arr_zero = np.zeros( (3, 4)) # zeros參數是元組()
 61 
 62 #[[0. 0. 0. 0.]
 63 # [0. 0. 0. 0.]
 64 # [0. 0. 0. 0.]]
 65 print(arr_zero)
 66 
 67 
 68 # In[8]:
 69 
 70 
 71 arr_one = np.ones( (3, 3) )
 72 
 73 #[[1. 1. 1.]
 74 # [1. 1. 1.]
 75 # [1. 1. 1.]]
 76 #[[100. 100. 100.]
 77 # [100. 100. 100.]
 78 # [100. 100. 100.]]
 79 print(arr_one)
 80 print(arr_one * 100)
 81 
 82 
 83 # In[9]:
 84 
 85 
 86 arr_eye = np.eye( 4, 4 ) # 對角線上元素為1，其他為0
 87 
 88 #[[1. 0. 0. 0.]
 89 # [0. 1. 0. 0.]
 90 # [0. 0. 1. 0.]
 91 # [0. 0. 0. 1.]]
 92 print(arr_eye)
 93 
 94 
 95 # In[10]:
 96 
 97 
 98 arr_eye2 = np.eye( 4, 5 )
 99 
100 #[[1. 0. 0. 0. 0.]
101 # [0. 1. 0. 0. 0.]
102 # [0. 0. 1. 0. 0.]
103 # [0. 0. 0. 1. 0.]]
104 print(arr_eye2)
105 
106 
107 # In[11]:
108 
109 
110 # 數組的索引和切片
111 
112 #[ 5 -2  0]
113 #[[3 4]]
114 print(arr1[2:5]) # 左閉右開
115 print(arr4[1:2, 1:3])
116 
117 
118 # In[12]:
119 
120 
121 # 通用的函數
122 
123 #sqrt : 
124 # [[1.41421356 2.23606798 0.        ]
125 # [3.31662479 1.73205081 2.        ]]
126 #exp : 
127 # [[7.38905610e+00 1.48413159e+02 1.00000000e+00]
128 # [5.98741417e+04 2.00855369e+01 5.45981500e+01]]
129 print("sqrt : \n", np.sqrt(arr4))
130 print("exp : \n", np.exp(arr4))
131 
132 
133 # In[13]:
134 
135 
136 arr2 = np.array( list2 )
137 new_arr = np.maximum( arr1, arr2 )
138 
139 #[ 2  4  5 -2  1 -7]
140 print(new_arr)
141 
142 
143 # In[14]:
144 
145 
146 # ReLU >0 保留原值，<0 取0
147 new_arr = np.maximum(0, arr1)
148 
149 #[1 3 5 0 0 0]
150 print(new_arr)
151 
152 
153 # In[15]:
154 
155 #(array([[0.41421356, 0.23606798, 0.        ],
156 #       [0.31662479, 0.73205081, 0.        ]]), array([[1., 2., 0.],
157 #       [3., 1., 2.]]))
158 print( np.modf( np.sqrt( arr4 ) ) ) # 把整數部分和小數部分，生成兩個獨立的數組
159 
160 
161 # In[16]:
162 
163 
164 new_arr1 = np.where( arr2>0, \'True\', \'False\' ) # if condition: x, y
165 
166 #[\'True\' \'True\' \'False\' \'False\' \'True\' \'False\']
167 print(new_arr1)
168 
169 
170 # In[17]:
171 
172 #[-7 -3  1  2  4]
173 #[ 0  2  3  4  5 11]
174 print( np.unique( arr2 ) )
175 print( np.unique( arr4 ) )
176 
177 
178 # In[18]:
179 
180 
181 # 數組作為檔案來輸入和輸出
182 
183 np.save( \'myarr\', arr2 ) # 把數組儲存為檔案 .npy
184 
185 
186 # In[19]:
187 
188 
189 new_arr2 = np.load( \'myarr.npy\' )
190 
191 #[ 2  4 -3 -7  1 -7]
192 print(new_arr2)
193 
194 
195 # In[20]:
196 
197 
198 np.savez( \'myarrzip\', a1=arr1, a2=arr2, a3=arr3 )
199 arr = np.load( \'myarrzip.npz\' )
200 
201 #[ 1  3  5 -2  0 -9]
202 print(arr[\'a1\'])
203 
204 
205 # In[21]:
206 
207 
208 # 線性代數 矩陣
209 # 矩陣的合并
210 
211 arr5 = np.array( list3 )
212 arr6 = np.array( list4 )
213 
214 #[[ 2  5  0  3 -1  8]
215 # [11  3  4  9 -3  9]]
216 #[[ 2  5  0]
217 # [11  3  4]
218 # [ 3 -1  8]
219 # [ 9 -3  9]]
220 print( np.hstack( [arr5, arr6] ) )
221 print( np.vstack( [arr5, arr6] ) )
222 
223 
224 # In[22]:
225 
226 
227 # 點乘
228 
229 arr6 = np.array( list4 ).reshape( 3, 2 ) 
230 
231 #[[ 3 -1]
232 # [ 8  9]
233 # [-3  9]]
234 #[[ -5  12  -4]
235 # [115  67  36]
236 # [ 93  12  36]]
237 print( arr6 )
238 print( arr6.dot( arr5 ) )
239 
240 
241 # In[23]:
242 
243 #[[ 3  8 -3]
244 # [-1  9  9]]
245 print( np.transpose(arr6) ) # 轉置

View Code

python — 資料分析之旅，pandas

  • 資料處理
    • 不幹淨的資料
    • 幹淨資料，随機采樣
    • 表格資料
    • 時間序列資料
    • 矩陣資料
    • 觀測資料
    • 統計資料
  • 資料清洗
    • 空值（缺失值）
  • pandas常用操作 
    • 大小可變
    • 資料自動對齊
    • Series（一維），Dataframe（二維）
    • 分組的功能
    • Numpy
    • 切片，索引
    • 清單和字元串
    • 資料集的形狀 
1 # coding: utf-8
  2 
  3 # In[1]:
  4 
  5 
  6 import pandas as pd
  7 import numpy as np
  8 
  9 
 10 # In[2]:
 11 
 12 
 13 data = pd.DataFrame(pd.read_excel(\'originalData.xlsx\'))
 14 
 15 #         date   hour  pressure  wind_direction  temperature
 16 #0  2016-07-01    0.0    1000.4           225.0         26.4
 17 #1  2016-07-01    NaN       NaN             NaN          NaN
 18 #2  2016-07-01    6.0     998.9           212.0         31.7
 19 #3  2016-07-01  235.0     998.7           244.0          NaN
 20 #4  2016-07-01   12.0     999.7           222.0          NaN
 21 #5  2016-07-01   15.0    1000.0           102.0          NaN
 22 #6  2016-07-01    NaN     998.8           202.0         26.0
 23 #7  2016-07-01    NaN    1000.2           334.0         25.5
 24 #8  2016-07-01    NaN    1000.2           334.0         25.5
 25 #9  2016-07-02    3.0    1002.4            46.0         30.0
 26 #10 2016-07-02    6.0    1001.3            37.0         29.3
 27 #11 2016-07-02    9.0    1001.9           345.0         25.9
 28 #12 2016-07-02   12.0    1003.6           113.0         25.1
 29 #13 2016-07-02   12.0    1003.6           113.0         25.1
 30 #14 2016-07-02   15.0    1002.4           138.0         25.3
 31 #             hour     pressure  wind_direction  temperature
 32 #count   11.000000    14.000000       14.000000    11.000000
 33 #mean    29.545455  1000.864286      190.500000    26.890909
 34 #std     68.313049     1.685963      102.932951     2.311473
 35 #min      0.000000   998.700000       37.000000    25.100000
 36 #25%      6.000000   999.775000      113.000000    25.400000
 37 #50%     12.000000  1000.300000      207.000000    25.900000
 38 #75%     13.500000  1002.275000      239.250000    27.850000
 39 #max    235.000000  1003.600000      345.000000    31.700000
 40 print(data)
 41 print(data.describe())
 42 
 43 
 44 # In[3]:
 45 
 46 #RangeIndex(start=0, stop=15, step=1)
 47 #Index([\'date\', \'hour\', \'pressure\', \'wind_direction\', \'temperature\'], dtype=\'object\')
 48 print(data.index)
 49 print(data.columns)
 50 
 51 
 52 # In[4]:
 53 
 54 #        date   hour  pressure  wind_direction  temperature
 55 #0 2016-07-01    0.0    1000.4           225.0         26.4
 56 #1 2016-07-01    NaN       NaN             NaN          NaN
 57 #2 2016-07-01    6.0     998.9           212.0         31.7
 58 #3 2016-07-01  235.0     998.7           244.0          NaN
 59 #4 2016-07-01   12.0     999.7           222.0          NaN
 60 #5 2016-07-01   15.0    1000.0           102.0          NaN
 61 #         date  hour  pressure  wind_direction  temperature
 62 #9  2016-07-02   3.0    1002.4            46.0         30.0
 63 #10 2016-07-02   6.0    1001.3            37.0         29.3
 64 #11 2016-07-02   9.0    1001.9           345.0         25.9
 65 #12 2016-07-02  12.0    1003.6           113.0         25.1
 66 #13 2016-07-02  12.0    1003.6           113.0         25.1
 67 #14 2016-07-02  15.0    1002.4           138.0         25.3
 68 print(data.head(6))
 69 print(data.tail(6))
 70 
 71 
 72 # In[5]:
 73 
 74 
 75 # 1. 删掉空白值超過3的行
 76 data.dropna(axis=0, thresh=3, inplace=True)
 77 data.reset_index(drop=True, inplace=True)
 78 
 79 #         date   hour  pressure  wind_direction  temperature
 80 #0  2016-07-01    0.0    1000.4           225.0         26.4
 81 #1  2016-07-01    6.0     998.9           212.0         31.7
 82 #2  2016-07-01  235.0     998.7           244.0          NaN
 83 #3  2016-07-01   12.0     999.7           222.0          NaN
 84 #4  2016-07-01   15.0    1000.0           102.0          NaN
 85 #5  2016-07-01    NaN     998.8           202.0         26.0
 86 #6  2016-07-01    NaN    1000.2           334.0         25.5
 87 #7  2016-07-01    NaN    1000.2           334.0         25.5
 88 #8  2016-07-02    3.0    1002.4            46.0         30.0
 89 #9  2016-07-02    6.0    1001.3            37.0         29.3
 90 #10 2016-07-02    9.0    1001.9           345.0         25.9
 91 #11 2016-07-02   12.0    1003.6           113.0         25.1
 92 #12 2016-07-02   12.0    1003.6           113.0         25.1
 93 #13 2016-07-02   15.0    1002.4           138.0         25.3
 94 print(data)
 95 
 96 
 97 # In[6]:
 98 
 99 
100 # 2. 填充空白，hour填充10，temperature填充25.5
101 data.fillna({\'hour\':10, \'temperature\':25.5}, inplace=True)
102 
103 #         date   hour  pressure  wind_direction  temperature
104 #0  2016-07-01    0.0    1000.4           225.0         26.4
105 #1  2016-07-01    6.0     998.9           212.0         31.7
106 #2  2016-07-01  235.0     998.7           244.0         25.5
107 #3  2016-07-01   12.0     999.7           222.0         25.5
108 #4  2016-07-01   15.0    1000.0           102.0         25.5
109 #5  2016-07-01   10.0     998.8           202.0         26.0
110 #6  2016-07-01   10.0    1000.2           334.0         25.5
111 #7  2016-07-01   10.0    1000.2           334.0         25.5
112 #8  2016-07-02    3.0    1002.4            46.0         30.0
113 #9  2016-07-02    6.0    1001.3            37.0         29.3
114 #10 2016-07-02    9.0    1001.9           345.0         25.9
115 #11 2016-07-02   12.0    1003.6           113.0         25.1
116 #12 2016-07-02   12.0    1003.6           113.0         25.1
117 #13 2016-07-02   15.0    1002.4           138.0         25.3
118 print(data)
119 
120 
121 # In[7]:
122 
123 
124 # 3. 删掉hour>24的行
125 num = data.index.max()
126 
127 for i in range(num):
128     if data.loc[i, \'hour\'] > 24:
129         data.drop([i], inplace=True)
130         print(\'hour > 24, deleted\')
131         
132 data.reset_index(drop=True, inplace=True)        
133 
134 #hour > 24, deleted
135 #         date  hour  pressure  wind_direction  temperature
136 #0  2016-07-01   0.0    1000.4           225.0         26.4
137 #1  2016-07-01   6.0     998.9           212.0         31.7
138 #2  2016-07-01  12.0     999.7           222.0         25.5
139 #3  2016-07-01  15.0    1000.0           102.0         25.5
140 #4  2016-07-01  10.0     998.8           202.0         26.0
141 #5  2016-07-01  10.0    1000.2           334.0         25.5
142 #6  2016-07-01  10.0    1000.2           334.0         25.5
143 #7  2016-07-02   3.0    1002.4            46.0         30.0
144 #8  2016-07-02   6.0    1001.3            37.0         29.3
145 #9  2016-07-02   9.0    1001.9           345.0         25.9
146 #10 2016-07-02  12.0    1003.6           113.0         25.1
147 #11 2016-07-02  12.0    1003.6           113.0         25.1
148 #12 2016-07-02  15.0    1002.4           138.0         25.3
149 print(data)
150 
151 
152 # In[8]:
153 
154 
155 # 4. 删掉重複的資料行，保留出現的第一行（全部删掉？保留最後一行？）
156 data.drop_duplicates(keep=\'first\', inplace=True)
157 data.reset_index(drop=True, inplace=True)
158 
159 #         date  hour  pressure  wind_direction  temperature
160 #0  2016-07-01   0.0    1000.4           225.0         26.4
161 #1  2016-07-01   6.0     998.9           212.0         31.7
162 #2  2016-07-01  12.0     999.7           222.0         25.5
163 #3  2016-07-01  15.0    1000.0           102.0         25.5
164 #4  2016-07-01  10.0     998.8           202.0         26.0
165 #5  2016-07-01  10.0    1000.2           334.0         25.5
166 #6  2016-07-02   3.0    1002.4            46.0         30.0
167 #7  2016-07-02   6.0    1001.3            37.0         29.3
168 #8  2016-07-02   9.0    1001.9           345.0         25.9
169 #9  2016-07-02  12.0    1003.6           113.0         25.1
170 #10 2016-07-02  15.0    1002.4           138.0         25.3
171 print(data)
172 
173 
174 # In[9]:
175 
176 
177 # 5. 資料重排
178 randnum = np.random.permutation(data.index.size)
179 
180 #[ 4  0 10  3  1  5  8  9  7  2  6]
181 print(randnum)
182 
183 
184 # In[10]:
185 
186 
187 data2 = data.take(randnum)
188 
189 #         date  hour  pressure  wind_direction  temperature
190 #4  2016-07-01  10.0     998.8           202.0         26.0
191 #0  2016-07-01   0.0    1000.4           225.0         26.4
192 #10 2016-07-02  15.0    1002.4           138.0         25.3
193 #3  2016-07-01  15.0    1000.0           102.0         25.5
194 #1  2016-07-01   6.0     998.9           212.0         31.7
195 #5  2016-07-01  10.0    1000.2           334.0         25.5
196 #8  2016-07-02   9.0    1001.9           345.0         25.9
197 #9  2016-07-02  12.0    1003.6           113.0         25.1
198 #7  2016-07-02   6.0    1001.3            37.0         29.3
199 #2  2016-07-01  12.0     999.7           222.0         25.5
200 #6  2016-07-02   3.0    1002.4            46.0         30.0
201 print(data2)
202 
203 
204 # In[11]:
205 
206 
207 # 6. 随機采樣
208 data3 = data.sample(8)
209 
210 #        date  hour  pressure  wind_direction  temperature
211 #4 2016-07-01  10.0     998.8           202.0         26.0
212 #0 2016-07-01   0.0    1000.4           225.0         26.4
213 #2 2016-07-01  12.0     999.7           222.0         25.5
214 #1 2016-07-01   6.0     998.9           212.0         31.7
215 #5 2016-07-01  10.0    1000.2           334.0         25.5
216 #9 2016-07-02  12.0    1003.6           113.0         25.1
217 #7 2016-07-02   6.0    1001.3            37.0         29.3
218 #8 2016-07-02   9.0    1001.9           345.0         25.9
219 print(data3)
220 data3.to_csv(\'data3.csv\')

View Code

python — 資料分析之旅，matplotlib

  • Numpy
    • 科學計算
  • pandas
    • 資料清洗 / 去重 / 修改删除異常值 / 随機采樣 / 重排
  • 資料分析的流程
    • 資料模組化
    • 學習規律，指導将來的決策 - 機器學習
    • 資料 圖
    • 資料可視化
  • Python開發
    • 文法簡潔
    • 豐富的庫
      • 标準庫
      • 第三方庫
        • numpy / pandas / matplotlib
        • PyPI.org
    • 建構快速原型
    • AI主流的程式設計語言   
1 # coding: utf-8
  2 
  3 # In[1]:
  4 
  5 
  6 import matplotlib.pyplot as plt
  7 import numpy as np
  8 from mpl_toolkits.mplot3d import Axes3D
  9 
 10 
 11 # In[2]:
 12 
 13 
 14 # 1. 線形圖 y = ax + b
 15 x = np.linspace(1, 21, 20)
 16 y = 2 * x + 3
 17 y2 = np.sin(x)
 18 
 19 plt.plot(x, y, \'m^:\', x, y2)
 20 
 21 plt.show()
 22 
 23 
 24 # In[3]:
 25 
 26 
 27 # 2. 散點圖
 28 n = 1024
 29 x = np.random.normal(0, 1, n) #1024個符合高斯分布的值
 30 y = np.random.normal(0, 1, n)
 31 
 32 plt.scatter(x, y, s=np.random.rand(n)*50, c=np.random.rand(n), alpha=0.7)
 33 
 34 plt.show()
 35 
 36 
 37 # In[4]:
 38 
 39 
 40 # 3. 柱狀圖
 41 n = 10
 42 x = np.arange(n)
 43 y1 = (1 - x / float(n)) * np.random.uniform(0.5, 1.0, n)
 44 y2 = (1 - x / float(n)) * np.random.uniform(0.5, 1.0, n)
 45 
 46 plt.bar(x, y1, facecolor=\'red\', edgecolor=\'white\')
 47 plt.bar(x, -y2, facecolor=\'blue\', edgecolor=\'black\')
 48 
 49 for xx, y in zip(x, y1):
 50     plt.text(xx, y + 0.1, \'%0.2f\'%y, ha=\'center\', va=\'bottom\')
 51 
 52 for xx, y in zip(x, -y2):
 53     plt.text(xx, y - 0.1, \'%0.2f\'%y, ha=\'center\', va=\'bottom\')
 54 
 55 plt.ylim(-1.5, 1.5)
 56 
 57 plt.show()
 58 
 59 
 60 # In[5]:
 61 
 62 
 63 # 4. 3D
 64 fig = plt.figure(figsize=(12, 8))
 65 ax = Axes3D(fig)
 66 x = np.arange(-4, 4, 0.25)
 67 y = np.arange(-4, 4, 0.25)
 68 
 69 x, y = np.meshgrid(x, y)
 70 #[[-4.   -3.75 -3.5  ...  3.25  3.5   3.75]
 71 # [-4.   -3.75 -3.5  ...  3.25  3.5   3.75]
 72 # [-4.   -3.75 -3.5  ...  3.25  3.5   3.75]
 73 # ...
 74 # [-4.   -3.75 -3.5  ...  3.25  3.5   3.75]
 75 # [-4.   -3.75 -3.5  ...  3.25  3.5   3.75]
 76 # [-4.   -3.75 -3.5  ...  3.25  3.5   3.75]]
 77 print(x)
 78 #[[-4.   -4.   -4.   ... -4.   -4.   -4.  ]
 79 # [-3.75 -3.75 -3.75 ... -3.75 -3.75 -3.75]
 80 # [-3.5  -3.5  -3.5  ... -3.5  -3.5  -3.5 ]
 81 # ...
 82 # [ 3.25  3.25  3.25 ...  3.25  3.25  3.25]
 83 # [ 3.5   3.5   3.5  ...  3.5   3.5   3.5 ]
 84 # [ 3.75  3.75  3.75 ...  3.75  3.75  3.75]]
 85 print(y)
 86 
 87 z = np.sin(np.sqrt(x**2 + y**2))
 88 
 89 ax.plot_surface(x, y, z, cmap=plt.get_cmap(\'autumn\'))
 90 
 91 plt.show()
 92 
 93 
 94 # In[6]:
 95 
 96 
 97 # 5. 一圖多畫
 98 x = np.linspace(0, 5, 5)
 99 y1 = x**2
100 y2 = 2 * x
101 y3 = np.sin(x)
102 y4 = np.cos(x)
103 
104 ax1 = plt.subplot(221)
105 plt.plot(x, y1)
106 ax2 = plt.subplot(2, 2, 2)
107 plt.plot(x, y2)
108 ax3 = plt.subplot(223)
109 plt.plot(x, y3)
110 ax4 = plt.subplot(2, 2, 4)
111 #plt.plot(x, y4)
112 
113 plt.show()

View Code

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個樣本中類标數最多的那一類。
  • 機器學習的主要步驟
  1. 準備資料集（量要大，模型才夠精确。資料要全面，模型才全面）
  2. 資料清洗，資料預處理（噪聲，缺失值，亂碼，特征的提取，分為訓練集和測試集）
  3. 選擇一個模型（算法）
  4. 訓練（訓練集訓練模型）
  5. 模型（分類，預測）- 測試集（驗證集）
  6. 評估
  7. 模型的優化
    • 調參，e.g. KNN（k）
    • 換模型
  8. 疊代4-6
  • 基于KNN的手寫體數字識别 
1 # coding: utf-8
 2 
 3 # In[1]:
 4 
 5 
 6 from sklearn.model_selection import train_test_split
 7 from sklearn.neighbors import KNeighborsClassifier
 8 from sklearn.metrics import accuracy_score
 9 from sklearn import datasets
10 
11 
12 # In[2]:
13 
14 
15 """
16 手寫體數字，監督學習
17 1、樣本集：一批手寫體數字的圖檔，帶标簽（0-9），10類
18 樣本資料量為1797，存在sklearn的datasets裡。
19 每一個資料樣本都是由image, target兩部分組成。
20 image是一個尺寸為8*8的圖像（手寫的數字0-9），
21 target是圖像的類别（數字0-9）。
22 2、劃分訓練集和測試集
23 3、選一個算法，構模組化型，KNN
24 4、訓練模型
25 5、預測、驗證
26 6、模型優化（SVM, 決策樹）
27 7、儲存模型（.model, load, predict）
28 8、建立多張手寫體圖檔，讓模型來識别新的圖檔
29 """
30 sample_data = datasets.load_digits()
31 images = sample_data.data
32 labels = sample_data.target
33 
34 
35 # In[3]:
36 
37 
38 #劃分訓練集和測試集
39 train_data, test_data, train_labels, test_labels = train_test_split(images, labels, test_size=0.1)
40 
41 
42 # In[4]:
43 
44 
45 #選擇模型
46 model_knn = KNeighborsClassifier(n_neighbors=4, algorithm=\'auto\', weights=\'distance\')
47 
48 
49 # In[5]:
50 
51 
52 #訓練模型
53 model_knn.fit(train_data, train_labels)
54 #KNeighborsClassifier(algorithm=\'auto\', leaf_size=30, metric=\'minkowski\',
55 #           metric_params=None, n_jobs=1, n_neighbors=4, p=2,
56 #           weights=\'distance\')
57 
58 # In[6]:
59 
60 
61 #預測、驗證
62 pred = model_knn.predict(test_data)
63 print("pred : \n", pred)
64 print("test_labels : \n", test_labels)
65 #pred : 
66 # [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
67 # 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
68 # 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
69 # 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
70 # 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]
71 #test_labels : 
72 # [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
73 # 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
74 # 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
75 # 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
76 # 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]
77 
78 # In[7]:
79 
80 
81 #檢視準确率
82 acc = accuracy_score(pred, test_labels)
83 print("Accuracy rate : %.3f" % acc)
84 #Accuracy rate : 0.994

View Code

基于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搭建神經網絡的過程
學習筆記之Python全棧開發/人工智能公開課_騰訊課堂
  • CNN - 卷積神經網絡
    • CNN的建造靈感來自于人類對視覺資訊的識别過程：點 -> 線 -> 面。
    • 卷積層
      • 卷是席卷，積為乘積。卷積實質上是用一個叫kernel的矩陣，從圖像的小塊上一一貼過去，每次和圖像塊的每一個像素乘積得到一個output值，掃過之後就得到一個新圖像。
    • 池化層
      • 下采樣（subsampling），分為最大值池化和平均值池化。
      • 為什麼池化
        • 圖像經過下采樣尺寸縮小
        • 增強了旋轉不定性，池化操作可以看作是一種強制性的模糊政策
      • 核的大小 / 步長
    • CNN的過程
學習筆記之Python全棧開發/人工智能公開課_騰訊課堂
    • 我們将輸入圖像傳遞到第一個卷積層，卷積後以激活圖形式輸出。圖檔在卷積層中過濾後的特征會被輸出，并傳遞下去。
    • 每個過濾器都會給出不同的特征，以幫助進行正确的類預測。
    • 随後加入池化層進一步減少參數的數量。
    • 在預測最終提出前，資料會經過多個卷積層和池化層的處理。卷積層會幫助提取特征，越深的卷積神經網絡會提取越具體的特征，越淺的神經網絡提取越淺顯的特征。
    • CNN中的輸出層是全連接配接層，其中來自其他層的輸入在這裡被平化和發送，以便将輸出轉換為網絡所需的參數。
    • 随後輸出層會産生輸出，這些資訊會互相比較排除錯誤。損失函數是全連接配接輸出層計算的均方根損失。随後我們會計算梯度錯誤。
    • 錯誤會進行反向傳播，以不斷改進過濾器（權重）和偏內插補點。
    • 一個訓練周期由單次正向和反向傳遞完成。 
1 # coding: utf-8
  2 
  3 # In[1]:
  4 
  5 
  6 """
  7 基于CNN的手寫體數字識别
  8 
  9 疊代一輪 80s
 10 """
 11 import keras
 12 from keras.datasets import mnist
 13 from keras.models import Sequential
 14 from keras.layers import Dense, Dropout, Flatten
 15 from keras.layers import Conv2D, MaxPooling2D
 16 from keras import backend as K
 17 
 18 
 19 # In[2]:
 20 
 21 
 22 # 設定初始參數
 23 batch_size = 128 # 一批喂給模型多少張圖檔 60000
 24 num_classes = 10 # 分類 0 - 9
 25 epochs = 12 # 疊代次數
 26 
 27 img_rows, img_cols = 28, 28 # 28 * 28
 28 
 29 
 30 # In[3]:
 31 
 32 
 33 # 加載資料
 34 (x_train, y_train), (x_test, y_test) = mnist.load_data() # 加載資料集，第一次運作慢
 35 
 36 # 判斷backend theano, tensorflow
 37 # 彩色圖檔 RGB 3 通道，灰階圖 1 通道
 38 if K.image_data_format() == \'channels_first\':
 39     x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) # (60000, 1, 28, 28)
 40     x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
 41     intput_shape = (1, img_rows, img_cols)
 42 else:
 43     x_train = x_train.reshape(x_train.shape[0],  img_rows, img_cols, 1)
 44     x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
 45     input_shape = (img_rows, img_cols, 1)
 46 
 47 
 48 # In[4]:
 49 
 50 
 51 # 資料處理
 52 
 53 # image處理
 54 x_train = x_train.astype(\'float32\')
 55 x_test = x_test.astype(\'float32\')
 56 x_train /= 255
 57 x_test /= 255
 58 
 59 #x_train shape:  (60000, 28, 28, 1)
 60 #60000 train samples
 61 #10000 test samples
 62 print(\'x_train shape: \', x_train.shape)
 63 print(x_train.shape[0], \'train samples\')
 64 print(x_test.shape[0], \'test samples\')
 65 
 66 # labels處理
 67 # 5 -> [0000010000] 2 -> [0010000000]
 68 y_train = keras.utils.to_categorical(y_train, num_classes)
 69 y_test = keras.utils.to_categorical(y_test, num_classes)
 70 
 71 
 72 # In[5]:
 73 
 74 
 75 # 1. 選擇模型 
 76 model = Sequential() # 序貫模型
 77 
 78 
 79 # In[6]:
 80 
 81 
 82 # 2. 建構網絡層
 83 # CNN的參數 權重（卷積核的構成），卷積核大小，數量，池化大小，步長，dropout rate
 84 model.add(Conv2D(32,
 85                  kernel_size=(3, 3),
 86                  activation=\'relu\',
 87                  input_shape=input_shape)) # 卷積層1
 88 
 89 model.add(Conv2D(64,
 90                  (3, 3),
 91                  activation=\'relu\')) # 卷積層2
 92 
 93 model.add(MaxPooling2D(pool_size=(2, 2))) # 池化, 預設步長1
 94 
 95 model.add(Dropout(0.25)) # 防止過拟合：訓練集特征提取太細緻，不适用于測試集
 96 
 97 model.add(Flatten()) # 壓平
 98 
 99 model.add(Dense(128,
100                 activation=\'relu\')) # 全連接配接：所有神經元之間都是互相連接配接的
101 
102 model.add(Dropout(0.5)) # 扔掉50%
103 
104 model.add(Dense(num_classes,
105                 activation=\'softmax\')) # 全連接配接，多分類
106 
107 
108 # In[7]:
109 
110 
111 # 3. 編譯
112 model.compile(loss=keras.losses.categorical_crossentropy,
113               optimizer=keras.optimizers.Adadelta(),
114               metrics=[\'accuracy\'])
115 
116 
117 # In[8]:
118 
119 
120 # 4. 訓練
121 model.fit(x_train,
122           y_train,
123           batch_size=batch_size,
124           epochs=epochs,
125           verbose=1,
126           validation_data=(x_test, y_test)) # 開始訓練
127 
128 #Train on 60000 samples, validate on 10000 samples
129 #Epoch 1/12
130 #60000/60000 [==============================] - 79s 1ms/step - loss: 0.2630 - acc: 0.9195 - val_loss: 0.0574 - val_acc: 0.9825
131 #Epoch 2/12
132 #60000/60000 [==============================] - 77s 1ms/step - loss: 0.0900 - acc: 0.9730 - val_loss: 0.0437 - val_acc: 0.9855
133 #Epoch 3/12
134 #60000/60000 [==============================] - 78s 1ms/step - loss: 0.0663 - acc: 0.9810 - val_loss: 0.0387 - val_acc: 0.9874
135 #Epoch 4/12
136 #60000/60000 [==============================] - 76s 1ms/step - loss: 0.0555 - acc: 0.9836 - val_loss: 0.0321 - val_acc: 0.9881
137 #Epoch 5/12
138 #60000/60000 [==============================] - 76s 1ms/step - loss: 0.0462 - acc: 0.9862 - val_loss: 0.0287 - val_acc: 0.9907
139 #Epoch 6/12
140 #60000/60000 [==============================] - 81s 1ms/step - loss: 0.0418 - acc: 0.9873 - val_loss: 0.0318 - val_acc: 0.9893
141 #Epoch 7/12
142 #60000/60000 [==============================] - 81s 1ms/step - loss: 0.0364 - acc: 0.9885 - val_loss: 0.0291 - val_acc: 0.9907
143 #Epoch 8/12
144 #60000/60000 [==============================] - 80s 1ms/step - loss: 0.0338 - acc: 0.9898 - val_loss: 0.0260 - val_acc: 0.9922
145 #Epoch 9/12
146 #60000/60000 [==============================] - 80s 1ms/step - loss: 0.0319 - acc: 0.9903 - val_loss: 0.0266 - val_acc: 0.9918
147 #Epoch 10/12
148 #60000/60000 [==============================] - 79s 1ms/step - loss: 0.0290 - acc: 0.9908 - val_loss: 0.0271 - val_acc: 0.9919
149 #Epoch 11/12
150 #60000/60000 [==============================] - 79s 1ms/step - loss: 0.0281 - acc: 0.9911 - val_loss: 0.0247 - val_acc: 0.9928
151 #Epoch 12/12
152 #60000/60000 [==============================] - 82s 1ms/step - loss: 0.0256 - acc: 0.9920 - val_loss: 0.0251 - val_acc: 0.9926
153 #<keras.callbacks.History at 0x182f48b128>
154 
155 
156 # In[9]:
157 
158 
159 # 5. 預測
160 score = model.evaluate(x_test, y_test, verbose=0) # 在測試集上測試
161 
162 #Test loss:  0.025120523367086936
163 #Test accuracy:  0.9926
164 print(\'Test loss: \', score[0])
165 print(\'Test accuracy: \', score[1])
166 
167 
168 # In[10]:
169 
170 
171 model.save(\'.\model\HandwritingRecUsingCNN.model\') # 儲存模型

View Code

學習筆記之Python全棧開發/人工智能公開課_騰訊課堂
上一篇: andriod stdio 如何通過按鈕儲存textview的内容到txt檔案中_Android彈性滑動在自定義View中的進階應用
下一篇: 最适合 Python 入門的資源有哪些？