#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import random
from functools import reduce
from numpy import *

# sigmoid 函数
def sigmoid(inX):
    '''
    Desc:
        sigmoid 函数实现
    Args:
        inX --- 输入向量
    Returns:
        对输入向量作用 sigmoid 函数之后得到的输出
    '''
    return 1.0 / (1 + exp(-inX))


# 定义神经网络的节点类
class Node(object):
    '''
    Desc:
        神经网络的节点类
    '''
    def __init__(self, layer_index, node_index):
        '''
        Desc:
            初始化一个节点
        Args:
            layer_index --- 层的索引，也就是表示第几层
            node_index --- 节点的索引，也就是表示节点的索引
        Returns:
            None
        '''
        # 设置节点所在的层的位置
        self.layer_index = layer_index
        # 设置层中的节点的索引
        self.node_index = node_index
        # 设置此节点的下游节点，也就是这个节点与下一层的哪个节点相连
        self.downstream = []
        # 设置此节点的上游节点，也就是哪几个节点的下游节点与此节点相连
        self.upstream = []
        # 此节点的输出
        self.output = 0
        # 此节点真实值与计算值之间的差值
        self.delta = 0

    def set_output(self, output):
        '''
        Desc:
            设置节点的 output
        Args:
            output --- 节点的 output
        Returns:
            None
        '''
        self.output = output

    def append_downstream_connection(self, conn):
        '''
        Desc:
           添加此节点的下游节点的连接
        Args:
            conn --- 当前节点的下游节点的连接的 list
        Returns:
            None
        '''
        # 使用 list 的 append 方法来将 conn 中的节点添加到 downstream 中
        self.downstream.append(conn)

    def append_upstream_connection(self, conn):
        '''
        Desc:
            添加此节点的上游节点的连接
        Args:
            conn ---- 当前节点的上游节点的连接的 list
        Returns:
            None
        '''
        # 使用 list 的 append 方法来将 conn 中的节点添加到 upstream 中
        self.upstream.append(conn)

    def calc_output(self):
        '''
        Desc:
            计算节点的输出，依据 output = sigmoid(wTx)
        Args:
            None
        Returns:
            None
        '''
        # 使用 reduce() 函数对其中的因素求和
        output = reduce(lambda ret, conn: ret + conn.upstream_node.output * conn.weight, self.upstream, 0)
        # 对上游节点的 output 乘 weights 之后求和得到的结果应用 sigmoid 函数，得到当前节点的 output
        self.output = sigmoid(output)

    def calc_hidden_layer_delta(self):
        '''
        Desc:
            计算隐藏层的节点的 delta
        Args:
            output --- 节点的 output
        Returns:
            None
        '''
        # 根据 https://www.zybuluo.com/hanbingtao/note/476663 的 式4 计算隐藏层的delta
        downstream_delta = reduce(lambda ret, conn: ret + conn.downstream_node.delta * conn.weight, self.downstream, 0.0)
        # 计算此节点的 delta
        self.delta = self.output * (1 - self.output) * downstream_delta

    def calc_output_layer_delta(self, label):
        '''
        Desc:
            计算输出层的 delta
        Args:
            label --- 输入向量对应的真实标签，不是计算得到的结果
        Returns:
            None
        '''
        # 就是那输出层的 delta
        self.delta = self.output * (1 - self.output) * (label - self.output)

    def __str__(self):
        '''
        Desc:
            将节点的信息打印出来
        Args:
            None
        Returns:
            None
        '''
        # 打印格式: 第几层 - 第几个节点，output 是多少，delta 是多少
        node_str = '%u-%u: output: %f delta: %f' % (self.layer_index, self.node_index, self.output, self.delta)
        # 下游节点
        downstream_str = reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
        # 上游节点
        upstream_str = reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.upstream, '')
        # 将本节点 + 下游节点 + 上游节点 的信息打印出来
        return node_str + '\n\tdownstream:' + downstream_str + '\n\tupstream:' + upstream_str


