「ハンズオンディープラーニング」 - 線形ニューラルネットワーク

参考文献:

• 「ディープラーニング体験」

3.1 線形回帰

3.1.1 線形回帰の基本要素

サンプル: $n$表示样権，${バツ}^{\left(私\right)}=[{\times }_1^{(私}、{バツ}_2^{(私}、\cdots 、{バツ}_d^{(私}]\; は$iiを意味します。$私は$サンプルを作ります。

予測: $y=w^T\times +b\; は$単一サンプルの予測値を表します。$y=Xw+b\; は$すべてのサンプルの予測値を表します。

损失関数数：
$$L(w,b)=\sum _{i=1}\frac{}{2}(y^{\left(私\right)}-y^{\left(i\right)})$$

確率的勾配降下法: 各反復では、まずミニバッチ$B$、固定数のトレーニング サンプルで構成されます。次に、パラメーターは次のように更新されます:
$$(w、b)\leftarrow (w、b)-\frac{}{|B|}\underset{i\in B}{}{\partial }_{(w,b}{私}^{\left(i\right)}(w、b)$$
其中，$\eta$は学習率であり、ハイパーパラメータです。

3.1.2 ベクトル化の高速化

可能な限り効率的な線形代数ライブラリを使用してください。

3.1.3 正規分布と二乗損失

観測にノイズが多いと仮定します$ϵ$ :
$$y=w^{\top }\times +b+ϵ,$$
lessϵ$ϵ〜N(0,p^2)$。

次の方程式を求めます。
$$P(と|\times ）=\frac{}{\sqrt{2本{\_}^2}}\mathrm{経験値}\left(-\frac{}{2P{\_}^2}(y-w^{\top }\times -b{)}^2\right)$$
この場合、尤度関数は次のようになります:
$$L(w,b)=\prod _{i=1}p({と}^{\left(i\right)}|x^{\left(i\right)})$$
取对数再加负号，得：
$$-l(w,b)=\sum _{i=1}\left(\frac{}{2}\log \right(2\pi \sigma \_{}^2)+\frac{}{2P{\_}^2}{\left(y^{\left(私\right)}-w^{\top }{\times }^{\left(私\right)}-b\right)}^2)\; .例外\pi$$
、σ \pi、 \$p、\sigma$は定数であるため、上式から、線形モデルの最小平均二乗誤差が最尤推定と同等であることがわかります。

3.1.4 線形回帰からディープネットワークへ

3.2 線形回帰を最初から実装する

3.2.1 データセットの生成

1000 個のサンプルを含むデータセットを生成したいとします。各サンプルには、標準正規分布からサンプリングされた2 つの特徴が含まれており、サンプルのラベルは次のとおりです。
$$y=Xw+b+ϵ$$
ここで、$w=[2、-3.4{]}^{\top }$、$b=4.2$ ,$ϵ\; は、$平均 0、標準偏差 0.01 の正規分布に従います。

def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, y.shape)
    # 如果没有y.reshape，那么y将只有一个维度
    return X, y.reshape((-1, 1))

3.2.2 データセットの読み取り

確率的勾配降下法では、毎回サンプルからサンプルの一部をランダムに選択する必要があるため、data_iterサンプル抽出を次のように定義できます。

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    # 这些样本是随机读取的，没有特定的顺序
    random.shuffle(indices)
    # 在一轮训练中要用到所有的样本
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)])
        # 每次参数更新只用到一小部分样本
        yield features[batch_indices], labels[batch_indices]

上記のコードはサンプルを抽出するプロセスを理解するためにのみ使用されており、実際の実装では組み込みの反復子を使用できます。

3.2.3 初期化パラメータ

w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

3.2.4 モデルの定義

def linreg(X, w, b):
    """线性回归模型"""
    return torch.matmul(X, w) + b

3.2.5 損失関数の定義

def squared_loss(y_hat, y):
    """均方损失"""
    # 这里的y.reshape其实是没有必要的，因为labels在前面已经reshape过了
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

3.2.6 最適化アルゴリズムの定義

def sgd(params, lr, batch_size):
    """小批量随机梯度下降"""
    # 表示下一个代码块不需要进行梯度计算
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            # 清空梯度
            param.grad.zero_()

3.2.7 トレーニング

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {
      
      epoch + 1}, loss {
      
      float(train_l.mean()):f}')

3.3 線形回帰の簡単な実装

3.3.1 データの生成

この部分は3.2.1と同じです。

3.3.2 データセットの読み取り

from torch.utils import data

dataAPI を直接使用してサンプル サンプリングを実行できます。

def load_array(data_arrays, batch_size, is_train=True):
    """构造一个PyTorch数据迭代器"""
    # TensorDataset相当于把所有tensor打包，传入的tensor的第0维必须相同
    # *的作用是“解压”参数列表
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)
# 访问数据
for input,label in data_iter:
    print(input,label)

