ゼファーネットのロゴ

データサイエンスのキャリアを急上昇させるXNUMXつのコンピュータビジョンプロジェクト!

日付:

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

ほとんどの人は、データサイエンスと機械学習を学び始めたときに、データサイエンスのパイプラインのさまざまな段階で作業できる実際のプロジェクトで興味深いコードを試す機会がないと、退屈することがよくあります。プロジェクトのライフサイクル。

そのため、この記事では、コードを使用した3つのデータサイエンスまたは機械学習プロジェクトについて説明しました。 これらのプロジェクトは、データサイエンスの初心者と実践者の両方に適しており、データサイエンスのプロジェクトの実装でこれらのプロジェクトの実装を試み、手を汚すことができます。

  • Pytorchを使用したディープ畳み込み生成的敵対的ネットワーク(DCGAN)を使用した顔画像の生成
  • OpenCV、Keras、StreamLitを使用したフェイスマスク検出システムの開発と展開
  • AutoEncoders(エンコーダー-デコーダーネットワーク)とKerasを使用したU-Netアーキテクチャを使用した画像のノイズ除去

最初のものから始めましょう:

Pytorchを使用したディープ畳み込み生成的敵対的ネットワーク(DCGAN)を使用した顔画像の生成

GAN

のアーキテクチャを示す図 敵対的生成ネットワーク (GAN)

画像1 

このプロジェクトでは、 深い畳み込み生成的敵対的ネットワーク (DCGAN) のモデル CelebFaces属性(CelebA) 可能な限りリアルに見える人間の顔の新しい画像を生成するのに役立つジェネレータネットワークを取得することを目的としたデータセット。 必要なデータセットをダウンロードする場合は、これを使用してください .

GANとDCGANの背後にある理論について知るには、これを参照できます。 記事

簡単に言うと、GANは次のように定義できます。

GANは次のように理解できます XNUMX人のプレーヤー(つまり、ジェネレーターとディスクリミネーター) 各プレイヤーが対応するコスト関数を最小化することを望む非協力ゲーム。

GoogleColabにGoogleドライブをマウントする

google.colabからインポートドライブdrive.mount( '/ content / drive')

このプロジェクトでは、 CelebFaces属性データセット(CelebA) 画像がトリミングされ、最終的に顔を含まない画像の部分が削除され、その後、サイズ変更のプロセスが次のサイズになりました。 64x64x3 寸法NumPy画像。

処理済みの解凍-CelebA-小さなジッパー

!unzip "/content/drive/MyDrive/processed-celeba-small.zip"

データディレクトリを指定します

data_dir = 'processed_celeba_small /'

必要な依存関係またはライブラリのインポート

import numpy as np import matplotlib.pyplot as plt import pickle as pkl%matplotlib inline

CelebAデータを視覚化する

このデータセットには 200,000人の有名人の画像 注釈またはラベル付き。 これらの画像は基本的に、それぞれ3つのカラーチャネル(RGB)を持つカラー画像です。 x次元とy次元では、画像はサイズの正方形テンソルである必要があります (image_size x image_size)。

!pip install torch torchvision

Pytorchの必要なモジュールをインポートする

torchvisionからトーチをインポートするtorchvisionからデータセットをインポートするインポートトランスフォーム

データローダーを使用したバッチニューラルネットワーク

ここで、バッチで画像にアクセスするために、 DataLoader。

def get_dataloader(batch_size、image_size、data_dir = 'processed_celeba_small /'):transform = transforms.Compose([transforms.Resize(image_size)、transforms.ToTensor()])image_dataset = datasets.ImageFolder(data_dir、transform = transform)return torch .utils.data.DataLoader(image_dataset、batch_size = batch_size、shuffle = True)

DataLoaderハイパーパラメータ

  • あなたは合理的なものを選ぶことができます バッチサイズ あなた自身に基づくパラメータ。
  • しかし、あなたの 画像サイズ データのサイズを変更すると、画像のサイズが小さい(ピクセル数が少ない)と、説得力のある顔の画像を作成しながら、モデルのトレーニングが高速になります。
batch_size = 64#ハイパーパラメータimg_size = 32#batch_sizeとimg_sizeを使用したデータローダーceleba_train_loader = get_dataloader(batch_size、img_size)

テンソル画像をNumPyタイプに変換し、次元を転置して画像を表示します

def imshow(img):npimg = img.numpy()plt.imshow(np.transpose(npimg、(1、2、0)))dataiter = iter(celeba_train_loader)images、_ = dataiter.next()#プロットバッチからの画像fig = plt.figure(figsize =(20,4))plot_size = 20 for idx in np.arange(plot_size):ax = fig.add_subplot(2、plot_size / 2、idx + 1、xticks = [ ]、yticks = [])imshow(images [idx])

出力:

出力| コンピュータビジョンプロジェクト

画像を-1から1の範囲にスケーリングします(仮定–入力xは0-1からスケーリングされます)

モデル定義を始める前に, トレーニング中に使用する-1から1のピクセル範囲に画像データをスケーリングする関数を記述します。 これを行うのは、双曲線正接アクティブ化ジェネレーターの出力に-1から1の範囲のピクセル値が含まれ、トレーニング画像を[-1,1]の範囲で再スケーリングする必要があるためです。範囲は0〜1です。

