作业帖 | 百度深度学习集训营

项目

数据集

课程

比赛

模型库

活动

论坛

访问飞桨官网

项目

数据集

课程

比赛

模型库

活动

论坛

访问飞桨官网

DJ星尘发布于2019-12

百度深度学习集训营已经正式开营，每个阶段的作业都将有各自的奖励，欢迎大家学习~

PS：如遇帖子过期、审核不通过的情况，请先复制内容保存在word文档，然后根据提示，完成个人实名验证，刷新后重新粘贴复制的内容，即可提交~

欢迎大家报名参加~

1月9日作业：

作业9-1：在第二章中学习过如何设置学习率衰减，这里建议使用分段衰减的方式，衰减系数为0.1，根据ResNet目前的训练情况，应该在训练到多少步的时候设置衰减合适？请设置好学习率衰减方式，在眼疾识别数据集iChallenge-PM上重新训练ResNet模型。

作业9-1奖励：在作业中随机各抽取5名同学送出飞桨本+数据线+飞桨贴纸

回复帖子形式：作业9-1：XXX

抽奖作业截止时间：2020年1月13日中午12点之前

作业9-2奖励：在作业中随机各抽取5名同学送出飞桨本+数据线+飞桨贴纸

回复帖子形式：作业9-2：XXX

抽奖作业截止时间：2020年1月13日中午12点之前

1月7日作业：

作业8：如果将LeNet模型中的中间层的激活函数Sigmoid换成ReLU，在眼底筛查数据集上将会得到什么样的结果？Loss是否能收敛，ReLU和Sigmoid之间的区别是引起结果不同的原因吗？请发表你的观点

作业8奖励：在作业中随机各抽取5名同学送出飞桨本+数据线+飞桨贴纸

回复帖子形式：作业8：XXX

获奖同学：#820 thunder95、#819 你还说不想我吗、 #818 百度用户#0762194095、#817 呵赫 he、#816 星光1dl

1月2日作业

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

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

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

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

提交方式：请回复乘法和加法操作的次数，例如：乘法1000，加法1000

作业7-1奖励：抽取5人赢得飞桨定制本+数据线，截止时间2020年1月6日中午12点之前

回复帖子形式：作业7-1：XXX

作业7-2奖励：从正确答案中抽取5人获得飞桨定制本+50元京东卡，截止时间2020年1月6日中午12点之前

12月31日作业

作业6-1：

1.将普通神经网络模型的每层输出打印，观察内容
2.将分类准确率的指标用PLT库画图表示
3.通过分类准确率，判断以采用不同损失函数训练模型的效果优劣
4.作图比较：随着训练进行，模型在训练集和测试集上的Loss曲线
5.调节正则化权重，观察4的作图曲线的变化，并分析原因
作业6-1奖励：抽取5人赢得飞桨定制本+数据线，回复帖子形式：作业6-1：XXX

作业6-2：

正确运行AI Studio《百度架构师手把手教深度学习》课程里面的作业3 的极简版代码，分析训练过程中可能出现的问题或值得优化的地方，通过以下几点优化：

（1）样本：数据增强的方法

（2）假设：改进网络模型

（2）损失：尝试各种Loss

（2）优化：尝试各种优化器和学习率

目标：尽可能使模型在mnist测试集上的分类准确率最高

提交实现最高分类准确率的代码和模型，我们筛选最优结果前10名进行评奖

作业6-2奖励：飞桨定制本+50元京东卡

12月25日作业

12月23日作业

作业4-1：在AI studio上运行作业2，用深度学习完成房价预测模型

作业4-1奖励：飞桨定制本+ 《深度学习导论与应用实践》教材，选取第2、3、23、123、223、323…名同学送出奖品

作业4-2：回复下面问题，将答案回复帖子下方：

通过Python、深度学习框架，不同方法写房价预测，Python编写的模型和基于飞桨编写的模型在哪些方面存在异同？例如程序结构，编写难易度，模型的预测效果，训练的耗时等等？

回复帖子形式：作业4-2:XXX

作业4-2奖励：在12月27日（本周五）中午12点前提交的作业中，我们选出最优前五名，送出百度定制数据线+《深度学习导论与应用实践》教材

12月17日作业

完成下面两个问题，并将答案回复在帖子下面，回帖形式：作业3-1（1）XX（2）XX

作业奖励：在2019年12月20日中午12点之前提交，随机抽取5名同学进行点评，礼品是本+数据线

12月12日作业

获奖者：第12名：飞天雄者

12月10日作业
作业1-1：在AI Studio平台上https://aistudio.baidu.com/aistudio/education/group/info/888 跑通房价预测案例

作业1-1奖励：最先完成作业的前3名，以及第6名、66名、166名、266名、366名、466名、566名、666名的同学均可获得飞桨定制大礼包：飞桨帽子、飞桨数据线、飞桨定制logo笔

