作业7-1 计算卷积中一共有多少次乘法和加法操作

原图有3通道 所以生成一个通道的卷积一次需要，27次乘法，27次加法

加法总数 27*224*224*64*10 = 867041280

乘法总数 27*224*224*64*10 = 867041280

作业6－1（4）：

6-1(3)

cross_entropy

softmax_with_cross_entropy

7-2 

6-1(5)

0.01

0.1

作业7-1：乘法次数867041280   加法次数610140160

输入数据形状是[10, 3, 224, 224]，卷积核kh = kw = 3，输出通道数为64，步幅stride=1，填充ph = pw =1

完成这样一个卷积，一共需要做多少次乘法和加法操作？

提示：先看输出一个像素点需要做多少次乘法和加法操作，然后再计算总共需要的操作次数

先从单次卷积乘法和加法的次数   kernel=3  batch=10，deepth=3 ， w_h=224， out_channel=64, stride=1, ph=pw=1

单次卷积 3*3*3=27次  乘法    2*3*3+1(偏置)=19次加法

需要进行的卷积次数为 10×（224+2-2）×（224-2+2）×64次

所以总乘法次数  27*10*224*224*64=867041280

总加法次数  19*10*224*224*64=610140160

作业7-2：

作业6-1：

1.将普通神经网络模型的每层输出打印，观察内容

网络：

结果：

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

下图使用SGDOptimizer优化器与cross_entropy损失函数生成

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

下图为使用SGDOptimizer优化器的两种损失函数曲线

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

下图使用AdamOptimizer优化器与cross_entropy损失函数生成

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

4出现了过拟合现象，即在训练集上的损失小，在校验集或测试集上的损失较大。

通过添加正则化项来降低模型的复杂度，使模型在“尽量减少训练损失”和“保持模型的泛化能力”之间取得平衡。

作业7-1  计算卷积中一共有多少次乘法和加法操作

输入数据形状是[10, 3, 224, 224]，卷积核kh = kw = 3，输出通道数为64，步幅stride=1，填充ph = pw =1

完成这样一个卷积，一共需要做多少次乘法和加法操作？

卷积后图片的尺寸（rgb共3个通道）为：（224+1×2-3+1）×（224+1×2-3+1）×3 = 150528
每个卷积点需要做乘法：3×3 = 9
每个卷积点需要做加法（加上bias）：3×3-1+1 = 9
输入卷积核参数为10个，输出卷积核参数为64个，需要做：
乘法：150528×9×10×64 = 867041280次
加法：150528×9×10×64 = 867041280次

作业7-2
名称        w形状        w参数个数          b形状         b参数个数        输出形状
conv1     [6,3,5,5]     450                     [6]            6                      [10,6,224,224]
pool1     无              无                        无             无                     [10,6,112,112] 
conv2    [16,6,5,5]   2400                    [16]           16                   [10,16,112,112]
pool2    无               无                        无             无                     [10,16,56,56]
fc1        [50176,64]  3211264             [64]          64                     [10, 64]
fc2        [64,1]          64                       [1]            1                       [10,1]

作业5-1：

# 用测试集计算当前面模型准确率
with fluid.dygraph.guard():
    model = MNIST("mnist")
    params_file_path = 'mnist'
    model_dict, _ = fluid.load_dygraph(params_file_path)
    model.load_dict(model_dict)
    
    model.eval()
    test_loader = paddle.batch(paddle.dataset.mnist.test(), batch_size=16)
    batches = 0
    acc_sum = 0
    for batch_id, data in enumerate(test_loader()):
        image_data = np.array([x[0] for x in data]).astype('float32')
        label_data = np.array([x[1] for x in data]).astype('int64').reshape(-1, 1)
        image = fluid.dygraph.to_variable(image_data)
        label = fluid.dygraph.to_variable(label_data)
        
        predict = model(image)
        predict.numpy().astype('int64')

        acc = fluid.layers.accuracy(input=predict, label=label)
        acc_sum += acc
        batches += 1
    print("acc on test set is", acc_sum.numpy()/batches)