def scale(x、feature_range =(-1、1)):min、max = feature_range x = x *(max-min)+ min return x
img = images [0] scaled_img = scale(img)print( 'Min:'、scaled_img.min())#スケーリングされたimgの範囲が約-1から1になるようにチェックしますprint( 'Max:'、scaled_img.max ())

モデルの定義

GANは、XNUMXつの敵対的ネットワークで構成されています。 弁別器 & 発電機

弁別器

弁別器は、最大プーリング層のない畳み込み分類器です。 弁別器への入力は32x32x3のテンソル画像であり、出力は画像が本物または偽物であることを示す単一の値になります。

import torch.nn as nn import torch.nn.functional as F
def conv(in_channels、out_channels、kernel_size、stride = 2、padding = 1、batch_norm = True):layers = [] layers.append(nn.Conv2d(in_channels、out_channels、kernel_size、stride = stride、padding = padding、bias = False))if(batch_norm):layers.append(nn.BatchNorm2d(out_channels))return nn.Sequential(* layers)
class Discriminator(nn.Module):def __init __(self、conv_dim): "" "conv_dim-最初の畳み込み層の深さ" "" super(Discriminator、self).__ init __()self.conv_dim = conv_dim self.conv1 = conv( 3、conv_dim、4、batch_norm = False)#3convレイヤーとそれに続く完全に接続されたレイヤーself.conv2 = conv(conv_dim、conv_dim * 2、4)self.conv3 = conv(conv_dim * 2、conv_dim * 4、4) self.fc = nn.Linear(conv_dim * 4 * 4 * 4、1)def forward(self、x): "" "x-ニューラルネットワークへの入力は、弁別子logits(output)" "" y = Fを返します。 .leaky_relu(self.conv1(x)、0.2)y = F.leaky_relu(self.conv2(y)、0.2)y = F.leaky_relu(self.conv3(y)、0.2)out = y.view(-1 、self.conv_dim * 4 * 4 * 4)#フラット化= self.fc(out)#出力層が戻る

発生器

GANのこのコンポーネントは、弁別器からのフィードバックを含めることによって偽のデータを作成する方法を学習し、弁別者が実際の出力を分類するのに役立ちます。 ネットワークのこのコンポーネントは、入力をアップサンプリングし、トレーニングデータと同じサイズの新しい画像を生成するのに役立ちます 32x32x3。 入力はある程度の長さのベクトルです z_size 出力は32x32x3の形状の画像です。

def deconv(in_channels、out_channels、kernel_size、stride = 2、padding = 1、batch_norm = True):layers = [] layers.append(nn.ConvTranspose2d(in_channels、out_channels、kernel_size、stride = stride、padding = padding、bias = False))if(batch_norm):layers.append(nn.BatchNorm2d(out_channels))return nn.Sequential(* layers)
class Generator(nn.Module):def __init __(self、z_size、conv_dim): "" "z_size-入力潜在ベクトルの長さzconv_dim-lats転置convレイヤーへの入力の深さ" "" super(Generator、self ).__ init __()self.conv_dim = conv_dim self.fc2 = nn.Linear(z_size、conv_dim * 4 * 4 * 4)self.t_conv1 = deconv(conv_dim * 4、conv_dim * 2、4)self.t_conv2 = deconv( conv_dim * 2、conv_dim、4)self.t_conv3 = deconv(conv_dim、3、4、batch_norm = False)def forward(self、x): "" "x-入出力-32x32x3テンソル画像" "" y = self。 fc2(x)y = y.view(-1、self.conv_dim * 4、4,4)z = F.relu(self.t_conv1(y))z = F.relu(self.t_conv2(z))z = torch.tanh(self.t_conv3(z))return z

重みの初期化

モデルができるだけ早く収束するのを助けるために、モデル内の畳み込み層と線形層の重みをに基づいて初期化しました。 オリジナルのDCGAN紙、それは言う– 「すべての重みは、標準偏差が0.02のゼロ中心の正規分布から初期化されます。」

def weights_init_normal(m): "" "重みはN(0,0.02)分布から取得されますm:レイヤー" "" classname = m .__ class __.__ name__ if hasattr(m、 'weight')and classname.find( 'Conv' )またはclassname.find( 'Linear')!= -1:m.weight.data.normal_(0.0、0.02)m.bias.data.fill_(0)

完全なネットワークの構築

ネットワークを構築するために、モデルのハイパーパラメータを定義し、で定義されたクラスからディスクリミネーターとジェネレーターをインスタンス化します。 モデルの定義 のセクションから無料でダウンロードできます。

#ディスクリミネーターとジェネレーターのインスタンス化def complete_network(d_conv_dim、g_conv_dim、z_size):D = Discriminator(d_conv_dim)G = Generator(z_size = z_size、conv_dim = g_conv_dim)D.apply(weights_init_normal)#モデルの重みを初期化G.apply(weights_init_normal )print(D)print(G)return D、G

#モデルハイパーパラメータd_conv_dim = 64 g_conv_dim = 64 z_size = 100 D、G = complete_network(d_conv_dim、g_conv_dim、z_size)
import torch train_on_gpu = torch.cuda.is_available()if not train_on_gpu:#利用可能な場合はGPUでのトレーニングを確実にするprint( 'No GPU')else:print( 'GPU Available.Training ...')

損失の計算–弁別器と生成損失

弁別器– 総損失= loss_real-image + loss_fake-image Discriminatorの場合、出力は実画像の場合は1、偽画像の場合は0です。 Generator Lossは、ディスクリミネーターが実際の画像を生成することを保証します。