作业1-1的获奖者如图：

作业1-2：完成下面两个问题，并将答案发布在帖子下面
①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？
②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？
作业1-2奖励：回复帖子且点赞top5，获得《深度学习导论与应用实践》教材+飞桨定制本

点赞Top5获奖者：1.飞天雄者 2.God_s_apple 3.177*******62 4.学痞龙 5.故乡237、qq526557820

作业截止时间2020年1月10日，再此之前完成，才有资格参加最终Mac大奖评选

报名流程：

1.加入QQ群：726887660，班主任会在QQ群里进行学习资料、答疑、奖品等活动

2.点此链接，加入课程报名并实践：https://aistudio.baidu.com/aistudio/course/introduce/888

温馨提示：课程的录播会在3个工作日内上传到AI studio《百度架构师手把手教深度学习》课程上

全部评论(953)

smile_a_ba

#702 回复于2020-01

作业7-1:

乘法3x3x3x10x64x224x224=867041280次，加法[(3x3-1)x3+(3-1)+1]x10x64x224x224=867041280次

smile_a_ba

#703 回复于2020-01

作业7-2：

i1083love

#704 回复于2020-01

作业4-2：python编写的模型需要考虑如何处理数据，网络模型的建立和需要使用哪种优化算法，之后需要模型训练和模型的保存等过程。整个流程中，需要自己编写每一个内容的代码，对于不是很熟悉代码的人来说比较困难，并且自己写的代码中会出现较多的错误，并且修改起来难度较大，即使能够把代码运行，训练结果不一定是理想的；相比较而言，飞浆框架更加简单，使用更加方便，因为飞浆框架已经把相应的函数，网络模型编写完成，我们只需要注意模型的结构设计和网络的配置就可以，不用再考虑一些底层的实现，只需要调用即可，使入门更加简单，并且效率和结果更加好一些。

foretribe

#705 回复于2020-01

作业1-1

已经跑过aistudio了：

作业1-2：完成下面两个问题，并将答案发布在帖子下面
①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？

股票预测明日指数的学习就是一个有监督学习：

假设： price=f(x)

模型可能是： f(x)=a1*x1+a2*x2+....an*xn+b

参数是：（a1, a2....an, b）

评价指标，拟合第二天的price

优化：找出最好的参数拟合第二天的指数
②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

因为deep learnin这几年才发展起来，能在各行各业应用，企业需求大，但是理论爆发时间比较短。人才较少。所以现在还是短缺的。但是伴随着人数的增加，以及应用的受限也会有平静的。

cheeryoung79

#706 回复于2020-01

作业6－1：
conv2: [100, 20, 14, 14]
pool2: [100, 20, 7, 7]
pool1: [100, 10]
conv1: [100, 20, 28, 28]
pool1: [100, 20, 14, 14]
conv2: [100, 20, 14, 14]
pool2: [100, 20, 7, 7]
pool1: [100, 10]
conv1: [100, 20, 28, 28]
pool1: [100, 20, 14, 14]
conv2: [100, 20, 14, 14]
pool2: [100, 20, 7, 7]
pool1: [100, 10]
conv1: [100, 20, 28, 28]
pool1: [100, 20, 14, 14]
conv2: [100, 20, 14, 14]
pool2: [100, 20, 7, 7]
pool1: [100, 10]
conv1: [100, 20, 28, 28]
pool1: [100, 20, 14, 14]
conv2: [100, 20, 14, 14]
pool2: [100, 20, 7, 7]
pool1: [100, 10]
conv1: [100, 20, 28, 28]
pool1: [100, 20, 14, 14]
conv2: [100, 20, 14, 14]