acc on test set is [0.098]

作业5-2：

AlexNet, EfficientNet

作业5-3：

Adam最好，learning rate 0.001效果最好。Adam完之后再来个SGD，有时候效果更佳。

作业6-1：

1.通过运行2-8代码，可以打印神经网络的参数尺寸、输出特征形状以及网络参数。

2.通过将2-8代码进行修改，画出训练过程中分类准确率的变化。

3.以下是使用交叉熵为损失函数所得到的分类准确率：

以下是使用噪音对比估计损失值nce所得的分类准确率：

4.下图是训练集：

下图是测试集：

5.正则化权重为0.01，保持其他超参数不变：

正则化权重为0.04，保持其他超参数不变：

正则化权重为0.07，保持其他超参数不变：

正则化权重为0.1，保持其他超参数不变：

作业7-1  计算卷积中一共有多少次乘法和加法操作

输入数据形状是[10, 3, 224, 224]，卷积核kh = kw = 3，输出通道数为64，步幅stride=1，填充ph = pw =1

完成这样一个卷积，一共需要做多少次乘法和加法操作？

输入数据形状[10,3,224,224],输出数据的为64个通道,
每个通道大小为 (224 + 2*1 - 3)/1 + 1 = 224,所以输出数据形状为[10,64,224,224];
所有输出的数据点数量为 224*224*64*10 = 32112640,对于每个通道中的每个神经元,
需要做乘法 (3*3) * 3 = 27 次,需要做加法 (3*3 -1)*3 + (3-1) + 1 = 27 次,
因此总共需要乘法 32112640 * 27 = 867041280 次,总共需要加法 867041280 次

作业 7-2：计算网络各层参数和输出形状

输入形状为[10,3,224]

作业7-1：

乘法867041280，加法867041280

作业7-2：

作业5-1：

计算得出的准确率为0.97

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_loader = load_data('eval')

    acc_set = []
    avg_loss_set = []
    for batch_id, data in enumerate(eval_loader()):
        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为100张，只用一个batch即可
        break;
    
    #计算多个batch的平均损失和准确率
    acc_val_mean = np.array(acc_set).mean()
    avg_loss_val_mean = np.array(avg_loss_set).mean()

    print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))

5-2

常见的卷积神经网络有，Letnet-5，AlexNet、ZFNet、VGGNet、GoogleNet，Resnet，FCN等

作业5-3：

Adam算法效果最好，学习率取0.01效果最好

作业5：

(1)

test_loader = paddle.batch(paddle.dataset.mnist.test(), batch_size=100)
with fluid.dygraph.guard():
    model = MNIST("mnist")
    # 加载模型参数
    model_dict, _ = fluid.load_dygraph("mnist")
    model.load_dict(model_dict)
    model.eval()
    for batch_id, data in enumerate(test_loader()):
        image_data = np.array([x[0] for x in data]).astype('float32')
        label_data = np.array([x[1] for x in data]).astype('float32').reshape(-1, 1)
        # 将数据转为飞桨动态图格式
        image = fluid.dygraph.to_variable(image_data)
        label = fluid.dygraph.to_variable(label_data)
        
        
        #前向计算的过程
        predict = model(image)
    # print(label.numpy().astype('int32'))
    # print(predict.numpy().astype('int32'))
    
    diff = predict.numpy().astype('int32') - label.numpy().astype('int32')
    true_result = np.sum((diff==0))
    print(true_result/diff.shape[0])

（2）常见卷积神经网络：LeNet、Alexnet、VGGNet、ResNet、Google Inception系列

 (3)

import matplotlib.pyplot as plt
%matplotlib inline
def getOptimizer(optimizer, learing_rate):
    if optimizer == 'SGD':
        optimizer = fluid.optimizer.SGDOptimizer(learing_rate)
    elif optimizer == 'Momentum':
        optimizer = fluid.optimizer.MomentumOptimizer(learing_rate, momentum=0.9)
    elif optimizer == 'Adagrad':
        optimizer = fluid.optimizer.AdagradOptimizer(learing_rate)
    else:
        optimizer = fluid.optimizer.AdamOptimizer(learing_rate)
    
    return optimizer

