1.4 使用神经网络解决问题

到这里为止，我们的准备工作就做好了。现在，我们对一个简单的数据集进行神经网络的学习。

1.4.1 螺旋状数据集

本书在dataset目录中提供了几个便于处理数据集的类，本节将使用其中的dataset/spiral.py文件。这个文件中实现了读取螺旋（旋涡）状数据的类，其用法如下所示（ch01/show_spiral_dataset.py）。

        import sys
        sys.path.append（'..'）  # 为了引入父目录的文件而进行的设定
        from dataset import spiral
        import matplotlib.pyplot as plt

        x, t = spiral.load_data（）
        print （'x', x.shape） # (300, 2)
        print （'t', t.shape） # (300, 3)

在上面的例子中，要从ch01目录的dataset目录引入spiral.py。因此，上面的代码通过sys.path.append（'..'）将父目录添加到了import的检索路径中。

然后，使用spiral.load_data（）进行数据的读入。此时，x是输入数据， t是监督标签。观察x和t的形状，可知它们各自有300笔样本数据，其中x是二维数据，t是三维数据。另外，t是one-hot向量，对应的正确解标签的类标记为1，其余的标记为0。下面，我们把这些数据绘制在图上，结果如图1-31所示。

如图1-31所示，输入是二维数据，类别数是3。观察这个数据集可知，它不能被直线分割。因此，我们需要学习非线性的分割线。那么，我们的神经网络（具有使用非线性的sigmoid激活函数的隐藏层的神经网络）能否正确学习这种非线性模式呢？让我们实验一下。

因为这个实验相对简单，所以我们不把数据集分成训练数据、验证数据和测试数据。不过，实际任务中会将数据集分为训练数据和测试数据（以及验证数据）来进行学习和评估。

1.4.2 神经网络的实现

现在，我们来实现一个具有一个隐藏层的神经网络。首先，import语句和初始化程序的__init__（）如下所示（ch01/two_layer_net.py）。

        import sys
        sys.path.append（'..'）
        import numpy as np
        from common.layers import Affine, Sigmoid, SoftmaxWithLoss

        class TwoLayerNet:
            def__init__（self, input_size, hidden_size, output_size）:
                I, H, O = input_size, hidden_size, output_size

                # 初始化权重和偏置
                W1 = 0.01 * np.random.randn（I, H）
                b1 = np.zeros（H）
                W2 = 0.01 * np.random.randn（H, O）
                b2 = np.zeros（O）

                # 生成层
                self.layers = [
                    Affine（W1, b1）,
                    Sigmoid（）,
                    Affine（W2, b2）
                ]
                self.loss_layer = SoftmaxWithLoss（）
                  # 将所有的权重和梯度整理到列表中
                  self.params, self.grads = [], []
                  for layer in self.layers:
                      self.params += layer.params
                      self.grads += layer.grads

初始化程序接收3个参数。input_size是输入层的神经元数，hidden_size是隐藏层的神经元数，output_size是输出层的神经元数。在内部实现中，首先用零向量（np.zeros（））初始化偏置，再用小的随机数（0.01 *np.random.randn（））初始化权重。通过将权重设成小的随机数，学习可以更容易地进行。接着，生成必要的层，并将它们整理到实例变量layers列表中。最后，将这个模型使用到的参数和梯度归纳在一起。

因为Softmax with Loss层和其他层的处理方式不同，所以不将它放入layers列表中，而是单独存储在实例变量loss_layer中。

接着，我们为TwoLayerNet实现3个方法，即进行推理的predict（）方法、正向传播的forward（）方法和反向传播的backward（）方法（ ch01/two_layer_net.py）。

        def predict（self, x）:
            for layer in self.layers:
                x = layer.forward（x）
            return x

        def forward（self, x, t）:
            score = self.predict（x）
            loss = self.loss_layer.forward（score, t）
            return loss

        def backward（self, dout=1）:
            dout = self.loss_layer.backward（dout）
            for layer in reversed（self.layers）:
                dout = layer.backward（dout）
            return dout

如上所示，这个实现非常清楚。因为我们已经将神经网络中要用的处理模块实现为了层，所以这里只需要以合理的顺序调用这些层的forward（）方法和backward（）方法即可。

1.4.3 学习用的代码