def real_loss(D_out): '' 'D_out-ディスクリミネーターロジット出力リアルロス' '' batch_size = D_out.size(0)labels = torch.ones(batch_size)* 0.9#train_on_gpu:labels = labels.cudaの場合の片面ラベルスムージング()criteria = nn.BCEWithLogitsLoss()#ロジットを使用したバイナリクロスエントロピー損失損失=基準(D_out.squeeze()、ラベル)#損失計算リターンロスdef fake_loss(D_out): '' 'D_out:ディスクリミネーターロジット出力-偽損失 '' 'batch_size = D_out.size(0)labels = torch.zeros(batch_size)#偽のラベル= 0 if train_on_gpu:labels = labels.cuda()基準= nn.BCEWithLogitsLoss()損失=基準(D_out.squeeze( )、ラベル)#損失計算リターンロス

import torch.optim as optim#params lr_d = 0.0002 lr_g = 0.0002 beta1 = 0.5 beta2 = 0.999#default#AdamOptimizerの使用d_optimizer = optim.Adam(D.parameters()、lr_d、[beta1、beta2])g_optimizer = optim。 Adam(G.parameters()、lr_g、[beta1、beta2])

モデルトレーニング

トレーニング中、白黒ディスクリミネーターとジェネレーターを交互に使用します。 ここでは、 real_loss & 偽の損失 DiscriminatorとGeneratorの損失を計算する関数。

  • まず、人間の顔の実際の画像と偽の画像を交互に使用して、識別器をトレーニングします
  • 次に、ジェネレータコンポーネントはディスクリミネータをだまそうとし、反対の損失関数を持つ必要があります
def train(D、G、n_epochs、print_every = 50): '' 'D-ディスクリミネーターネットワークG-ジェネレーターネットワークn_epochs-エポック数print_every-モデル損失出力を印刷および記録する間隔-DおよびG損失' ' 'if train_on_gpu:D.cuda()G.cuda()#損失と生成された「偽の」サンプル損失= []サンプル= []#サンプリングのデータは固定されています-トレーニング全体を通じて一定です#モデルのパフォーマンスの検査にも役立ちますsample_size = 16 fixed_z = np.random.uniform(-1、1、size =(sample_size、z_size))fixed_z = torch.from_numpy(fixed_z).float()if train_on_gpu:fixed_z = fixed_z.cuda()for epoch in range (n_epochs):#epoch for batch_i、(real_images、_)in enumerate(celeba_train_loader):#バッチトレインループbatch_size = real_images.size(0)real_images = scale(real_images)if train_on_gpu:real_images = real_images.cuda()d_optimizer。 zero_grad()if train_on_gpu:real_images = real_images.cuda()out_real = D(real_images)d_loss_real = real_loss(out_real)z = np.random.uniform(-1、1、size =(batch _size、z_size))z = torch.from_numpy(z).float()if train_on_gpu:z = z.cuda()fake_out = G(z)out_fake = D(fake_out)d_loss_fake = fake_loss(out_fake)d_loss = d_loss_real + d_loss_fake d_loss.backward()d_optimizer.step()g_optimizer.zero_grad()z = np.random.uniform(-1、1、size =(batch_size、z_size))z = torch.from_numpy(z).float()if train_on_gpu :z = z.cuda()fake_out_g = G(z)G_D_out = D(fake_out_g)g_loss = real_loss(G_D_out)g_loss.backward()g_optimizer.step()if(batch_i%print_every == 0):loss.append( (d_loss.item()、g_loss.item()))#DとGの損失を追加#統計を出力print( 'Epoch [{:5d} / {:5d}] | d_loss:{:6.4f} | g_loss:{:6.4f} '。format(epoch + 1、n_epochs、d_loss.item()、g_loss.item()))G.eval()#サンプルを生成samples_z = G(fixed_z)samples.append(samples_z) G.train()with open( 'train_samples.pkl'、 'wb')as f:#pkl file pkl.dump(samples、f)リターンロス

n_epochs = 30#エポック損失の数= train(D、G、n_epochs = n_epochs)#トレーニング

各エポック後の弁別器と発電機の損失のプロット

fig、ax = plt.subplots()loss = np.array(losses)plt.plot(losses.T [0]、label = 'Discriminator')plt.plot(losses.T [1]、label = 'Generator' )plt.title( "Train Loss")plt.legend()

出力:

損失プロット| コンピュータビジョンプロジェクト

トレーニングからサンプルを生成する

#サンプルから渡されたリストの表示def view_samples(epoch、samples):fig、axes = plt.subplots(figsize =(20,4)、nrows = 2、ncols = 8、sharex = True、sharey = True)for ax、 img in zip(axes.flatten()、samples [epoch]):img = img.detach()。cpu()。numpy()img = np.transpose(img、(1、2、0))img =( (img + 1)* 255 /(2))。astype(np.uint8)ax.xaxis.set_visible(False)ax.yaxis.set_visible(False)im = ax.imshow(img.reshape((32,32,3、 XNUMX))))
open( 'train_samples.pkl'、 'rb')をfとして使用:samples = pkl.load(f)v_s = view_samples(-1、samples)

出力:

出力| コンピュータビジョンプロジェクト

まとめ

