作业帖 | 百度深度学习集训营
DJ星尘 发布于2019-12-09 23:08 浏览:29089 回复:949
48
收藏
最后编辑于2020-06-28

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

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《百度架构师手把手教深度学习》课程上

 

收藏
点赞
48
个赞
共949条回复 最后由superbusiness0回复于2020-06-28 20:29
#933随缘0323回复于2020-02-03 16:08:04

作业3:

3-1: 用numpy实现tanh函数的计算,并画出其函数曲线

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-10, 11, 1)
y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

plt.figure(figsize=(5, 3))
plt.plot(x, y)
plt.text(-7, 0.7, 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()

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

import numpy as np

p = np.random.randn(10, 10)
q = (p>0)
#print(q)
print('大于0的个数:{}'.format(np.sum(q)))

 

作业2

2-1:

0
#932hycoment回复于2020-02-02 11:58:03

作业3-1 使用numpy计算tanh激活函数

程序代码:

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函数
y = (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))

#画出训练过程中Loss的变化曲线
plt.figure()
plt.title("y = tanh(x)", fontsize=14)
plt.xlabel("x", fontsize=14)
plt.ylabel("y", fontsize=14)
plt.plot(x, y,color='red',label='y = tanh(x)') 
plt.grid()
plt.show()

 

作业3-1(2)统计随机生成矩阵中有多少个元素大于0

import numpy as np

p = np.random.randn(10, 10)
#print(type(p))
print(p.shape)
print(p)
q = (p > 0) #对矩阵p的每个元素进行判断
print(q.dtype)

q = q.astype('int32') # bool类型转换成int32类型
print(q)
#print(q.sum(axis=1)) #按行求和
#print(q.sum(axis=0)) #按列求和
q.sum() # 对每个元素求和
0
#931cheeryoung79回复于2020-01-31 11:18:32
#930 星光ld1回复
是不是把Batch写的太大的,如果实在跑不起来可以改小一点

我改为2也不行

0
#930星光ld1回复于2020-01-30 15:08:00
#928 cheeryoung79回复
跑Googlenet报错,说内存不足[图片]

是不是把Batch写的太大的,如果实在跑不起来可以改小一点

0
#929xhjinuuu2016回复于2020-01-30 14:45:10

作业7-2

0
#928cheeryoung79回复于2020-01-30 14:21:18

跑Googlenet报错,说内存不足

0
#927万国风云回复于2020-01-29 16:33:59

作业9-2:

代码修改:

(1)train中使用分段衰减的学习率;

(2)网络构成修改:

(3)网络前向输出:

验证集上的结果:

2
#926万国风云回复于2020-01-29 14:17:18

作业9-1:

boundaries = [150,300]

values=[0.01,0.001,0.0001]

可见使用分段衰减后,accuracy可以达到0.96甚至0.97

 

0
#925cheeryoung79回复于2020-01-29 13:36:33

作业9-1:在1000-3000步设置0.01, 在3000步设0.001

0
#924万国风云回复于2020-01-29 12:37:31

作业8:

relu:

sigmoid:

可以看到使用relu激活函数在验证集上的loss和accuracy震荡更小而且更加稳定

0
#923WangHiro回复于2020-01-29 10:24:23

作业3-1(1)

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

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

def tanh(x):
y = (np.exp(x) - np.exp(- x)) / (np.exp(x) + np.exp(- x))
return y
x = np.arange(-10, 10, 0.1)

