# %%
import glob
import imageio
import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
from tensorflow.keras import layers
import time
import tensorflow as tf
from IPython import display
import tensorflow_addons as tfa
from tensorflow.keras.preprocessing import image_dataset_from_directory
import keras
# %% [markdown]
# ### 이미지 경로, 이미지 크기, 배치 크기
# %%
IMAGE_PATH = r"D:\ADC_POC\transistor\train"
IMAGE_SIZE = (56,56)
IMG_SHAPE = IMAGE_SIZE+(3,)
BATCH_SIZE = 256
train_dataset = image_dataset_from_directory(IMAGE_PATH,
shuffle=True,
labels=None,
color_mode="grayscale",
batch_size=BATCH_SIZE,
image_size=IMAGE_SIZE)
# %% [markdown]
# ### Data Augmentation
# %%
def convert_to_float(image):
image = tf.image.convert_image_dtype(image, dtype=tf.float32)
return image
def trans1(img):
return tfa.image.rotate(tf.image.flip_left_right(tf.image.flip_up_down(img)),-.2,fill_mode="reflect",interpolation="bilinear")
def trans2(img):
return tfa.image.rotate(img,-.2,fill_mode="reflect",interpolation="bilinear")
def trans3(img):
return tfa.image.rotate(img,.2,fill_mode="reflect",interpolation="bilinear")
def trans4(img):
return tfa.image.mean_filter2d(img, filter_shape=5)
def trans5(img):
return tfa.image.median_filter2d(img, filter_shape=5)
def trans6(img):
return tfa.image.sharpness(img, 0.1)
ds1,ds2,ds3,ds4 = train_dataset,train_dataset.map(trans1),train_dataset.map(trans2),train_dataset.map(trans3)
ds5,ds6,ds7 = train_dataset.map(trans4),train_dataset.map(trans5),train_dataset.map(trans6)
train_dataset = ds1.repeat(300).concatenate(ds2).concatenate(ds3).concatenate(ds4).concatenate(ds5).concatenate(ds6).concatenate(ds7)
AUTOTUNE = tf.data.experimental.AUTOTUNE
train_dataset = (
train_dataset
.map(convert_to_float)
.cache()
.prefetch(buffer_size=AUTOTUNE)
)
# %%
total_batches = tf.data.experimental.cardinality(train_dataset)
print(f'total_batches : {total_batches}')
print(f'total_images : {total_batches*BATCH_SIZE}')
# %%
for var in train_dataset.take(1):
plt.figure(figsize=(10,10))
for i in range(25):
ax = plt.subplot(5,5,i+1)
# augmented_image = data_augmentation(tf.expand_dims(image[i], 0))
plt.imshow(var[0]/255, cmap='gray')
plt.axis('off')
plt.show()
# %% [markdown]
# ### Geneator
# %%
def make_generator_model():
model = tf.keras.Sequential()
model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Reshape((7, 7, 256)))
assert model.output_shape == (None, 7, 7, 256) # 주목: 배치사이즈로 None이 주어집니다.
model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
assert model.output_shape == (None, 7, 7, 128)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
assert model.output_shape == (None, 14, 14, 64)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Conv2DTranspose(32, (5, 5), strides=(2, 2), padding='same', use_bias=False))
assert model.output_shape == (None, 28, 28, 32)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
assert model.output_shape == (None, 56, 56, 1)
return model
# %% [markdown]
# ### SEED Image
# %%
generator = make_generator_model()
#generator.summary()
noise = tf.random.normal([1, 100])
generated_image = generator(noise, training=False)
plt.imshow(generated_image[0, :, :, 0], cmap='gray')
# %% [markdown]
# ### Discriminator
# %%
def make_discriminator_model():
model = tf.keras.Sequential()
model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[56, 56, 1]))
model.add(layers.LeakyReLU())
model.add(layers.Dropout(0.3))
model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
model.add(layers.LeakyReLU())
model.add(layers.Dropout(0.3))
model.add(layers.Flatten())
model.add(layers.Dense(1))
return model
# %%
discriminator = make_discriminator_model()
decision = discriminator(generated_image)
print (decision)
# %% [markdown]
# ### LOSS
# %%
# 이 메서드는 크로스 엔트로피 손실함수 (cross entropy loss)를 계산하기 위해 헬퍼 (helper) 함수를 반환합니다.
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
# %%
def discriminator_loss(real_output, fake_output):
real_loss = cross_entropy(tf.ones_like(real_output), real_output)
fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
total_loss = real_loss + fake_loss
return total_loss
# %%
def generator_loss(fake_output):
return cross_entropy(tf.ones_like(fake_output), fake_output)
# %% [markdown]
# ### Optimizer & Saving Model
# %%
generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)
# %%
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
discriminator_optimizer=discriminator_optimizer,
generator=generator,
discriminator=discriminator)
# %% [markdown]
# ### Model Compile
# %%
EPOCHS = 100
noise_dim = 100
num_examples_to_generate = 16
# 이 시드를 시간이 지나도 재활용하겠습니다.
# (GIF 애니메이션에서 진전 내용을 시각화하는데 쉽기 때문입니다.)
seed = tf.random.normal([num_examples_to_generate, noise_dim])
# %%
# `tf.function`이 어떻게 사용되는지 주목해 주세요.
# 이 데코레이터는 함수를 "컴파일"합니다.
@tf.function
def train_step(images):
noise = tf.random.normal([BATCH_SIZE, noise_dim])
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
generated_images = generator(noise, training=True)
real_output = discriminator(images, training=True)
fake_output = discriminator(generated_images, training=True)
gen_loss = generator_loss(fake_output)
disc_loss = discriminator_loss(real_output, fake_output)
gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
# %% [markdown]
# ### Train Progressbar
# %%
def train(dataset, epochs):
for epoch in range(epochs):
start = time.time()
for image_batch in dataset:
train_step(image_batch)
# GIF를 위한 이미지를 바로 생성합니다.
display.clear_output(wait=True)
generate_and_save_images(generator,
epoch + 1,
seed)
# 15 에포크가 지날 때마다 모델을 저장합니다.
if (epoch + 1) % 15 == 0:
checkpoint.save(file_prefix = checkpoint_prefix)
# print (' 에포크 {} 에서 걸린 시간은 {} 초 입니다'.format(epoch +1, time.time()-start))
print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))
# 마지막 에포크가 끝난 후 생성합니다.
display.clear_output(wait=True)
generate_and_save_images(generator,
epochs,
seed)
# %%
def generate_and_save_images(model, epoch, test_input):
# `training`이 False로 맞춰진 것을 주목하세요.
# 이렇게 하면 (배치정규화를 포함하여) 모든 층들이 추론 모드로 실행됩니다.
predictions = model(test_input, training=False)
fig = plt.figure(figsize=(4,4))
for i in range(predictions.shape[0]):
plt.subplot(4, 4, i+1)
# plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
plt.imshow(predictions[i, :, :, 0], cmap='gray')
plt.axis('off')
plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
plt.show()
# %% [markdown]
# ### Training
# %%
%%time
train(train_dataset, EPOCHS)
# %%
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))
# %%
# 에포크 숫자를 사용하여 하나의 이미지를 보여줍니다.
def display_image(epoch_no):
return PIL.Image.open('image_at_epoch_{:04d}.png'.format(epoch_no))
# %%
display_image(EPOCHS)
# %%
anim_file = 'dcgan.gif'
with imageio.get_writer(anim_file, mode='I') as writer:
filenames = glob.glob('image*.png')
filenames = sorted(filenames)
last = -1
for i,filename in enumerate(filenames):
frame = 2*(i**0.5)
if round(frame) > round(last):
last = frame
else:
continue
image = imageio.imread(filename)
writer.append_data(image)
image = imageio.imread(filename)
writer.append_data(image)
import IPython
if IPython.version_info > (6,2,0,''):
display.Image(filename=anim_file)