9.神经网络与深度学习（八）—程序

最新推荐文章于 2022-06-04 19:30:00 发布

quinn1994

最新推荐文章于 2022-06-04 19:30:00 发布

阅读量489

点赞数

分类专栏：机器学习神经网络与机器学习

本文链接：https://blog.csdn.net/quinn1994/article/details/79930009

版权

机器学习同时被 2 个专栏收录

24 篇文章 9 订阅

订阅专栏

神经网络与机器学习

16 篇文章 5 订阅

订阅专栏

这里我们主要介绍与之前代码所不同的地方。

1）cost function

示例代码如下：

class QuadraticCost(object):
    @staticmethod
    def fn(a, y):
        return 0.5*np.linalg.norm(a-y)**2

    @staticmethod
    def delta(z, a, y):
        """Return the error delta from the output layer."""
        return (a-y) * sigmoid_prime(z)

这里定义了一个二次代价函数的类，你可能注意到这里用了这里静态方法@staticmethod来定义类，这样我们无需声明实例就可以调用类。这里还有一个要注意的地方就是np.linalg.norm(x, ord=None, axis=None, keepdims=False)方法，这里numpy自带的线性代数库中的求矩阵范数的方法。x表示矩阵，ord是范数类型。

class CrossEntropyCost(object):
    @staticmethod
    def fn(a, y):
        return np.sum(np.nan_to_num(-y*np.log(a)-(1-y)*np.log(1-a)))

    @staticmethod
    def delta(z, a, y):
        return (a-y)

这里定义了crossentropycost类。这里要注意的是nan_to_num方法，这是一个数值转化函数。在使用numpy运算数组的时候，时常会出现nan或者inf的元素，可能会造成数值计算时的一些错误。这里使用0代替数组中的nan元素，使用有限的数字代替inf元素。

你可能要问了，为什么代价函数要定义类呢？直接定义一个函数多方便。

实际上cost函数在整个算法中有两个作用：

衡量网络输出值和理想值的匹配程度。
用BP计算偏导数时，需要计算误差ξ。

因此，我们需要定义一个类来应付不同的情况。

2）权重初始化(weight initial)

示例代码如下：

def default_weight_initializer(self):
 
        self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]
        self.weights = [np.random.randn(y, x)/np.sqrt(x)
                        for x, y in zip(self.sizes[:-1], self.sizes[1:])]

    def large_weight_initializer(self):

        self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]
        self.weights = [np.random.randn(y, x)
                        for x, y in zip(self.sizes[:-1], self.sizes[1:])]

这里又定义了一种权重初始化方式default_weight_initializer，就是我们之前所说的将权重按照正态分布N(0，1/√n)来初始化。我们可以看到这里程序中的权重矩阵randn(y,x)都除以了sqrt(x)。

3）SGD

这里的SGD函数多加了些标志位，用来监控返回各种参数的变化情况。示例代码如下：

  def SGD(self, training_data, epochs, mini_batch_size, eta,
            lmbda = 0.0,   #规范化参数
            evaluation_data=None,#验证数据
            monitor_evaluation_cost=False,#验证集cost
            monitor_evaluation_accuracy=False,#验证集准确率
            monitor_training_cost=False,#训练集cost
            monitor_training_accuracy=False):#训练集准确率

        if evaluation_data: n_data = len(evaluation_data)
                #如果验证集存在 对验证集求长
        n = len(training_data)
        evaluation_cost, evaluation_accuracy = [], []
        training_cost, training_accuracy = [], []
                #初始化数组
        for j in range(epochs):
            random.shuffle(training_data)
            mini_batches = [
                training_data[k:k+mini_batch_size]
                for k in range(0, n, mini_batch_size)]
            for mini_batch in mini_batches:
                self.update_mini_batch(
                    mini_batch, eta, lmbda, len(training_data))
            print ("Epoch %s training complete"% j)
            if monitor_training_cost:
                cost = self.total_cost(training_data, lmbda)
                training_cost.append(cost)
                print ("Cost on training data: {}".format(cost))
             #如果训练集监控标志位开启，则对训练集数据计算准确率，并打印
            if monitor_training_accuracy:
                accuracy = self.accuracy(training_data, convert=True)
                training_accuracy.append(accuracy)
                print ("Accuracy on training data: {} / {}".format(
                    accuracy, n))
            if monitor_evaluation_cost:
                cost = self.total_cost(evaluation_data, lmbda, convert=True)
                evaluation_cost.append(cost)
                print ("Cost on evaluation data: {}".format(cost))
            if monitor_evaluation_accuracy:
                accuracy = self.accuracy(evaluation_data)
                evaluation_accuracy.append(accuracy)
                print( "Accuracy on evaluation data: {} / {}".format(
                    self.accuracy(evaluation_data), n_data))
            print
        return evaluation_cost, evaluation_accuracy, \
            training_cost, training_accuracy

