google.colab에서 드라이브 가져오기 drive.mount('/content/drive')

가공-CelebA-small zip 압축 풀기

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

데이터 디렉토리 제공

data_dir = 'processed_celeba_small/'

필요한 종속성 또는 라이브러리 가져오기

numpy를 np로 가져오기 matplotlib.pyplot을 plt로 가져오기 피클을 pkl로 가져오기 %matplotlib 인라인

! pip 설치 토치 토치 비전

필요한 Pytorch 모듈 가져오기

토치비전에서 토치 가져오기 토치비전에서 데이터셋 가져오기 변환 가져오기

데이터 로더를 사용한 배치 신경망

이제 일괄적으로 이미지에 액세스하기 위해 데이터로더.

def get_dataloader(batch_size, image_size, data_dir='processed_celeba_small/'): transform = transforms.Compose([transforms.Resize(image_size),transforms.ToTensor()]) image_dataset = dataset.ImageFolder(data_dir, transform = transform) 반환 토치 .utils.data.DataLoader(image_dataset, batch_size = batch_size, shuffle=True)

batch_size = 64 # 하이퍼파라미터 img_size = 32 # batch_size 및 img_size가 있는 데이터 로더 celeba_train_loader = get_dataloader(batch_size, img_size)

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)) np.arange(plot_size)의 idx에 대한 plot_size=20: ax = fig.add_subplot(2, plot_size/2, idx+1, xticks=[ ], yticks=[]) imshow(이미지[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 * (최대 - 최소) + 최소 반환 x

img = images[0] scaled_img = scale(img) print('Min: ', scaled_img.min()) # 크기가 조정된 img의 범위가 -1에서 1 사이인지 확인합니다. print('Max: ', scaled_img.max ())

토치.nn을 nn으로 가져오기 토치.nn.기능을 F로 가져오기

def conv (in_channels, out_channels, kernel_size, stride=2, padding=1, batch_norm = True): layer =[]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)) 반환 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) # 3 conv 레이어 다음에 완전히 연결된 레이어 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(출력) """를 반환합니다. 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) # flattening out = self.fc(out) # 출력 레이어 반환

def deconv (in_channels, out_channels, kernel_size, stride=2, padding=1, batch_norm = True): 레이어 =[]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)) nn.Sequential(*layers) 반환

class Generator(nn.Module): def __init__(self, z_size, conv_dim): """ z_size - 입력 잠재 벡터의 길이 z conv_dim - 위도 전치 변환 레이어에 대한 입력 깊이 """ 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 = 토치.tanh(self.t_conv3(z)) 반환 z

def weights_init_normal(m): """ 가중치는 N(0,0.02) 분포 m: 계층 """ classname = m.__class__.__name__ if hasattr(m, 'weight') 및 classname.find('Conv' ) 또는 classname.find('선형') != -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 ) 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() # 로짓이 있는 이진 교차 엔트로피 loss loss = criteria(D_out.squeeze(), labels) # 손실 계산 return loss def fake_loss(D_out): ''' D_out: 판별자 로짓 출력 - 가짜 loss ''' batch_size = D_out.size(0) 레이블 = torch.zeros(batch_size) # 가짜 레이블 = 0 if train_on_gpu: 레이블 = 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 # Adam Optimizer 사용 d_optimizer = optim.Adam(D.parameters(), lr_d, [beta1, beta2]) g_optimizer 아담(G.parameters(), lr_g, [베타1, 베타2])

모델 훈련

훈련하는 동안 우리는 b/w 판별자와 생성자를 교대로 사용합니다. 여기서 우리가 사용할 진짜 손실 과 가짜 손실 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() 범위 내 epoch (n_epochs): # 배치_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_ 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 추가 loss # 통계 출력 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 # Epoch 손실 수 = train(D, G, n_epochs=n_epochs) #훈련

fig, ax = plt.subplots() 손실 = np.array(losses) plt.plot(losses.T[0], label='Discriminator') plt.plot(losses.T[1], label='Generator' ) plt.title("열차 손실") plt.legend()

# 샘플에서 전달된 목록 보기 def view_samples(epoch, samples): fig, axes = plt.subplots(figsize=(20,4), nrows=2, ncols=8, sharex=True,sharey=True) for ax, zip(axes.flatten(), samples[epoch])의 img: 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, 삼)))