conv1: name tmp_3, dtype: VarType.FP32 shape: [20, 28, 28] lod: {}
dim: 20, 28, 28
layout: NCHW
dtype: float
data: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.120295 0.0941693 0.000903809 0.0347722 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0249382 0.0633655 0 0.254581 0.213028 0.489775 0.427606 0.335145 0.176135 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0640216 0.193383 0.211131 0.283889 0.618642 0.598464 0.173985 0.00164694 0.266728 0.539463 0.099654 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0354239 0.0405537 0.314686 0.345185 0.205278 0.204435 0 0 0 0.131115 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.00912852 0 0 0.258873 0 0 0 0 0 0 0 0 0 0 0 0.108418 0.175356 0.566467 0.580711 0.337751 0.256263 0 0 0 0 0 0 0 0 0 0 0.0883363 0 0 0 0 0.27339 0.0999921 0.276625 0.432139 0.465549 0 0.0757958 0.799293 0.715822 0.854278 0.580682 0.380209 0.146538 0 0 0 0 0 0 0 0 0 0 0.119237 0.228755 0.0298381 0.359391 0.646999 0.361627 0.0148198 0.173325 0.86572 1.20233 0.402903 0.122236 0.316703 0.249407 0.241039 0.100655 0.0892967 0 0 0 0 0 0 0 0 0 0 0 0.152886 0.101925 0.374047 0.435827 1.22663 0.802572 0.323776 0.46776 0.786183 0.814579 0.538734 0.468735 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0926291 0.051329 0 0.520052 0.635396 0.752438 0 0.226808 0.26342 0.324598 0.0186499 0.352881 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.524664 0.461957 0 0 0.279047 0.26898 0.172026 0.0206961 0.00684493 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.325181 0.902412 0.402015 0 0 0 0.148196 0.170589 0.0581071 0.00739252 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0693386 0.375946 0.70651 0.298389 0 0 0 0.157675 0.0943604 0.0849208 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0974682 0.158744 0.717389 0.390013 0.0318813 0 0 0 0.197394 0.017523 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.744794 0.971963 0.732392 0.221936 0 0 0.0804783 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.142282 1.16531 1.4453 0.611549 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0674758 0.0682864 0.243956 0.501137 0.76584 0.651911 0.00540312 0.0460677 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.0318526 0.255659 0.35552 0.00143518 0 0.0819287 0.145186 0.600751 0 0 0.145459 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.00895977 0.150418 0.349933 0.0885917 0 0 0 0.00411179 0.0955088 0.35

cheeryoung79

#707 回复于2020-01

作业6－1（2）

C孤独K患者

#708 回复于2020-01

作业7-1：

乘法：3*3*3*224*224*10*64=867041280

加法：（（3*3-1+1）+（3-1））*224*224*10*64 =931266560

月下蓝雨

#709 回复于2020-01

作业6-1：

# 定义模型结构
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, act="relu")
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, act="relu")
self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')
self.fc = FC(name_scope, size=10, act='softmax')

# 加入分类准确率的评估指标
def forward(self, inputs, label=None,check_shape=False,check_content=False):
output1 = self.conv1(inputs)
output2 = self.pool1(output1)
output3 = self.conv2(output2)
output4 = self.pool2(output3)
output5 = self.fc(output4)

if check_shape:
print("#######################")
print("input_shape:{}".format(inputs.shape))
print("output1_shape:{}".format(output1.shape))
print("output2_shape:{}".format(output2.shape))
print("output3_shape:{}".format(output3.shape))
print("output4_shape:{}".format(output4.shape))
print("output5_shape:{}".format(output5.shape))
if check_content:
print("output5:{}".format(output5))
if label is not None:
acc = fluid.layers.accuracy(input=output5, label=label)
return output5, acc
else:
return output5

with fluid.dygraph.guard():
model = MNIST('mnist')
model_state_dict,_ = fluid.load_dygraph('mnist')
model.load_dict(model_state_dict)
model.eval()

eval_loader = load_data('eval')
for _,data in enumerate(eval_loader()):
image_data,label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)

predict = model(image,label=None,check_shape=True,check_content=True)
break
每层输出打印的结果

input_shape:[100, 1, 28, 28]
output1_shape:[100, 20, 28, 28]
output2_shape:[100, 20, 14, 14]
output3_shape:[100, 20, 14, 14]
output4_shape:[100, 20, 7, 7]
output5_shape:[100, 10]

output5_shape为二维，但是data显示的是一维，经过咨询，老师解释说是可以理解为paddle对数据的内部存储方式