3.3.3 モデルの定義

# nn是神经网络的缩写
from torch import nn

net = nn.Sequential(nn.Linear(2, 1))

上記のコードでは、Sequential複数のレイヤーを直列に接続できます。Linear完全に接続されたレイヤーが実装され、そのパラメーターによって2,1入力の形状と出力の形状が指定されます。

3.3.4 モデルパラメータの初期化

# net[0]表示选中网络中的第0层
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

3.3.5 損失関数の定義

# 返回所有样本损失的均值
loss = nn.MSELoss()

3.3.6 最適化アルゴリズムの定義

# SGD的输入为参数和超参数
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

3.3.7 トレーニング

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        trainer.zero_grad()
        l.backward()
        # 使用优化器对参数进行更新
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch {
      
      epoch + 1}, loss {
      
      l:f}')

3.4 ソフトマックス回帰

3.4.1 分類の問題

一般に、さまざまなカテゴリはワンホット エンコーディングによって表されます。

3.4.2 ネットワークアーキテクチャ

各サンプルに 4 つの特徴と 3 つの可能なカテゴリがあると仮定すると、ソフトマックス回帰のネットワーク構造は次の図に示されます。

3.4.3 全結合層のパラメータオーバーヘッド

一般に、全結合層には$d$入力と$q$出力の場合、そのパラメータのオーバーヘッドは$O\left(dp\right)$。

3.4.4 ソフトマックス演算

