Educoed--实现神经网络模型的前向传播、反向传播和训练

第1关：实现神经网络模型的前向传播

import numpy

from layers import Convolution, Relu, FullyConnected, MaxPool, SoftmaxWithLoss

 

class TinyNet:

    def __init__(self, W_conv1, b_conv1, W_conv2, b_conv2, W_fc, b_fc):

        ########## Begin ##########

        self.conv1 = Convolution(W_conv1, b_conv1, stride=1, pad=1)  

        self.relu1 = Relu()  

        self.pool1 = MaxPool(2, 2, stride=2, pad=0)  

        self.conv2 = Convolution(W_conv2, b_conv2, stride=1, pad=1)  

        self.relu2 = Relu()  

        self.pool2 = MaxPool(2, 2, stride=2, pad=0)  

        self.fc = FullyConnected(W_fc, b_fc)  

        self.loss = SoftmaxWithLoss()

        ########## End ##########

    def forward(self, x, t):

        ########## Begin ##########

        x = self.conv1.forward(x)  

        x = self.relu1.forward(x)  

        x = self.pool1.forward(x)  

        x = self.conv2.forward(x)  

        x = self.relu2.forward(x)  

        x = self.pool2.forward(x)  

        x = self.fc.forward(x)  

        loss = self.loss.forward(x, t)  

        return x, loss 

        ########## End ##########

第2关： 实现神经网络模型的反向传播

import numpy

from layers import Convolution, Relu, FullyConnected, MaxPool, SoftmaxWithLoss

 

class TinyNet:

    def __init__(self, W_conv1, b_conv1, W_conv2, b_conv2, W_fc, b_fc):

        self.conv1 = Convolution(W_conv1, b_conv1, stride=1, pad=1)

        self.relu1 = Relu()

        self.pool1 = MaxPool(2, 2, stride=2, pad=0)

        self.conv2 = Convolution(W_conv2, b_conv2, stride=1, pad=1)

        self.relu2 = Relu()

        self.pool2 = MaxPool(2, 2, stride=2, pad=0)

        self.fc = FullyConnected(W_fc, b_fc)

        self.loss = SoftmaxWithLoss()

 

    def forward(self, x, t):

        x = self.conv1.forward(x)

        x = self.relu1.forward(x)

        x = self.pool1.forward(x)

        x = self.conv2.forward(x)

        x = self.relu2.forward(x)

        x = self.pool2.forward(x)

        x = self.fc.forward(x)

        loss = self.loss.forward(x, t)

        return x, loss

    def backward(self):

        ########## Begin ##########

        dx = self.loss.backward()  

        dx = self.fc.backward(dx)  

        dx = self.pool2.backward(dx)  

        dx = self.relu2.backward(dx)  

        dx = self.conv2.backward(dx)  

        dx = self.pool1.backward(dx)  

        dx = self.relu1.backward(dx)  

        dx = self.conv1.backward(dx)

        ########## End ##########

        return self.conv1.dW, self.conv1.db, self.conv2.dW, self.conv2.db, self.fc.dW, self.fc.db

第3关：实现神经网络的梯度下降训练

import numpy

from layers import Convolution, Relu, FullyConnected, MaxPool, SoftmaxWithLoss

 

class TinyNet:

    def __init__(self, W_conv1, b_conv1, W_conv2, b_conv2, W_fc, b_fc):

        self.conv1 = Convolution(W_conv1, b_conv1, stride=1, pad=1)

        self.relu1 = Relu()

        self.pool1 = MaxPool(2, 2, stride=2, pad=0)

        self.conv2 = Convolution(W_conv2, b_conv2, stride=1, pad=1)

        self.relu2 = Relu()

        self.pool2 = MaxPool(2, 2, stride=2, pad=0)

        self.fc = FullyConnected(W_fc, b_fc)

        self.loss = SoftmaxWithLoss()

    def forward(self, x, t):

        x = self.conv1.forward(x)

        x = self.relu1.forward(x)

        x = self.pool1.forward(x)

        x = self.conv2.forward(x)

        x = self.relu2.forward(x)

        x = self.pool2.forward(x)

        x = self.fc.forward(x)

        loss = self.loss.forward(x, t)

        return x, loss

    def backward(self):

        dx = self.loss.backward()

        dx = self.fc.backward(dx)

        dx = self.pool2.backward(dx)

        dx = self.relu2.backward(dx)

        dx = self.conv2.backward(dx)

        dx = self.pool1.backward(dx)

        dx = self.relu1.backward(dx)

        dx = self.conv1.backward(dx)

        return self.conv1.dW, self.conv1.db, self.conv2.dW, self.conv2.db, self.fc.dW, self.fc.db

 

def train_one_iter(W_conv1, b_conv1, W_conv2, b_conv2, W_fc, b_fc, x, t, learning_rate):

    network = TinyNet(W_conv1, b_conv1, W_conv2, b_conv2, W_fc, b_fc)

    out, loss = network.forward(x, t)

    dW_conv1, db_conv1, dW_conv2, db_conv2, dW_fc, db_fc = network.backward()

    ########## Begin ##########

    new_W_conv1 = W_conv1 - dW_conv1 * learning_rate  

    new_b_conv1 = b_conv1 - db_conv1 * learning_rate  

    new_W_conv2 = W_conv2 - dW_conv2 * learning_rate  

    new_b_conv2 = b_conv2 - db_conv2 * learning_rate  

    new_W_fc = W_fc - dW_fc * learning_rate  

    new_b_fc = b_fc - db_fc * learning_rate 

    ########## End ##########

    return new_W_conv1, new_b_conv1, new_W_conv2, new_b_conv2, new_W_fc, new_b_fc