出力を見ると、モデルが可能な限りリアルに見える偽の人間の顔の新しい画像を生成できたことがわかります。 また、すべての画像は日陰で明るくなり、茶色の顔でも少し明るくなります。 これは、 セレブA データセットは、ほとんどが白い「有名人」の顔で構成されているため、多少偏っています。 最後に、私たちのDCGANモデルは、単なるノイズからほぼ実像を生成することに成功しています。

私もチェックできます Githubレポ このプロジェクトに関しても。

XNUMX番目のプロジェクトに移りましょう:👇

OpenCV、Keras、StreamLitを使用したフェイスマスク検出システムの開発と展開

要約: COVID-19の危機では、公衆衛生とパンデミックの蔓延を抑えるためにマスクの着用が絶対に必要であることがわかりました。 機械学習の学生として、周囲の人がこれらの安全対策を遵守しているかどうかを監視できるシステムを作ったらどうなるでしょうか。 そこで、このプロジェクトでは、人がマスクを着用しているかどうかを検出するフェイスマスク検出システムの作成を試み、そのモデルをWebアプリの形式で展開して、本番環境でも使用できるようにします。 。

AIを利用したフェイスマスク検知システム| コンピュータビジョンプロジェクト

                                                            画像2 

モデルのアーキテクチャとトレーニング

このプロジェクトでは、私はを利用しました 転移学習、その 非常に簡単な作業です。 ここで私は使用しました モバイルネットV2 分類器ネットワークを構築するためのモデル。

Transfer Learningを使用することで、事前にトレーニングされたMobileNetV2の機能検出機能を利用し、それをかなり単純なモデルに適用しています。 MobileNetV2の後には、次のようなレイヤーで構成されるDNNが続きます。 GlobalAveragePooling、Dense、 & ドロップアウト。 私たちの問題はバイナリ分類の問題であるため、最終層には2つのニューロンとソフトマックス活性化があります。

また、私は使用の一般的な考え方に従います アダムオプティマイザー と一緒に Categorical_crossentropy オプティマイザーと損失関数のこの組み合わせは、ネットワークに最適な重みに収束するため、損失はうまく機能します。

必要なパッケージをインポートします

from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.applications import MobileNetV2 from tensorflow.keras.layers import AveragePooling2D from tensorflow.keras.layers import Dropout from tensorflow.keras.layers import Flatten from tensorflow.keras.layers import Dense from tensorflow.keras.layers import Input from tensorflow.keras.models import Model from tensorflow.keras.optimizers import Adam from tensorflow.keras.applications.mobilenet_v2 import preprocess_input from tensorflow.keras.preprocessing.image import img_to_array from tensorflow.keras.preprocessing .image import load_img from tensorflow.keras.utils import to_categorical from sklearn.preprocessing import LabelBinarizer from sklearn.model_selection import train_test_split from sklearn.metrics import Classification_report from imutils import path import matplotlib.pyplot as plt import numpy as np import argparse import os

引数パーサーを形成し、引数を解析します

ap = argparse.ArgumentParser()ap.add_argument( "-d"、 "--dataset"、required = True、help = "入力データセットへのパス")ap.add_argument( "-p"、 "--plot"、 type = str、default = "plot.png"、help = "出力損失/精度プロットへのパス")ap.add_argument( "-m"、 "--model"、type = str、default = "mask_detector.model" 、help = "出力フェイスマスク検出器モデルへのパス")args = vars(ap.parse_args())

学習率、エポック数、バッチサイズの値を初期化しました

INIT_LR = 1e-4 EPOCHS = 20 BS = 32

データセットディレクトリで画像のリストを見つけて、データとクラスの画像のリストを初期化します

print( "[INFO]画像を読み込んでいます...")imagePaths = list(paths.list_images(args ["dataset"]))data = []ラベル= []

画像パスをループする

imagePathsのimagePathの場合:#ファイル名からクラスラベルを取得しますlabel = imagePath.split(os.path.sep)[-2]#ディメンション224x224の入力画像を読み込み、前処理しますimage = load_img(imagePath、target_size =(224 、224))image = img_to_array(image)image = preprocess_input(image)#データとラベルのリストの更新が発生しますdata.append(image)labels.append(label)

データとラベルのNumPy配列形式への変換

data = np.array(data、dtype = "float32")labels = np.array(labels)

ラベルでワンホットエンコーディングを実行します

lb = LabelBinarizer()labels = lb.fit_transform(labels)labels = to_categorical(labels)

データの75%をトレーニングに使用し、残りの25%をテストに使用して、データをトレーニングとテストの分割に分割します

(trainX、testX、trainY、testY)= train_test_split(data、labels、test_size = 0.20、stratify = labels、random_state = 42)

データ拡張を目的としたトレーニング画像ジェネレータを形成

aug = ImageDataGenerator(rotation_range = 20、zoom_range = 0.15、width_shift_range = 0.2、height_shift_range = 0.2、shear_range = 0.15、horizo​​ntal_flip = True、fill_mode = "nearest")

MobileNetV2ネットワークをロードし、完全に接続されたヘッドのレイヤーセットがオフになっていることを確認します

baseModel = MobileNetV2(weights = "imagenet"、include_top = False、input_tensor = Input(shape =(224、224、3)))

ベースモデルの上に配置するためのモデルのヘッドを作成します

headModel = baseModel.output headModel = AveragePooling2D(pool_size =(7、7))(headModel)headModel = Flatten(name = "flatten")(headModel)headModel = Dense(128、activation = "relu")(headModel)headModel = Dropout(0.5)(headModel)headModel = Dense(2、activation = "softmax")(headModel)

