作业2-1

作业3-1：

1 使用numpy计算tanh激活函数
tanh也是神经网络中常用的一种激活函数，其定义如下：

y=ex−e−xex+e−xy = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}} y=ex+e−xex−e−x​

请参照讲义中Sigmoid激活函数的计算程序，用numpy实现tanh函数的计算，并画出其函数曲线

提交方式：请用numpy写出计算程序，并画出tanh函数曲线图，x的取值范围设置为[-10., 10.]

plt.figure(figsize=(8, 5))

x = np.arange(-10, 10, 0.1)
y=(np.exp(x)-np.exp(-x))/(np.exp(x)+np.exp(-x))
plt.plot(x,y, color='r')
plt.text(-3.0, 0.9, r'$y=tanh(x)')
plt.show()

作业3-2:

2 统计随机生成矩阵中有多少个元素大于0
假设使用np.random.randn生成了随机数构成的矩阵：

p = np.random.randn(10, 10)

请写一段程序统计其中有多少个元素大于0？

提示：可以试下使用 q = (p > 0)，观察q是什么的数据类型和元素的取值

提交方式：提交计算的代码，能够直接运行输出统计出来的结果

p = np.random.randn(10, 10)
s=np.extract(p>0, p)
print(s.size)

作业7-1:

乘法：867041280 加法：867041280

作业3-1：

（1）

# ReLU和Sigmoid激活函数示意图
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.patches as patches

#设置图片大小
plt.figure(figsize=(8, 3))

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
x = np.arange(-10., 10., 0.1)
# 计算 tanh函数
s = np.exp(x) - np.exp(- x) / (np.exp(x) + np.exp(- x))

#########################################################
# 以下部分为画图程序

# 设置两个子图窗口，将Sigmoid的函数图像画在左边
f = plt.subplot(121)
# 画出函数曲线
plt.plot(x, s, color='r')
# 添加文字说明
plt.text(-5., 0.9, r'$y=\tanh(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)

plt.show()

（2）

p = np.random.randn(10, 10)
print(np.sum(p>0))

作业7-1:
总体乘法数为867041280
总体加法数为834928640
总共需要的操作次数为1701969920

作业3-1:

1 使用numpy计算tanh激活函数
tanh也是神经网络中常用的一种激活函数，其定义如下：

y=ex−e−xex+e−xy = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}y=ex+e−xex−e−x​

请参照讲义中Sigmoid激活函数的计算程序，用numpy实现tanh函数的计算，并画出其函数曲线

提交方式：请用numpy写出计算程序，并画出tanh函数曲线图，x的取值范围设置为[-10., 10.]

import numpy as np
#% matplotlib inline
import matplotlib.pyplot as plt

# 设置图片大小
plt.figure(figsize=(8, 3))

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
x = np.arange(-10, 10, 0.1)

my_tanh = ((np.exp(x)) - (np.exp(- x))) / ((np.exp(x)) + (np.exp(- x)))

