Class Network

your_first_network.py:122–245

#-----------------------------------------------------------------   
#定义一个网络类
class Network:
    def __init__(self, network_shape):
        self.shape = network_shape
        self.layers = []
        for i in range(len(network_shape)-1):
            layer = Layer(network_shape[i], network_shape[i+1])
            self.layers.append(layer)
     
    #前馈运算函数 
    def network_forward(self, inputs):
        outputs = [inputs]
        for i in range(len(self.layers)):
            layer_sum = self.layers[i].layer_forward(outputs[i])
            if i < len(self.layers)-1:
                layer_output = activation_ReLU(layer_sum)
                layer_output = normalize(layer_output)
            else:
                layer_output = activation_softmax(layer_sum)
            outputs.append(layer_output)
        return outputs
    
    #反向传播函数
    def network_backward(self, layer_outputs, target_vector):
        backup_network = copy.deepcopy(self) # 备用网络
        preAct_demands = get_final_layer_preAct_damands(layer_outputs[-1], target_vector)
        for i in range(len(self.layers)):
            layer = backup_network.layers[len(self.layers) - (1+i)] # 倒序
            if i != 0:
                layer.biases += LEARNING_RATE * np.mean(preAct_demands, axis=0)
                layer.biases = vector_normalize(layer.biases)
                
            outputs = layer_outputs[len(layer_outputs) - (2+i)]
            results_list = layer.layer_backward(outputs, preAct_demands)
            preAct_demands = results_list[0]
            weights_adjust_matrix = results_list[1]
            layer.weights += LEARNING_RATE * weights_adjust_matrix
            layer.weights = normalize(layer.weights)
        return backup_network
    
    #单批次训练
    def one_batch_train(self, batch):
        global force_train, random_train, n_improved, n_not_improved

        inputs = batch[:,(0, 1)]
        targets = copy.deepcopy(batch[:, 2]).astype(int) # 标准答案
        outputs = self.network_forward(inputs)
        precise_loss = precise_loss_function(outputs[-1], targets)
        loss = loss_function(outputs[-1], targets)
            
        if np.mean(loss) <= LOSS_THRESHOLD:#损失函数小于这个值就不需要训练了
            print('No need for training')
        else:
            backup_network = self.network_backward(outputs, targets)
            backup_outputs = backup_network.network_forward(inputs)
            backup_precise_loss = precise_loss_function(backup_outputs[-1], targets)
            backup_loss = loss_function(backup_outputs[-1], targets)
            
            if np.mean(precise_loss) >= np.mean(backup_precise_loss) or np.mean(loss) >= np.mean(backup_loss):