f로 open('train_samples.pkl', 'rb') 사용: samples = pkl.load(f) v_s = view_samples(-1, samples)

데이터 및 클래스 이미지 목록을 초기화하기 위해 데이터세트 디렉토리에서 이미지 목록을 찾습니다.

print("[INFO] 이미지 로드 중...") imagePaths = list(paths.list_images(args["dataset"])) 데이터 = [] 레이블 = []

이미지 경로를 반복합니다.

for imagePath in imagePaths: # 파일 이름에서 클래스 레이블을 가져옵니다. 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 배열 형식으로 변환

데이터 = np.array(데이터, dtype="float32") 레이블 = np.array(레이블)

레이블에 대한 원-핫 인코딩 수행

lb = LabelBinarizer() 레이블 = lb.fit_transform(labels) 레이블 = to_categorical(labels)

데이터의 75%를 훈련용으로 사용하고 나머지 25%를 테스트용으로 사용하여 데이터를 훈련 및 테스트 분할로 분할합니다.

(trainX, testX, trainY, testY) = train_test_split(데이터, 레이블, test_size=0.20, stratify=labels, random_state=42)

Data Augmentation을 위한 학습 이미지 생성기 구성

20월 = ImageDataGenerator(회전 범위=0.15, 확대/축소 범위=0.2, 너비_시프트_범위=0.2, 높이_시프트_범위=0.15, 전단_범위=XNUMX, 수평_플립=참, 채우기 모드="가까운")

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, 출력=headModel)

기본 모델의 모든 레이어를 탐색하고 첫 번째 교육 프로세스 중에 업데이트되지 않도록 고정합니다.

baseModel.layers의 레이어: layer.trainable = False

모델 편집

print("[INFO] 컴파일링 모델...") opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["정확도"])

네트워크 책임자 교육

print("[INFO] 트레이닝 헤드...") H = model.fit( aug.flow(trainX, trainY, batch_size=BS), steps_per_epoch=len(trainX) // BS, validation_data=(testX, testY), validation_steps=len(testX) // BS, epochs=EPOCHS)

테스트 세트에 대한 예측

print("[INFO] 네트워크 평가 중...") predIdxs = model.predict(testX, batch_size=BS)

테스트 세트의 각 이미지에 대해 해당 확률의 가장 큰 예측 값이 있는 레이블의 인덱스를 찾으려고 시도합니다.

predIdxs = np.argmax(predIdxs, 축=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["손실"], label="train_loss") plt.plot( np.arange(0, N), H.history["val_loss"], label="val_loss") plt.plot(np.arange(0, N), H.history["정확도"], label="train_acc ") plt.plot(np.arange(0, N), H.history["val_accuracy"], label="val_acc") plt.title("훈련 손실 및 정확도") plt.xlabel("시대 번호") plt.ylabel("손실/정확도") plt.legend(loc="왼쪽 하단") plt.savefig(인수["플롯"])

 Keras에서 AutoEncoder(Encoder-Decoder 네트워크) 및 U-Net 아키텍처를 사용한 이미지 노이즈 제거

일반적인 자동 인코더 아키텍처는 다음과 같습니다.

                                             이미지 3

import numpy as np # 행렬 연산 최적화 import matplotlib.pyplot as plt # tensorflow.keras.layers에서 데이터 시각화 import Conv2D, Input, Dense, Reshape, Conv2DTranspose, Activation, BatchNormalization, ReLU, Concatenate, add, LeakyReLU from tensorflow.keras. 모델 가져오기 모델 # tensorflow.keras.callbacks에서 기능 keras 모델 가져오기 ModelCheckpoint # tensorflow.keras.datasets에서 유효성 검사 오류를 기반으로 모델 가중치를 저장하려면 import cifar100, cifar10 # 필수 데이터 세트 이 문제 설명에서 사용 from keras.optimizers import Adam # 손실 함수 최적화를 위한 Optimizer ADAM

# CIFAR-100 데이터셋 사용 (train_data_clean, _), (test_data_clean, _) = cifar100.load_data(label_mode='fine')

# 데이터를 정규화하기 위해 모든 이미지 픽셀을 float(255) train_data_clean = train_data_clean.astype('float32') / 255로 나눕니다. test_data_clean = test_data_clean.astype('float32') / 255.

# 이미지에 노이즈를 추가하고 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 = data + noise_factor * 노이즈 데이터 = np.clip(data, 0., 1.) 반환 데이터 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)) # i in range(rows): for j in range(cols): f.add_subplot(rows* 2,cols, (2*i*cols)+(j+1)) # 각 반복에서 Figure에 서브플롯 추가 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)) # 각 반복에서 Figure에 subplot 추가 plt.imshow(train_data_clean[i*cols + j]) plt.axis("off") f.suptitle("샘플 교육 데이터", fontsize=20) plt.show()

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, conv 3) conv_block3 , 2, 128) conv_block3 = conv_block(conv_block4, 3, 256) conv_block3 = conv_block(conv_block5, 4, 256, 3) deconv_block1 = deconv_block(conv_block1, 5, 256) de_conv_block3 = Concatenate()][) = deconv_block(merge1, 1, 3) merge2 = 연결()([deconv_block1, conv_block128]) deconv_block3 = deconv_block(merge2, 2, 2) merge3 = 연결()([deconv_block2, conv_block64]) deconv_block3m = deconv_block3 , 3) final_deconv = Conv1DTranspose(filters=4, kernel_size=3, padding='same')(deconv_block32) den_outputs = Activation('sigmoid', name='dae_output')(final_deconv) return Model(den_inputs, den_outputs, name= '대')