f = plt.subplot(133)
# 画出函数曲线
plt.plot(x, my_tanh, color='b')
# 添加文字说明
plt.text(-5.0, 0.75, r'$y=tanh(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis = plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)

plt.show()

2 统计随机生成矩阵中有多少个元素大于0
假设使用np.random.randn生成了随机数构成的矩阵：

p = np.random.randn(10, 10)

请写一段程序统计其中有多少个元素大于0？

提示：可以试下使用 q = (p > 0)，观察q是什么的数据类型和元素的取值

提交方式：提交计算的代码，能够直接运行输出统计出来的结果

p = np.random.randn(10, 10)
q = (p > 0)

print(q)
print(q.dtype)
print(sum(q))
print(sum(sum(q)))

作业7-2:

作业7-2:

作业7-1

乘法数=224*224*9*3*64*10=867041280

加法数=224*224*(8*3+2+1)*64*10 = 867041280

作业7-2

作业6-1：

1.将普通神经网络模型的每层输出打印，观察内容
########## print network layer's superparams ##############
conv1-- kernel_size:[20, 1, 5, 5], padding:[2, 2], stride:[1, 1]
pool1-- pool_type:max, pool_size:[2, 2], pool_stride:[2, 2]
conv2-- kernel_size:[20, 20, 5, 5], padding:[2, 2], stride:[1, 1]
pool2-- pool_type:max, pool_size:[2, 2], pool_stride:[2, 2]
fc-- weight_size:[980, 10], bias_size_[10], activation:softmax

########## print shape of features of every layer ###############
inputs_shape: [100, 1, 28, 28]
conv1: [100, 20, 28, 28]
pool1_shape: [100, 20, 14, 14]
conv2_shape: [100, 20, 14, 14]
pool2_shape: [100, 20, 7, 7]
fc_shape: [100, 10]

2.将分类准确率的指标 用PLT库画图表示

3.通过分类准确率，判断以采用不同损失函数训练模型的效果优劣

4.作图比较：随着训练进行，模型在训练集和测试集上的Loss曲线

5.调节正则化权重，观察4的作图曲线的变化，并分析原因

作业7-2：

作业6-1：

1.将普通神经网络模型的每层输出打印，观察内容
########## print network layer's superparams ##############
conv1-- kernel_size:[20, 1, 5, 5], padding:[2, 2], stride:[1, 1]
pool1-- pool_type:max, pool_size:[2, 2], pool_stride:[2, 2]
conv2-- kernel_size:[20, 20, 5, 5], padding:[2, 2], stride:[1, 1]
pool2-- pool_type:max, pool_size:[2, 2], pool_stride:[2, 2]
fc-- weight_size:[980, 10], bias_size_[10], activation:softmax

########## print shape of features of every layer ###############
inputs_shape: [100, 1, 28, 28]
conv1: [100, 20, 28, 28]
pool1_shape: [100, 20, 14, 14]
conv2_shape: [100, 20, 14, 14]
pool2_shape: [100, 20, 7, 7]
fc_shape: [100, 10]

2.将分类准确率的指标 用PLT库画图表示

3.通过分类准确率，判断以采用不同损失函数训练模型的效果优劣

# 多层全连接神经网络实现
class MNIST(fluid.dygraph.Layer):
def __init__(self, name_scope, out_size=10):
super(MNIST, self).__init__(name_scope)
name_scope = self.full_name()
# 定义卷积层，输出通道20，卷积核大小为5，步长为1，padding为2，使用relu激活函数
self.conv1 = Conv2D(name_scope, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
# 定义池化层，池化核为2，采用最大池化方式
self.pool1 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
# 定义卷积层，输出通道20，卷积核大小为5，步长为1，padding为2，使用relu激活函数
self.conv2 = Conv2D(name_scope, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
# 定义池化层，池化核为2，采用最大池化方式
self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
# 定义全连接层，输出节点数为10，激活函数使用softmax
self.fc = FC(name_scope, size=out_size, act='softmax')

# 定义网络的前向计算过程
# 加入对每一层输入和输出的尺寸和数据内容的打印，根据check参数决策是否打印每层的参数和输出尺寸
def forward(self, inputs, label=None, check_shape=True, check_content=True):
conv1 = self.conv1(inputs)
pool1 = self.pool1(conv1)
conv2 = self.conv2(pool1)
pool2 = self.pool2(conv2)
fc = self.fc(pool2)
return fc

"""##############@@@@ 模板3: 模型训练 @@@@##############"""
"""##############@@@@ 模板3-1: 优化器 @@@@##############"""
"""##############@@@@ 模板3-2: 损失函数 @@@@##############"""
"""##############@@@@ 模板3-3: 后向传播 @@@@##############"""
"""##############@@@@ 模板3-4: 保存模型 @@@@##############"""

def train():
model = MNIST("mnist", out_size=out_size)
model.train()
# 调用加载数据的函数，获得MNIST训练数据集
train_loader = load_data('train')
# 加入正则化项，避免模型过拟合
regular = fluid.regularizer.L2Decay(regularization_coeff=0.1)
# 使用SGD优化器，learning_rate设置为0.01
optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01, regularization=regular)
# 训练5轮
EPOCH_NUM = 2
iter = 0
iters = []
avg_acces = []
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
# 准备数据
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
# 前向计算的过程
predict = model(image)
# 交叉熵和均方根损失函数
if out_size == 10:
label = fluid.dygraph.to_variable(label_data)
loss = fluid.layers.cross_entropy(predict, label)
avg_loss = fluid.layers.mean(loss)
avg_acc = fluid.layers.accuracy(input=predict, label=label)
avg_acc = avg_acc.numpy()
else:
label = fluid.dygraph.to_variable(label_data.astype('float32'))
loss = fluid.layers.square_error_cost(predict, label)
loss = fluid.layers.sqrt(loss)
avg_loss = fluid.layers.mean(loss)
# 取正负0.3内为正确
label_num = len(label_data)
acc_array = np.reshape(predict.numpy() - label_data, [label_num])
acc_list = [ 1 if -0.3 < a < 0.3 else 0 for a in acc_array]
acc_num = sum(acc_list)
avg_acc = acc_num / label_num
print('epoch_id = {}, batch_id = {}, acc_num = {}, avg_acc = {}'.format(epoch_id, batch_id, acc_num, avg_acc))

# 每训练了200批次的数据，打印下当前Loss的情况
if batch_id % 100 == 0:
iters.append(iter)
avg_acces.append(avg_acc)
iter = iter + 100

# 后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
return iters, avg_acces

if __name__ == '__main__':
# 网络结构部分之后的代码，保持不变
with fluid.dygraph.guard():
out_size = 10
iters_1, avg_acces_1 = train()
print(
'out_size = {}, len(iters_1) = {}, len(avg_acces_1) = {}'.format(out_size, len(iters_1), len(avg_acces_1)))
out_size = 1
iters_2, avg_acces_2 = train()
print('out_size = {}, len(iters_2) = {}, len() = {}'.format(out_size, len(iters_2), len(avg_acces_2)))

# 画出训练过程中Loss的变化曲线
plt.figure()
plt.title("train avg_acc", fontsize=24)
plt.xlabel("iter", fontsize=14)
plt.ylabel("accuracy", fontsize=14)
plt.plot(iters_1, avg_acces_1, color='r', label='avg_acc by cross_entropy')
plt.plot(iters_2, avg_acces_2, color='b', label='avg_acc by square_error_cost')
plt.legend(['avg_acc by cross_entropy', 'avg_acc by square_error_cost'], loc=1)
plt.grid()
plt.show()

4.作图比较：随着训练进行，模型在训练集和测试集上的Loss曲线

5.调节正则化权重，观察4的作图曲线的变化，并分析原因

# 加载相关库
# !gunzip mnist.json.gz
import random
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC
import numpy as np
import json
import matplotlib.pyplot as plt

# %matplotlib inline

# 保存目录
datafile = '/home/aistudio/work/mnist.json'
modelDir = '/home/aistudio/workwork/model'

# 定义数据集读取器
def load_data(mode='train'):
# 数据集读取
file = open(datafile, encoding='utf-8')
# 读取数据集中的训练集，验证集和测试集
train_set, val_set, eval_set = json.load(file)

# 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
IMG_ROWS = 28
IMG_COLS = 28
# 根据输入mode参数决定使用训练集，验证集还是测试
if mode == 'train':
imgs = train_set[0]
labels = train_set[1]
elif mode == 'valid':
imgs = val_set[0]
labels = val_set[1]
elif mode == 'eval':
imgs = eval_set[0]
labels = eval_set[1]
# 获得所有图像的数量
imgs_length = len(imgs)
# 验证图像数量和标签数量是否一致
assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})" \
.format(len(imgs), len(labels))