# 画图
plt.plot(x, tanh(x), color='r')
plt.text(-7., 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()

作业3-1(2)

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

0
#922WangHiro回复于2020-01-29 10:07:25

作业2-1

(1)

(2)

import numpy as np
import matplotlib.pyplot as plt

class Network(object):
def __init__(self, num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性,设置固定的随机数种子
#np.random.seed(0)
self.w_1 = np.random.randn(num_of_weights, num_of_weights)
self.b_1 = np.zeros(num_of_weights)
#定义第二层的初始权重
self.w_2=np.random.randn(num_of_weights,1)
self.b_2=0.

def forward_1(self, x):
z = np.dot(x, self.w_1) + self.b_1
return z

def forward_2(self,x):
z=np.dot(x,self.w_2)+self.b_2
return z

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, z):
#z = self.forward_1(x) or 为2
N = x.shape[0]
gradient_w = 1. / N * np.sum((z-y) * x, axis=0)
gradient_w = gradient_w[:, np.newaxis]
gradient_b = 1. / N * np.sum(z-y)
return gradient_w, gradient_b

def update_1(self, gradient_w, gradient_b, eta = 0.01):
self.w_1 = self.w_1 - eta * gradient_w
self.b_1 = self.b_1 - eta * gradient_b

def update_2(self, gradient_w, gradient_b, eta = 0.01):
self.w_2=self.w_2 - eta * gradient_w
self.b_2 = self.b_2 - eta * gradient_b


def train(self, training_data, num_epoches, batch_size=10, eta=0.01):
n = len(training_data)
losses = []
for epoch_id in range(num_epoches):
# 每轮迭代开始之前,将训练数据的顺序打乱,
# 然后再按每次取batch_size条数据的方式取出
np.random.shuffle(training_data)
# 将训练数据进行拆分,每个mini_batch包含batch_size条的数据
mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
for iter_id, mini_batch in enumerate(mini_batches):
#print(self.w.shape)
#print(self.b)
x = mini_batch[:, :-1]
y = mini_batch[:, -1:]
#前向传播
a_1 = self.forward_1(x)
a_2=self.forward_2(a_1)

#反向传播第二层的
loss = self.loss(a_2, y)
gradient_w_2, gradient_b_2 = self.gradient(a_1, y,self.forward_2(a_1))
self.update_2(gradient_w_2, gradient_b_2, eta)

#反向传播第一层的
gradient_w_1,gradient_b_1=self.gradient(x,a_1,self.forward_1(x))
self.update_1(gradient_w_1,gradient_b_1,eta)

losses.append(loss)
print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.
format(epoch_id, iter_id, loss))

return losses

# 获取数据
train_data, test_data = load_data()

# 创建网络
net = Network(13)
# 启动训练
losses = net.train(train_data, num_epoches=50, batch_size=100, eta=0.1)

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

 

0
#921WangHiro回复于2020-01-29 09:53:59

①F=n*μ
通过增加正压力N,求得一个值F,通过组数据可以求得μ。假设是呈线性关系,参数是模型中的变量μ。优化目标是寻找使得数据拟合较好的参数。

       曾经在听一次讲座时,主讲嘉宾讲未来的职业有两种,制作人工智能的程序员,和使用人工智能完成一定目的的使用者。在机器学习特别是深度学习的出现后,使得人们在解决某些领域的问题时不需要掌握那么多该领域的知识,并对系统的输入数据依据该领域的深厚知识进行精妙的变化和处理,这提高了行业的自动化程度,加快了业务的迭代速度。

       因为现在这个阶段的深度学习的概念从2010年左右又变得火热,目前各大高校培养的机器学习方面的人才对于现在市场的需求来说还是相对滞后的,相关从业人员不但需要丰富的工程经验,对业务数据有准确的把握,同时也要能紧跟机器学习当下最前沿的理论并尝试加以应用,这个要求还是比较高的,市场上满足这些要求的人并不算多,整体高素质的机器学习从业者是供少于求。所以说机器学习的前景很好。

0
#920东南林美回复于2020-01-28 19:30:05

作业7-2:

0
#919东南林美回复于2020-01-28 18:17:21

作业7-1:

输出一个像素点需要:

9次乘法

8次加法+1次偏置项加法=9次加法

单层数据[224, 224]卷积不填充输出数据[222, 222],输出像素点为222*222

因此:

一次卷积需要的乘法=9*222*222*3*64*10=851,627,520次

一次卷积需要的加法=9*222*222*3*64*10=851,627,520次

0
#918awesomezzzz000回复于2020-01-27 08:48:04

作业9-1:

使用分段衰减的方式,衰减系数为0.1


boundaries =[160,180]
values = [0.001,0.0001,0.0001]
opt = fluid.optimizer.Momentum(learning_rate=fluid.layers.piecewise_decay(boundaries, values), momentum=0.9)