dae = denoising_autoencoder() # 함수 호출 dae.compile(loss='mse', optimizer='adam') # Model Compilation checkpoint = 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])

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('원본') plt.subplot(1,3,2) plt.imshow(test_data_noisy[idx]) plt .title('잡음') plt.subplot(1,3,3) plt.imshow(test_data_denoised[idx]) plt.title('잡음 제거') plt.show()

def mse(image_1, image_2): return np.square(np.subtract(image_1, image_2)).mean() noise_clean_mse = mse(test_data_clean, test_data_noisy) # 초기 테스트 데이터와 잡음 테스트 데이터 간의 MSE denoised_clean_mse = mseclean(test_data_denoised) # noise_clean_mse, denoised_clean_mse 모델에 의해 주어진 노이즈와 정리된 테스트 데이터 사이의 MSE # MSE 값 모두 인쇄

clean_noisy = mse(cifar10_test, cifar10_test_noisy) clean_denoised = mse(cifar10_test, cifar10_test_denoised) clean_noisy, clean_denoised print("두 이미지의 차이점은 다음과 같습니다.", clean_noisy-clean_denoised)

size = 32 channel = 3 from keras.layers import Conv2D, Input, Dense, Dropout, MaxPool2D, UpSampling2D # Autoencoder 네트워크의 Encoder 컴포넌트 입력 = 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, 패딩 ='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)coded = 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) decoded = Conv2DTranspose(3, 3, activation='sigmoid',strides=(2,2), padding='same')(x) autoencoder = Model(inputs, decoded) # 컴파일 model autoencoder.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy') # 모델 요약 분석 autoencoder.summary()

# epochs 및 batch_size 수를 하이퍼파라미터 epochs = 25 batch_size = 256 history = autoencoder.fit(train_data_noisy, train_data_clean, epochs=epochs, batch_size=batch_size, shuffle=True, validation_data=(test_data_noisy), test)_data로 수정합니다.

# 그림 정의 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("손실 곡선",fontsize=18) plt.xlabel( "Epochs", fontsize=15) plt.ylabel("손실", 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._ 예측하다

행 = 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)) # 각 반복에서 Figure에 subplot 추가 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("자동 인코더 결과 - Cifar10", fontsize=18) plt.show()

def mse(data_1, data_2): np.square(np.subtract(data_1, data_2)).mean()을 반환합니다. noise_clean_mse = mse(test_data_clean, test_data_noisy) denoised_clean_mse = mse(test_data_denoised, test_data_clean) noise_senoised

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()

clean_noisy = mse(cifar10_test, cifar10_test_noisy) clean_denoised = mse(cifar10_test, cifar10_test_denoised) clean_noisy, clean_denoised print("두 이미지의 차이점은 다음과 같습니다.", clean_noisy-clean_denoised)