メインコンテンツへスキップ
見出し画像

PyTorchで作るノイズ除去オートエンコーダ

    この記事では、入力画像からノイズを除去するためのオートエンコーダ(Auto-Encoder)をPyTorchで実装します。

    画像データセットはMNISTを使います。データセットの詳細はこちらを参照してください。ノイズを加えた画像を訓練データとして使用し、ノイズのない画像を復元することを目的としています。そのために、オートエンコーダのアーキテクチャを利用します。

    画像
    上段:ノイズ有り。下段:ノイズ除去後。

    また、実装では線形層を主に使ったものと畳み込み層を導入したもの両方を使って実験し、その効果を比較します。畳み込みを利用したオートエンコーダでは、以前に解説した転置畳み込み層を利用します。よって、転置畳み込みを使ったモデルの実装の参考にもなります。

    では、さっそく始めましょう。

    オートエンコーダの仕組み

    オートエンコーダには2つの部分があります。それは、エンコーダ(Encoder)とデコーダ(デコーダ)です。

    エンコーダ

    エンコーダは入力データを圧縮します。つまり、次元が削減されます。こうすることによって元のデータから重要な特徴量などの情報を抽出することを目的としています。

    画像
    エンコーダは画像を圧縮

    デコーダ

    デコーダは圧縮された情報を使って画像を復元します。

    画像
    デコーダは画像を復元

    そのためエンコーダが圧縮したデータには画像を復元できるだけの重要な情報が含まれている必要があります。

    オートエンコーダ

    エンコーダが圧縮した情報は、デコーダが利用するためのものです。よって、エンコーダとデコーダを組み合わせて同時に訓練します。

    画像
    オートエンコーダ

    つまり、エンコーダが入力画像から抽出した情報をもとにエンコーダが画像を復元します。復元された画像が入力画像に近くなるように平均二乗誤差(MSE、Mean Sqaured Error)を使って訓練します。

    このように自らがエンコードした情報をデコードで復元します。これをオートエンコーダと呼びます。

    2つの実装について

    今回は、2種類のオートエンコーダを実装します。

    • 線形オートエンコーダ(LinearAutoEncoder)の実装では線形層と活性化関数ReLUを交互に繰り返します。

    • 畳み込みオートエンコーダ(ConvolutionalAutoEncoder)の実装では畳み込み層と転置畳み込み層を利用します。

    畳み込みを使うのは、画像からの特徴量を抽出するのに適しているからです。線形層よりも良い結果になることが期待されます。また、転置畳み込みを使うことで画像の拡大を効果的に行うことを学習できるようになっています。

    これら二つの実装の効果を比較するために、後で実験します。

    以下に各オートエンコーダの実装を解説します。

    線形オートエンコーダ

    線形オートエンコーダは次のように定義されています。

    class LinearAutoEncoder(nn.Module):
        def __init__(self):
            super().__init__()
    
            # エンコーダ
            self.encoder = nn.Sequential(
                nn.Linear(28 * 28, 256),
                nn.ReLU(),
                nn.Linear(256, 128),
                nn.ReLU(),
                nn.Linear(128, 64),
            )
    
            # デコーダ
            self.decoder = nn.Sequential(
                nn.Linear(64, 128),
                nn.ReLU(),
                nn.Linear(128, 256),
                nn.ReLU(),
                nn.Linear(256, 28 * 28),
                nn.Sigmoid()
            )
    
        def forward(self, x: torch.Tensor) -> torch.Tensor:
            # 平坦化する
            x = x.flatten(start_dim=1)
    
            # エンコーダで入力画像データを圧縮
            x = self.encoder(x)
    
            # デコーダで入力画像データを復元
            x = self.decoder(x)
    
            # 画像サイズに戻す
            x = x.view(-1, 1, 28, 28)
            return x

    エンコーダ

    MNISTの画像のサイズは 28x28 なので、これを平坦化したものを入力データとします。よって、入力データの次元は28x28=784 ですが、これを線形層を使って 256 へと圧縮します。その後に、ReLU で非線形の変換を行います。なお、非線形性が必要な理由についてはこちらで解説しています。

    続けて、エンコーダは線形層とReLUを交互に繰り返し、128、64へとデータの次元を圧縮していきます。

            # エンコーダ
            self.encoder = nn.Sequential(
                nn.Linear(28 * 28, 256),
                nn.ReLU(),
                nn.Linear(256, 128),
                nn.ReLU(),
                nn.Linear(128, 64),
            )

    デコーダ

    デコーダは、圧縮されたデータを64から128、256へと変換し、最終的には 28x28 へと復元します。

            # デコーダ
            self.decoder = nn.Sequential(
                nn.Linear(64, 128),
                nn.ReLU(),
                nn.Linear(128, 256),
                nn.ReLU(),
                nn.Linear(256, 28 * 28),
                nn.Sigmoid()
            )

    最後は、データの値を0から1の範囲に収めるためにシグモイド関数(nn.Sigmoid)を使います。

    フィードフォワード

    フィードフォワードでは、エンコーダとデコーダを順番に実行します。

        def forward(self, x: torch.Tensor) -> torch.Tensor:
            # 平坦化する
            x = x.flatten(start_dim=1)
    
            # エンコーダで入力画像データを圧縮
            x = self.encoder(x)
    
            # デコーダで入力画像データを復元
            x = self.decoder(x)
    
            # 画像サイズに戻す
            x = x.view(-1, 1, 28, 28)
            return x

    まず、画像データを平坦化したものをエンコーダで圧縮します。圧縮されたデータはデコーダによって画像データへと復元されます。最後に平坦なデータを縦横28x28ピクセルのサイズに戻します。

    畳み込みオートエンコーダ

    畳み込みオートエンコーダも線形オートエンコーダと同じ構造を持ちますが、畳み込み層や転置畳み込みを使うところが異なります。また、畳み込み層や転置畳み込みでは、画像を平坦化する必要はありません。

    class ConvolutionalAutoEncoder(nn.Module):
        def __init__(self):
            super().__init__()
    
            # Encoder
            self.encoder = nn.Sequential(
                nn.Conv2d(1, 16, kernel_size=3, padding=1),  # 1x28x28 -> 16x28x28
                nn.ReLU(),
                nn.MaxPool2d(2),                             # 16x14x14
                nn.Conv2d(16, 32, kernel_size=3, padding=1), # 32x14x14
                nn.ReLU(),
                nn.MaxPool2d(2),                             # 32x7x7
                nn.Conv2d(32, 64, kernel_size=7),            # 64x1x1
            )
    
            # Decoder
            self.decoder = nn.Sequential(
                nn.ConvTranspose2d(64, 32, kernel_size=7),   # 64x1x1 -> 32x7x7
                nn.ReLU(),
                nn.ConvTranspose2d(32, 16, kernel_size=3,    # 32x7x7 -> 16x14x14
                    padding=1, stride=2, output_padding=1),
                nn.ReLU(),
                nn.ConvTranspose2d(16, 1, kernel_size=3,     # 16x14x14 -> 1x28x28
                    padding=1, stride=2, output_padding=1),
                nn.Sigmoid()                                 # [0,1]に変換する
            )
    
        def forward(self, x):
            # エンコーダで入力画像データを圧縮
            x = self.encoder(x)
    
            # デコーダで入力画像データを復元
            x = self.decoder(x)
            return x

    エンコーダ

    MNSITの画像はモノクロで、1つのチャンネルしかありません。まず、畳み込み(nn.Conv2d)を使うことで1つのチャンネルから16のチャンネル(特徴マップ)へと次元を高め、さらにReLUで非線形性を加えます。その後に、最大値プーリング(nn.MaxPool2d)で縦横のサイズを半分し削減します。

            # Encoder
            self.encoder = nn.Sequential(
                nn.Conv2d(1, 16, kernel_size=3, padding=1),  # 1x28x28 -> 16x28x28
                nn.ReLU(),
                nn.MaxPool2d(2),                             # 16x14x14
                nn.Conv2d(16, 32, kernel_size=3, padding=1), # 32x14x14
                nn.ReLU(),
                nn.MaxPool2d(2),                             # 32x7x7
                nn.Conv2d(32, 64, kernel_size=7),            # 64x1x1
            )

    このように畳み込み、ReLUと最大値プーリングを繰り返すことで特徴マップの数を増やしつつ、縦横のサイズを小さくしていきます。最終的には、7x7のエリアに7x7の畳み込みを適用しているのでサイズが縦横1x1になります。また、特徴マップのチャンネル数は64となるので、画像データが64個の値へと圧縮されています。

    デコーダ

    デコーダは、転置畳み込み層を用いて、入力されたデータを段階的に元の大きさに戻す処理を行っています。画像サイズは、1x1、7x7、14x14、28x28 へと拡大されます。また、特徴マップを64、32、16、1へと変換し、最終的には1チャンネルの画像を復元します。

            # Decoder
            self.decoder = nn.Sequential(
                nn.ConvTranspose2d(64, 32, kernel_size=7),   # 64x1x1 -> 32x7x7
                nn.ReLU(),
                nn.ConvTranspose2d(32, 16, kernel_size=3,    # 32x7x7 -> 16x14x14
                    padding=1, stride=2, output_padding=1),
                nn.ReLU(),
                nn.ConvTranspose2d(16, 1, kernel_size=3,     # 16x14x14 -> 1x28x28
                    padding=1, stride=2, output_padding=1),
                nn.Sigmoid()                                 # [0,1]に変換する
            )

    転置畳み込みは、畳み込みとは逆に画像を拡大するために使われます。ちょっと複雑なのですが、出力サイズは次のように計算できます。

    S(I−1)−2P+D(K−1)+O+1S (I - 1) - 2P + D (K - 1) + O + 1

    • SS:ストライド(stride)

    • II:入力データの縦サイズ、あるいは横サイズ

    • DD:膨張(dilation)

    • PP:パディング(padding)

    • KK:カーネルサイズ(kernel_size)

    • OO:出力パディング(output_padding)

    例えば、1番目の転置畳み込みでは、カーネルサイズが7だけ指定してあるので、他はデフォルトの値(S=1, P=0, D=1, O=0)となります。

    nn.ConvTranspose2d(64, 32, kernel_size=7),   # 64x1x1 -> 32x7x7

    よって、出力サイズは、1(1−1)−2×0+1(7−1)+0+1=71(1-1)-2\times 0 + 1(7 - 1) + 0 + 1 = 7となります。つまり、エンコーダが圧縮した 1x1 のサイズのデータは、7x7のサイズに拡大されて出力されます。

    逆に考えると、7x7 のサイズに対してカーネルサイズが7の畳み込みを適用すると 1x1 のサイズに圧縮されることの反対を行なっていることになります。つまり、エンコーダの最後の畳み込みの逆を行く演算を行なっている分けです。

    また、2番目の転置畳み込みで、stride = 2 としているのは出力側で位置を2つずつ移動させているということでサイズを拡大する効果があります。これも反対に考えると、出力から入力へとサイズを縮小することの逆を行なっていることになります。

                nn.ConvTranspose2d(32, 16, kernel_size=3,    # 32x7x7 -> 16x14x14
                    padding=1, stride=2, output_padding=1),

    さらに、padding=1 になっているのは、出力の周りの値を削る効果があります。つまり、反対に考えると出力から入力へと畳み込みを適用する際にパディングを1としているのだから元のデータはパディングのぶんだけ小さくなるということです。また、output_padding = 1 は、出力のサイズに1を足す効果があります。

    2番目の転置畳み込みをまとめると、次のようになります。7x7の入力データに3x3のカーネルを適用する(1x1 から 3x3 へのマッピングをする)ので、stride=1 だとサイズは 9x9 です。しかし、ここでは stride=2 となっているので出力側にマッピングするときに2つずつ位置をずらします。よって、サイズは 13x13 となります。ただし、output_padding=1 が指定されているのでサイズは 14x14 となり望まれるサイズへと拡大されるのがわかります。

    3番目の転置畳み込みも同様の操作をしてサイズを28x28にしています。つまり、14x14の入力データに3x3のカーネルを適用する(1x1 から 3x3 へのマッピングをする)ので、stride=1 だとサイズはサイズは 16x16 です。しかし、ここでも stride=2 となっているので出力側にマッピングするときに2つずつ位置をずらしています。よって、サイズは 27x27 となります。ただし、output_padding=1 が指定されているのでサイズは 28x28 となり元の画像のサイズへと変換されています。

    PyTorchのnn.ConvTranspose2dの詳細はこちらを参照してください。

    フィードフォワード

    畳み込みを使うので画像の変形を行う必要がなく、フィードフォワードの実装はとても簡単です。

        def forward(self, x):
            # エンコーダで入力画像データを圧縮
            x = self.encoder(x)
    
            # デコーダで入力画像データを復元
            x = self.decoder(x)
            return x

    エンコーダで入力データを圧縮して、デコーダで復元するだけです。

    訓練ループ

    以下は、訓練ループのコードです。ただし、画像を表示するコードを除外して読みやすくしています。全体のコードは後に掲載します。

    def train(
        epochs: int,
        batch_size: int,
        learning_rate: float,
        n_test_images: int,
        noise_factor: float,
        use_conv: bool):
    
        # MNISTデータセット
        train_data = MNIST(
            root='./data/',
            train=True,                      # 訓練データを取得する
            transform=transforms.ToTensor(), # NumPy配列をTensorに変換する
                                             # 0から255の値を0.0から1.0の範囲に変換する
            download=True,                   # ./data/にデータがない場合はダウンロードする
        )
    
        # データローダー(ミニバッチ)を作成する
        train_loader = DataLoader(dataset=train_data, 
                                  batch_size=batch_size,
                                  shuffle=True)
        
        # モデルを作成する
        if use_conv:
            autoencoder = ConvolutionalAutoEncoder()
        else:
            autoencoder = LinearAutoEncoder()
    
        # 最適化アルゴリズムと損失関数を定義する
        optimizer = torch.optim.Adam(autoencoder.parameters(), lr=learning_rate)
        loss_func = nn.MSELoss()
    
        # 訓練ループ
        for epoch in range(epochs):
            losses = []
            for step, (image, label) in enumerate(train_loader):
                # ノイズを加える
                noisy_image = add_noise(image, noise_factor)
    
                # 入力画像をエンコードしてデコードする
                decoded = autoencoder(noisy_image)
                
                # もとの画像と再構成した画像の誤差
                loss = loss_func(decoded, image)
                
                # パラメータを更新する
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    
                # 損失を記録する
                losses.append(loss.item())

    データセットやデータローダの解説はここでは省きますが、詳細はこちらにあります。

    モデルの作成

    モデルは、use_conv が True ならば、畳み込みオートエンコーダを作成し、さもなければ(デフォルトで)線形オートエンコーダを作成します。

        # モデルを作成する
        if use_conv:
            autoencoder = ConvolutionalAutoEncoder()
        else:
            autoencoder = LinearAutoEncoder()

    オプティマイザと損失関数

    特筆することはありませんが、オプティマイザとしてADAMを使っています。また、損失関数は、平均2条誤差(Mean Squared Error)です。

        # 最適化アルゴリズムと損失関数を定義する
        optimizer = torch.optim.Adam(autoencoder.parameters(), lr=learning_rate)
        loss_func = nn.MSELoss()

    訓練ループ

    オプティマイザ、損失関数、訓練ループなどはこちらでも解説しています。このでの訓練ループでも基本的な流れは同じです。ただし、ノイズを除去を学習するために幾つかの工夫があります。

        # 訓練ループ
        for epoch in range(epochs):
            losses = []
            for step, (image, label) in enumerate(train_loader):
                # ノイズを加える
                noisy_image = add_noise(image, noise_factor)
    
                # 入力画像をエンコードしてデコードする
                decoded = autoencoder(noisy_image)
                
                # もとの画像と再構成した画像の誤差
                loss = loss_func(decoded, image)
                
                # パラメータを更新する
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    
                # 損失を記録する
                losses.append(loss.item())

    まず、ノイズを除去を学習するために、入力データにノイズを追加しています。そのため次のファンクションを定義しました。

    def add_noise(image: torch.Tensor, noise_factor: float) -> torch.Tensor:
        # ノイズを加えない場合はそのまま返す
        if noise_factor <= 0.0:
            return image
        
        # ノイズを加える
        noise = torch.randn(image.size()) * noise_factor
        noisy_image = image + noise
        noisy_image = torch.clamp(noisy_image, 0., 1.)
        return noisy_image

    単純に標準正規分布からのランダムな値を画像に対しています。その際に noise_factor で指定された値を掛け合わせています。これによってノイズの大きさをコントロールします。また、画像データなので値の範囲は0から1に限定されるように torch.clamp を使っています。

    なお、noise_factor が0以下だとノイズは追加されません。

    あとは、オートエンコーダにノイズ付きの画像(noisy_image)を入力してデコーダによって復元された画像(decoded)とノイズを含まないオリジナルの画像(image)とを比較して損失値を計算します。

                # 入力画像をエンコードしてデコードする
                decoded = autoencoder(noisy_image)
                
                # もとの画像と再構成した画像の誤差
                loss = loss_func(decoded, image)

    こうすることで、ノイズ付きの画像からノイズ無しの画像を復元できるようになります。エンコーダとデコーダを使うことでノイズ無しの画像を構成する特徴量を抽出してノイズ無しの画像を生成することを学習することが可能となっています。

    実験の準備

    ソースコード

    以下は、全体のソースコードです。

    import argparse
    import matplotlib.pyplot as plt
    import numpy as np
    import torch
    from torchvision import transforms
    from torchvision.datasets import MNIST
    from torch.utils.data import DataLoader, Dataset
    from torch import nn
    
    
    class LinearAutoEncoder(nn.Module):
        def __init__(self):
            super().__init__()
    
            # エンコーダ
            self.encoder = nn.Sequential(
                nn.Linear(28 * 28, 256),
                nn.ReLU(),
                nn.Linear(256, 128),
                nn.ReLU(),
                nn.Linear(128, 64),
            )
    
            # デコーダ
            self.decoder = nn.Sequential(
                nn.Linear(64, 128),
                nn.ReLU(),
                nn.Linear(128, 256),
                nn.ReLU(),
                nn.Linear(256, 28 * 28),
                nn.Sigmoid()
            )
    
        def forward(self, x: torch.Tensor) -> torch.Tensor:
            # 平坦化する
            x = x.flatten(start_dim=1)
    
            # エンコーダで入力画像データを圧縮
            x = self.encoder(x)
    
            # デコーダで入力画像データを復元
            x = self.decoder(x)
    
            # 画像サイズに戻す
            x = x.view(-1, 1, 28, 28)
            return x
    
    
    class ConvolutionalAutoEncoder(nn.Module):
        def __init__(self):
            super().__init__()
    
            # Encoder
            self.encoder = nn.Sequential(
                nn.Conv2d(1, 16, kernel_size=3, padding=1),  # 1x28x28 -> 16x28x28
                nn.ReLU(),
                nn.MaxPool2d(2),                             # 16x14x14
                nn.Conv2d(16, 32, kernel_size=3, padding=1), # 32x14x14
                nn.ReLU(),
                nn.MaxPool2d(2),                             # 32x7x7
                nn.Conv2d(32, 64, kernel_size=7),            # 64x1x1
            )
    
            # Decoder
            self.decoder = nn.Sequential(
                nn.ConvTranspose2d(64, 32, kernel_size=7),   # 64x1x1 -> 32x7x7
                nn.ReLU(),
                nn.ConvTranspose2d(32, 16, kernel_size=3,    # 32x7x7 -> 16x14x14
                    padding=1, stride=2, output_padding=1),
                nn.ReLU(),
                nn.ConvTranspose2d(16, 1, kernel_size=3,     # 16x14x14 -> 1x28x28
                    padding=1, stride=2, output_padding=1),
                nn.Sigmoid()                                 # [0,1]に変換する
            )
    
        def forward(self, x):
            # エンコーダで入力画像データを圧縮
            x = self.encoder(x)
    
            # デコーダで入力画像データを復元
            x = self.decoder(x)
            return x
    
    
    def train(
        epochs: int,
        batch_size: int,
        learning_rate: float,
        n_test_images: int,
        noise_factor: float,
        use_conv: bool):
    
        # MNISTデータセット
        train_data = MNIST(
            root='./data/',
            train=True,                         # 訓練データを取得する
            transform=transforms.ToTensor(),    # NumPy配列をTensorに変換する
                                                # 0から255の範囲の整数値を0から1の範囲の浮動小数点数に変換する
            download=True,                      # ./data/にデータがない場合はダウンロードする
        )
    
        # データローダー(ミニバッチ)を作成する
        train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True)
        
        # モデルを作成する
        if use_conv:
            autoencoder = ConvolutionalAutoEncoder()
        else:
            autoencoder = LinearAutoEncoder()
    
        # 最適化アルゴリズムと損失関数を定義する
        optimizer = torch.optim.Adam(autoencoder.parameters(), lr=learning_rate)
        loss_func = nn.MSELoss()
    
        # テスト用の画像を準備する
        test_images = []
        for i in range(n_test_images):
            test_images.append(add_noise(train_data[i][0], noise_factor))
        test_images = torch.stack(test_images)
    
        # 画像を継続して表示する
        fig, (ax1, ax2) = plt.subplots(2, n_test_images, figsize=(n_test_images, 2))
        plt.ion() # インタラクティブモードをオンにする
        
        # テスト用の画像を表示する(最初の行)
        show_input_images(test_images, ax1)
    
        # 訓練ループ
        for epoch in range(epochs):
            losses = []
            for step, (image, label) in enumerate(train_loader):
                # ノイズを加える
                noisy_image = add_noise(image, noise_factor)
    
                # 入力画像をエンコードしてデコードする
                decoded = autoencoder(noisy_image)
                
                # もとの画像と再構成した画像の誤差
                loss = loss_func(decoded, image)
                
                # パラメータを更新する
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    
                # 損失を記録する
                losses.append(loss.item())
                
                # 100ステップごとに進捗を画像として表示する
                if step % 100 == 0:
                    # テスト用の画像を表示する(2行目)
                    show_decoded_images(test_images, ax2, autoencoder)
    
                    # 画像を更新する
                    plt.draw()
                    plt.pause(0.05) # 一時停止して描画する時間を与える
    
            # エポックごとに進捗の数値を表示する
            print(f'Epoch: {epoch+1} | 平均損失: {np.mean(losses):.4f}')
    
        # インタラクティブモードをオフにして、最後の画像を表示する
        plt.ioff()
        plt.show()
    
    
    def add_noise(image: torch.Tensor, noise_factor: float) -> torch.Tensor:
        # ノイズを加えない場合はそのまま返す
        if noise_factor <= 0.0:
            return image
        
        # ノイズを加える
        noise = torch.randn(image.size()) * noise_factor
        noisy_image = image + noise
        noisy_image = torch.clamp(noisy_image, 0., 1.)
        return noisy_image
    
    
    def show_input_images(test_images: torch.Tensor, ax: plt.Axes):
        for i, image in enumerate(test_images):
            # チャンネルの次元を削除する
            image = image.numpy().squeeze() # 1x28x28 -> 28x28
    
            # 画像を表示する
            ax[i].imshow(image, cmap='gray')
            ax[i].set_xticks(())
            ax[i].set_yticks(())
    
    
    def show_decoded_images(test_images: torch.Tensor, ax: plt.Axes, autoencoder: nn.Module):
        for i, image in enumerate(test_images):
            # 入力画像をエンコードしてデコードする
            batch = image.unsqueeze(0) # バッチの次元を追加する
            decoded = autoencoder(batch)
    
            # デコードされた画像から不要な次元(バッチ、チャンネル)を削除する
            decoded = decoded.detach().numpy().squeeze()
    
            # 画像を追加する
            ax[i].clear()
            ax[i].imshow(decoded, cmap='gray')
            ax[i].set_xticks(())
            ax[i].set_yticks(())
    
    
    def main():
        # コマンドライン引数を取得する
        parser = argparse.ArgumentParser(description='AutoEncoder')
        parser.add_argument('--epoch', type=int, default=5)
        parser.add_argument('--batch_size', type=int, default=16)
        parser.add_argument('--lr', type=float, default=0.5e-3)
        parser.add_argument('--n_test_images', type=int, default=10)
        parser.add_argument('--noise', type=float, default=0.0)
        parser.add_argument('--conv', action='store_true')
        args = parser.parse_args()
    
        # 訓練する
        train(
            epochs        = args.epoch,
            batch_size    = args.batch_size,
            learning_rate = args.lr,
            n_test_images = args.n_test_images,
            noise_factor  = args.noise,
            use_conv      = args.conv
        )
    
    
    if __name__ == '__main__':
        main()
    

    このコードを autoencoder.py に保存してください。

    Python環境の設定

    ここでは、pip を使ってPython環境を設定します。以下を requirements.txt に保存してください。

    matplotlib==3.8.1
    torch==2.1.0
    torchvision==0.16.0

    次のようにしてPython環境を設定してください。

    # 適当な場所にフォルダを作る
    mkdir autoencoder
    cd autoencoder
    
    # pip を使える環境を作る
    python3 -m venv venv
    source venv/bin/activate
    
    # pip を最新にする
    pip install --upgrade pip
    
    # 依存関係をインストールする
    pip install -r requirements.txt 

    以上で、実験をする準備ができました。

    実験結果

    コマンドライン引数

    コマンドラインからは次のパラメータの指定が可能です。

    usage: autoencoder.py [-h] [--epoch EPOCH] [--batch_size BATCH_SIZE]
                               [--lr LR] [--n_test_images N_TEST_IMAGES]
                               [--noise NOISE] [--conv]
    
    AutoEncoder
    
    options:
      -h, --help            show this help message and exit
      --epoch EPOCH
      --batch_size BATCH_SIZE
      --lr LR
      --n_test_images N_TEST_IMAGES
      --noise NOISE
      --conv
    • ecoch: 訓練のエポックの数

    • batch_size: バッチサイズ

    • lr: 学習率(Learning rate)

    • n_test_images(テストで使う画像の数)

    • noise: ノイズの大きさ

    • conv: 畳み込みオートエンコーダを使うときに指定する

    線形オートエンコーダ(ノイズ無し)

    デフォルトでは、線形オートエンコーダがノイズ無しで学習します。

    python autoencoder.py

    ノイズがないのでオリジナルの画像を圧縮して復元するだけです。学習はかなり速く進みます。

    画像
    上段が入力画像、下段が出力画像

    5回のエポックの後の結果は以下になります。

    Epoch: 1 | 平均損失: 0.0309
    Epoch: 2 | 平均損失: 0.0151
    Epoch: 3 | 平均損失: 0.0113
    Epoch: 4 | 平均損失: 0.0094
    Epoch: 5 | 平均損失: 0.0083
    画像

    かなり精巧にオリジナルの画像を復元しているのがわかります。

    線形オートエンコーダ(ノイズ有り)

    ノイズ付きで線形オートエンコーダを訓練します。

     python autoencoder.py --noise 0.5

    ノイズ有りでも学習が進んでいるのが確認できます。

    画像
    上段が入力画像、下段が出力画像

    5回のエポックの後の結果は以下になります。

    Epoch: 1 | 平均損失: 0.0422
    Epoch: 2 | 平均損失: 0.0269
    Epoch: 3 | 平均損失: 0.0226
    Epoch: 4 | 平均損失: 0.0203
    Epoch: 5 | 平均損失: 0.0188
    画像

    ノイズが削除されているのが確認できます。ただし、4と5の復元が少し曖昧な感じがします。

    畳み込みオートエンコーダ(ノイズ有り)

    ノイズ付きで畳み込みオートエンコーダを訓練します。

    python autoencoder.py --noise 0.5 --conv

    こちらもノイズ有りで学習が進んでいるのが確認できます。

    画像

    5回のエポックの後の結果は以下になります。

    Epoch: 1 | 平均損失: 0.0303
    Epoch: 2 | 平均損失: 0.0148
    Epoch: 3 | 平均損失: 0.0131
    Epoch: 4 | 平均損失: 0.0123
    Epoch: 5 | 平均損失: 0.0117
    画像

    いい勝負ですが、線形オートエンコーダよりも細部の再現度が高いように感じます。損失値も多少低くなっています。

    まとめ

    今回は、PyTorchを使ってノイズ除去をするオートエンコーダを実装しました。仕組みは簡単ですが、効果は抜群なのが実験を通して確認できました。

     
     
    「わかりやすく、具体的に」AIとサイエンスの情報を発信中

    あなたへのおすすめ