index_list = list(range(imgs_length))

# 读入数据时用到的batchsize
BATCHSIZE = 100

# 定义数据生成器
def data_generator():
# 训练模式下，打乱训练数据
if mode == 'train':
random.shuffle(index_list)
imgs_list = []
labels_list = []
# 按照索引读取数据
for i in index_list:
# 读取图像和标签，转换其尺寸和类型
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('int64')
imgs_list.append(img)
labels_list.append(label)
# 如果当前数据缓存达到了batch size，就返回一个批次数据
if len(imgs_list) == BATCHSIZE:
yield np.array(imgs_list), np.array(labels_list)
# 清空数据缓存列表
imgs_list = []
labels_list = []

# 如果剩余数据的数目小于BATCHSIZE，
# 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
if len(imgs_list) > 0:
yield np.array(imgs_list), np.array(labels_list)

return data_generator

# 定义模型结构
class MNIST(fluid.dygraph.Layer):
def __init__(self, name_scope):
super(MNIST, self).__init__(name_scope)
name_scope = self.full_name()
self.conv1 = Conv2D(name_scope, num_filters=20, filter_size=5, stride=1, padding=2)
self.pool1 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
self.conv2 = Conv2D(name_scope, num_filters=20, filter_size=5, stride=1, padding=2)
self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
self.fc = FC(name_scope, size=10, act='softmax')

