相关介绍
目前在在跟着大佬学习人工智能，学了两个章节后，感觉自己学的不是很通透，所以想试试写下来会不会好一点，也是给自己做一个总结。
人工智能算法，是仿照人大脑中神经元的构成和运行的机制所提出的算法。
上图就是一个神经元的示意图，从多个触角上进行输入，每个触角的权重不相同，权重与触角的输入相乘后决定一个人的行为。就比如说一个人面对水，他把手伸进去，决定他要不要拿出来的因素有几个，比如说水的温度，外界的温度，个人的体温等等，每个都有不同的权重。第一次不知道水温的时候，就是试探，之后再决定伸进去与否，这个过程就是权重的调节。而人工智能就是仿照这么一个过程，在不断调节权重的过程中，最终实现想要的结果的一个过程。
这几天学习了一个单神经元的人工智能算法，对于是或者不是的选择上有着比较好的应用。下面，我就分享一个单神经元情况下的人工智能算法的思路和代码。上文我们说到，人工智能算法是一个不断计算和调节的过程，想必大家高中的时候就学过求导的运算，但是那个时候的其实算是一种理想情况的求导，而现在我们需要利用实际的计算值实现实际值和理想值之间的误差，在通过学习率调节权重变化的速率，最终达到相对理想的一个权重效果。
既然涉及到求导的问题，这里需要大家去复习一下链式法则（这个以后的博文会出现，本文只是人工智能的一个记录帖），通过链式法则进行反向求导。下面我先展示一下，单个神经元的人工智能算法的思维导图：
之后是涉及到的一些函数及相关函数用法的简单表达（更复杂的以后会相继给大家更新）：
所需函数
以上便是各种函数以及各种函数的用法，下面进入实战环节：
首先我们要加载几个用到的库：
import numpy as np #科学计算的库
import matplotlib.pyplot as plt #画图的库
import h5py #h5数据类型读取的库
数据的读取和存储
我们要实现数据的读取，先编写一个能够读取数据集的函数：
def load_data():
train_dataset = h5py.File('datasets/train_catvnoncat.h5',"r") #加载训练数据集
train_set_x_orig = np.array(train_dataset["train_set_x"][ : ]) #加载数据集中的图片特征数据
train_set_y_orig = np.array(train_dataset["train_set_y"][ : ]) #加载标签数据(已经预处理过，确定了那些是那些不是)
test_dataset = h5py.File('datasets/test_catvnoncat.h5',"r") #加载测试数据集
test_set_x_orig = np.array(test_dataset["test_set_x"][:])
test_set_y_orig = np.array(test_dataset["test_set_y"][:])
classes = np.array(test_dataset["list_classes"][ : ]) #加载标签类别数据
train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0])) # 把数组的维度从(209,)变成(1, 209)
test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0])) # 从(50,)变成(1, 50)
return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
激活函数
激活函数在思维导图中也写了，是为了提高学习的效率和最后的结果，也就是提升整个人工智能的智商。前面所进行的计算全都是线性的，而激活函数最大的最用就是打破线性的约束条件，强化网络学习的能力，所以激活函数最大的特点就是非线性，而且不同的激活函数也有不同的特点。常用的激活函数大家可以转到下面这个帖子去看看：链接: https://zhuanlan.zhihu.com/p/73214810.
本次单个神经元的网络使用的是Sigmoid函数，函数的值域是(0,1)：
def sigmoid(z):
s = 1 / (1 + np.exp(-z)) #z可以是一个数值，也可以是一个数组，结果与之相对应
return s
参数初始化
在单个神经元的人工智能函数中，可以对权重数组w和偏量数组b(个人觉得有点像线性回归函数里后面在y轴上的轴距)全部初始化为0(神经网络中是不可以对权重设置为0的)：
def initialize_with_zeros(dim):
w = np.zeros((dim, 1))
b = 0
return w, b
损失函数
损失函数，就是利用正向传导（学习已知结果的图片）和反向传导（计算误差，也就是求导的过程）实现对参数变化过程的计算，方便在学习函数中进行参数的学习和调节。损失函数的种类也有很多种，需要根据自己的实际需要进行选择，有需要的可以看看下面这个帖子：链接: https://zhuanlan.zhihu.com/p/58883095.下面使用的是交叉熵损失函数：
def propagate(w, b, X, Y):
m = X.shape[1]
# 前向传播
A = sigmoid(np.dot(w.T, X) + b)
cost = -np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A)) / m
# 反向传播
dZ = A - Y
dw = np.dot(X, dZ.T) / m
db = np.sum(dZ) / m
# 将dw和db保存到字典里面,这里就是确定权重和偏置量变化量的过程
grads = {"dw": dw,
"db": db}
return grads, cost
学习函数
学习，顾名思义：就像人类学习的过程一样，通过不断微调自己的行为达到一个自己理想值的情况，每个人的学习过程也受到个人天赋的影响，学习率高，就少学几次；学习率低可能就需要多学几次。但是数学计算的过程却非常容易因为取值的不合理，在极值附近反复横跳达不到好的结果，所以每次学习的时候，需要根据实际的情况设置学习率，在实验中进行调节。
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost=False):
costs = []
for i in range(num_iterations):
grads, cost = propagate(w, b, X, Y) # 计算得出梯度和成本
# 从字典中取出梯度
dw = grads["dw"]
db = grads["db"]
'''
下面的learning_rate就是学习率的意思，通过学习率的计算，最终实现对权重和偏置的确定
'''
w = w - learning_rate * dw
b = b - learning_rate * db
# 将成本记录下来
if i % 100 == 0:
costs.append(cost)
if print_cost:
print("优化%i次后成本是: %f" % (i, cost))
params = {"w": w,
"b": b}
return params, costs
预测函数
这个函数是为了检测在不同学习率情况下预测的准确率（实际编程中，需要准确率时，可以写）：
def predict(w, b, X):
def predict(w, b, X):
m = X.shape[1]
Y_prediction = np.zeros((1, m))
A = sigmoid(np.dot(w.T, X) + b) # 通过这行代码来对图片进行预测
# 上面得出的预测结果是小数的形式，为了方便后面显示，我们将其转换成0和1的形式（大于等于0.5就是1/有猫，小于0.5就是0/无猫）
for i in range(A.shape[1]):
if A[0, i] >= 0.5:
Y_prediction[0, i] = 1
return Y_prediction
模型函数
通过模型函数，实现对训练数据的学习，和对测试数据的测试
def model(X_train, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):
# 初始化待训练的参数
w, b = initialize_with_zeros(X_train.shape[0])
# 使用训练数据来训练/优化参数
parameters, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)
# 从字典中分别取出训练好的w和b
w = parameters["w"]
b = parameters["b"]
# 使用训练好的w和b来分别对训练图片和测试图片进行预测
Y_prediction_train = predict(w, b, X_train)
Y_prediction_test = predict(w, b, X_test)
# 打印出预测的准确率
print("对训练图片的预测准确率为: {}%".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
print("对测试图片的预测准确率为: {}%".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations}
return d
源码
以上便是需要用到的所有函数的编写，下面则是单个神经元人工智能的源码：
import numpy as np
import matplotlib.pyplot as plt
import h5py
import skimage.transform as tf
def load_dataset():
train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
train_set_x_orig = np.array(train_dataset["train_set_x"][:])
train_set_y_orig = np.array(train_dataset["train_set_y"][:])
test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
test_set_x_orig = np.array(test_dataset["test_set_x"][:])
test_set_y_orig = np.array(test_dataset["test_set_y"][:])
classes = np.array(test_dataset["list_classes"][:])
train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0])) # 从(50,)变成(1, 50)
return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
index = 0
plt.imshow(train_set_x_orig[index])
print ("标签为" + str(train_set_y[:, index]) + ", 这是一个'" + classes[np.squeeze(train_set_y[:, index])].decode("utf-8") + "' 图片.")
#把他们的维度打印出来。
print ("train_set_x_orig shape: " + str(train_set_x_orig.shape))
print ("train_set_y shape: " + str(train_set_y.shape))
print ("test_set_x_orig shape: " + str(test_set_x_orig.shape))
print ("test_set_y shape: " + str(test_set_y.shape))
m_train = train_set_x_orig.shape[0]
m_test = test_set_x_orig.shape[0]
num_px = test_set_x_orig.shape[1] # 由于我们的图片是正方形的，所以长宽相等
print ("训练样本数: m_train = " + str(m_train))
print ("测试样本数: m_test = " + str(m_test))
print ("每张图片的宽/高: num_px = " + str(num_px))
train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T
test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
print ("train_set_x_flatten shape: " + str(train_set_x_flatten.shape))
print ("test_set_x_flatten shape: " + str(test_set_x_flatten.shape))
train_set_x = train_set_x_flatten/255.
test_set_x = test_set_x_flatten/255.
def sigmoid(z):
s = 1 / (1 + np.exp(-z))
return s
def initialize_with_zeros(dim):
w = np.zeros((dim, 1))
b = 0
return w, b
def propagate(w, b, X, Y):
m = X.shape[1]
# 前向传播
A = sigmoid(np.dot(w.T, X) + b)
cost = -np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A)) / m
# 反向传播
dZ = A - Y
dw = np.dot(X, dZ.T) / m
db = np.sum(dZ) / m
# 将dw和db保存到字典里面
grads = {"dw": dw,
"db": db}
return grads, cost
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost=False):
costs = []
for i in range(num_iterations):
grads, cost = propagate(w, b, X, Y) # 计算得出梯度和成本
# 从字典中取出梯度
dw = grads["dw"]
db = grads["db"]
# 进行梯度下降，更新参数，使其越来越优化，使成本越来越小
w = w - learning_rate * dw
b = b - learning_rate * db
# 将成本记录下来
if i % 100 == 0:
costs.append(cost)
if print_cost:
print("优化%i次后成本是: %f" % (i, cost))
params = {"w": w,
"b": b}
return params, costs
def predict(w, b, X):
m = X.shape[1]
Y_prediction = np.zeros((1, m))
A = sigmoid(np.dot(w.T, X) + b) # 通过这行代码来对图片进行预测
# 上面得出的预测结果是小数的形式，为了方便后面显示，我们将其转换成0和1的形式（大于等于0.5就是1/有猫，小于0.5就是0/无猫）
for i in range(A.shape[1]):
if A[0, i] >= 0.5:
Y_prediction[0, i] = 1
return Y_prediction
def model(X_train, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):
# 初始化待训练的参数
w, b = initialize_with_zeros(X_train.shape[0])
# 使用训练数据来训练/优化参数
parameters, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)
# 从字典中分别取出训练好的w和b
w = parameters["w"]
b = parameters["b"]
# 使用训练好的w和b来分别对训练图片和测试图片进行预测
Y_prediction_train = predict(w, b, X_train)
Y_prediction_test = predict(w, b, X_test)
# 打印出预测的准确率
print("对训练图片的预测准确率为: {}%".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
print("对测试图片的预测准确率为: {}%".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations}
return d
# 调用上面的模型函数对我们最开始加载的数据进行训练
d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)
# 这里我们可以改变index，来看看哪些图片预测对了
index = 30
plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))
print ("这张图的标签是 " + str(test_set_y[0,index]) + ", 预测结果是 " + str(int(d["Y_prediction_test"][0,index])))
# 下面我们打印出成本随着训练次数增加时的变化情况。可以很直观的看出，训练次数越多，成本越小，也就是预测结果更精确
costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('cost') # 成本
plt.xlabel('iterations (per hundreds)') # 横坐标为训练次数，以100为单位
plt.title("Learning rate =" + str(d["learning_rate"]))
plt.show()
learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
print ("学习率为: " + str(i) + "时")
models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
print ('\n' + "-------------------------------------------------------" + '\n')
for i in learning_rates:
plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))
plt.ylabel('cost')
plt.xlabel('iterations (hundreds)')
legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()
以上便是单个神经元人工智能的学习全部内容，我学习的老师是床长，大家有兴趣的可以去他的微博学习，传送门如下：http://blog.csdn.net/jiangjunshow.
感谢床长的教程
427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
