「GANが人工的なセレブリティのアイデンティティを作り出す方法」

「人工的なセレブリティのアイデンティティを創造するGANの方法」

イントロダクション

人工知能の時代において、驚くべき現象が展開されています――生成対抗ネットワーク（GAN）が創造的に人工的なセレブリティのアイデンティティを作り出しています。このテクノロジーと創造性の興味深い融合により、完全に新しいタイプのデジタルセレブリティが生まれました。私たちと一緒に、仮想世界を魅了する人工的なセレブリティパーソナリティの創造の魔法を紐解いていく興味深い旅に出かけましょう。GAN の世界に飛び込み、このデジタル芸術の秘密を探求しましょう。どのようにしてGANがこれを実現するのでしょうか？このデジタルアートの裏に隠された秘密を探求しましょう。

学習目標

この記事では、以下のことを学びます。

• 生成対抗ネットワーク（GAN）の概念
• ジェネレーターとディスクリミネーターの訓練方法
• GANモデルの実装のステップバイステッププロセス
• 敵対的なトレーニングを通じてGANが時間とともに改善する仕組み

この記事は、データサイエンスブログマラソンの一環として公開されました。

生成対抗ネットワーク（GAN）

生成対抗ネットワーク（GAN）は、Goodfellowによって開発された深層学習モデルです。その名前からも、GANの目的を理解することができます。そうです！私たちは生成の目的でそれを使用します。GANは何かを生成するネットワークです。画像、テキスト、音声など、現実世界のデータに似た合成データを生成するためにGANを使用します。GANは2つのニューラルネットワークから構成されています。これらはジェネレーターとディスクリミネーターと呼ばれます。トレーニング中、この2つのネットワークはお互いに競い合いながらより良い性能を発揮するように訓練されます。

• 「カスタムファインチューニングされた大規模言語モデルの安全性への深い潜入」
• 「Hugging Face AutoTrainを使用して、LLM（Language Model）を微調整する方法」
• このAIの論文は、純粋なゼロショットの設定で、タスクの適応と未知のタスクや環境への一般化に優れたCLIN（Continuous Learning Language Agent）を紹介しています

ジェネレーターとは？

ジェネレーターは、生成を担当するニューラルネットワークです。出力をするためには入力が必要です。ジェネレーターが受け取る入力はランダムなノイズです。ジェネレーターはこのランダムなノイズを受け取り、実データに似た出力を生成しようとします。ディスクリミネーターからフィードバックを受け取るたびに、ジェネレーターは自己改善し、次回はより良いデータを生成します。たとえば、画像生成の場合、ジェネレーターは画像を生成します。トレーニングを通じてジェネレーターが改善するにつれ、最初はランダムなノイズから始まり、次第に出力を洗練させてより現実的になります。最初の試行では、元のデータに最も似たものを生成することができないかもしれません。時にはまったく画像ではないものさえ生成することもあります。トレーニングが進むにつれ、より正確な良質なデータが生成されます。

ディスクリミネーターとは？

ディスクリミネーターは、評価を担当するニューラルネットワークです。簡単に理解するために、それを探偵と呼ぶことができます。このディスクリミネーターは、実際のデータとジェネレーターによって生成された偽のデータの両方を受け取ります。偽のデータを実データと区別する必要があります。簡単に言えば、実際のデータと偽のデータを分類するということです。ジェネレーターと同様に、トレーニングが進むとディスクリミネーターもより優れた判別ができるようになります。最初の試みでは最高の結果を出せないかもしれませんが、トレーニングが進むにつれてより良い結果を出せるようになり、最終的にはほとんどの偽のデータを識別できるようになります。探偵のように働く必要があります。

敵対的トレーニング