with fluid.dygraph.guard():
model = MNIST('mnist')
model.train()
EPOCH_NUM = 10
BATCH_SIZE = 100
train_loader = load_data('train')
dataloader = fluid.io.DataLoader.from_generator(capacity=5,return_list=True)
dataloader.set_batch_generator(train_loader,places=place)
total_steps = int(60000//BATCH_SIZE)*EPOCH_NUM
lr = fluid.dygraph.PolynomialDecay(0.01,total_steps,0.001)
optimizer = fluid.optimizer.SGD(learning_rate=lr,regularization=fluid.regularizer.L2Decay(regularization_coeff=0.1))

iter = 0
iters = []
acces = []
for epoch in range(EPOCH_NUM):
for batch_id,data in enumerate(dataloader()):
img_data,label_data = data
image = fluid.dygraph.to_variable(img_data)
label = fluid.dygraph.to_variable(label_data)

# 前向计算的过程，同时拿到模型输出值和分类准确率
predict, acc = model(image, label)
avg_acc = fluid.layers.mean(acc)

# 计算损失，取一个批次样本损失的平均值
loss = fluid.layers.cross_entropy(predict,label)
avg_loss = fluid.layers.mean(loss)

if batch_id % 100 == 0:
print("epoch: {},batch: {},loss: {},acc {}".format(epoch,batch_id,avg_loss,avg_acc))
iters.append(iter)
acces.append(avg_acc.numpy())
iter = iter + 100

avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()

fluid.save_dygraph(model.state_dict(),'mnist')
plt.figure()
plt.title("train loss",fontsize=24)
plt.xlabel('iter',fontsize=14)
plt.ylabel("acc",fontsize=14)
plt.plot(iters,acces,color='red',label='train acc')
plt.grid()# 生成网格
plt.show()

用三种损失函数作比较

平方误差损失（squared error loss）:这个没有搞出来

交叉熵（cross entropy），参考【2】

softmax_with_cross_entropy。根据需要修改网络最后一层的激活函数。

红色为训练的loss，epoch_num训练结束之后，上图是直接load_data切换成eval模式得到的结果

可能第四个问题没搞明白，

5，改变正则化系数

上图为正则化系数0.5时的损失，正则化系数越高精度越低损失越大

C孤独K患者

#710 回复于2020-01

作业7-2：

小

小公主mini516

#711 回复于2020-01

作业5-1：

因为2-8 3. 加入校验或测试，更好评价模型效果的代码里，一个batch是随机抽取100个，因此直接用这段代码即可

loss=0.2591372962296009, acc=0.9247000014781952

寂寞你快进去

#712 回复于2020-01

作业4-2:通过Python、深度学习框架，不同方法写房价预测，Python编写的模型和基于飞桨编写的模型在哪些方面存在异同？例如程序结构，编写难易度，模型的预测效果，训练的耗时等等？

答：

同：编写的程序结构大致相同，实现的功能和效果也基本一致

异：python编写程序比较复杂，飞桨编写程序相对简单方便。python编写和训练的耗时较长，飞桨耗时较短。

xlwan11

#713 回复于2020-01

作业5-1：

作业5-2：

常见的卷积网络：

LeNet、Alexnet、GoogleNet、VGG、ResNext、ShuffleNet、MobileNet

作业5-3：

import matplotlib.pyplot as plt
%matplotlib inline
def train(optimizer,ls,name):
with fluid.dygraph.guard():
model = MNIST("mnist")
model.train()
train_loader = paddle.batch(paddle.dataset.mnist.train(), batch_size=32)
EPOCH_NUM = 1
iter = 0
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_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)

#计算损失，取一个批次样本损失的平均值
loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)

if batch_id%100 == 0:
ls.append((iter, avg_loss.numpy()))
iter += 100
# #每训练了1000批次的数据，打印下当前Loss的情况
# if batch_id !=0 and batch_id % 1000 == 0:
# print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))

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

# 保存模型
fluid.save_dygraph(model.state_dict(), name)
opts = ['SGD','Momentum','Adagrad','Adam']
lrs = [0.0001,0.001, 0.01, 0.1]
colors = ['red', 'blue', 'green', 'orange']
markers = ['+', 'x', 'o', 's']
all_losses = []
for opt in opts:
losses = []
for lr in lrs:
if opt == 'SGD':
optimizer = fluid.optimizer.SGDOptimizer(learning_rate = lr)
elif opt == 'Momentum':
optimizer = fluid.optimizer.MomentumOptimizer(learning_rate = lr, momentum = 0.1)
elif opt == 'Adagrad':
optimizer = fluid.optimizer.AdagradOptimizer(learning_rate = lr)
elif opt == 'Adam':
optimizer = fluid.optimizer.AdamOptimizer(learning_rate = lr)
loss = []
train(optimizer,loss,opt+'_'+str(lr))
losses.append(loss)
all_losses.append(losses)
for i,losses in enumerate(all_losses):
for j,lss in enumerate(losses):
xx = [ls[0] for ls in lss]
yy = [ls[1] for ls in lss]
plt.plot(xx, yy, color=colors[j], marker=markers[j])
legends = [opts[i]+"_"+str(lr) for lr in lrs]
plt.title(opts[i]+" Optimizer")
plt.legend(legends,loc=1)
plt.xlabel('iterations')
plt.ylabel('loss')
plt.show()

Adam优化算法效果比较好，学习率设置为0.001

fly

#714 回复于2020-01

作业6-1：

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

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

这里用的是MSE损失函数，和3题做对比。

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

可以看出交叉熵损失函数更适合标签离散的分类问题；

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

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

对比发现，正则化权重不可以过高，这样模型会欠拟合，要取适当的值。

fly

#715 回复于2020-01

7-1：

乘法：3*3*3*10*64*224*224 = 867041280

加法：（（3*3-1+1）* 3+2）*10*64*224*224 =931768320

7-2：

小

小公主mini516

#716 回复于2020-01

作业5-3

Adagrad学习率越小越好，0.001最好.其余三个0.01表现可以。在合适的学习率下，Momentum最好