#仅优化算法的设置有所差别
with fluid.dygraph.guard():
    #四种优化算法的设置方案，可以逐一尝试效果
    # optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01)
    #optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.01)
    #optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.01)
    #optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01)
    
    optimizerList = ['SGD','Momentum','Adagrad','Adam']
    learingRateList = [0.1,0.01,0.001]
    
    for i,optimizerStr in enumerate(optimizerList):
        title = optimizerStr
        plt.subplot(2, 2, i+1)
        for learingRate in learingRateList:
            optimizer = getOptimizer(optimizerStr, learingRate)
            
            model = MNIST("mnist")
            model.train()
            #调用加载数据的函数
            train_loader = load_data('train')
            
            losses = []
            EPOCH_NUM = 2
            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)
                    label = fluid.dygraph.to_variable(label_data)
                    
                    #前向计算的过程
                    predict = model(image)
                    
                    #计算损失，取一个批次样本损失的平均值
                    loss = fluid.layers.cross_entropy(predict, label)
                    avg_loss = fluid.layers.mean(loss)
                    losses.append(avg_loss.numpy())
                    
                    #每训练了100批次的数据，打印下当前Loss的情况
                    if batch_id % 200 == 0:
                        print("{}_{}, epoch: {}, batch: {}, loss is: {}".format(optimizerStr, str(learingRate), epoch_id, batch_id, avg_loss.numpy()))
                    
                    #后向传播，更新参数的过程
                    avg_loss.backward()
                    optimizer.minimize(avg_loss)
                    model.clear_gradients()
        
            plot_x = np.arange(len(losses))
            plot_y = np.array(losses)
            plt.plot(plot_x, plot_y, label=str(learingRate))
            plt.title(title)
            plt.xlabel('iteration')
            plt.ylabel('loss')
            plt.legend(loc='best')
    plt.show()       

########## print network layer's superparams ##############
conv1-- kernel_size:[20, 1, 5, 5], padding:[2, 2], stride:[1, 1]
conv2-- kernel_size:[20, 20, 5, 5], padding:[2, 2], stride:[1, 1]
pool1-- pool_type:max, pool_size:[2, 2], pool_stride:[2, 2]
pool2-- pool_type:max, poo2_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]
outputs1_shape: [100, 20, 28, 28]
outputs2_shape: [100, 20, 14, 14]
outputs3_shape: [100, 20, 14, 14]
outputs4_shape: [100, 20, 7, 7]
outputs5_shape: [100, 10]

2

作业7-1：乘法 867041280，加法（有bias）867041280，加法（无bias）834928640

简单总结一下：批次大小B，输入通道Cin，输入高度H，输入宽度W，卷积核高kh，卷积核宽kw，输出通道Cout，步长stride，填充高度ph，填充宽度pw

乘法数量为：kh * kw * Cin * [(H + 2 * ph - kh + 1) / stride] * [(W + 2 * pw - kw + 1) / stride] * Cout * B

加法数量为（有bias）：[(kh * kw - 1) * Cin + (Cin - 1) + 1] * [(H + 2 * ph - kh + 1) / stride] * [(W + 2 * pw - kw + 1) / stride] * Cout * B 化简下来，会发现和乘法的计算数量是一致的。

加法数量为（无bias）：[(kh * kw - 1) * Cin + (Cin - 1) ] * [(H + 2 * ph - kh + 1) / stride] * [(W + 2 * pw - kw + 1) / stride] * Cout * B ，其实就是在单个窗口的时候少加了一个偏置项，化简下来

(kh * kw * Cin - 1) * [(H + 2 * ph - kh + 1) / stride] * [(W + 2 * pw - kw + 1) / stride] * Cout * B