ジェネレーターとディスクリミネーターの両方が訓練を受け、これは敵対的トレーニングと呼ばれています。両者はお互いに競争的なトレーニングを行います。ジェネレーターが実データに似た偽のデータを生成し、ディスクリミネーターは偽のデータを識別しようとします。トレーニングプロセスの次のステップでは、ジェネレーターは自己改善を目指し、ディスクリミネーターを騙すための偽のデータを生成します。再びディスクリミネーターが偽のデータを検出します。このようにトレーニング中、両者はそれぞれのタスクでより良いパフォーマンスを発揮します。このプロセスは、ジェネレーターが非常に現実的なデータを生成し、ディスクリミネーターが本物と区別できなくなるまで続けられます。この段階でGANはある種の均衡状態に達し、生成されたデータは非常に実データに似ています。

“`html

実装

まず、必要なライブラリをすべてインポートしましょう。これには主にtorchモジュールが含まれます。可視化のためにmatplotlibを使用します。

from __future__ import print_function%matplotlib inlineimport argparseimport osimport randomimport torchimport torch.nn as nnimport torch.nn.parallelimport torch.backends.cudnn as cudnnimport torch.optim as optimimport torch.utils.dataimport torchvision.datasets as dsetimport torchvision.transforms as transformsimport torchvision.utils as vutilsimport numpy as npimport matplotlib.pyplot as pltimport matplotlib.animation as animationfrom IPython.display import HTML

データセット

このプロジェクトの実装では、CelebFaces属性（CelebA）データセットを使用します。このデータセットはKaggleで利用できます。次のリンクからダウンロードできます。

データセットのリンク：　https://www.kaggle.com/datasets/jessicali9530/celeba-dataset

このデータセットには、さまざまな有名人の202,599枚の顔画像が含まれています。特定の顔の特徴を認識できるモデルの訓練とテストに使用します。

初期設定およびセットアップ

実際の実装を開始する前に、いくつかのパラメータと設定を行いましょう。まず、データセットが存在するパスを指定する必要があります。ワーカーの数を定義します。これは、データローダーのデータ読み込みワーカーの数を表します。データローダーでは、並列でデータのバッチを読み込んでデータの読み込みプロセスを高速化します。バッチサイズ、画像サイズ、トレーニング画像のチャネル数、潜在ベクトルのサイズ、ジェネレータの特徴マップのサイズ、ディスクリミネータの特徴マップのサイズ、エポック数、学習率、Adam最適化アルゴリズムのbeta1ハイパーパラメーターを定義します。トレーニングに利用できるGPUの数を指定します。GPUが利用できない場合は、CPUを使用します。これらの設定を行い、選択されたデバイス（CPUまたはGPU）とトレーニングに使用されるGPUの数を出力します。GANモデルをトレーニングする際には、これらの設定を重要視する必要があります。

# データセットdataroot = r"C:\Users\Admin\Downloads\faces\img_align_celeba"workers = 1batch_size = 16image_size = 64nc = 3# z潜在ベクトルの大きさnz = 64# ジェネレータの特徴マップの大きさngf = 64# ディスクリミネータの特徴マップの大きさndf = 64num_epochs = 5lr = 0.0001beta1 = 0.2ngpu = 1device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")torch.backends.cudnn.benchmark = Trueprint(device)print(ngpu)

データローダー

トレーニングデータのためのPyTorchのデータセットとデータローダーを作成しましょう。dset.ImageFolderクラスを使用してデータセット変数を作成します。このPyTorchデータセットクラスは、フォルダに整理されたデータを読み込むために2つの必須引数を要求します。データセット内の各画像に対して一連の変更を適用する、変換として知られるものです。

torch.utils.data.DataLoaderを使用して、データをバッチでロードするためのdataloader変数を作成します。これは、定義したデータセットとバッチサイズを取ります。それに加えて、データのロードに使用するワーカープロセスの数とデータをシャッフルするかどうかを指定する必要があります。このワーカープロセスの数は先に定義しておきました。トレーニング前にデータをシャッフルすることで、モデルがすべてのエポックで同じ順序の画像を見ることがないようにします。

その後、いくつかのトレーニング画像をプロットして、トレーニングデータの外観を把握しましょう。

# データセットの作成dataset = dset.ImageFolder(root=dataroot,                           transform=transforms.Compose([                               transforms.Resize(image_size),                               transforms.CenterCrop(image_size),                               transforms.ToTensor(),                               transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),                           ]))# データローダーの作成dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,                                         shuffle=True, num_workers=workers)# いくつかのトレーニング画像のプロットreal_batch = next(iter(dataloader))plt.figure(figsize=(8,8))plt.axis("off")plt.title("トレーニング画像")plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64],            padding=2, normalize=True).cpu(),(1,2,0)))

“`