# ConstNode 对象，为了实现一个输出恒为 1 的节点（计算偏置项 wb 时需要）
class ConstNode(object):
    '''
    Desc:
        常数项对象，即相当于计算的时候的偏置项
    '''
    def __init__(self, layer_index, node_index):
        '''
        Desc:
            初始化节点对象
        Args:
            layer_index --- 节点所属的层的编号
            node_index --- 节点的编号
        Returns:
            None
        '''    
        self.layer_index = layer_index
        self.node_index = node_index
        self.downstream = []
        self.output = 1


    def append_downstream_connection(self, conn):
        '''
        Desc:
            添加一个到下游节点的连接
        Args:
            conn --- 到下游节点的连接                                           
        Returns:
            None
        '''
        # 使用 list 的 append 方法将包含下游节点的 conn 添加到 downstream 中        
        self.downstream.append(conn)


    def calc_hidden_layer_delta(self):
        '''
        Desc:
            计算隐藏层的 delta
        Args:
            None
        Returns:
            None
        '''
        # 使用我们的 公式 4 来计算下游节点的 delta，求和
        downstream_delta = reduce(lambda ret, conn: ret + conn.downstream_node.delta * conn.weight, self.downstream, 0.0)
        # 计算隐藏层的本节点的 delta
        self.delta = self.output * (1 - self.output) * downstream_delta


    def __str__(self):
        '''
        Desc:
           将节点信息打印出来
        Args:
            None
        Returns:
            None
        '''
        # 将节点的信息打印出来
        # 格式 第几层-第几个节点的 output 
        node_str = '%u-%u: output: 1' % (self.layer_index, self.node_index)
        # 此节点的下游节点的信息
        downstream_str = reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
        # 将此节点与下游节点的信息组合，一起打印出来
        return node_str + '\n\tdownstream:' + downstream_str


# 神经网络的层对象，负责初始化一层。此外，作为 Node 的集合对象，提供对 Node 集合的操作
class Layer(object):
    '''
    Desc:
        神经网络的 Layer 类
    '''

    def __init__(self, layer_index, node_count):
        '''
        Desc:
            神经网络的层对象的初始化
        Args:
            layer_index --- 层的索引
            node_count --- 节点的个数
        Returns:
            None
        '''
        # 设置 层的索引
        self.layer_index = layer_index
        # 设置层中的节点的 list
        self.nodes = []
        # 将 Node 节点添加到 nodes 中
        for i in range(node_count):
            self.nodes.append(Node(layer_index, i))
        # 将 ConstNode 节点也添加到 nodes 中
        self.nodes.append(ConstNode(layer_index, node_count))

    def set_output(self, data):
        '''
        Desc:
            设置层的输出，当层是输入层时会用到
        Args:
            data --- 输出的值的 list
        Returns:
            None
        '''
        # 设置输入层中各个节点的 output
        for i in range(len(data)):
            self.nodes[i].set_output(data[i])

    def calc_output(self):
        '''
        Desc:
            计算层的输出向量
        Args:
            None
        Returns:
            None
        '''
        # 遍历本层的所有节点（除去最后一个节点，因为它是恒为常数的偏置项b）
        # 调用节点的 calc_output 方法来计算输出向量
        for node in self.nodes[:-1]:
            node.calc_output()

    def dump(self):
        '''
        Desc:
            将层信息打印出来
        Args:
            None
        Returns:
            None
        '''
        # 遍历层的所有的节点 nodes，将节点信息打印出来
        for node in self.nodes:
            print(node)