分類問題の場合、取得したいのは入力が各カテゴリに属する​​確率であるため、確率の基本公理を満たすように出力を処理する必要があります:
$$y=ソフトマックス\left(o\right)\text{の}{y}_{}=\frac{\exp (o_{}}{\underset{k}{}\exp \left(o_{}\right)}$$
形式、$y$の各成分は正の定数であり、合計は$1$、およびソフトマックスは変更されません$o$と の間の大きさのオーダー

3.4.5 ミニバッチサンプルのベクトル化

KaTeX 解析エラー: 'EOF' が予期されましたが、位置 13 で '&' を取得しました: \mathbf{O} &̲= \mathbf{X}\m。

3.4.6 損失関数

ソフトマックス回帰の尤度関数は次のとおりです。
$$L\left(i\right)=\prod _{i=1}P({と}^{\left(私\right)}|{バツ}^{\left(i\right)})$$
取数、得：
$$\begin{array}{rl}-ログ\_L\left(i\right)& =\sum _{i=1}-ログ\_P({と}^{\left(私\right)}|{バツ}^{\left(i\right)})\\ & =\sum _{i=1}\sum _{j=1}-y_{}ログ\_y_{}\end{array}$$

上の式を次のように説明します。サンプルのラベルは$q$のワンホット エンコーディングであるため、内部の合計は実際には入力からラベルを導出する確率の負の対数であり、これは− log ⁡ P ( y ( i ) ∣ x ( i ) ) -\と同じです。$-ログ\_P({と}^{\left(私\right)}|{バツ}^{\left(i\right)})\; は$同等です。

略称：
$$l(y,y)=\sum _{j=1}-y_{}ログ\_y_{}$$
1 つはクロスエントロピー損失(クロスエントロピー損失)
$$\begin{array}{rl}l(y,y)& =-\sum _{j=1}{y}_{}ログ\_\frac{\exp (o_{}}{{\sum }_{k=1}^{}\exp \left(o_{}\right)}\\ & =\sum _{j=1}{y}_{}ログ\_\sum _{k=1}\exp \left(o_{}\right)-\sum _{j=1}{y}_{}{ああ}_{}\\ & =ログ\_\sum _{k=1}\exp \left(o_{}\right)-\sum _{j=1}{y}_{}{ああ}_{}\\ {\partial }_{{ああ}_{}}l(y,y& =\frac{\exp (o_{}}{{\sum }_{k=1}^{}\exp \left(o_{}\right)}-y_{}=ソフトマックス(o{)}_{}-y_{}\end{array}$$
勾配が観測値yyであることがわかります。$y$と推定値$y$これにより、実際の勾配の計算が非常に簡単になります。

3.5 画像分類データセット

3.5.2 データの小さなバッチの読み取り

batch_size = 256

def get_dataloader_workers():
    """使用4个进程来读取数据"""
    return 4

train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
                             num_workers=get_dataloader_workers())

3.6 ソフトマックス回帰を最初から実装する

3.6.1 モデルパラメータの初期化

入力は 28*28 の画像で、長さ 784 のベクトルと見なすことができます。出力は 10 の可能なカテゴリに属する​​確率であるため、$W\; は$784*10 行列、$b$は 1*10 の行ベクトルです。

num_inputs = 784
num_outputs = 10

W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

3.6.2 ソフトマックス演算の定義

ソフトマックスの実装は3 つのステップで構成されます。

1. 各項を累乗します。
2. 各行 (各サンプルはミニバッチ内の行です) を合計して、各サンプルの正規化定数を取得します。
3. 各行を正規化定数で除算し、結果の合計が 1 になるようにします。

対応するコードは次のとおりです。

def softmax(X):
    X_exp = torch.exp(X)
    # 确保求和之后张量的维度不变
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition  # 这里应用了广播机制

3.6.3 モデルの定義

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

ここでの入力が画像だけなのはなぜですか?

3.6.4 損失関数の定義

def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

cross_entropy(y_hat, y)

その中には、yサンプルのカテゴリ番号を表すラベル リスト ( など) があります[0,1,3]。

3.6.5 分類精度

精度 = 正しい予測の数 / 予測の総数

def accuracy(y_hat, y):
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

上記のコードは次のように述べています。 がy_hat行列の場合、2 番目の次元には各クラスの予測スコアが格納されると想定されます。を使用してargmax各行の最大要素のインデックスを取得し、予測されたクラスを取得します。次に、y予測されたカテゴリをグラウンド トゥルース要​​素と比較します。等価演算子 " ==" はデータ型に依存するため、 のデータ型と一致するようy_hatに のデータ型を変換します。y結果は、0 (偽) と 1 (真) を含むテンソルになります。最後に、合計して正しい予測の数を取得します。

3.7 ソフトマックス回帰の簡単な実装

3.7.1 モデルパラメータの初期化

# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

# apply会对net里的每一层执行init_weights函数
# 所以init_weights函数里的m是用来限定只初始化Linear层参数的
net.apply(init_weights);

3.7.2 損失関数の定義

CorssEntropyLoss入力は$o$ (ソフトマックスなし) とラベルのリストの場合、出力はクロス エントロピーです。言い換えれば、ソフトマックスの指数演算は非常にオーバーフローしやすいため、損失を計算するときにソフトマックスを通じて出力を確率に変換する必要はありません。

# none表示不合并结果，即loss为一个列表，元素为每个样本的交叉熵
# 这里之所以选择none，是因为后面既要用到损失的总和，又要用到损失的均值
loss = nn.CrossEntropyLoss(reduction='none')

3.7.3 最適化アルゴリズム

trainer = torch.optim.SGD(net.parameters(), lr=0.1)

3.7.4 トレーニング

# 累加器类
class Accumulator:
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
	
    # 将参数列表逐个加到累加器里
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

def train_epoch_ch3(net, train_iter, loss, updater):
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练精度
    return metric[0] / metric[2], metric[1] / metric[2]

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式
    metric = Accumulator(2)  # 正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            # 这里的accuracy出自3.6.5
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型（定义见第3章）"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        # 训练一轮
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        # 在测试集上测试精度
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    train_loss, train_acc = train_metrics
    # 这条代码的意思是：如果train_loss<0.5则继续执行，否则报错，报错内容为"train_loss"
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc

num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

3.7.5 予測

を使用するだけですy_hat.argmax(axis=1)。