ノイズジェネレーション

さあ、ノイズを作成しましょう。このノイズはGANのジェネレータへの入力です。ノイズ（）関数はランダムなノイズを生成します。それでは定義しましょう。この関数は引数を取らず、値が0から1の一様分布からサンプリングされた形状（nz, ngf）のランダムテンソルを作成します。また、乱数テンソルを2倍してから1を引いて、値が-1から1の間になるようにスケーリングします。このノイズテンソルは他のデータ（ラベルや潜在ベクトルなど）と連結され、イメージを生成するためにジェネレータにフィードされます。

def noise(): return 2 * torch.rand(nz, ngf, device=device) - 1

ジェネレータ

それでは、ジェネレータを定義しましょう。そのために、ジェネレータクラスを定義する必要があります。次に、コンストラクタメソッドを指定します。ngpu入力を受け入れ、どれだけのGPUがトレーニングに使用可能かを示します。ngpuパラメータはマルチGPUトレーニングを扱うために使用されますが、このコードでは使用されていません。コンストラクタ内では、ジェネレータのアーキテクチャが定義されています。

Sequentialブロックは、入力xに対して一連の畳み込み操作、バッチ正規化、および活性化関数を適用します。次に、出力イメージを生成する最終畳み込み層を定義します。それがself.toImageです。過去の層からのフィーチャマップを使用して、所望の3チャネルイメージを作成します。

次に、forwardメソッドを定義する必要があります。ジェネレータのジェネレータパスフォワードは、このメソッドによって定義されます。入力xを取ります。このxはノイズベクトルまたは潜在ベクトルであり、コンストラクタで定義されたレイヤーを通過させます。結果は生成されたイメージです。最初に、入力xは潜在層を通過した後に変換されます。その後、定義されたすべての畳み込み層を通して処理されます。各畳み込み層の後に、対応する層の前のフィーチャマップとフィーチャマップが連結されます。これにより、ジェネレータは高レベルの特徴と空間の詳細をキャプチャできます。生成されたイメージは最終畳み込み層の出力から取得され、フォワードパスの結果として返されます。

# GeneratorCodeclass Generator(nn.Module): def __init__(self, ngpu): super(Generator, self).__init__() self.ngpu = ngpu self.fromLatent = nn.Linear(ngf, (image_size*image_size//16)*ndf) self.dlayer1 = nn.Sequential( nn.Conv2d(ndf, ndf, 3, padding=1), nn.BatchNorm2d(ndf), nn.ELU(inplace=True), nn.Conv2d(ndf, ndf, 3, padding=1), nn.BatchNorm2d(ndf), nn.ELU(inplace=True) ) self.dlayer2 = nn.Sequential( nn.Upsample(scale_factor=2), nn.Conv2d(2 * ndf, ndf, 3, padding=1), nn.BatchNorm2d(ndf), nn.ELU(inplace=True), nn.Conv2d(ndf, ndf, 3, padding=1), nn.BatchNorm2d(ndf), nn.ELU(inplace=True) ) self.dlayer3 = nn.Sequential( nn.Upsample(scale_factor=2), nn.Conv2d(2 * ndf, ndf, 3, padding=1), nn.BatchNorm2d(ndf), nn.ELU(inplace=True), nn.Conv2d(ndf, ndf, 3, padding=1), nn.BatchNorm2d(ndf), nn.ELU(inplace=True) ) self.toImage = nn.Conv2d(ndf, 3, 3, padding=1) def forward(self, x): x = self.fromLatent(x) x = x.view(x.size(0), ndf, image_size//4, image_size//4) h0 = x x = self.dlayer1(x) x = torch.cat([x, h0], dim=1) x = self.dlayer2(x) h0 = nn.functional.interpolate(h0, scale_factor=2, mode='nearest') x = torch.cat([x, h0], dim=1) x = self.dlayer3(x) x = self.toImage(x) return x

