# 定義網(wǎng)絡(luò) define neural network
	class DigitModule(Module):
	    def __init__(self):
	        # 計(jì)算順序就會(huì)按照這里定義的順序進(jìn)行
	        sequential = Sequential([
	            layers.Linear2(in_dim=ROW_NUM * COLUM_NUM, out_dim=16, coe=2),
	            layers.Relu(16),
	            layers.Linear2(in_dim=16, out_dim=16, coe=2),
	            layers.Relu(16),
	            layers.Linear2(in_dim=16, out_dim=CLASS_NUM, coe=1),
	            layers.Sigmoid(CLASS_NUM)
	        ])
	        super(DigitModule, self).__init__(sequential)
	
	
	module = DigitModule()  # 創(chuàng)建模型 create module
	loss_func = SquareLoss(backward_func=module.backward)  # 定義損失函數(shù) define loss function
	optimizer = SGD(module, lr=learning_rate)  # 定義優(yōu)化器 define optimizer
	
	
	for i in range(EPOCH_NUM):  # 共訓(xùn)練EPOCH_NUM輪
	    trainning_loss = 0  # 計(jì)算一下當(dāng)前一輪訓(xùn)練的loss值，可以沒有
	    for data in train_loader:  # 遍歷所有樣本，train_loader是可迭代對(duì)象，保存了數(shù)據(jù)集中所有的數(shù)據(jù)
	        imgs, targets = data  # 將數(shù)據(jù)拆分成圖片和標(biāo)簽
	        outputs = module(imgs)  # 將樣本的輸入值輸入到自己的神經(jīng)網(wǎng)絡(luò)中
	        loss = loss_func(outputs, targets, transform=True)  # 計(jì)算loss / calculate loss
	        trainning_loss += loss.value
	        loss.backward()  # 通過反向傳播計(jì)算梯度 / calculate gradiant through back propagation
	        optimizer.step()  # 通過優(yōu)化器調(diào)整模型參數(shù) / adjust the weights of network through optimizer
	    if i % TEST_STEP == 0:  # 每訓(xùn)練TEST_STEP輪就測(cè)試一下當(dāng)前訓(xùn)練的成果
	        show_effect(i, module, loss_func, test_loader, i // TEST_STEP)
	        print("{} turn finished, loss of train set = {}".format(i, trainning_loss))

	def forward(self, x):
	    out = x
	    for layer in self.layers:
	        out = layer(out)
	    return out
	
	def backward(self, output_gradiant):
	    layer_num = len(self.layers)
	    delta = output_gradiant
	    for i in range(layer_num - 1, -1, -1):
	        # 反向遍歷各個(gè)層, 將期望改變量反向傳播
	        delta = self.layers[i].backward(delta)
	
	def step(self, lr):
	    for layer in self.layers:
	        layer.step(lr)

    def forward(self, inputs):
	        """
	        :param inputs: input = (h0, x) h0.shape == (batch, out_dim) x.shape == (seq, batch, in_dim)
	        :return: outputs: outputs.shape == (seq, batch, out_dim)
	        """
	        h = inputs[0]  # 輸入的inputs由兩部分組成
	        X = inputs[1]
	        if X.shape[2] != self.in_dim or h.shape[1] != self.out_dim:
	            # 檢查輸入的形狀是否有問題
	            raise ShapeNotMatchException(self, "forward: wrong shape: h0 = {}, X = {}".format(h.shape, X.shape))
	
	        self.seq_len = X.shape[0]  # 時(shí)間序列的長(zhǎng)度
	        self.inputs = X  # 保存輸入，之后的反向傳播還要用
	        output_list = []  # 保存每個(gè)時(shí)間點(diǎn)的輸出
	        for x in X:
	            # 按時(shí)間序列遍歷input
	            # x.shape == (batch, in_dim), h.shape == (batch, out_dim)
	            h = self.activation(self.linear(np.c_[h, x]))
	            output_list.append(h)
	        self.outputs = np.stack(output_list, axis=0)  # 將列表轉(zhuǎn)換成一個(gè)矩陣保存起來
	        return self.outputs

	def backward(self, output_gradiant):
	    """
	    :param output_gradiant: shape == (seq, batch, out_dim)
	    :return: input_gradiant
	    """
	    if output_gradiant.shape != self.outputs.shape:
	        # 期望得到(seq, batch, out_dim)形狀
	        raise ShapeNotMatchException(self, "__backward: expected {}, but we got "
	                                           "{}".format(self.outputs.shape, output_gradiant.shape))
	
	    input_gradients = []
	    # 每個(gè)time_step上的虛擬weight_gradient, 最后求平均值就是總的weight_gradient
	    weight_gradients = np.zeros(self.linear.weights_shape())
	    bias_gradients = np.zeros(self.linear.bias_shape())
	    batch_size = output_gradiant.shape[1]
	
	    # total_gradient: 前向傳播的時(shí)候是將x, h合成為一個(gè)矩陣，所以反向傳播也先計(jì)算這個(gè)大矩陣的梯度再拆分為x_grad, h_grad
	    total_gradient = np.zeros((batch_size, self.out_dim + self.in_dim))
	    h_gradient = None
	    
	    # 反向遍歷各個(gè)時(shí)間層，計(jì)算該層的梯度值
	    for i in range(self.seq_len - 1, -1, -1):
	        # 前向傳播順序: x, h -> z -> h
	        # 所以反向傳播計(jì)算順序：h_grad -> z_grad -> x_grad, h_grad, w_grad, b_grad
	
	        # %%%%%%%%%%%%%%計(jì)算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
	        # h_gradient = (output_gradiant[i] + total_gradient[:, 0:self.out_dim]) / 2
	        # %%%%%%%%%%%%%%不計(jì)算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
	        #  計(jì)算h_grad: 這一時(shí)間點(diǎn)的h_grad包括輸出的grad和之前的時(shí)間點(diǎn)計(jì)算所得grad兩部分
	        h_gradient = output_gradiant[i] + total_gradient[:, 0:self.out_dim]  
	
	        # w_grad和b_grad是在linear.backward()內(nèi)計(jì)算的，不用手動(dòng)再計(jì)算了
	        z_gradient = self.activation.backward(h_gradient)  # 計(jì)算z_grad
	        total_gradient = self.linear.backward(z_gradient)  # 計(jì)算x_grad和h_grad合成的大矩陣的梯度
	
	        # total_gradient 同時(shí)包含了h和x的gradient, shape == (batch, out_dim + in_dim)
	        x_gradient = total_gradient[:, self.out_dim:]
	
	        input_gradients.append(x_gradient)  
	        weight_gradients += self.linear.gradients["w"]
	        bias_gradients += self.linear.gradients["b"]
	
	    # %%%%%%%%%%%%%%%%%%計(jì)算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
	    # self.linear.set_gradients(w=weight_gradients / self.seq_len, b=bias_gradients / self.seq_len)
	    # %%%%%%%%%%%%%%%%%%不計(jì)算平均值的版本%%%%%%%%%%%%%%%%%%%%%%%
	    self.linear.set_gradients(w=weight_gradients, b=bias_gradients)  # 設(shè)置梯度值
	    
	    list.reverse(input_gradients)  # input_gradients是逆序的，最后輸出時(shí)需要reverse一下
	    print("sum(weight_gradients) = {}".format(np.sum(weight_gradients)))
	    
	    # np.stack的作用是將列表轉(zhuǎn)變成一個(gè)矩陣
	    return np.stack(input_gradients), h_gradient