def _test_straight_line(fnn_flag):
"""
测试 ax + b 分割
:param fnn_flag: 神经网络分类标记
:return:
"""
# 训练样本个数
train_sample_count = 1000
# 训练样本，输入，每个向量元素的最大值
train_sx_max = list()
train_sx_max.append(200)
train_sx_max.append(500)
# ax + b 分割的样本对象
sample = straight_line_sample.StraightLineSample()
# 激活函数对象
activation = normal_activation.Sigmoid()
# 神经网络对象
if fnn_flag == FNN_0:
nn = bp_nn.BPFNN(activation)
else:
nn = bp_nn_ex.BPFnnEx(activation)
# 每一层网络的神经元个数
neuron_count_list = [2, 1]
# 最大循环训练次数
loop_max = 10
# 学习效率
rate = 0.1
# 预测样本参数
predict_sample_count = 500
# 预测样本，输入，每个向量元素的最大值
predict_sx_max = list()
predict_sx_max.append(2000)
predict_sx_max.append(5000)
# 是否画训练样本
draw_train_sample_flag = draw.ShowFlag.SHOW
# 是否画预测样本
draw_predict_sample_flag = draw.ShowFlag.SHOW
# 是否画预测结果
draw_predict_result_flag = draw.ShowFlag.SHOW
# 神经网络测试对象：
if fnn_flag == FNN_0:
nn_test = NNTest()
else:
nn_test = FNNExTest()
nn_test.test(train_sample_count, train_sx_max, sample, neuron_count_list, loop_max, rate,
predict_sample_count, predict_sx_max, nn, BP_NN_TITLE,
draw_train_sample_flag, draw_predict_sample_flag, draw_predict_result_flag)
def _test_sin_without_train(fnn_flag):
"""
测试 sin(x) 分割，不经过训练，直接赋值参数
:param fnn_flag: 神经网络分类标记
:return: NULL
"""
# 激活函数对象
activation = normal_activation.Sigmoid()
# 神经网络对象
if fnn_flag == FNN_0:
nn = bp_nn.BPFNN(activation)
else:
nn = bp_nn_ex.BPFnnEx(activation)
# 预测样本个数
predict_sample_count = 1000
# 预测样本，输入，每个向量元素的最大值
predict_sx_max = list()
predict_sx_max.append(1)
predict_sx_max.append(1)
# 神经网络输入/输出，向量维度
sx_dim = 2
sy_dim = 1
# 每一层神经元的数量(Neuron Count)
neuron_count_list = [5, 1]
# 每一层 w、B 参数，w 是个 matrix，b 是个 vector（数据类型也是一个 matrix）
W = list()
B = list()
# 第1层
w0 = np.asarray([[-20.69514968, - 3.52723041],
[-11.69201431, 2.12957366],
[20.53242169, 3.31010044],
[-18.77519677, 3.54389238],
[-9.44057119, 2.41633713]])
b0 = np.asarray([[-9.81608468],
[-11.76723006],
[-9.91804491],
[-0.22741755],
[9.6019504]])
W.append(w0)
B.append(b0)
# 第2层
w1 = np.asarray([[-16.96090009, 14.45759092, 13.19833084, 17.00121887, 10.07422065]])
b1 = np.asarray([[-17.35104879]])
W.append(w1)
B.append(b1)
# sin(x) 分割的样本对象
sample = sin_sample.SinSample()
# 是否画预测样本
draw_predict_sample_flag = draw.ShowFlag.NO_SHOW
# 是否画预测结果
draw_predict_result_flag = draw.ShowFlag.SHOW
# 神经网络测试对象：
if fnn_flag == FNN_0:
nn_test = NNTest()
else:
nn_test = FNNExTest()
nn_test.test_stub(predict_sample_count, predict_sx_max, neuron_count_list, W, B, sample, nn, BP_NN_TITLE,
draw_predict_sample_flag, draw_predict_result_flag,
sx_dim, sy_dim)
def _test_straight_line_without_train(fnn_flag):
"""
测试 ax + b 分割，不经过训练，直接赋值参数
:param fnn_flag: 神经网络分类标记
:return: NULL
"""
# 激活函数对象
activation = normal_activation.Sigmoid()
# 神经网络对象
if fnn_flag == FNN_0:
nn = bp_nn.BPFNN(activation)
else:
nn = bp_nn_ex.BPFnnEx(activation)
# 预测样本个数
predict_sample_count = 500
# 预测样本，输入，每个向量元素的最大值
predict_sx_max = list()
predict_sx_max.append(2000)
predict_sx_max.append(5000)
# 神经网络输入/输出，向量维度
sx_dim = 2
sy_dim = 1
# 每一层神经元的数量(Neuron Count)
neuron_count_list = [2, 1]
# 每一层 w、B 参数，w 是个 matrix，b 是个 vector（数据类型也是一个 matrix）
W = list()
B = list()
# 第1层
w0 = np.asarray([[-18.82131354, 9.6738681],
[-8.15464853, 7.34378254]])
b0 = np.asarray([[0.07273821],
[0.22575042]])
W.append(w0)
B.append(b0)
# 第2层
w1 = np.asarray([[8.96780964, 0.42862565]])
b1 = np.asarray([[-3.94002764]])
W.append(w1)
B.append(b1)
# ax + b 分割的样本对象
sample = straight_line_sample.StraightLineSample()
# 是否画预测样本
draw_predict_sample_flag = draw.ShowFlag.NO_SHOW
# 是否画预测结果
draw_predict_result_flag = draw.ShowFlag.SHOW
# 神经网络测试对象：
if fnn_flag == FNN_0:
nn_test = NNTest()
else:
nn_test = FNNExTest()
nn_test.test_stub(predict_sample_count, predict_sx_max, neuron_count_list, W, B, sample, nn, BP_NN_TITLE,
draw_predict_sample_flag, draw_predict_result_flag,
sx_dim, sy_dim)
def _test_two_line_without_train(fnn_flag):
"""
测试 两根直线 分割，不经过训练，直接赋值参数
:param fnn_flag: 神经网络分类标记
:return: NULL
"""
# 激活函数对象
activation = normal_activation.Sigmoid()
# 神经网络对象
if fnn_flag == FNN_0:
nn = bp_nn.BPFNN(activation)
else:
nn = bp_nn_ex.BPFnnEx(activation)
# 预测样本个数
predict_sample_count = 1000
# 预测样本，输入，每个向量元素的最大值
predict_sx_max = list()
predict_sx_max.append(1)
predict_sx_max.append(1)
# 神经网络输入/输出，向量维度
sx_dim = 2
sy_dim = 1
# 每一层神经元的数量(Neuron Count)
neuron_count_list = [2, 1]
# 每一层 w、B 参数，w 是个 matrix，b 是个 vector（数据类型也是一个 matrix）
W = list()
B = list()
# 第1层
w0 = np.asarray([[15.3875926, -15.33421447],
[-14.19520774, 14.33819683]])
b0 = np.asarray([[-7.82673954],
[-6.9671098]])
W.append(w0)
B.append(b0)
# 第2层
w1 = np.asarray([[20.86723432, 19.43161973]])
b1 = np.asarray([[-9.78812464]])
W.append(w1)
B.append(b1)
# 两根直线 分割的样本对象
sample = two_line_sample.TwoLineSample()
# 是否画预测样本
draw_predict_sample_flag = draw.ShowFlag.NO_SHOW
# 是否画预测结果
draw_predict_result_flag = draw.ShowFlag.SHOW
# 神经网络测试对象：
if fnn_flag == FNN_0:
nn_test = NNTest()
else:
nn_test = FNNExTest()
nn_test.test_stub(predict_sample_count, predict_sx_max, neuron_count_list, W, B, sample, nn, BP_NN_TITLE,
draw_predict_sample_flag, draw_predict_result_flag,
sx_dim, sy_dim)
def test_softmax():
# 1. 构建神经网络对象
# 激活函数
# activation = Sigmoid()
activation = ReLU(20)
# 最后一跳激活函数
last_hop_activation = SoftMaxLHA()
# 损失函数
loss = CrossEntropyLoss()
# 神经网络
# nn = bp_nn.BPFNN(activation, last_hop_activation, loss)
nn = bp_nn_ex.BPFnnEx(activation, last_hop_activation, loss)
# 2. 构建训练样本
# 训练样本对象
sample = ImageSoftMaxSample()
# 训练样本输入，向量维度
sx_dim = 400 # 20 * 20 的图像， 400维向量
# 训练样本输出，向量维度
sy_dim = 10 # one-hot, 10维向量
# 创建训练样本，输入/输出
train_image_root_path = "./../picture/number_softmax_train"
train_image_root_path = os.path.abspath(train_image_root_path)
sample.create_sample(train_image_root_path)
# sample.create_sample_ex(100)
# train_sx_list = sample.get_sx_list()
# train_sy_list = sample.get_sy_list()
train_sx_group = sample.get_sx_group()
train_sy_group = sample.get_sy_group()
# 3. 训练
# 每一层网络的神经元个数
neuron_count_list = [10, 10]
# 最大循环训练次数
loop_max = 30
# 学习效率
rate = 0.1
# 训练
# nn.train(train_sx_list, train_sy_list, loop_max, neuron_count_list, rate)
nn.train(train_sx_group, train_sy_group, loop_max, neuron_count_list, rate)
# 4. 测试
# 4.1 创建测试样本
test_image_root_path = "./../picture/number_softmax_test"
test_image_root_path = os.path.abspath(test_image_root_path)
sample.create_sample(test_image_root_path, confuse=False)
# sample.create_sample_ex(2)
test_sx_list = sample.get_sx_list()
test_sy_list = sample.get_sy_list()
py_list = nn.predict(test_sx_list, test_sy_list)
print("\n")
print("py:\n")
count = len(py_list)
for i in range(0, count):
number = _get_max_index(test_sy_list[i])
print("\n")
print("index = %d, number = %d" % (i, number))
print(py_list[i])