ディスクリミネータ

本物と偽物の画像を識別するために、既に定義したジェネレータと似たようなディスクリミネータネットワークを構築する必要があります。この場合、ディスクリミネータクラスが存在します。ディスクリミネータクラスのコンストラクタメソッドを定義します。これにはngpu入力を受け入れます。これは、トレーニングに使用できるGPUの数を指定します。ジェネレータと同様です。

elayer1には3つの畳み込み層が含まれており、各層の後にはバッチ正規化とELU活性化関数が続きます。self.toLatentは畳み込み層の出力を受け取り、テンソルにマッピングするFC層です。self.fromLatentは別のFC層です。ジェネレータからの出力を受け取り、テンソルにマッピングします。

これらのブロックはジェネレータと似ていますが、デコードに使用されます。つまり、画像生成です。self.toImageは最終的な畳み込み層で、出力画像を生成します。以前の層からの特徴マップを使用して、3チャンネルの画像を作成します。forwardメソッドでは、ディスクリミネータの順方向パスを指定します。本物または生成された画像を入力し、コンストラクタで定義されたレイヤーを通過させます。結果は画像のような出力です。

コードの実装

class Discriminator(nn.Module):    def __init__(self, ngpu):        super(Discriminator, self).__init__()        self.ngpu = ngpu        self.elayer1 = nn.Sequential(            nn.Conv2d(nc, ndf, 3, padding = 1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True),            nn.Conv2d(ndf, ndf, 3, padding = 1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True),            nn.Conv2d(ndf, 2 * ndf, 3, padding = 1),            nn.BatchNorm2d(2 * ndf),            nn.ELU(inplace=True),        )        self.elayer2 = nn.Sequential(            nn.MaxPool2d(2),            nn.Conv2d(2 * ndf, 2 * ndf, 3, padding = 1),            nn.BatchNorm2d(2 * ndf),            nn.ELU(inplace=True),            nn.Conv2d(2 * ndf, 3 * ndf, 3, padding = 1),            nn.BatchNorm2d(3 * ndf),            nn.ELU(inplace=True)        )        self.elayer3 = nn.Sequential(            nn.MaxPool2d(2),            nn.Conv2d(3 * ndf, 3 * ndf, 3, padding = 1),            nn.BatchNorm2d(3 * ndf),            nn.ELU(inplace=True),            nn.Conv2d(3 * ndf, 3 * ndf, 3, padding = 1),            nn.BatchNorm2d(3 * ndf),            nn.ELU(inplace=True)        )        self.toLatent = nn.Linear((image_size*image_size//16)*3*ndf, ngf)        self.fromLatent = nn.Linear(ngf, (image_size*image_size//16)*ndf)        self.dlayer1 = nn.Sequential(            nn.Conv2d(ndf, ndf, 3, padding=1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True),            nn.Conv2d(ndf, ndf, 3, padding=1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True)        )        self.dlayer2 = nn.Sequential(            nn.Upsample(scale_factor=2),            nn.Conv2d(2*ndf, ndf, 3, padding=1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True),            nn.Conv2d(ndf, ndf, 3, padding=1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True)        )        self.dlayer3 = nn.Sequential(            nn.Upsample(scale_factor=2),            nn.Conv2d(2*ndf, ndf, 3, padding=1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True),            nn.Conv2d(nsdf, ndf, 3, padding=1),            nn.BatchNorm2d(ndf),            nn.ELU(inplace=True)        )        self.toImage = nn.Conv2d(ndf, 3, 3, padding = 1)            def forward(self, x):        x = self.elayer1(x)        x = self.elayer2(x)        x = self.elayer3(x)        x = x.view(x.size(0), -1)        x = self.toLatent(x)        x = self.fromLatent(x)        x = x.view(x.size(0), ndf, image_size//4, image_size//4)        h0 = x        x = self.dlayer1(x)        x = torch.cat([x, h0], dim=1)        x = self.dlayer2(x)        h0 = torch.nn.functional.interpolate(h0, scale_factor=2, mode='nearest')        x = torch.cat([x, h0], dim=1)        x = self.dlayer3(x)        x = self.toImage(x)        return x

今、Generatorというクラスを作成し、ngpuを渡してジェネレータニューラルネットワークを構築します。もし複数のGPUを持っている場合、トレーニング効率を向上させるため、より多くのGPUを使用することができます。Discriminatorニューラルネットワークも同様にGeneratorと同じくDiscriminatorというクラスをインスタンス化することで作成されます。次のステップでは損失関数を初期化します。

次に、fixed_noiseという潜在ベクトルのバッチを作成する必要があります。これらの潜在ベクトルは通常、一般的には正規分布から選ばれるランダムなノイズベクトルです。これらはGeneratorからの偽の画像をトレーニング中に生成するために使用されます。そして、ジェネレータとディスクリミネータの両方のオプティマイザを設定する必要があります。両方に対してAdamオプティマイザを使用します。Adamは人気のある最適化アルゴリズムです。

# ジェネレータを作成するnetG = Generator(ngpu).to(device)# multi-gpuを処理するためのコードif (device.type == 'cuda') and (ngpu > 1):    netG = nn.DataParallel(netG, list(range(ngpu)))# ディスクリミネータを作成するnetD = Discriminator(ngpu).to(device)# multi-gpuを処理するためのコードif (device.type == 'cuda') and (ngpu > 1):    netD = nn.DataParallel(netD, list(range(ngpu)))    # 損失関数の初期化criterion = nn.L1Loss()fixed_noise = noise()# GeneratorとDiscriminatorの両方にAdamオプティマイザを設定するoptimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))    

トレーニング

いよいよモデルのトレーニングの時間です。その前に、トレーニングの各ステップでの経過時間を計算するためにTimerというクラスを作成します。いくつかの必要な空のリストを作成し、トレーニング中にデータを保存するためのいくつかの必要なパラメータを定義します。トレーニングループ内で、事前に設定されたエポック数とデータローダからのデータのバッチを反復処理します。ディスクリミネータはジェネレータによって生成された偽のデータでトレーニングされます。トレーニング中にジェネレータとディスクリミネータの両方が更新されます。同時に、各ステップでのトレーニング中にすべての統計情報が出力されます。損失と生成された画像はトレーニング中およびトレーニング後の分析と可視化のために収集されます。

import timeclass Timer():    def __init__(self):        self.startTime = time.time()        self.lastTime = time.time()      def timeElapsed(self):        auxTime = self.lastTime        self.lastTime = time.time()        return self.lastTime - auxTime    def timeSinceStart(self):        self.lastTime = time.time()        return self.lastTime - self.startTime        # Training Loopk = 0gamma = 0.4lambda_k = 0.005img_list = []G_losses = []D_losses = []iters = 0print("Training Loop Started...")timer = Timer()for epoch in range(num_epochs):    # データローダの各バッチごとに    for i, data in enumerate(dataloader, 0):             netD.zero_grad()        # バッチのフォーマット        real_cpu = data[0].to(device)        b_size = real_cpu.size(0)        # Dを通過する実際のバッチのフォワードパス        output = netD(real_cpu).view(-1)        # すべての実際のバッチに対する損失の計算        errD_real = criterion(output, real_cpu.view(-1))        # バックワードパスでDのための勾配を計算        D_x = output.mean().item()          fake = netG(noise())        # Dで偽のバッチすべてを分類        output = netD(fake.detach()).view(-1)        # すべての偽のバッチに対するDの損失の計算        errD_fake = criterion(output, fake.view(-1))        # このバッチのための勾配の計算        D_loss = errD_real - k * errD_fake        D_loss.backward()        D_G_z1 = output.mean().item()        # すべての実際のバッチとすべての偽のバッチからの勾配の追加        optimizerD.step()             netG.zero_grad()        fake = netG(noise())        output = netD(fake).view(-1)        # この出力に基づくGの損失の計算        errG = criterion(output, fake.view(-1))        # Gのための勾配の計算        errG.backward()        D_G_z2 = output.mean().item()        # Gの更新        optimizerG.step()        delta = (gamma*errD_real - errG).data        k = max(min(k + lambda_k*delta, 1.0), 0.0)                # トレーニングの統計情報の出力        if i % 50 == 0:            print(            '[%.4f] [%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'                  % (timer.timeElapsed(), epoch, num_epochs, i, len(dataloader),                     D_loss.item(), errG.item(), D_x, D_G_z1, D_G_z2))                # プロッティングのために損失を保存        G_losses.append(errG.item())        D_losses.append(D_loss.item())                if (iters % 1000 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):            with torch.no_grad():                fake = netG(fixed_noise).detach().cpu()            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))                    iters += 1   

ビジュアライゼーション

さて、GANのトレーニング中に生成器と識別器の損失を可視化するためのプロットを生成しましょう。

plt.figure(figsize=(10,5))plt.title("トレーニング中の生成器と識別器の損失")plt.plot(G_losses,label="G")plt.plot(D_losses,label="D")plt.xlabel("イテレーション")plt.ylabel("損失")plt.legend()plt.show() 

同様に、GANによって生成された本物の画像と偽の画像の比較のためのプロットを生成しましょう。そのために、データローダーからバッチの本物の画像を取得する必要があります。これらの本物の画像は、GANによって生成された画像と比較するために使用されます。その後、本物の画像とGANによって生成された偽の画像をプロットします。これにより、生成された画像の品質を実データと視覚的に比較することができます。

# データローダーからバッチの本物の画像を取得するreal_batch = next(iter(dataloader))# 本物の画像をプロットplt.figure(figsize=(15,15))plt.subplot(1,2,1)plt.axis("off")plt.title("本物の画像")plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64],            padding=5, normalize=True).cpu(),(1,2,0)))# 最後のエポックからの偽の画像をプロットplt.subplot(1,2,2)plt.axis("off")plt.title("偽の画像")plt.imshow(np.transpose(img_list[-1],(1,2,0)))plt.savefig('fake_image.png')plt.show()

結論

この記事では、CelebFaces Attributes (CelebA) データセット上で Generative Adversarial Networks (GANs) を使用し、いくつかの偽の有名人の顔を生成しました。Generative Adversarial Networks (GANs) は画期的な技術の突破口です。非常にリアルに見える偽データを作成することができます。これには多くの用途があり、プロジェクトで大量のデータが必要な場合に非常に役立ちます。最近では急速に発展しており、さまざまなアプリケーションに向けて利用されるようになっています。この技術は人工知能の分野で興味深い進展であり、将来のさまざまな応用に有望です。

主なポイント

• Generative Adversarial Networks (GANs) は、リアルなデータに非常に似たデータを生成する革新的なAI技術です。
• これは2つのニューラルネットワークから成ります。1つは生成器であり、もう1つは識別器です。これら2つのネットワークは敵対的なトレーニングを行います。
• GANsは、画像生成、超解像度、スタイル変換、データ拡張など、さまざまな分野での応用があります。
• さまざまな種類のGANがあり、それぞれ利点や欠点、独自の応用があります。
• GANはディープフェイク、偽のコンテンツ生成、プライバシー侵害などの倫理的な問題を引き起こす可能性があります。

よくある質問

本記事に掲載されているメディアは、Analytics Vidhyaの所有ではなく、著者の裁量によって使用されています。

We will continue to update VoAGI; if you have any questions or suggestions, please contact us!