start training ...
epoch: 0, batch_id: 0, loss is: [0.6900862]
epoch: 0, batch_id: 10, loss is: [0.7834173]
epoch: 0, batch_id: 20, loss is: [0.6089426]
epoch: 0, batch_id: 30, loss is: [0.44614416]
[validation] accuracy/loss: 0.7675000429154332/0.4995689392086477
epoch: 1, batch_id: 0, loss is: [0.62597416]
epoch: 1, batch_id: 10, loss is: [0.37226442]
epoch: 1, batch_id: 20, loss is: [0.56305483]
epoch: 1, batch_id: 30, loss is: [0.5852426]
[validation] accuracy/loss: 0.8700000643732244/0.31707146763804465
epoch: 2, batch_id: 0, loss is: [0.34716362]
epoch: 2, batch_id: 10, loss is: [0.29987423]
epoch: 2, batch_id: 20, loss is: [0.40632883]
epoch: 2, batch_id: 30, loss is: [0.23577423]
[validation] accuracy/loss: 0.8725000619888042/0.3043900728224676
epoch: 3, batch_id: 0, loss is: [0.6481099]
epoch: 3, batch_id: 10, loss is: [0.3430357]
epoch: 3, batch_id: 20, loss is: [0.5004776]
epoch: 3, batch_id: 30, loss is: [0.46621162]
[validation] accuracy/loss: 0.925000011924293/0.22478042542934418
epoch: 4, batch_id: 0, loss is: [0.05665208]
epoch: 4, batch_id: 10, loss is: [0.08026776]
epoch: 4, batch_id: 20, loss is: [0.10686707]
epoch: 4, batch_id: 30, loss is: [0.0466433]
[validation] accuracy/loss: 0.9524999856949982/0.17152376472945694
1
#917awesomezzzz000回复于2020-01-27 08:31:26

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

使用激活函数Sigmoid, Loss难以收敛。原因是多层sigmoid叠加会出现梯度消失。

0
#916ZTC8990回复于2020-01-25 16:05:19

作业3-1(1)使用numpy计算tanh激活函数(请用numpy写出计算程序,并画出tanh函数曲线图,x的取值范围设置为[-10., 10.])

程序:

# x是1维数组,数组大小是从-10. 到10.的实数,每隔0.1取一个点
import numpy as np
import matplotlib.pyplot as plt
#设置图片大小
plt.figure(figsize=(8, 3))
x = np.arange(-10, 10, 0.1)
# 计算 Sigmoid函数
s =(np.exp(x) - np.exp(- x)) / (np.exp(x) + np.exp(- x))
# 设置一个子图窗口,将Sigmoid的函数图像画在左边
f = plt.subplot(111)
# 画出函数曲线
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()

 

作业:3-2 统计随机生成矩阵中有多少个元素大于0

程序:

import numpy as np
#生成随机数构成的矩阵
p = np.random.randn(10,10)
#在10*10矩阵中筛选出大于0的元素
q = p[p>0]
#输出符合条件的结果
#print(q)
#统计符合条件的个数
print(q.shape)

 

0
#915hyy永勇回复于2020-01-23 05:59:52

作业5-3:在手写数字识别任务上,哪种优化算法的效果最好,多大的学习率最优? 通过loss的下降趋势来判断

我在这里测试了四种优化算法,分别是SGD、Momentum、Adagrad和Adam,每种算法分别设置三种学习率,0.1 、0.01、和0.001,

其中训练参数为 batch-num = 5, batch-num = 100,其中loss下降最快且数值最小的是Adam算法学习率在0.001的时候。

 

0
#914hyy永勇回复于2020-01-23 02:49:05

作业5-2:了解下对于计算机视觉,有哪些常见的卷积神经网络?

LeNet,1989年,LeCun提出的卷积神经网络的鼻祖,

AlexNet,2012年提出的5卷积层+2 全连接层的卷积神经网络

GoogleNet,2015年提出的深度卷积神经网络中的一个重要的结构,层数推进到了22层,跳出AlexNet的基本结构,提出了inception单元

ResNet,2015年何凯明提出的更深的网络。

0
TOP
切换版块