# Connection 对象类，主要负责记录连接的权重，以及这个连接所关联的上下游的节点
class Connection(object):
    '''
    Desc:
        Connection 对象，记录连接权重和连接所关联的上下游节点，注意，这里的 connection 没有 s ，不是复数
    '''
    def __init__(self, upstream_node, downstream_node):
        '''
        Desc:
            初始化 Connection 对象
        Args:
            upstream_node --- 上游节点
            downstream_node --- 下游节点
        Returns:
            None
        '''
        # 设置上游节点
        self.upstream_node = upstream_node
        # 设置下游节点
        self.downstream_node = downstream_node
        # 设置权重，这里设置的权重是 -0.1 到 0.1 之间的任何数
        self.weight = random.uniform(-0.1, 0.1)
        # 设置梯度 为 0.0
        self.gradient = 0.0

    def calc_gradient(self):
        '''
        Desc:
            计算梯度
        Args:
            None
        Returns:
            None
        '''
        # 下游节点的 delta * 上游节点的 output 计算得到梯度
        self.gradient = self.downstream_node.delta * self.upstream_node.output

    def update_weight(self, rate):
        '''
        Desc:
            根据梯度下降算法更新权重
        Args:
            rate --- 学习率 / 或者成为步长
        Returns:
            None
        '''
        # 调用计算梯度的函数来将梯度计算出来
        self.calc_gradient()
        # 使用梯度下降算法来更新权重
        self.weight += rate * self.gradient

    def get_gradient(self):
        '''
        Desc:
            获取当前的梯度
        Args:
            None
        Returns:
            当前的梯度 gradient 
        '''
        return self.gradient

    def __str__(self):
        '''
        Desc:
            将连接信息打印出来
        Args:
            None
        Returns:
            连接信息进行返回
        '''
        # 格式为: 上游节点的层的索引+上游节点的节点索引 ---> 下游节点的层的索引+下游节点的节点索引，最后一个数是权重
        return '(%u-%u) -> (%u-%u) = %f' % (
            self.upstream_node.layer_index, 
            self.upstream_node.node_index,
            self.downstream_node.layer_index, 
            self.downstream_node.node_index, 
            self.weight)



# Connections 对象，提供 Connection 集合操作。
class Connections(object):
    '''
    Desc:
        Connections 对象，提供 Connection 集合的操作，看清楚后面有没有 s ，不要看错
    '''
    def __init__(self):
        '''
        Desc:
            初始化 Connections 对象
        Args:
            None
        Returns:
            None
        '''
        # 初始化一个列表 list 
        self.connections = []

    def add_connection(self, connection):
        '''
        Desc:
            将 connection 中的节点信息 append 到 connections 中
        Args:
            None
        Returns:
            None
        '''
        self.connections.append(connection)

    def dump(self):
        '''
        Desc:
            将 Connections 的节点信息打印出来
        Args:
            None
        Returns:
            None
        '''
        for conn in self.connections:
            print(conn)


