9.神经网络与深度学习(八)—程序

 

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

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

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


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值