ヘッドの完全接続モデルをベースモデルの上に配置します(トレーニングする実際のモデルになります)

モデル=モデル(入力= baseModel.input、出力=ヘッドモデル)

ベースモデルのすべてのレイヤーをトラバースしてフリーズし、最初のトレーニングプロセス中に更新されないようにします。

baseModel.layersのレイヤーの場合:layer.trainable = False

モデルのコンパイル

print( "[INFO]コンパイルモデル...")opt = Adam(lr = INIT_LR、decay = INIT_LR / EPOCHS)model.compile(loss = "binary_crossentropy"、optimizer = opt、metrics = ["accuracy"])

ネットワークの責任者をトレーニングする

print( "[INFO]トレーニングヘッド...")H = model.fit(aug.flow(trainX、trainY、batch_size = BS)、steps_per_epoch = len(trainX)// BS、validation_data =(testX、testY)、 validate_steps = len(testX)// BS、epochs = EPOCHS)

テストセットで予測を行う

print( "[INFO]ネットワークを評価しています...")predIdxs = model.predict(testX、batch_size = BS)

テストセット内の各画像について、確率の対応する最大予測値を持つラベルのインデックスを見つけてみてください

predIdxs = np.argmax(predIdxs、axis = 1)

分類レポートを印刷する

print(classification_report(testY.argmax(axis = 1)、predIdxs、target_names = lb.classes_))

出力:

代替テキスト

モデルをディスクにシリアル化する

print( "[INFO]マスク検出器モデルを保存しています...")model.save(args ["model"]、save_format = "h5")

トレーニングの損失と精度をプロットします

N = EPOCHS plt.style.use( "ggplot")plt.figure()plt.plot(np.arange(0、N)、H.history ["loss"]、label = "train_loss")plt.plot( np.arange(0、N)、H.history ["val_loss"]、label = "val_loss")plt.plot(np.arange(0、N)、H.history ["accuracy"]、label = "train_acc ")plt.plot(np.arange(0、N)、H.history [" val_accuracy "]、label =" val_acc ")plt.title(" Training Loss and Accuracy ")plt.xlabel(" Epoch# ") plt.ylabel( "Loss / Accuracy")plt.legend(loc = "左下")plt.savefig(args ["plot"])

出力:

plot.png | コンピュータビジョンプロジェクト

一部のテスト画像の出力

さて、このセクションでは、フェイスマスク検出器システムへの入力として画像を渡した後に得られる出力のタイプについて説明します。

出力

まとめ

やあ、私たちは成功しました🥳約99%の精度でフェイスマスク検出器システムを構築しました。 このモデルのWebアプリケーションも作成しました。 私のGitHubからそのコードを直接確認し、自分の側からアプリを作成して、本番環境で使用することもできます。

私もチェックできます Githubレポ このプロジェクトに関しても。

XNUMX番目の最後のプロジェクトに移りましょう:👇

 AutoEncoders(エンコーダー-デコーダーネットワーク)とKerasを使用したU-Netアーキテクチャを使用した画像のノイズ除去

一般的なオートエンコーダアーキテクチャを以下に示します。

コンピュータビジョン用オートエンコーダ| コンピュータビジョンプロジェクト

のアーキテクチャを示す図 オートエンコーダ

                                             画像3

コード部分に直接入る前に、まずこれを実行することをお勧めします オートエンコーダに関するチュートリアル 次に、理論的知識と実践的知識の両方をよりよく理解するために、このプロジェクトを進めます。

必要な依存関係またはライブラリをインポートする

まず、この実装で使用する必要なすべてのPythonライブラリまたはモジュールをインポートする必要があります。

import numpy as np#マトリックス操作の最適化import matplotlib.pyplot as plt#tensorflow.keras.layersからのデータ視覚化import Conv2D、Input、Dense、Reshape、Conv2DTranspose、Activation、BatchNormalization、ReLU、Concatenate、add、LeakyReLU fromtensorflow.keras。 models import Model#tensorflow.keras.callbacksからの機能的なkerasモデルimport ModelCheckpoint#tensorflow.keras.datasetsからの検証エラーに基づいてモデルの重みを保存するにはimport cifar100、cifar10#keras.optimizersからのこの問題ステートメントで使用される必須データセットimport Adam #損失関数を最適化するためのオプティマイザーADAM

KerasからCIFAR-100データセットを直接ロードする

これを実装するために、有名な CIFAR-100 データセット 入力として。 このため、Kerasライブラリから直接インポートできるため、データセットをダウンロードする必要はありません。

#CIFAR-100データセットを使用(train_data_clean、_)、(test_data_clean、_)= cifar100.load_data(label_mode = 'fine')

データを0から1の間で正規化します

現在、計算を減らすために、[0,1]の範囲でデータを縮小しています。

#データを正規化するために、すべての画像ピクセルをfloat(255)で除算しますtrain_data_clean = train_data_clean.astype( 'float32')/255。test_data_clean= test_data_clean.astype( 'float32')/ 255。

入力画像にノイズを追加する

次に、ノイズを追加してノイズの多い画像を生成する必要があります。 ノイズを追加するために、次の正規分布を使用して、[0,1]の間のランダムな値を持つ画像と同じ次元の配列を生成できます。 平均= 0 & 標準偏差= 1.

正規分布を生成するには、次を使用できます。 np.random.normal(loc、scale、size)。 次に、ノイズを何らかの係数でスケーリングします。ここでは、 0.5。 ノイズを追加した後、ピクセル値が範囲外になる可能性があるため、を使用して値をクリップする必要があります np.clip(arr、arr_min、arr_max).

#画像にノイズを追加し、そのピクセル値を0から1の間でクリッピングする関数def add_noise_and_clip_data(data、noise_factor):noise = np.random.normal(loc = 0.0、scale = 0.1、size = data.shape)data =データ+ノイズファクター*ノイズデータ= np.clip(data、0.、1。)return data train_data_noisy = add_noise_and_clip_data(train_data_clean、0.5)test_data_noisy = add_noise_and_clip_data(test_data_clean、0.5)

ノイズの多い画像でいくつかのトレーニング画像を視覚化する

トレーニングデータがどのように見えるかと、対応するノイズの多い画像を見てみましょう。

行= 2#定義番号図の行数cols = 8#定義なし。 図の列の数f = plt.figure(figsize =(2 * cols、2 * rows * 2))#range(rows)内のiの図の定義:range(cols)内のjの場合:f.add_subplot(rows * 2、cols、(2 * i * cols)+(j + 1))#各反復の図にサブプロットを追加plt.imshow(train_data_noisy [i * cols + j])plt.axis( "off")for j in range(cols):f.add_subplot(rows * 2、cols、((2 * i + 1)* cols)+(j + 1))#各反復の図にサブプロットを追加plt.imshow(train_data_clean [i * cols + j])plt.axis( "off")f.suptitle( "サンプルトレーニングデータ"、fontsize = 20)plt.show()

出力:

サンプルトレーニングデータ| コンピュータビジョンプロジェクト

単純なCNNアーキテクチャを定義する

ここでは、XNUMXつの関数を定義します。XNUMXつは畳み込み演算用、もうXNUMXつはデコンボリューション演算用で、カスタマイズされたオートエンコーダモデルにエンコーダブロックとデコーダブロックを含めます。

#モデルアーキテクチャに畳み込みレイヤーを含める関数def conv_block(x、filters、kernel_size、strides = 2):x = Conv2D(filters = filters、kernel_size = kernel_size、strides = strides、padding = 'same')(x) x = BatchNormalization()(x)x = ReLU()(x)return x#モデルアーキテクチャにデコンボリューションレイヤーを含める関数def deconv_block(x、filters、kernel_size):x = Conv2DTranspose(filters = filters、kernel_size = kernel_size、strides = 2、padding = 'same')(x)x = BatchNormalization()(x)x = ReLU()(x)return x

画像のノイズを除去する機能がモデルに与えられます

ここで、問題ステートメントのコアであるメイン関数を定義します。これは、この関数が入力として提供する画像のノイズを除去し、これが特定の問題ステートメントの主な目的であるためです。

def denoising_autoencoder():den_inputs = Input(shape =(32、32、3)、name = 'dae_input')conv_block1 = conv_block(den_inputs、32、3)conv_block2 = conv_block(conv_block1、64、3)conv_block3 = conv_block(conv_block2 、128、3)conv_block4 = conv_block(conv_block3、256、3)conv_block5 = conv_block(conv_block4、256、3、1)deconv_block1 = deconv_block(conv_block5、256、3)merge1 = Concatenate()([deconv_block1、conv_block3])deconv_block2 = deconv_block(merge1、128、3)merge2 = Concatenate()([deconv_block2、conv_block2])deconv_block3 = deconv_block(merge2、64、3)merge3 = Concatenate()([deconv_block3、conv_block1])deconv_block4 = deconv_block(merge3、32 、3)final_deconv = Conv2DTranspose(filters = 3、kernel_size = 3、padding = 'same')(deconv_block4)den_outputs = Activation( 'sigmoid'、name = 'dae_output')(final_deconv)return Model(den_inputs、den_outputs、name = 'dae')

関数の呼び出し、モデルのコンパイル、およびトレーニング

Pythonでは、関数の作成後に、指定されたパラメーターを指定してその関数のオブジェクトを作成することにより、この関数を呼び出す必要があります。 次に、この後、モデルをコンパイルしてトレーニングします。 ここでは、次のようなハイパーパラメータを選択できます エポック、batch_size、などをご自身で。

dae = denoising_autoencoder()#関数呼び出しdae.compile(loss = 'mse'、optimizer = 'adam')#モデルコンパイルチェックポイント= ModelCheckpoint( 'best_model.h5'、verbose = 1、save_best_only = True、save_weights_only = True)#最適な重みを保存する#モデルのトレーニングまたはフィッティングdae.fit(train_data_noisy、train_data_clean、validation_data =(test_data_noisy、test_data_clean)、epochs = 5、batch_size = 128、callbacks = [checkpoint])

モデルの重みを保存し、上記のトレーニング済みモデルを使用してノイズ除去された画像を予測します

ここでは、h5ファイルに保存された最適な重みをロードし、それらの重みを使用して、テストデータセットの出力を予測します。

dae.load_weights( 'best_model.h5')#前のセクションで保存した重みをロードしますtest_data_denoised = dae.predict(test_data_noisy)#最適な重みのトレーニング済みモデルを使用して出力画像を予測します

画像の元の、ノイズの多い、ノイズ除去されたバージョンを印刷します

idx = 4 plt.subplot(1,3,1)plt.imshow(test_data_clean [idx])plt.title( 'original')plt.subplot(1,3,2)plt.imshow(test_data_noisy [idx])plt .title( 'noisy')plt.subplot(1,3,3)plt.imshow(test_data_denoised [idx])plt.title( 'denoised')plt.show()

出力:

出力| コンピュータビジョンプロジェクト

MSEを使用してモデルを評価する

次に、XNUMXつの画像の差を計算する関数を定義します。 ここでは、損失関数として平均二乗誤差を使用します。

def mse(image_1、image_2):return np.square(np.subtract(image_1、image_2))。mean()noisy_clean_mse = mse(test_data_clean、test_data_noisy)#初期テストデータとノイズの多いテストデータ間のMSE denoised_clean_mse = mse(test_data_denoised、test_data_clean) #モデルnoisy_clean_mse、denoised_clean_mseによって指定されたノイズの多いテストデータとクリーンなテストデータ間のMSE#両方のMSE値を出力する

CIFAR10データセットでDAEをテストする

モデルのトレーニングが完了したら、モデルをテストします。

クリーンアップされた画像と、その画像を比較する入力との間の損失を見つけます

clean_noisy = mse(cifar10_test、cifar10_test_noisy)clean_denoised = mse(cifar10_test、cifar10_test_denoised)clean_noisy、clean_denoised print( "XNUMXつの画像の違いは次のとおりです:"、clean_noisy-clean_denoised)

それでは、スキップ接続を備えたエンコーダ-デコーダネットワーク(つまり、U-Netアーキテクチャ)を設計しましょう。

畳み込み操作とデコンボリューション操作の両方が実行されるネットワークで作業している間、スキップ接続は非常に重要な役割を果たします。 畳み込みおよびデコンボリューション中に失われる可能性のある情報を復元するのに役立ちます。

U-Netアーキテクチャを以下に示します。

ユーネット

を示す図 Uネット 建築

                                     Image4 

それでは、コード部分から始めましょう。

size = 32 channel = 3 from keras.layers import Conv2D、Input、Dense、Dropout、MaxPool2D、UpSampling2D#オートエンコーダネットワーク入力のエンコーダコンポーネント= Input(shape =(size、size、channel))x = Conv2D(32、3 、activation = 'relu'、padding = 'same')(inputs)x = BatchNormalization()(x)x = MaxPool2D()(x)x = Dropout(0.5)(x)skip = Conv2D(32、3、padding = 'same')(x)#デコーダーの接続をスキップx = LeakyReLU()(skip)x = BatchNormalization()(x)x = MaxPool2D()(x)x = Dropout(0.5)(x)x = Conv2D( 64、3、activation = 'relu'、padding = 'same')(x)x = BatchNormalization()(x)エンコード= MaxPool2D()(x)#オートエンコーダネットワークのデコーダコンポーネントx = Conv2DTranspose(64、3、 Activation = 'relu'、strides =(2,2)、padding = 'same')(encoded)x = BatchNormalization()(x)x = Dropout(0.5)(x)x = Conv2DTranspose(32、3、activation = 'relu'、strides =(2,2)、padding = 'same')(x)x = BatchNormalization()(x)x = Dropout(0.5)(x)x = Conv2DTranspose(32、3、padding = 'same ')(x)x = add([x、skip])#スキップ接続の追加x = LeakyReLU()(x)x = BatchNormalization()(x)デコード= Conv2DTranspose(3、3、activation = 'sigmoid'、strides =(2,2)、padding = 'same')(x)autoencoder = Model(inputs、decode)#コンパイルmodel autoencoder.compile(optimizer = Adam(learning_rate = 0.001)、loss = 'binary_crossentropy')#モデルサマリーの分析autoencoder.summary()

モデルのトレーニングまたはフィッティング

#エポック数とbatch_sizeをハイパーパラメータとして修正epochs = 25 batch_size = 256 history = autoencoder.fit(train_data_noisy、train_data_clean、epochs = epichs、batch_size = batch_size、shuffle = True、validation_data =(test_data_noisy、test_data_clean))

損失対エポック数曲線の描画

#図の定義f = plt.figure(figsize =(10,7))f.add_subplot()#サブプロットの追加plt.plot(history.epoch、history.history ['loss']、label = "loss")#損失トレーニングセットの曲線plt.plot(history.epoch、history.history ['val_loss']、label = "val_loss")#検証セットの損失曲線plt.title( "Loss Curve"、fontsize = 18)plt.xlabel( "Epochs"、fontsize = 15)plt.ylabel( "Loss"、fontsize = 15)plt.grid(alpha = 0.3)plt.legend()plt.savefig( "Loss_curve_cifar10.png")plt.show()

いくつかのランダムなテスト画像を選択します

#選択する画像の数num_imgs = 48 rand = np.random.randint(1、test_data_noisy.shape [0] -48)cifar_test_images = test_data_noisy [rand:rand + num_imgs]#スライスcifar_test_denoised = autoencoder.predict(test_data_clean)#予測する

ノイズ除去された画像でテスト画像を視覚化する

行= 4#定義なし。 図の行数cols = 12#定義なし。 図の列数cell_size = 1.5 f = plt.figure(figsize =(cell_size * cols、cell_size * rows * 2))#図の定義f.tight_layout()for i in range(rows):for j in range(cols ):f.add_subplot(rows * 2、cols、(2 * i * cols)+(j + 1))#各反復の図にサブプロットを追加plt.imshow(test_data_clean [i * cols + j])plt.axis ( "off")for j in range(cols):f.add_subplot(rows * 2、cols、((2 * i + 1)* cols)+(j + 1))#各反復の図にサブプロットを追加plt .imshow(test_data_noisy [i * cols + j])plt.axis( "off")f.suptitle( "Autoencoder Results-Cifar10"、fontsize = 18)plt.show()

次に、XNUMXつの画像の差を計算する関数を定義します。 ここでは、損失関数として平均二乗誤差を使用します

def mse(data_1、data_2):return np.square(np.subtract(data_1、data_2))。mean()noisy_clean_mse = mse(test_data_clean、test_data_noisy)denoised_clean_mse = mse(test_data_denoised、test_data_clean)noisy_clean_mse、denoise

画像のノイズ除去バージョンを予測する

cifar10_test_denoised = autoencoder.predict(cifar10_test_noisy)

画像の元の、ノイズの多い、ノイズ除去されたバージョンを印刷します

idx = 6
plt.subplot(1,3,1)
plt.imshow(cifar10_test[idx])
plt.title('original')
plt.subplot(1,3,2)
plt.imshow(cifar10_test_noisy[idx])
plt.title('noisy')
plt.subplot(1,3,3)
plt.imshow(cifar10_test_denoised[idx])
plt.title('denoised')
plt.show()

画像間のMSEを見つける

clean_noisy = mse(cifar10_test、cifar10_test_noisy)clean_denoised = mse(cifar10_test、cifar10_test_denoised)clean_noisy、clean_denoised print( "XNUMXつの画像の違いは次のとおりです:"、clean_noisy-clean_denoised)

それは今のところすべてです! オートエンコーダーを構築できます😎😎。 より多くのデータセットを探索し、独自のオートエンコーダーのトレーニングを楽しんでください。

まとめ

オートエンコーダは強力で、さらに多くのことができます。 ここでは、2つの簡単なモデルの例を紹介しました。ここでは、ノイズ除去タスクでモデルがどの程度うまく機能しているかを確認できます。 シーケンシャルデータにオートエンコーダを使用するなど、他の用途もあります。 そのような例のXNUMXつは 変分オートエンコーダ(VAE)、これはもう少し高度でモダンなコンセプトです。 また、画像の生成にも使用できます。

私もチェックできます Githubレポ このプロジェクトに関しても。

これで、XNUMXつのプロジェクトすべてに関するディスカッションは完了です。 🥳

特別な感謝!

この記事のために、私は特別な感謝を捧げます Vetrivel_PS これらのタイプの記事は、データサイエンスへの移行を希望する、またはデータサイエンスの分野で卓越したいすべての人々にとって非常に役立つため、定期的にこのようなタイプの記事を書くように私を動機付けています。

Vetrivelのデータサイエンスコミュニティにも参加したい場合は、 Hackweekly Linkedinコミュニティ(https://www.linkedin.com/company/thehackweekly) それに参加します。

著者について

以前のブログ投稿も確認できます。

以前のデータサイエンスブログの投稿。

ここにある 私のLinkedinプロフィール あなたが私とつながりたい場合に備えて。 よろしくお願いします。

メール

ご不明な点がございましたら、メールでお問い合わせください。 Gmailの.

参考文献:

画像1:https://towardsdatascience.com/fake-face-generator-using-dcgan-model-ae9322ccfd65

Image 2: https://www.google.co.in/url?sa=i&url=https%3A%2F%2Fwww.leewayhertz.com%2Fface-mask-detection-system%2F&psig=AOvVaw02aHbLLICPG-G31GnWPnwF&ust=1629113361404000&source=images&cd=vfe&ved=0CAsQjRxqFwoTCKivvrH2svICFQAAAAAdAAAAABAD

Image 3: https://www.google.co.in/url?sa=i&url=https%3A%2F%2Fwww.analyticsvidhya.com%2Fblog%2F2021%2F01%2Fauto-encoders-for-computer-vision-an-endless-world-of-possibilities%2F&psig=AOvVaw1LmmWrE4OS1_Cjr6QO9pmg&ust=1628144426721000&source=images&cd=vfe&ved=0CAsQjRxqFwoTCODNwvHclvICFQAAAAAdAAAAABAI

Image 4 : https://www.google.co.in/url?sa=i&url=https%3A%2F%2Fwww.researchgate.net%2Ffigure%2FThe-architecture-of-Unet_fig2_334287825&psig=AOvVaw2DB1XzXKEZAAf_mzzSwhlC&ust=1628144257443000&source=images&cd=vfe&ved=0CAsQjRxqFwoTCOi1zaHclvICFQAAAAAdAAAAABAD

エンドノート

読んでくれてありがとう!

この記事を楽しんでいただけたでしょうか。 あなたがそれを好きなら、あなたの友人にもそれを共有してください。 言及されていないこと、またはあなたの考えを共有したいことはありますか? 以下にコメントしてください。折り返しご連絡いたします。 😉

この記事に示されているメディアは、Analytics Vidhyaが所有しておらず、作成者の裁量で使用されています。

PlatoAi。 Web3の再考。 増幅されたデータインテリジェンス。
アクセスするには、ここをクリックしてください。

出典:https://www.analyticsvidhya.com/blog/2021/09/three-computer-vision-projects-to-skyrocket-your-data-science-career/

スポット画像

最新のインテリジェンス

スポット画像