# Network 对象，提供相应 API
class Network(object):
    '''
    Desc:
        Network 类
    '''
    def __init__(self, layers):
        '''
        Desc:
            初始化一个全连接神经网络
        Args:
            layers --- 二维数组，描述神经网络的每层节点数
        Returns:
            None
        '''
        # 初始化 connections，使用的是 Connections 对象
        self.connections = Connections()
        # 初始化 layers
        self.layers = []
        # 我们的神经网络的层数
        layer_count = len(layers)
        # 节点数
        node_count = 0
        # 遍历所有的层，将每层信息添加到 layers 中去
        for i in range(layer_count):
            self.layers.append(Layer(i, layers[i]))
        # 遍历除去输出层之外的所有层，将连接信息添加到 connections 对象中
        for layer in range(layer_count - 1):
            connections = [Connection(upstream_node, downstream_node) for upstream_node in self.layers[layer].nodes for downstream_node in self.layers[layer + 1].nodes[:-1]]
            # 遍历 connections，将 conn 添加到 connections 中
            for conn in connections:
                self.connections.add_connection(conn)
                # 为下游节点添加上游节点为 conn
                conn.downstream_node.append_upstream_connection(conn)
                # 为上游节点添加下游节点为 conn
                conn.upstream_node.append_downstream_connection(conn)


    def train(self, labels, data_set, rate, epoch):
        '''
        Desc:
            训练神经网络
        Args:
            labels --- 数组，训练样本标签，每个元素是一个样本的标签
            data_set --- 二维数组，训练样本的特征数据。每行数据是一个样本的特征
            rate --- 学习率
            epoch --- 迭代次数
        Returns:
            None
        '''
        # 循环迭代 epoch 次
        for i in range(epoch):
            # 遍历每个训练样本
            for d in range(len(data_set)):
                # 使用此样本进行训练（一条样本进行训练）
                self.train_one_sample(labels[d], data_set[d], rate)
                # print 'sample %d training finished' % d

    def train_one_sample(self, label, sample, rate):
        '''
        Desc:
            内部函数，使用一个样本对网络进行训练
        Args:
            label --- 样本的标签
            sample --- 样本的特征
            rate --- 学习率
        Returns:
            None
        '''
        # 调用 Network 的 predict 方法，对这个样本进行预测
        self.predict(sample)
        # 计算根据此样本得到的结果的 delta
        self.calc_delta(label)
        # 更新权重
        self.update_weight(rate)

    def calc_delta(self, label):
        '''
        Desc:
            计算每个节点的 delta
        Args:
            label --- 样本的真实值，也就是样本的标签
        Returns:
            None
        '''
        # 获取输出层的所有节点
        output_nodes = self.layers[-1].nodes
        # 遍历所有的 label
        for i in range(len(label)):
            # 计算输出层节点的 delta
            output_nodes[i].calc_output_layer_delta(label[i])
        # 这个用法就是切片的用法， [-2::-1] 就是将 layers 这个数组倒过来，从没倒过来的时候的倒数第二个元素开始，到翻转过来的倒数第一个数，比如这样: aaa = [1,2,3,4,5,6,7,8,9],bbb = aaa[-2::-1] ==> bbb = [8, 7, 6, 5, 4, 3, 2, 1]
        # 实际上就是除掉输出层之外的所有层按照相反的顺序进行遍历
        for layer in self.layers[-2::-1]:
            # 遍历每层的所有节点
            for node in layer.nodes:
                # 计算隐藏层的 delta
                node.calc_hidden_layer_delta()

    def update_weight(self, rate):
        '''
        Desc:
            更新每个连接的权重
        Args:
            rate --- 学习率
        Returns:
            None
        '''
        # 按照正常顺序遍历除了输出层的层
        for layer in self.layers[:-1]:
            # 遍历每层的所有节点
            for node in layer.nodes:
                # 遍历节点的下游节点
                for conn in node.downstream:
                    # 根据下游节点来更新连接的权重
                    conn.update_weight(rate)

    def calc_gradient(self):
        '''
        Desc:
            计算每个连接的梯度
        Args:
            None
        Returns:
            None
        '''
        # 按照正常顺序遍历除了输出层之外的层
        for layer in self.layers[:-1]:
            # 遍历层中的所有节点
            for node in layer.nodes:
                # 遍历节点的下游节点
                for conn in node.downstream:
                    # 计算梯度
                    conn.calc_gradient()

    def get_gradient(self, label, sample):
        '''
        Desc:
            获得网络在一个样本下，每个连接上的梯度
        Args:
            label --- 样本标签
            sample --- 样本特征
        Returns:
            None
        '''
        # 调用 predict() 方法，利用样本的特征数据对样本进行预测
        self.predict(sample)
        # 计算 delta
        self.calc_delta(label)
        # 计算梯度
        self.calc_gradient()

    def predict(self, sample):
        '''
        Desc:
            根据输入的样本预测输出值
        Args:
            sample --- 数组，样本的特征，也就是网络的输入向量
        Returns:
            使用我们的感知器规则计算网络的输出
        '''
        # 首先为输入层设置输出值output为样本的输入向量，即不发生任何变化
        self.layers[0].set_output(sample)
        # 遍历除去输入层开始到最后一层
        for i in range(1, len(self.layers)):
            # 计算 output
            self.layers[i].calc_output()
        # 将计算得到的输出，也就是我们的预测值返回
        return list(map(lambda node: node.output, self.layers[-1].nodes[:-1]))

    def dump(self):
        '''
        Desc:
            打印出我们的网络信息
        Args:
            None
        Returns:
            None
        '''
        # 遍历所有的 layers
        for layer in self.layers:
            # 将所有的层的信息打印出来
            layer.dump()