# 加入对每一层输入和输出的尺寸和数据内容的打印，根据check参数决策是否打印每层的参数和输出尺寸
def forward(self, inputs, label=None, check_shape=False, check_content=False):
# 给不同层的输出不同命名，方便调试
outputs1 = self.conv1(inputs)
outputs2 = self.pool1(outputs1)
outputs3 = self.conv2(outputs2)
outputs4 = self.pool2(outputs3)
outputs5 = self.fc(outputs4)

# 如果label不是None，则计算分类精度并返回
if label is not None:
acc = fluid.layers.accuracy(input=outputs5, label=label)
return outputs5, acc
else:
return outputs5

def train(lr=0.01, regu=0.1):
train_loss, train_acc = [], []
model = MNIST("mnist")
model.train()
regular = fluid.regularizer.L2Decay(regularization_coeff=regu)
optimizer = fluid.optimizer.AdamOptimizer(learning_rate=lr, regularization=regular)
# 调用加载数据的函数
train_loader = load_data('train')
EPOCH_NUM = 20
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
# 1、训练
# 准备数据，变得更加简洁
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)
# 前向计算的过程，同时拿到模型输出值和分类准确率
predict, avg_acc = model(image, label)
# 计算损失，取一个批次样本损失的平均值
loss = fluid.layers.cross_entropy(predict, label)
avg_loss = fluid.layers.mean(loss)

if batch_id % 200 == 0:
print("epoch: {}, batch: {}, lr is: {}, regu is {}, loss is: {}, acc is {}"
.format(epoch_id, batch_id, lr, regu, avg_loss.numpy(), avg_acc.numpy()))
train_loss.append(avg_loss.numpy())
train_acc.append(avg_acc.numpy())

# 后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()

# 保存模型参数
fluid.save_dygraph(model.state_dict(), modelDir)
# 2、验证
print('start evaluation .......')
model.eval()
eval_loader = load_data('eval')
acc_set = []
avg_loss_set = []
for batch_id, data in enumerate(eval_loader()):
x_data, y_data = data
img = fluid.dygraph.to_variable(x_data)
label = fluid.dygraph.to_variable(y_data)
prediction, acc = model(img, label)
loss = fluid.layers.cross_entropy(input=prediction, label=label)
avg_loss = fluid.layers.mean(loss)
acc_set.append(float(acc.numpy()))
avg_loss_set.append(float(avg_loss.numpy()))

# 计算多个batch的平均损失和准确率
eval_loss = np.array(acc_set).mean()
eval_acc = np.array(avg_loss_set).mean()
return train_loss, train_acc, eval_loss, eval_acc

def plot(train_loss, train_acc, lr=0.01, regu=0.1):
# 画出训练过程中Loss的变化曲线
plt.figure()
plt.title('lr_{}_regu_{}_loss_and_acc'.format(lr, regu), fontsize=24)
plt.xlabel("x", fontsize=14)
plt.ylabel("y", fontsize=14)
iters = [100 * i for i in range(len(train_loss))]
plt.plot(iters, train_loss, color='b', label='train_loss')
plt.plot(iters, train_acc, color='g', label='train_acc')
plt.legend(['train_loss', 'train_acc'], loc=1)
plt.grid()
plt.show()