利用2-8 的 5可视化分析，可以得到：

optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01)

epoch: 1, batch: 400, loss is: [0.20786642], acc is [0.94]
epoch: 2, batch: 0, loss is: [0.22625248], acc is [0.93]
epoch: 2, batch: 100, loss is: [0.21758236], acc is [0.94]
epoch: 2, batch: 200, loss is: [0.2814051], acc is [0.9]
epoch: 2, batch: 300, loss is: [0.2879953], acc is [0.94]
epoch: 2, batch: 400, loss is: [0.22267054], acc is [0.92]
epoch: 3, batch: 0, loss is: [0.1277017], acc is [0.97]
epoch: 3, batch: 100, loss is: [0.12908807], acc is [0.96]
epoch: 3, batch: 200, loss is: [0.10434591], acc is [0.99]
epoch: 3, batch: 300, loss is: [0.16983934], acc is [0.96]
epoch: 3, batch: 400, loss is: [0.1391889], acc is [0.94]
epoch: 4, batch: 0, loss is: [0.1534107], acc is [0.97]
epoch: 4, batch: 100, loss is: [0.17136821], acc is [0.94]
epoch: 4, batch: 200, loss is: [0.18960176], acc is [0.94]
epoch: 4, batch: 300, loss is: [0.11647968], acc is [0.94]
epoch: 4, batch: 400, loss is: [0.04429736], acc is [0.99]]

optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.01)

epoch: 0, batch: 0, loss is: [2.5652096], acc is [0.07]
epoch: 0, batch: 100, loss is: [0.08399723], acc is [0.97]
epoch: 0, batch: 200, loss is: [0.27223304], acc is [0.94]
epoch: 0, batch: 300, loss is: [0.3968815], acc is [0.95]
epoch: 0, batch: 400, loss is: [0.21741082], acc is [0.97]
epoch: 1, batch: 0, loss is: [0.3112899], acc is [0.95]
epoch: 1, batch: 100, loss is: [0.02206602], acc is [0.99]
epoch: 1, batch: 200, loss is: [0.06237905], acc is [0.98]
epoch: 1, batch: 300, loss is: [0.8858853], acc is [0.87]
epoch: 1, batch: 400, loss is: [0.06076068], acc is [0.98]
epoch: 2, batch: 0, loss is: [0.25891554], acc is [0.96]
epoch: 2, batch: 100, loss is: [1.0058957], acc is [0.92]
epoch: 2, batch: 200, loss is: [0.12687615], acc is [0.98]
epoch: 2, batch: 300, loss is: [0.21069747], acc is [0.95]
epoch: 2, batch: 400, loss is: [0.11462435], acc is [0.97]
epoch: 3, batch: 0, loss is: [0.2954991], acc is [0.93]
epoch: 3, batch: 100, loss is: [0.05351718], acc is [0.99]
epoch: 3, batch: 200, loss is: [0.3778988], acc is [0.95]
epoch: 3, batch: 300, loss is: [0.29180273], acc is [0.96]
epoch: 3, batch: 400, loss is: [0.7578727], acc is [0.95]
epoch: 4, batch: 0, loss is: [0.33984047], acc is [0.96]
epoch: 4, batch: 100, loss is: [0.3817606], acc is [0.98]
epoch: 4, batch: 200, loss is: [0.12537138], acc is [0.99]
epoch: 4, batch: 300, loss is: [2.8619752e-05], acc is [1.]
epoch: 4, batch: 400, loss is: [0.0761006], acc is [0.97]

optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.001)

epoch: 0, batch: 0, loss is: [3.1680908], acc is [0.09]
epoch: 0, batch: 100, loss is: [0.3963665], acc is [0.85]
epoch: 0, batch: 200, loss is: [0.2890004], acc is [0.94]
epoch: 0, batch: 300, loss is: [0.07627446], acc is [0.98]
epoch: 0, batch: 400, loss is: [0.26756757], acc is [0.93]
epoch: 1, batch: 0, loss is: [0.13806003], acc is [0.95]
epoch: 1, batch: 100, loss is: [0.08746967], acc is [0.98]
epoch: 1, batch: 200, loss is: [0.08016918], acc is [0.98]
epoch: 1, batch: 300, loss is: [0.23897219], acc is [0.94]
epoch: 1, batch: 400, loss is: [0.06473158], acc is [0.98]
epoch: 2, batch: 0, loss is: [0.06124211], acc is [0.99]
epoch: 2, batch: 100, loss is: [0.0828645], acc is [0.98]
epoch: 2, batch: 200, loss is: [0.03559828], acc is [0.98]
epoch: 2, batch: 300, loss is: [0.07306914], acc is [0.98]
epoch: 2, batch: 400, loss is: [0.03965713], acc is [0.99]
epoch: 3, batch: 0, loss is: [0.02671868], acc is [0.99]
epoch: 3, batch: 100, loss is: [0.02139901], acc is [1.]
epoch: 3, batch: 200, loss is: [0.0346868], acc is [0.98]
epoch: 3, batch: 300, loss is: [0.02665671], acc is [0.98]
epoch: 3, batch: 400, loss is: [0.00776238], acc is [1.]
epoch: 4, batch: 0, loss is: [0.03432809], acc is [0.99]
epoch: 4, batch: 100, loss is: [0.07302525], acc is [0.97]
epoch: 4, batch: 200, loss is: [0.02171521], acc is [0.99]
epoch: 4, batch: 300, loss is: [0.04548466], acc is [0.99]
epoch: 4, batch: 400, loss is: [0.06920998], acc is [0.98]

optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.05)

epoch: 0, batch: 0, loss is: [3.175653], acc is [0.03]
epoch: 0, batch: 100, loss is: [1.3524828], acc is [0.86]
epoch: 0, batch: 200, loss is: [1.5728978], acc is [0.84]
epoch: 0, batch: 300, loss is: [1.9164505], acc is [0.94]
epoch: 0, batch: 400, loss is: [1.046659], acc is [0.91]
epoch: 1, batch: 0, loss is: [0.9897412], acc is [0.96]
epoch: 1, batch: 100, loss is: [0.2467628], acc is [0.97]
epoch: 1, batch: 200, loss is: [1.2785058], acc is [0.95]
epoch: 1, batch: 300, loss is: [1.02796], acc is [0.95]
epoch: 1, batch: 400, loss is: [1.0520186], acc is [0.94]
epoch: 2, batch: 0, loss is: [2.4787643], acc is [0.93]
epoch: 2, batch: 100, loss is: [2.7129335], acc is [0.92]
epoch: 2, batch: 200, loss is: [1.9643632], acc is [0.95]
epoch: 2, batch: 300, loss is: [4.3932333], acc is [0.87]
epoch: 2, batch: 400, loss is: [5.3962336], acc is [0.86]
epoch: 3, batch: 0, loss is: [0.9003433], acc is [0.97]
epoch: 3, batch: 100, loss is: [2.7144027], acc is [0.9]
epoch: 3, batch: 200, loss is: [2.5751987], acc is [0.91]
epoch: 3, batch: 300, loss is: [2.449292], acc is [0.95]
epoch: 3, batch: 400, loss is: [2.1861162], acc is [0.89]
epoch: 4, batch: 0, loss is: [2.8878639], acc is [0.86]
epoch: 4, batch: 100, loss is: [5.7550855], acc is [0.9]
epoch: 4, batch: 200, loss is: [1.7968951], acc is [0.96]
epoch: 4, batch: 300, loss is: [1.7705508], acc is [0.96]
epoch: 4, batch: 400, loss is: [3.710977], acc is [0.92]

AdamOptimizer(learning_rate=0.01)

epoch: 0, batch: 0, loss is: [2.7228658], acc is [0.14]
epoch: 0, batch: 100, loss is: [0.08467755], acc is [0.97]
epoch: 0, batch: 200, loss is: [0.12777735], acc is [0.96]
epoch: 0, batch: 300, loss is: [0.12188359], acc is [0.95]
epoch: 0, batch: 400, loss is: [0.24224037], acc is [0.95]
epoch: 1, batch: 0, loss is: [0.03813685], acc is [0.99]
epoch: 1, batch: 100, loss is: [0.05681484], acc is [0.99]
epoch: 1, batch: 200, loss is: [0.06868968], acc is [0.97]
epoch: 1, batch: 300, loss is: [0.1036892], acc is [0.97]
epoch: 1, batch: 400, loss is: [0.02300769], acc is [1.]
epoch: 2, batch: 0, loss is: [0.04247484], acc is [1.]
epoch: 2, batch: 100, loss is: [0.1061397], acc is [0.97]
epoch: 2, batch: 200, loss is: [0.00756415], acc is [1.]
epoch: 2, batch: 300, loss is: [0.14318658], acc is [0.97]
epoch: 2, batch: 400, loss is: [0.05834055], acc is [0.98]
epoch: 3, batch: 0, loss is: [0.03478176], acc is [0.98]
epoch: 3, batch: 100, loss is: [0.00845072], acc is [1.]
epoch: 3, batch: 200, loss is: [0.01726537], acc is [0.99]
epoch: 3, batch: 300, loss is: [0.0241767], acc is [0.99]
epoch: 3, batch: 400, loss is: [0.03578701], acc is [0.99]
epoch: 4, batch: 0, loss is: [0.07068685], acc is [0.97]
epoch: 4, batch: 100, loss is: [0.00072876], acc is [1.]
epoch: 4, batch: 200, loss is: [0.11759568], acc is [0.98]
epoch: 4, batch: 300, loss is: [0.06649398], acc is [0.98]
epoch: 4, batch: 400, loss is: [0.15924767], acc is [0.97]

optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.05)

epoch: 0, batch: 0, loss is: [2.6998017], acc is [0.01]
epoch: 0, batch: 100, loss is: [0.40688008], acc is [0.87]
epoch: 0, batch: 200, loss is: [0.34527627], acc is [0.89]
epoch: 0, batch: 300, loss is: [0.16690037], acc is [0.96]
epoch: 0, batch: 400, loss is: [0.31930047], acc is [0.92]
epoch: 1, batch: 0, loss is: [0.2899204], acc is [0.91]
epoch: 1, batch: 100, loss is: [0.16774327], acc is [0.95]
epoch: 1, batch: 200, loss is: [0.2723666], acc is [0.9]
epoch: 1, batch: 300, loss is: [0.18758966], acc is [0.94]
epoch: 1, batch: 400, loss is: [0.16943987], acc is [0.96]
epoch: 2, batch: 0, loss is: [0.32347172], acc is [0.92]
epoch: 2, batch: 100, loss is: [0.201409], acc is [0.93]
epoch: 2, batch: 200, loss is: [0.14817585], acc is [0.94]
epoch: 2, batch: 300, loss is: [0.38007167], acc is [0.89]
epoch: 2, batch: 400, loss is: [0.37605485], acc is [0.82]
epoch: 3, batch: 0, loss is: [0.28675053], acc is [0.94]
epoch: 3, batch: 100, loss is: [0.28110692], acc is [0.92]
epoch: 3, batch: 200, loss is: [0.22482894], acc is [0.93]
epoch: 3, batch: 300, loss is: [0.0877963], acc is [0.96]
epoch: 3, batch: 400, loss is: [0.08527756], acc is [0.98]
epoch: 4, batch: 0, loss is: [0.28089437], acc is [0.92]
epoch: 4, batch: 100, loss is: [0.26715964], acc is [0.92]
epoch: 4, batch: 200, loss is: [0.24698181], acc is [0.93]
epoch: 4, batch: 300, loss is: [0.2700761], acc is [0.95]
epoch: 4, batch: 400, loss is: [0.1489182], acc is [0.93]

optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.01,momentum=0.9)

epoch: 0, batch: 0, loss is: [2.4078474], acc is [0.1]
epoch: 0, batch: 100, loss is: [0.07707215], acc is [0.99]
epoch: 0, batch: 200, loss is: [0.15584494], acc is [0.95]
epoch: 0, batch: 300, loss is: [0.14929302], acc is [0.95]
epoch: 0, batch: 400, loss is: [0.04746217], acc is [0.98]
epoch: 1, batch: 0, loss is: [0.02641357], acc is [1.]
epoch: 1, batch: 100, loss is: [0.04320879], acc is [0.99]
epoch: 1, batch: 200, loss is: [0.04737204], acc is [0.98]
epoch: 1, batch: 300, loss is: [0.10216624], acc is [0.97]
epoch: 1, batch: 400, loss is: [0.10267925], acc is [0.96]
epoch: 2, batch: 0, loss is: [0.04679686], acc is [0.99]
epoch: 2, batch: 100, loss is: [0.03990461], acc is [0.98]
epoch: 2, batch: 200, loss is: [0.04612859], acc is [0.99]
epoch: 2, batch: 300, loss is: [0.07779605], acc is [0.97]
epoch: 2, batch: 400, loss is: [0.01606311], acc is [1.]
epoch: 3, batch: 0, loss is: [0.02597752], acc is [1.]
epoch: 3, batch: 100, loss is: [0.02485457], acc is [0.99]
epoch: 3, batch: 200, loss is: [0.05462885], acc is [0.98]
epoch: 3, batch: 300, loss is: [0.02850331], acc is [0.99]
epoch: 3, batch: 400, loss is: [0.08091646], acc is [0.97]
epoch: 4, batch: 0, loss is: [0.05408163], acc is [0.97]
epoch: 4, batch: 100, loss is: [0.01439537], acc is [0.99]
epoch: 4, batch: 200, loss is: [0.12736222], acc is [0.96]
epoch: 4, batch: 300, loss is: [0.01605669], acc is [0.99]
epoch: 4, batch: 400, loss is: [0.00572791], acc is [1.]

yuzaihuan

#717 回复于2020-01

作业7-1：

乘法：（3*3*3）*（224*224）*10*64=867041280，三个通道，每个点计算三次，10个样本，输出64通道

加法：【（3*3-1+1）*3+2】*224*224*64*10=931266560，一个点计算3*3-1（9个位置8此运算），加一个偏置，3个通道，之后两次累加

作业7-2：