# # ------------------------- 至此，基本上我们把 我们的神经网络实现完成，下面还会介绍一下对应的梯度检查相关的算法，现在我们首先回顾一下我们上面写道的类及他们的作用 ------------------------
'''
1、节点类的实现 Node : 负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算。如下: 
layer_index --- 节点所属的层的编号
node_index --- 节点的编号
downstream --- 下游节点
upstream  ---- 上游节点
output    ---- 节点的输出值
delta   ------ 节点的误差项

2、ConstNode 类，偏置项类的实现: 实现一个输出恒为 1 的节点（计算偏置项的时候会用到），如下: 
layer_index --- 节点所属层的编号
node_index ---- 节点的编号
downstream ---- 下游节点
没有记录上游节点，因为一个偏置项的输出与上游节点的输出无关
output    ----- 偏置项的输出

3、layer 类，负责初始化一层。作为的是 Node 节点的集合对象，提供对 Node 集合的操作。也就是说，layer 包含的是 Node 的集合。
layer_index ---- 层的编号
node_count ----- 层所包含的节点的个数
def set_ouput() -- 设置层的输出，当层是输入层时会用到
def calc_output -- 计算层的输出向量，调用的 Node 类的 计算输出 方法

4、Connection 类: 负责记录连接的权重，以及这个连接所关联的上下游节点，如下: 
upstream_node --- 连接的上游节点
downstream_node -- 连接的下游节点
weight   -------- random.uniform(-0.1, 0.1) 初始化为一个很小的随机数
gradient -------- 0.0 梯度，初始化为 0.0 
def calc_gradient() --- 计算梯度，使用的是下游节点的 delta 与上游节点的 output 相乘计算得到
def get_gradient() ---- 获取当前的梯度
def update_weight() --- 根据梯度下降算法更新权重

5、Connections 类: 提供对 Connection 集合操作，如下: 
def add_connection() --- 添加一个 connection

6、Network 类: 提供相应的 API，如下: 
connections --- Connections 对象
layers -------- 神经网络的层
layer_count --- 神经网络的层数
node_count  --- 节点个数
def train() --- 训练神经网络
def train_one_sample() --- 用一个样本训练网络
def calc_delta() --- 计算误差项
def update_weight() --- 更新每个连接权重
def calc_gradient() --- 计算每个连接的梯度
def get_gradient() --- 获得网络在一个样本下，每个连接上的梯度
def predict() --- 根据输入的样本预测输出值 
'''

# #--------------------------------------回顾完成了，有些问题可能还是没有弄懂，没事，我们接着看下面---------------------------------------------

class Normalizer(object):
    '''
    Desc:
        归一化工具类
    Args:
        object --- 对象
    Returns:
        None
    '''
    def __init__(self):
        '''
        Desc:
            初始化
        Args:
            None
        Returns:
            None
        '''
        # 初始化 16 进制的数，用来判断位的，分别是
        # 0x1 ---- 00000001
        # 0x2 ---- 00000010
        # 0x4 ---- 00000100
        # 0x8 ---- 00001000
        # 0x10 --- 00010000
        # 0x20 --- 00100000
        # 0x40 --- 01000000
        # 0x80 --- 10000000
        self.mask = [0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80]

    def norm(self, number):
        '''
        Desc:
            对 number 进行规范化
        Args:
            number --- 要规范化的数据
        Returns:
            规范化之后的数据
        '''
        # 此方法就相当于判断一个 8 位的向量，哪一位上有数字，如果有就将这个数设置为  0.9 ，否则，设置为 0.1，通俗比较来说，就是我们这里用 0.9 表示 1，用 0.1 表示 0
        return list(map(lambda m: 0.9 if number & m else 0.1, self.mask))

    def denorm(self, vec):
        '''
        Desc:
            对我们得到的向量进行反规范化
        Args:
            vec --- 得到的向量
        Returns:
            最终的预测结果
        '''
        # 进行二分类，大于 0.5 就设置为 1，小于 0.5 就设置为 0
        binary = list(map(lambda i: 1 if i > 0.5 else 0, vec))
        # 遍历 mask
        for i in range(len(self.mask)):
            binary[i] = binary[i] * self.mask[i]
        # 将结果相加得到最终的预测结果
        return reduce(lambda x,y: x + y, binary)


def mean_square_error(vec1, vec2):
    '''
    Desc:
        计算平均平方误差
    Args:
        vec1 --- 第一个数
        vec2 --- 第二个数
    Returns:
        返回 1/2 * (x-y)^2 计算得到的值
    '''
    return 0.5 * reduce(lambda a, b: a + b, map(lambda v: (v[0] - v[1]) * (v[0] - v[1]), zip(vec1, vec2)))



