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

项目

数据集

课程

比赛

模型库

活动

论坛

访问飞桨官网

项目

数据集

课程

比赛

模型库

活动

论坛

访问飞桨官网

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)

C孤独K患者

#142 回复于2019-12

作业1-2：

人类的交互方式主要为图像，文字和语音。传统的方法无法实时精确的处理图像，文字和语音。所谓市场我觉得都是为了满足人类懒惰性的需求。懒惰讲究时效性。AI的处理方法相对于传统的图像处理和语音识别等技术，优点在于提高了速度和准确性。特别是随着计算机硬件和摄像头等外设的发展，这个处理速度和精确度会不断提高，使得模拟人类的能力越来越强，从而能够够好的满足人类的懒惰性。比如无人驾驶，是为了在出行时，解放人类的双手等。

sljackson

#143 回复于2019-12

故

故乡237

#144 回复于2019-12

作业 2-1 ：购买苹果和句子的梯度传播

自在e鹤悠

#145 回复于2019-12

作业2-1

jiangethos

#146 回复于2019-12

xiaolin1122334

#147 回复于2019-12

yun101bd

#148 回复于2019-12

作业1-2：完成下面两个问题，并将答案发布在帖子下面

①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？

答:

流体在管道内的阻力问题，可以用监督学习的框架来解决。

假设:流体在管道内的阻力F与管道长度L成正比，求解系数w。

F=w*L

参数:流体在管道内的阻力，实验取得管段两端的压力差数据。

管道长度，管道两端长度数据。

优化目标:训练得出的系数w，与L的乘积接近于实验数据F。

②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

答：

AI技术己经成熟，已经广泛应用于人类的生产和生活的每个领域，正处于从学术界向产业应用推广阶段，需要AI技术与产业需求相结合，实现产业落地。这就要求AI工程师既要掌握深度学习技能，又要了解产业需求和必要的知识，人才匮乏，需求量很大，所以AI工程师很有发展前景。

张小黄

#149 回复于2019-12

作业2-1:

过程解析：

[ (2*100) + (150*3) ] * 1.1 = 715
所以715对1.1的偏导数是[ (2*100) + (150*3) ]（把这一项当作一个数）即650；
对650（[ (2*100) + (150*3) ]）的偏导数是1.1；
对200的偏导数是1*1.1=1.1，把小括号中的数当作一个数；
对450的偏导数是1*1.1=1.1，同上一条；
对2的偏导数是100*1*1.1=110；
对100的偏导数是2*1*1.1=2.2；

对其他的偏导数同理可得...

C孤独K患者

#150 回复于2019-12

作业2-2：

class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
        np.random.seed(0)
        # 第一层的参数 为了保证第二层的输入为 (1*13) 第一层的输入权重应为（13*13） （1*13） * （13*13） = (1*13)
        self.w0 = np.random.randn(num_of_weights, num_of_weights)
        self.b0 = np.zeros(num_of_weights)
        
        self.w1 = np.random.randn(num_of_weights, 1)
        self.b1 = 0.
        
    def forward0(self, x):
        print(x.shape)
        x = np.dot(x, self.w0) + self.b0
        return x
    def forward1(self, x):
        x = np.dot(x, self.w1) + self.b1
        return x
    
    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 update0(self, gradient_w, gradient_b, eta = 0.01):
        self.w0 = self.w0 - eta * gradient_w
        self.b0 = self.b0 - eta * gradient_b
    def update1(self, gradient_w, gradient_b, eta = 0.01):
        self.w1 = self.w1 - eta * gradient_w
        self.b1 = self.b1 - eta * gradient_b
        
    def train(self, x, y, iterations=100, eta=0.01):
        losses = []
        for i in range(iterations):
            out0 = self.forward0(x)
            out1 = self.forward1(out0)
            L = self.loss(out1, y)
            
            gradient_w1, gradient_b1 = self.gradient(out0, y, self.forward1(out0))
            self.update1(gradient_w1, gradient_b1, eta)
            
            gradient_w0, gradient_b0 = self.gradient(x, out0, self.forward1(x))
            self.update0(gradient_w0, gradient_b0, eta)
            
            losses.append(L)
            if (i+1) % 10 == 0:
                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=300
# 启动训练
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()

我湖nb

#151 回复于2019-12

作业1_2

①类比牛顿第二定律的案例，在你的工作和生活中还有哪些问题可以用监督学习的框架来解决？假设和参数是什么？优化目标是什么？

