【人工智能原理自学】初识Keras：轻松完成神经网络模型搭建
你好，我是小航，一个正在变秃、变强的文艺倾年。
笔记来自B站UP主Ele实验室的《小白也能听懂的人工智能原理》。
本文讲解初识Keras：轻松完成神经网络模型搭建，一起卷起来叭！
目录
- 一、“矩阵、向量”
- 二、Keras
- 三、代码实现
一、“矩阵、向量”
在之前我们都是将每个元素做运算，这样做看着费时费力，现在我们从万物皆向量的角度重新看待这个问题，用向量的运算去表示线性函数。
现在我们使用代码来实现以上过程：
之前的代码：
import numpy as np
import dataset
import plot_utils
m = 100
xs, ys = dataset.get_beans(m)
print(xs)
print(ys)
plot_utils.show_scatter(xs, ys)
w1 = 0.1
w2 = 0.2
b = 0.1
## [[a,b][c,d]]
## x1s[a,c]
## x2s[b,d]
## 逗号，区分的是维度，冒号：区分的是索引，省略号… 用来代替全索引长度
# 在所有的行上，把第0列切割下来形成一个新的数组
x1s = xs[:, 0]
x2s = xs[:, 1]
# 前端传播
def forward_propgation(x1s, x2s):
z = w1 * x1s + w2 * x2s + b
a = 1 / (1 + np.exp(-z))
return a
plot_utils.show_scatter_surface(xs, ys, forward_propgation)
for _ in range(500):
for i in range(m):
x = xs[i] ## 豆豆特征
y = ys[i] ## 豆豆是否有毒
x1 = x[0]
x2 = x[1]
a = forward_propgation(x1, x2)
e = (y - a) ** 2
deda = -2 * (y - a)
dadz = a * (1 - a)
dzdw1 = x1
dzdw2 = x2
dzdb = 1
dedw1 = deda * dadz * dzdw1
dedw2 = deda * dadz * dzdw2
dedb = deda * dadz * dzdb
alpha = 0.01
w1 = w1 - alpha * dedw1
w2 = w2 - alpha * dedw2
b = b - alpha * dedb
plot_utils.show_scatter_surface(xs, ys, forward_propgation)
使用向量矩阵后的代码：
import numpy as np
import dataset
import plot_utils
m = 100
X, Y = dataset.get_beans(m)
print(X)
print(Y)
plot_utils.show_scatter(X, Y)
# w1 = 0.1
# w2 = 0.2
W = np.array([0.1, 0.1])
# b = 0.1
B = np.array([0.1])
# 前端传播
def forward_propgation(X):
# z = w1 * x1s + w2 * x2s + b
# ndarray的dot函数：点乘运算
# ndarray的T属性：转置运算
Z = X.dot(W.T) + B
# a = 1 / (1 + np.exp(-z))
A = 1 / (1 + np.exp(-Z))
return A
plot_utils.show_scatter_surface(X, Y, forward_propgation)
for _ in range(500):
for i in range(m):
Xi = X[i] ## 豆豆特征
Yi = Y[i] ## 豆豆是否有毒
A = forward_propgation(Xi)
E = (Yi - A) ** 2
dEdA = -2 * (Yi - A)
dAdZ = A * (1 - A)
dZdW = Xi
dZdB = 1
dEdW = dEdA * dAdZ * dZdW
dEdB = dEdA * dAdZ * dZdB
alpha = 0.01
W = W - alpha * dEdW
B = B - alpha * dEdB
plot_utils.show_scatter_surface(X, Y, forward_propgation)
二、Keras
诚如你所见，你恰好发现了 Keras。Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。Keras 的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果，是做好研究的关键。
参考链接：Keras官网
环境准备：
安装Tensorflow和Keras：
pip install keras -i https://pypi.mirrors.ustc.edu.cn/simple/
pip install tensorflow -i https://pypi.mirrors.ustc.edu.cn/simple/
参考链接：tensorflow和keras版本对应关系
如果遇到ddl缺失问题，我们只需要去微软的官网下载一个Visual C++软件包：参考链接
三、代码实现
我们对上述过程代码实现：
豆豆数据集模拟：dataset.py
import numpy as np
def get_beans(counts):
xs = np.random.rand(counts,2)*2
ys = np.zeros(counts)
for i in range(counts):
x = xs[i]
if (x[0]-0.5*x[1]-0.1)>0:
ys[i] = 1
return xs,ys
def get_beans1(counts):
xs = np.random.rand(counts)
xs = np.sort(xs)
ys = np.zeros(counts)
for i in range(counts):
x = xs[i]
yi = 0.7*x+(0.5-np.random.rand())/50+0.5
if yi > 0.8:
ys[i] = 1
else:
ys[i] = 0
return xs,ys
def get_beans2(counts):
xs = np.random.rand(counts)*2
xs = np.sort(xs)
ys = np.zeros(counts)
for i in range(counts):
x = xs[i]
yi = 0.7*x+(0.5-np.random.rand())/50+0.5
if yi > 0.8 and yi < 1.4:
ys[i] = 1
return xs,ys
def get_beans3(counts):
xs = np.random.rand(counts)*2
xs = np.sort(xs)
ys = np.zeros(counts)
for i in range(counts):
x = xs[i]
yi = 0.7*x+(0.5-np.random.rand())/50+0.5
if yi > 0.8 and yi < 1.4:
ys[i] = 1
if yi > 1.6 and yi < 1.8:
ys[i] = 1
return xs,ys
def get_beans4(counts):
xs = np.random.rand(counts,2)*2
ys = np.zeros(counts)
for i in range(counts):
x = xs[i]
if (np.power(x[0]-1,2)+np.power(x[1]-0.3,2))<0.5:
ys[i] = 1
return xs,ys
绘图工具：plot_utils.py
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
from keras.models import Sequential#导入keras
def show_scatter_curve(X,Y,pres):
plt.scatter(X, Y)
plt.plot(X, pres)
plt.show()
def show_scatter(X,Y):
if X.ndim>1:
show_3d_scatter(X,Y)
else:
plt.scatter(X, Y)
plt.show()
def show_3d_scatter(X,Y):
x = X[:,0]
z = X[:,1]
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(x, z, Y)
plt.show()
def show_surface(x,z,forward_propgation):
x = np.arange(np.min(x),np.max(x),0.1)
z = np.arange(np.min(z),np.max(z),0.1)
x,z = np.meshgrid(x,z)
y = forward_propgation(X)
fig = plt.figure()
ax = Axes3D(fig)
ax.plot_surface(x, z, y, cmap='rainbow')
plt.show()
def show_scatter_surface(X,Y,forward_propgation):
if type(forward_propgation) == Sequential:
show_scatter_surface_with_model(X,Y,forward_propgation)
return
x = X[:,0]
z = X[:,1]
y = Y
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(x, z, y)
x = np.arange(np.min(x),np.max(x),0.1)
z = np.arange(np.min(z),np.max(z),0.1)
x,z = np.meshgrid(x,z)
X = np.column_stack((x[0],z[0]))
for j in range(z.shape[0]):
if j == 0:
continue
X = np.vstack((X,np.column_stack((x[0],z[j]))))
r = forward_propgation(X)
y = r[0]
if type(r) == np.ndarray:
y = r
y = np.array([y])
y = y.reshape(x.shape[0],z.shape[1])
ax.plot_surface(x, z, y, cmap='rainbow')
plt.show()
def show_scatter_surface_with_model(X,Y,model):
#model.predict(X)
x = X[:,0]
z = X[:,1]
y = Y
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(x, z, y)
x = np.arange(np.min(x),np.max(x),0.1)
z = np.arange(np.min(z),np.max(z),0.1)
x,z = np.meshgrid(x,z)
X = np.column_stack((x[0],z[0]))
for j in range(z.shape[0]):
if j == 0:
continue
X = np.vstack((X,np.column_stack((x[0],z[j]))))
y = model.predict(X)
# return
# y = model.predcit(X)
y = np.array([y])
y = y.reshape(x.shape[0],z.shape[1])
ax.plot_surface(x, z, y, cmap='rainbow')
plt.show()
def pre(X,Y,model):
model.predict(X)
第一批豆豆：
import dataset
import plot_utils
from keras.models import Sequential
from keras.layers import Dense
m = 100
X, Y = dataset.get_beans1(m)
plot_utils.show_scatter(X, Y)
model = Sequential()
# 当前层神经元的数量为1，激活函数类型：sigmoid，输入数据特征维度：1
model.add(Dense(units=1, activation='sigmoid', input_dim=1))
# loss（损失函数、代价函数）：mean_squared_error均方误差；
# optimizer（优化器）：sgd（随机梯度下降算法）；
# metrics（评估标准）：accuracy（准确度）；
model.compile(loss='mean_squared_error', optimizer='sgd', metrics=['accuracy'])
# epochs：回合数（全部样本完成一次训练）、batch_size：批数量（一次训练使用多少个样本）
model.fit(X, Y, epochs=5000, batch_size=10)
pres = model.predict(X)
plot_utils.show_scatter_curve(X, Y, pres)
训练结果：
第二批豆豆：
import dataset
import plot_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
m = 100
X, Y = dataset.get_beans2(m)
plot_utils.show_scatter(X, Y)
model = Sequential()
model.add(Dense(units=2, activation='sigmoid', input_dim=1))
model.add(Dense(units=1, activation='sigmoid'))
# 调整学习率为0.05
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])
model.fit(X, Y, epochs=5000, batch_size=10)
pres = model.predict(X)
plot_utils.show_scatter_curve(X, Y, pres)
训练结果：
第三批豆豆：
import dataset
import plot_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
m = 100
X, Y = dataset.get_beans(m)
plot_utils.show_scatter(X, Y)
model = Sequential()
# 当前层神经元的数量为1，激活函数类型：sigmoid，输入数据特征维度：2
model.add(Dense(units=1, activation='sigmoid', input_dim=2))
# loss（损失函数、代价函数）：mean_squared_error均方误差；
# optimizer（优化器）：sgd（随机梯度下降算法）；
# metrics（评估标准）：accuracy（准确度）；
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])
# epochs：回合数（全部样本完成一次训练）、batch_size：批数量（一次训练使用多少个样本）
model.fit(X, Y, epochs=5000, batch_size=10)
pres = model.predict(X)
plot_utils.show_scatter_surface(X, Y, model)
豆豆毒性分布：
训练结果：
第四批豆豆：
import dataset
import plot_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
m = 100
X, Y = dataset.get_beans(m)
plot_utils.show_scatter(X, Y)
model = Sequential()
# 当前层神经元的数量为2，激活函数类型：sigmoid，输入数据特征维度：2
model.add(Dense(units=2, activation='sigmoid', input_dim=2))
model.add(Dense(units=1, activation='sigmoid'))
# loss（损失函数、代价函数）：mean_squared_error均方误差；
# optimizer（优化器）：sgd（随机梯度下降算法）；
# metrics（评估标准）：accuracy（准确度）；
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.05), metrics=['accuracy'])
# epochs：回合数（全部样本完成一次训练）、batch_size：批数量（一次训练使用多少个样本）
model.fit(X, Y, epochs=5000, batch_size=10)
pres = model.predict(X)
plot_utils.show_scatter_surface(X, Y, model)
豆豆毒性分布：
训练结果：
[ 笔者 ] 文艺倾年
[ 更新 ] 2023.1.19
❌ [ 勘误 ] /* 暂无 */
[ 声明 ] 由于作者水平有限，本文有错误和不准确之处在所难免，
本人也很想知道这些错误，恳望读者批评指正！
[ 代码 ] https://github.com/itxaiohanglover/ai_lesson