def gradient_check(network, sample_feature, sample_label):
    '''
    Desc:
        梯度检查
    Args:
        network --- 神经网络对象
        sample_feature --- 样本的特征
        sample_label --- 样本的标签   
    Returns:
        None
    '''
    # 计算网络误差
    network_error = lambda vec1, vec2: 0.5 * reduce(lambda a, b: a + b, map(lambda v: (v[0] - v[1]) * (v[0] - v[1]), zip(vec1, vec2)))

    # 获取网络在当前样本下每个连接的梯度
    network.get_gradient(sample_feature, sample_label)

    # 对每个权重做梯度检查    
    for conn in network.connections.connections: 
        # 获取指定连接的梯度
        actual_gradient = conn.get_gradient()
    
        # 增加一个很小的值，计算网络的误差
        epsilon = 0.0001
        conn.weight += epsilon
        error1 = network_error(network.predict(sample_feature), sample_label)
    
        # 减去一个很小的值，计算网络的误差
        conn.weight -= 2 * epsilon # 刚才加过了一次，因此这里需要减去2倍
        error2 = network_error(network.predict(sample_feature), sample_label)
    
        # 根据式6计算期望的梯度值
        expected_gradient = (error2 - error1) / (2 * epsilon)
    
        # 打印
        print('expected gradient: \t%f\nactual gradient: \t%f' % (expected_gradient, actual_gradient))


def train_data_set():
    '''
    Desc:
        获取训练数据集
    Args:
        None
    Returns:
        labels --- 训练数据集每条数据对应的标签
    '''
    # 调用 Normalizer() 类
    normalizer = Normalizer()
    # 初始化一个 list，用来存储后面的数据
    data_set = []
    labels = []
    # 0 到 256 ，其中以 8 为步长
    for i in range(0, 256, 8):
        # 调用 normalizer 对象的 norm 方法
        n = normalizer.norm(int(random.uniform(0, 256)))
        # 在 data_set 中 append n
        data_set.append(n)
        # 在 labels 中 append n
        labels.append(n)
    # 将它们返回
    return labels, data_set


def train(network):
    '''
    Desc:
        使用我们的神经网络进行训练
    Args:
        network --- 神经网络对象
    Returns:
        None
    '''
    # 获取训练数据集
    labels, data_set = train_data_set()
    labels = list(labels)
    data_set = list(labels)
    # 调用 network 中的 train方法来训练我们的神经网络
    network.train(labels, data_set, 0.3, 50)


def test(net,data):
    #此函数不明觉厉，但是传参就有问题，如果跑不通就把这段代码注释掉吧。。。

    '''
    Desc:
        对我们的全连接神经网络进行测试
    Args:
        network --- 神经网络对象
        data ------ 测试数据集
    Returns:
        None
    '''
    # 调用 Normalizer() 类

    normalizer = Normalizer()
    # 调用 norm 方法，对数据进行规范化
    norm_data = normalizer.norm(data)
    norm_data = list(norm_data)
    # 对测试数据进行预测
    predict_data = net.predict(norm_data)
    # 将结果打印出来
    print('\ttestdata(%u)\tpredict(%u)' % (data, normalizer.denorm(predict_data)))


def correct_ratio(network):
    '''
    Desc:
        计算我们的神经网络的正确率
    Args:
        network --- 神经网络对象
    Returns:
        None
    '''
    normalizer = Normalizer()
    correct = 0.0
    for i in range(256):
        if normalizer.denorm(network.predict(normalizer.norm(i))) == i:
            correct += 1.0
    print('correct_ratio: %.2f%%' % (correct / 256 * 100))


def gradient_check_test():
    '''
    Desc:
        梯度检查测试
    Args:
        None
    Returns:
        None
    '''
    # 创建一个有 3 层的网络，每层有 2 个节点
    net = Network([2, 2, 2])
    # 样本的特征
    sample_feature = [0.9, 0.1]
    # 样本对应的标签
    sample_label = [0.9, 0.1]
    # 使用梯度检查来查看是否正确
    gradient_check(net, sample_feature, sample_label)


if __name__ == '__main__':
    '''
    Desc:
        主函数
    Args:
        None
    Returns:
        None
    '''
    # 初始化一个神经网络，输入层 8 个节点，隐藏层 3 个节点，输出层 8 个节点
    net = Network([8, 3, 8])
    # 训练我们的神经网络
    train(net)
    # 将我们的神经网络的信息打印出来
    net.dump()
    # 打印出神经网络的正确率
    correct_ratio(net)