应用于智能小车的控制无人车控制算法参数是舵机的状态电机的速度通过摄像头得到的小车位置目标尽可能快的完成比赛
②为什么说AI工程师有发展前景？怎样从经济学（市场供需）的角度做出解读？

因为我们位于新工业革命的起点多年的技术积累让AI有更广阔的应用空间

我湖nb

#152 回复于2019-12

作业2_1

星光ld1

#153 回复于2019-12

作业2-1：基础题

lu66a

#154 回复于2019-12

作业2-2提高题，把最后的代码改成如下就是两层的了：

import numpy as np

class Network(object):
def __init__(self, num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
#np.random.seed(0)
self.w1 = np.random.randn(num_of_weights, num_of_weights)
self.b1 = np.random.randn(num_of_weights)
self.w2 = np.random.randn(num_of_weights, 1)
self.b2 = 0.

def forward1(self, x):
z = np.dot(x, self.w1) + self.b1
return z

def forward2(self, x):
z = np.dot(x, self.w2) + self.b2
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,z, x, y):
#z = self.forward(x)
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 update1(self, gradient_w, gradient_b, eta = 0.01):
self.w1 = self.w1 - eta * gradient_w
self.b1 = self.b1 - eta * gradient_b
def update2(self, gradient_w, gradient_b, eta = 0.01):
self.w2 = self.w2 - eta * gradient_w
self.b2 = self.b2 - 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:]
a1 = self.forward1(x)
a2 = self.forward2(a1)

loss = self.loss(a2, y)
gradient_w2, gradient_b2 = self.gradient(a2,a1, y)
self.update2(gradient_w2, gradient_b2, eta)

gradient_w1, gradient_b1 = self.gradient(a1,x, a1)
self.update1(gradient_w1, gradient_b1, 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()

效果如下

得儿飘飘飘飘

#155 回复于2019-12

作业 2-1 ：购买苹果和句子的梯度传播

星光ld1

#156 回复于2019-12

作业2-1：挑战题

import sys, os
from matplotlib import pyplot as plt
sys.path.append(os.pardir)
import numpy as np
# from common.layers import *
# from common.gradient import numerical_gradient
from collections import OrderedDict

class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b
        self.x = None
        self.dW = None
        self.db = None
    def forward(self, x):
        self.x = x
        out = np.dot(x, self.W) + self.b
        return out
    def backward(self, dout):
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)
        return dx
        
class MSELoss:
    def __init__(self):
        self.loss = None # 损失
        self.y = None # 输出
        self.t = None # 监督数据（one-hot vector）
    def forward(self, x, t):
        self.t = t
        self.y = x
        self.loss = np.mean(0.5*(self.y - self.t)*(self.y - self.t))
        return self.loss
        
    def backward(self, dout=1):
        batch_size = self.t.shape[0]
        dx = (self.y - self.t) / batch_size
        return dx

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size,
    weight_init_std=0.01):
        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * \
        np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * \
        np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)
        # 生成层
        self.layers = OrderedDict()
        self.layers['Affine1'] = \
        Affine(self.params['W1'], self.params['b1'])
        self.layers['Affine2'] = \
        Affine(self.params['W2'], self.params['b2'])
        self.lastLayer = MSELoss()
        
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        return x
    # x:输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
        
    def gradient(self, x, t):
        # forward
        self.loss(x, t)
        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)
            # 设定
            grads = {}
            grads['W1'] = self.layers['Affine1'].dW
            grads['b1'] = self.layers['Affine1'].db
            grads['W2'] = self.layers['Affine2'].dW
            grads['b2'] = self.layers['Affine2'].db
        return grads
    
    def train(self, training_data, num_epoches, batch_size=10, learning_rate=0.02):
        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):
                x = mini_batch[:, :-1]
                y = mini_batch[:, -1:]
                
                grad = self.gradient(x,y)
                for key in ('W1', 'b1', 'W2', 'b2'):
                    self.params[key] -= learning_rate * grad[key]
                loss = self.loss(x,y)
                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 = TwoLayerNet(input_size=13, hidden_size=13, output_size=1)
# 启动训练
losses = net.train(train_data, num_epoches=100, batch_size=128, learning_rate=0.5)

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

# test
plot_x = train_data[:, -1]
plot_y = net.predict(train_data[:, :-1])
plt.scatter(plot_x, plot_y)
plt.plot(plot_x, plot_x, 'r--')
plt.xlim([-0.5,0.5])
plt.ylim([-0.5,0.5])
plt.ylabel('y_pred')
plt.xlabel("y_true")
plt.show()

效果图