准确率计算函数（类似于之前的evaluate函数）如下：

 def accuracy(self, data, convert=False):
        if convert:
            results = [(np.argmax(self.feedforward(x)), np.argmax(y))
                       for (x, y) in data]
        #如果设置开启，那么输出最大的实际值和期望值
        else:
            results = [(np.argmax(self.feedforward(x)), y)
                        for (x, y) in data]
        return sum(int(x == y) for (x, y) in results)
        # 返回实际值和期望值相等的值的个数

这里要注意的是argmax(a, axis=None, out=None) 函数，这个函数的意思是返回轴axis上最大值的索引。

代价计算函数，示例代码如下：

    def total_cost(self, data, lmbda, convert=False):
        cost = 0.0
        for x, y in data:#遍历数据中的输入值（784）和期望值（标签）
            a = self.feedforward(x)
            #激励输入值
            if convert: y = vectorized_result(y)
            #将期望值向量化
            cost += self.cost.fn(a, y)/len(data)
            #求平均cross-entropy代价
        cost += 0.5*(lmbda/len(data))*sum(
            np.linalg.norm(w)**2 for w in self.weights)
            #w向量二范数的平方和
        return cost

4）update_mini_batch

示例代码如下：

    def update_mini_batch(self, mini_batch, eta, lmbda, n):
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        for x, y in mini_batch:
            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
            #BP算法得到偏导数
            nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
            nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
            #偏导数求和
        self.weights = [(1-eta*(lmbda/n))*w-(eta/len(mini_batch))*nw
                        for w, nw in zip(self.weights, nabla_w)]
         #权重w规范化
        self.biases = [b-(eta/len(mini_batch))*nb
                       for b, nb in zip(self.biases, nabla_b)]

这里唯一不同的就是加入了权重规范化，公式如下：

5）存储参数

示例代码如下：

    def save(self, filename):
        data = {"sizes": self.sizes,
                "weights": [w.tolist() for w in self.weights],
                "biases": [b.tolist() for b in self.biases],
                "cost": str(self.cost.__name__)}
        f = open(filename, "w")
        json.dump(data, f)
        f.close()

该方法将神经网络训练好的参数放到一个文件当中。这里要注意的是numpy.tolist()函数，这里将矩阵转化成列表保存。还有json.dump函数，将数据转化成字符存到文件中。

6）载入参数

#### Loading a Network
def load(filename):
    f = open(filename, "r")
    #打开文件
    data = json.load(f)
    #载入数据放到data中
    f.close()
    cost = getattr(sys.modules[__name__], data["cost"])
    #根据函数名（func_name）获得对象
    net = Network(data["sizes"], cost=cost)
    #实例化对象，将data的大小和cost实例化
    net.weights = [np.array(w) for w in data["weights"]]
    net.biases = [np.array(b) for b in data["biases"]]
    return net

结束。希望有志同道合的小伙伴关注我的公众平台，欢迎您的批评指正，共同交流进步。