if __name__ == '__main__':
# 在使用GPU机器时，可以将use_gpu变量设置成True
use_gpu = True
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()

# 网络结构部分之后的代码，保持不变
with fluid.dygraph.guard():
values = []
for r in [0.01, 0.05, 0.1, 0.5, 1, 5]:
for lr in [0.1, 0.05, 0.01, 0.005, 0.001]:
train_loss, train_acc, eval_loss, eval_acc = train(lr=lr, regu=r)
plot(train_loss, train_acc, lr=lr, regu=r)
values.append([lr, r, eval_loss, eval_acc])

for l in values:
print('lr= {}, regu = {}, eval_loss = {}, eval_acc = {}'.format(l[0], l[1], l[2], l[3]))

在学习率和正则化系数迭代绘图中regu in [0.01, 0.05, 0.1, 0.5, 1, 5]，
lr in [0.1, 0.05, 0.01, 0.005, 0.001]，发现当学习率取0.05, 0.01，正则

化参数为0.5时训练损失函数和正确率比较稳定，正则化参数过大约束比较严格，

容易欠拟合，如果正则化参数过小约束比较宽松，训练过程不够稳定。

作业7-1：

乘法 867041280 加法 867041280

12月17日作业

统计随机生成矩阵中有多少个元素大于0

p = np.random.randn(10, 10)
#print(p)
q=(p>0)
#print(q)
sumq=np.sum(q)
#print(sumq)
#print(p.size)
print(p.size-np.sum(q))

使用numpy计算tanh激活函数

# ReLU和Sigmoid激活函数示意图
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.patches as patches

#设置图片大小
plt.figure(figsize=(8, 3))

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
x = np.arange(-10, 10, 0.1)
# 计算 tanh函数
s = (np.exp(x)- np.exp(- x))/(np.exp(x)+ np.exp(- x))

#########################################################
# 以下部分为画图程序

# 设置两个子图窗口，将Sigmoid的函数图像画在左边
f = plt.subplot(121)
# 画出函数曲线
plt.plot(x, s, color='r')

# 添加文字说明
plt.text(-5., 0.9, r'$y=\tanh(x)$', fontsize=13)
# 设置坐标轴格式
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

作业7-1：
乘法：3*3*3*224*10*64 = 3870720
加法：3*3*3*224*10*64 + 64*10 + 64*10 = 3872000
作业7-2：

作业4-2:

通过使用Python和深度学习框架，这些不同方法写房价预测，Python编写的模型 和 基于飞桨编写的模型在程序结构方面大致是相同的，但是在开发效率和易用性上，飞桨更好些。训练耗时方面，因为飞桨底层是C++的，要比python解释性的要快

  作业7-1：

乘法：867041280
加法：876675072

作业5：

5-1

import matplotlib.pyplot as plt

def get_data(mode='train'):
     # 读取数据文件
    datafile = './work/mnist.json.gz'
    print('loading mnist dataset from {} ......'.format(datafile))
    data = json.load(gzip.open(datafile))
    # 读取数据集中的训练集，验证集和测试集
    train_set, val_set, eval_set = data
    
    if mode == 'eval':
        imgs, labels = val_set[0], val_set[1]
    elif mode == 'test':
        imgs, labels = eval_set[0], eval_set[1]
    elif mode == 'train':
        imgs, labels = train_set[0], train_set[1]
    return imgs, labels
       

def get_100_data(mode='eval'):
    imgs, labels = get_data(mode)
    IMG_ROWS = 28
    IMG_COLS = 28
    
    imgs_length = len(imgs)
    index_list = list(range(imgs_length))
    random.shuffle(index_list)

    imgs_list = []
    labels_list = []
    # 按照索引读取数据
    for i in index_list:
        # 读取图像和标签，转换其尺寸和类型
        img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
        label = np.reshape(labels[i], [1]).astype('int64')
        imgs_list.append(img) 
        labels_list.append(label)
        
        if len(imgs_list) == 100:
            return np.array(imgs_list), np.array(labels_list)
            
def get_class(prediction):
    prediction = prediction.numpy()
    return prediction.argmax(axis=1)
        
