原文链接:
https://blog.csdn.net/zzukun/article/details/49968129
代码(python3.7 + tensorflow2.0):
# -- coding: utf-8 --
import copy
import numpy as np
from time import time
# sigmoid函数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# sigmoid函数的导数，这里out=sigmoid(x)
def sigmoid_out_to_derivative(output):
return output * (1 - output)
# 获取二进制对应关系，将所有数转二进制(我们的数据生成器)
int2binary = {} # 字典格式
binary_dim = 8 # 二进制的最长位数
largest_number = pow(2, binary_dim) # 最大值
binary = np.unpackbits(np.array([range(largest_number)], dtype=np.uint8).T, axis=1) # unpackbits函数, 将整数转为2进制
for i in range(largest_number):
int2binary[i] = binary[i] # 使用字典格式赋值，得到结果类似{0:array([0,0,0,0,0,0,0,1], dtype = uint8), 1:array(......}
def main():
start = time()
# 设置学习速率
alpha = 0.1
# 输入层
input_dim = 2
# 隐藏层神经元个数
hidden_dim = 16
# 输出层
output_dim = 1
# 连接输入层与隐藏层的权值矩阵2行16列，取值区间为[-1, 1)，使用区间内随机数初始化
synapse_0 = 2 * np.random.random((input_dim, hidden_dim)) - 1
# 连接隐藏层与输出层的权值矩阵16行1列，取值区间为[-1, 1)，使用区间内随机数初始化
synapse_1 = 2 * np.random.random((hidden_dim, output_dim)) - 1
# 连接(上一个)隐藏层与(当前)隐藏层的权值矩阵16行16列，取值区间为[-1, 1)，使用区间内随机数初始化
synapse_h = 2 * np.random.random((hidden_dim, hidden_dim)) - 1
# 上面三个矩阵更新时的缓冲矩阵
synapse_0_update = np.zeros_like(synapse_0)
synapse_1_update = np.zeros_like(synapse_1)
synapse_h_update = np.zeros_like(synapse_h)
# 做一万次迭代
for j in range(10000):
# 针对其中一次：
# 生成一个简单的加法问题(a + b = c, a < max / 2, b < max/2, c使用tensorflow实现(python3.7+tensorflow2.0):
# -- coding: utf-8 --
import numpy as np
from matplotlib import pyplot as plt
import tensorflow as tf
from tensorflow.keras import layers, models, Sequential
global binary_dim, largest_number
binary_dim = 8
largest_number = pow(2, binary_dim)
# binary = np.unpackbits(np.array([np.arange(largest_number)], dtype=np.uint8).T, axis=1)
# for i in range(largest_number):
# int2binary[i] = binary[i]
def main():
# X = np.random.randint(0, largest_number / 2, 4000).reshape(-1, 2)
# np.save("X", X)
X = np.load('X.npy')
X_train_old, X_test_old = X[:1800], X[1800:]
y = np.sum(X, axis=1).reshape(-1, 1)
y_train_old, y_test_old = y[:1800], y[1800:]
# X, y转二进制
# input: X_train (1800x2x8)
# output: y_train (1800x8)
# 单次输入 2x8的X 对应 1x8的y
X = np.unpackbits(X.astype(np.uint8), axis=1).reshape(-1, 2, 8).astype(np.float32)
X_train, X_test = X[:1800], X[1800:]
y = np.unpackbits(y.astype(np.uint8), axis=1).reshape(-1, 8).astype(np.float32)
y_train, y_test = y[:1800], y[1800:]
# 创建模型
model = Sequential()
# LSTM: 记忆相邻两组数据
model.add(layers.LSTM(16, activation='relu', input_shape=(2, 8)))
model.add(layers.Dense(8, activation='relu'))
model.compile(loss='mse', optimizer='adam')
h = model.fit(X_train, y_train, batch_size=20, epochs=1000)
# 绘制loss的变化
plt.figure(figsize=(16,2))
plt.plot(h.history['loss'])
plt.show()
model.save('lstm_model.h5')
model = models.load_model('lstm_model.h5')
cc = pow(2, np.arange(8))[::-1]
y_test_predict = np.round(model.predict(X_test))
# 将model预测值二级制转十进制
y_test_predict = np.dot(y_test_predict, cc).reshape(-1, 1)
print(X_test_old)
print(y_test_old)
print(y_test_predict)
print(y_test_predict - y_test_old)
# errorAll = np.sum(np.abs(y_test_predict - y_test_old)) / 200
# print(errorAll)
print('finish.')
if __name__ == '__main__':
main()
损失函数loss:
Figure_1.png