执

执念路漫长

#718 回复于2020-01

作业7-1：

乘法：867041280，加法867041280

作业7-2：

vortual_skyphet

#719 回复于2020-01

作业2-1：

(1)

（2）

class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
        np.random.seed(0)
        self.w0 = np.random.randn(num_of_weights, 13)
        self.b0 = 0
        self.w1 = np.random.randn(13, 13)
        self.b1 = 0
        self.w2 = np.random.randn(13, 1)
        self.b2 = 0
        
    def forward(self, x):
        self.z1 = np.dot(x, self.w0) + self.b0 # N * 13
        self.z2 = np.dot(self.z1, self.w1) + self.b1 # N * 13
        self.z3 = np.dot(self.z2, self.w2) + self.b2 # N * 1
        return self.z3
    
    def loss(self, z, y):
        error = z - y
        num_samples = error.shape[0]
        cost = error * error
        cost = np.sum(cost) / num_samples
        return cost
    
    def gradient(self, x, y):
        z3 = self.forward(x)
        # print("*"*50)
        gradient_w2 = (z3-y) * self.z2 
        gradient_w2 = np.mean(gradient_w2, axis=0)
        gradient_w2 = gradient_w2[:, np.newaxis]  
        gradient_b2 = (z3 - y)
        gradient_b2 = np.mean(gradient_b2)
        
        gradient_w1 = (z3-y) * self.w2.T * self.z1 
        gradient_w1 = np.mean(gradient_w1, axis=0)
        gradient_w1 = gradient_w1[:, np.newaxis]  
        gradient_b1 = (z3 - y) * self.w2.T
        gradient_b1 = np.mean(gradient_b1)
        
        w1 = self.w1.T
        gradient_b0 = (z3-y) * self.w2.T * w1[0:1]
        gradient_b0 = np.mean(gradient_b0)
        gradient_b0 = gradient_b0.reshape(-1,1)
        gradient_w0 = (z3-y) * self.w2.T * w1[0:1] * x
        gradient_w0 = np.mean(gradient_w0, axis=0)
        gradient_w0 = gradient_w0[:, np.newaxis]
        
        for k in range(1,w1.shape[0],1):
            t = w1[k:k+1] 
            gw0 = (z3-y) * self.w2.T * t * x
            gw0 = np.mean(gw0, axis=0)
            gw0 = gw0[:, np.newaxis]
            gradient_w0 = np.hstack((gradient_w0,gw0))
            b0 = (z3-y) * self.w2.T * t
            b0 = np.mean(b0)
            b0 = b0.reshape(-1,1)
            gradient_b0 = np.hstack((gradient_b0,b0))
            
        return gradient_w0, gradient_b0,gradient_w1, gradient_b1,gradient_w2, gradient_b2
    
    def update(self, gradient_w0, gradient_b0, gradient_w1, gradient_b1,gradient_w2, gradient_b2, eta = 0.01):
        self.w0 = self.w0 - eta * gradient_w0
        self.b0 = self.b0 - eta * gradient_b0
        self.w1 = self.w1 - eta * gradient_w1
        self.b1 = self.b1 - eta * gradient_b1
        self.w2 = self.w2 - eta * gradient_w2
        self.b2 = self.b2 - eta * gradient_b2
        
        
    def train(self, x, y, iterations=1000, eta=0.01):
        losses = []
        for i in range(iterations):
            z = self.forward(x)
            L = self.loss(z, y)
            gradient_w0, gradient_b0,gradient_w1, gradient_b1,gradient_w2, gradient_b2 = self.gradient(x, y)
            self.update(gradient_w0, gradient_b0,gradient_w1, gradient_b1,gradient_w2, gradient_b2, eta)
            losses.append(L)
            # if (i+1) % 10 == 0:
            #     print('iter {}, loss {}'.format(i, L))
            print('iter {}, loss {}'.format(i, L))
        return losses

# 获取数据
train_data, test_data = load_data()
x = train_data[:, :-1]
y = train_data[:, -1:]
# 创建网络
net = Network(13)
num_iterations=100
# 启动训练
losses = net.train(x,y, iterations=num_iterations, eta=0.01)

# 画出损失函数的变化趋势
plot_x = np.arange(num_iterations)
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

vortual_skyphet

#720 回复于2020-01

作业3-1：

(1)

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-10,10,0.1)
tanh = (np.exp(x)-np.exp(-x))/(np.exp(x)+np.exp(-x))

plt.plot(x,tanh,color='y')
plt.title('y=tanh(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

（2）

import numpy as np

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

vortual_skyphet

#721 回复于2020-01

作业4-2：

Python编写的模型和基于飞桨编写的模型的区别：框架实现功能起来比较容易，比如前向计算和反向传播都不需要自己去实现，所以开发效率也比较快。