下面，我们来看一下学习用的代码。首先，读入学习数据，生成神经网络（模型）和优化器。然后，按照之前介绍的学习的4个步骤进行学习。另外，在机器学习领域，通常将针对具体问题设计的方法（神经网络、SVM等）称为模型。学习用的代码如下所示（ch01/train_custom_loop.py）。

        import sys
        sys.path.append（'..'）
        import numpy as np
        from common.optimizer import SGD
        from dataset import spiral
        import matplotlib.pyplot as plt
        from two layer net import TwoLayerNet

        # ❶设定超参数
        max_epoch = 300
        batch_size = 30
        hidden_size = 10
        learning_rate = 1.0

        # ❷读入数据，生成模型和优化器
        x, t = spiral.load_data（）
        model = TwoLayerNet（input_size=2, hidden_size=hidden_size, output_size=3）
        optimizer = SGD（lr=learning_rate）

        # 学习用的变量
        data_size = len（x）
        max_iters = data_size // batch_size
        total_loss = 0
        loss_count = 0
        loss_list = []
        for epoch in range（max_epoch）:
            # ❸打乱数据
            idx = np.random.permutation（data_size）
            x = x[idx]
            t = t[idx]

            for iters in range（max_iters）:
                batch_x = x[iters*batch_size:（iters+1）*batch_size]
                batch_t = t[iters*batch_size:（iters+1）*batch_size]

            # ❹计算梯度，更新参数
            loss = model.forward（batch_x, batch_t）
            model.backward（）
            optimizer.update（model.params, model.grads）
            total_loss += loss
            loss_count += 1

            # ❺定期输出学习过程
            if （iters+1） % 10 == 0:
                avg_loss = total_loss / loss_count
                print （'| epoch %d |  iter %d / %d | loss %.2f'
                      % （epoch + 1, iters + 1, max_iters, avg_loss））
                loss_list.append（avg_loss）
                total_loss, loss_count = 0, 0

首先，在代码❶的地方设定超参数。具体而言，就是设定学习的epoch数、mini-batch的大小、隐藏层的神经元数和学习率。接着，在代码❷的地方进行数据的读入，生成神经网络（模型）和优化器。我们已经将2层神经网络实现为了TwoLayerNet类，将优化器实现为了SGD类，这里直接使用它们就可以。

epoch表示学习的单位。1个epoch相当于模型“看过”一遍所有的学习数据（遍历数据集）。这里我们进行300个epoch的学习。

在进行学习时，需要随机选择数据作为mini-batch。这里，我们以epoch为单位打乱数据，对于打乱后的数据，按顺序从头开始抽取数据。数据的打乱（准确地说，是数据索引的打乱）使用np.random.permutation（）方法。给定参数N，该方法可以返回0到N-1的随机序列，其实际的使用示例如下所示。

        >>> import numpy as np
        >>> np.random.permutation(10)
        array（[7, 6, 8, 3, 5, 0, 4, 1, 9, 2]）

        >>> np.random.permutation(10)
        array（[1, 5, 7, 3, 9, 2, 8, 6, 0, 4]）

像这样，调用np.random.permutation（）可以随机打乱数据的索引。

接着，在代码❹的地方计算梯度，更新参数。最后，在代码❺的地方定期地输出学习结果。这里，每10次迭代计算1次平均损失，并将其添加到变量loss_list中。以上就是学习用的代码。

这里实现的神经网络的学习用的代码在本书其他地方也可以使用。因此，本书将这部分代码作为Trainer类提供出来。使用Trainer类，可以将神经网络的学习细节嵌入Trainer类。详细的用法将在1.4.4节说明。

运行一下上面的代码（ch01/train_custom_loop.py）就会发现，向终端输出的损失的值在平稳下降。我们将结果画出来，如图1-32所示。

由图1-32可知，随着学习的进行，损失在减小。我们的神经网络正在朝着正确的方向学习！接下来，我们将学习后的神经网络的区域划分（也称为决策边界）可视化，结果如图1-33所示。

由图1-33可知，学习后的神经网络可以正确地捕获“旋涡”这个模式。也就说，模型正确地学习了非线性的区域划分。像这样，神经网络通过隐藏层可以实现复杂的表现力。深度学习的特征之一就是叠加的层越多，表现力越丰富。

1.4.4 Trainer类

如前所述，本书中有很多机会执行神经网络的学习。为此，就需要编写前面那样的学习用的代码。然而，每次都写相同的代码太无聊了，因此我们将进行学习的类作为Trainer类提供出来。Trainer类的内部实现和刚才的源代码几乎相同，只是添加了一些新的功能而已，我们在需要的时候再详细说明其用法。

Trainer类的代码在common/trainer.py中。这个类的初始化程序接收神经网络（模型）和优化器，具体如下所示。

        model = TwoLayerNet（...）
        optimizer = SGD（lr=1.0）
        trainer = Trainer（model, optimizer）

然后，调用fit（）方法开始学习。fit（）方法的参数如表1-1所示。

另外，Trainer类有plot（）方法，它将fit（）方法记录的损失（准确地说，是按照eval_interval评价的平均损失）在图上画出来。使用Trainer类进行学习的代码如下所示（ch01/train.py）。

        import sys
        sys.path.append（'..'）
        from common.optimizer import SGD
        from common.trainer import Trainer
        from dataset import spiral
        from two layer net import TwoLayerNet

        max_epoch = 300
        batch_size = 30
        hidden_size = 10
        learning_rate = 1.0

        x, t = spiral.load_data（）
        model = TwoLayerNet（input_size=2, hidden_size=hidden_size, output_size=3）
        optimizer = SGD（lr=learning_rate）

        trainer = Trainer（model, optimizer）
        trainer.fit（x, t, max_epoch, batch_size, eval_interval=10）
        trainer.plot（）

执行这段代码，会进行和之前一样的神经网络的学习。通过将之前展示的学习用的代码交给Trainer类负责，代码变简洁了。本书今后都将使用Trainer类进行学习。