def show_result(image, label, predict):
    # print(image.shape[0], image.shape)
    pre = get_class(prediction)
    
    fig=plt.figure(figsize=(15,15)) 
    for i in  range(0,100):
        fig.add_subplot(10, 10 , i+1)
        one = image[i].numpy()
        # temp = one.reshape([28,28])
        plt.imshow(one.reshape([28,28]))
        # 错误的图片标题用红色字体显示
        if label[i].numpy()[0] != pre[i]:
            color = 'r'
        else:
            color = 'b'
        plt.title('L:'+str(label[i].numpy()[0])+'  P:'+str(pre[i]),size=15, color=color)
        plt.axis('off')
        plt.tight_layout()
    plt.show()
    
    
with fluid.dygraph.guard():
    print('start evaluation .......')
    #加载模型参数
    model = MNIST("mnist")
    model_state_dict, _ = fluid.load_dygraph('mnist')
    model.load_dict(model_state_dict)
    model.eval()
    
    eval_images_data, eval_labels_data = get_100_data() 
    print('Getting random 100 images is OK......')
    
    img = fluid.dygraph.to_variable(eval_images_data)
    label = fluid.dygraph.to_variable(eval_labels_data)
    # print(img.shape, label.shape)
    prediction, acc = model(img, label)
    loss = fluid.layers.cross_entropy(input=prediction, label=label)
    avg_loss = fluid.layers.mean(loss)
    
    print('Result: loss={}, acc={}'.format(avg_loss.numpy()[0], acc.numpy()[0]))
    show_result(img, label, prediction)

5-2：

常见的卷积神经网络有：LeNet，AlexNet，VggNet，ResNet

5-3：

（1）如下图，在学习率为0.01时，Adam最优

（2 ）如下图，对于SGD算法，lr =0.2左右的最合适

作业6-1：
1.将普通神经网络模型的每层输出打印，观察内容
print("conv1_shape: {}".format(x.shape))
该条输出内容超过1000行，保存时将被截断
cconv1_shape: [1000, 20, 28, 28]
pool1_shape: [1000, 20, 14, 14]
conv2_shape: [1000, 20, 14, 14]
pool2_shape: [1000, 20, 7, 7]
conv3_shape: [1000, 20, 7, 7]
pool3_shape: [1000, 20, 3, 3]
outputs_shape: [1000, 10]
2.将分类准确率的指标 用PLT库画图表示
print('【update1】查看训练集与测试集loss、accuracy')
lossArr = np.load('./loss_acc_test/lossArr_300_L2_bn.npy')[EPOCH_NUM * scale:]
accArr = np.load('./loss_acc_test/accArr_300_L2_bn.npy')[EPOCH_NUM * scale:]
lossTestArr = np.load('./loss_acc_test/lossTestArr_300_L2_bn.npy')[EPOCH_NUM * scale:]
accTestArr = np.load('./loss_acc_test/accTestArr_300_L2_bn.npy')[EPOCH_NUM * scale:]

plt.figure(figsize=(12,8),dpi=80)
plt.plot(range(len(lossArr)), lossArr, label='trainLoss')
plt.plot(range(len(lossTestArr)), lossTestArr, label='testLoss')
plt.legend(loc="upper left")
plt.show()

plt.figure(figsize=(12,8),dpi=80)
plt.plot(range(len(accArr)), accArr, label='trainAccuracy')
plt.plot(range(len(accTestArr)), accTestArr, label='testAccuracy')
plt.legend(loc="upper left")
plt.show()
3.通过分类准确率，判断以采用不同损失函数训练模型的效果优劣

分类问题确实交叉商损失函数效果好于均方差损失函数。

4.作图比较：随着训练进行，模型在训练集和测试集上的Loss曲线

5.调节正则化权重，观察4的作图曲线的变化，并分析原因
正则化权重太大会过于限制w权值的范围，以致使模型拟合能力不足，导致欠拟合。

作业7-1：
乘法：224*224*3*10*64*9=867041280
乘法：224*224*3*10*64*8+224*224*3*10*64=867041280

作业7-2：