学习笔记之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

  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个样本中类标数最多的那一类。
机器学习的主要步骤

准备数据集（量要大，模型才够精确。数据要全面，模型才全面）
数据清洗，数据预处理（噪声，缺失值，乱码，特征的提取，分为训练集和测试集）
选择一个模型（算法）
训练（训练集训练模型）
模型（分类，预测）- 测试集（验证集）
评估
模型的优化
- 调参，e.g. KNN（k）
- 换模型
迭代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搭建神经网络的过程

CNN - 卷积神经网络
- CNN的建造灵感来自于人类对视觉信息的识别过程：点 -> 线 -> 面。
- 卷积层
  - 卷是席卷，积为乘积。卷积实质上是用一个叫kernel的矩阵，从图像的小块上一一贴过去，每次和图像块的每一个像素乘积得到一个output值，扫过之后就得到一个新图像。
- 池化层
  - 下采样（subsampling），分为最大值池化和平均值池化。
  - 为什么池化
    - 图像经过下采样尺寸缩小
    - 增强了旋转不定性，池化操作可以看作是一种强制性的模糊策略
  - 核的大小 / 步长
- CNN的过程

- 我们将输入图像传递到第一个卷积层，卷积后以激活图形式输出。图片在卷积层中过滤后的特征会被输出，并传递下去。
- 每个过滤器都会给出不同的特征，以帮助进行正确的类预测。
- 随后加入池化层进一步减少参数的数量。
- 在预测最终提出前，数据会经过多个卷积层和池化层的处理。卷积层会帮助提取特征，越深的卷积神经网络会提取越具体的特征，越浅的神经网络提取越浅显的特征。
- 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 #
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

转载于:https://www.cnblogs.com/pegasus923/p/9826483.html

你可能感兴趣的:(人工智能,爬虫,python)

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchain easyui 前端 python
#探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首张三叨
你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
web报表工具FineReport常见的数据集报错错误代码和解释老A不折腾 web报表 finereport 代码可视化工具
在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
Java的WeakReference与WeakHashMap bylijinnan java 弱引用
首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
Linux——（hostname）主机名与ip的映射 eksliang linux hostname
一、什么是主机名无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的；主机名是用于什么的呢？答：在一个局域网中，每台机器都有一个主
oracle 常用技巧 18289753290
oracle常用技巧 ①复制表结构和数据 create table temp_clientloginUser as select distinct userid from tbusrtloginlog ②仅复制数据如果表结构一样 insert into mytable select * &nb
使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
IT系统分析师如何学习大数据蓝儿唯美大数据
我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
spring学习——简介 a-john spring
Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
自定义颜色的xml文件 aijuans xml
<?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
运营到底是做什么的？ aoyouzi 运营到底是做什么的？
文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
js面向对象类和对象百合不是茶 js 面向对象函数创建类和对象
接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下 ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似下面介绍一些js的类和对象的创建的技术一:类和对
web.xml之资源管理对象配置 resource-env-ref bijian1013 java web.xml servlet
resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
Create a composite component with a custom namespace sunjing
https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace When you developed a composite component the namespace you would be seeing would
【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
一、复本集为什么要加入Arbiter这个角色回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
Javascript开发笔记白糖_ JavaScript
获取iframe内的元素通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
Web浏览器Chrome打开一段时间后，运行alert无效 bozch Web chorme alert 无效
今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。试了试其他浏览器，发现都是没有问题的。开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了就关闭浏览器重启。结果就好了，这也太怪异了。难道是cho
编程之美-高效地安排会议图着色问题贪心算法 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美高效地安排会议图着色问题贪心算法 * 假设要用很多个教室对一组
机器学习相关概念和开发工具 chenbowen00 算法 matlab 机器学习
基本概念：机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。开发工具 M
[宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
oracle 11g database control 证书错误 daizj oracle 证书错误 oracle 11G 安装
oracle 11g database control 证书错误 win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面解决办法：是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
Java I/O之用FilenameFilter实现根据文件扩展名删除文件游其是你 FilenameFilter
在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com c array
# include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。就是唯一且不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。就是唯一且不能为空。INDEX 索引，普通的UNIQUE 唯一索引。不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号 INT会员姓名
java集合辅助类 Collections、Arrays shuizhaosi888 Collections Arrays HashCode
Arrays、Collections 1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); } a）Arrays.asL
Spring Security（10）——退出登录logout 234390216 logout Spring Security 退出登录 logout-url LogoutFilter
要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
透过源码学前端之 Backbone 三 Model 逐行分析JS源代码 backbone 源码分析 js学习
Backbone 分析第三部分 Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里，但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件，如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
分布式基础知识和算法理论 bluky999 算法 zookeeper 分布式一致性哈希 paxos
分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218 在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
Android Studio的.gitignore以及gitignore无效的解决 bell0901 android gitignore
　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
成为高级程序员的10个步骤 tomcat_oracle 编程
What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进历经更大的挑战。随着你的成长，各种影响力也会提高。
mongdb在linux下的安装 xtuhcy mongodb linux
一、查询linux版本号： lsb_release -a LSB Version: :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa