Delete pix2pix.py

pix2pix.py

@@ -1,477 +0,0 @@
-import tensorflow as tf
-import os
-import pathlib
-import time
-import datetime
-from matplotlib import pyplot as plt
-from IPython import display
-from glob import glob
-import numpy as np
-import cv2
-import math 
-import keras
-
-import zipfile
-with zipfile.ZipFile("NewDataSet.zip", 'r') as zip_ref:
-    zip_ref.extractall("")
-
-#tuz-karabiber gürültüsü
-def saltpepperNoise(image):
-  row,col,ch = image.shape
-  s_vs_p = 0.5
-  amount = 0.004
-  out = image
-  # Salt mode
-  num_salt = np.ceil(amount * image.size * s_vs_p)
-  coords = [np.random.randint(0, i - 1, int(num_salt))
-            for i in image.shape]
-  out[coords] = 1
-
-  # Pepper mode
-  num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))
-  coords = [np.random.randint(0, i - 1, int(num_pepper))
-            for i in image.shape]
-  out[coords] = 0
-  return out
-
-def color_imread(path):
-    img = cv2.imread(path)
-    img = cv2.cvtColor(img , cv2.COLOR_BGR2RGB)
-    img = (img/127.5) - 1
-    img = img.astype(np.float32)
-    return img
-
-def gray_imread(path):
-    img = cv2.imread(path)
-    img = cv2.cvtColor(img ,cv2.COLOR_BGR2GRAY)
-    img = img.astype(np.float32)
-    return img
-
-def load():
-  input_paths = sorted(glob('NewDataSet/*'))
-  real_paths = sorted(glob('NewDataSet/*'))
-  input_images = []
-  real_images = []
-  for path in input_paths:
-      image = gray_imread(path)
-      input_images.append(image)
-  for path in real_paths:
-      image = color_imread(path)
-      real_images.append(image)
-
-  return input_images , real_images
-
-def reshape(gray_img):
-  gray_img = np.asarray(gray_img)
-  gray_img = gray_img.reshape(256,256,1)
-  return gray_img
-
-input_images , real_images = load()
-
-#test = gray_imread("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png")
-#test = cv2.resize(test,(256,256))
-
-for i in range(len(input_images)):
-  input_images[i] = reshape(input_images[i])
-
-#test = reshape(test)
-
-#print(np.asarray(test).shape)
-
-def ssim(original,predict):
-   ssim = tf.image.ssim(original, predict, max_val=1.0, filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03)
-   return ssim
-
-def psnr(img1, img2):
-  psnr = tf.image.psnr(img1, img2, max_val=255)
-  return psnr
-
-array_Gen_loss=[]
-
-def histogram_graphic(img):
-  hist,bins = np.histogram(img.flatten(),256,[0,256])
-  cdf = hist.cumsum()
-  cdf_normalized = cdf * float(hist.max()) / cdf.max()
-  plt.plot(cdf_normalized, color = 'b')
-  plt.hist(img.flatten(),256,[0,256], color = 'r')
-  plt.xlim([0, 230])
-  plt.legend(('cdf','histogram'), loc = 'upper left')
-  plt.show()
-
-def preprocessing(path):
-  img = cv2.imread(path)
-  img = np.asarray(img).reshape(256,256,3)
-  #print(img.shape)
-  #cv2.imshow(img)
-  #cv2.imwrite("/content/drive/MyDrive/ColabNotebooks/enhance/Before_hist_equalizer.png",img)
-    
-  #Işık ayarı
-  hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) #hsv formatında gerekiyor
-  hue, sat, val = cv2.split(hsv)
-
-  mid = 0.5
-  mean = np.mean(val)
-  gamma = math.log(mid*255)/math.log(mean)
-  #print("Gamma:",gamma)
-  #Çıkan gamma değerine göre ters işlem uygulayacak
-
-  #value kanalında gamma correction
-  val_gamma = np.power(val, gamma).clip(0,255).astype(np.uint8)
-
-  # yeni value kanalı orijinal hue ve sat kanallarıyla birleştiriliyor 
-  hsv_gamma = cv2.merge([hue, sat, val_gamma])
-  img_gamma = cv2.cvtColor(hsv_gamma, cv2.COLOR_HSV2BGR)
-  cv2.imwrite("/content/drive/MyDrive/ColabNotebooks/img_gamma.png",img_gamma)
-  #cv2.imshow(img_gamma)
-
-  #Adaptive Histogram Equalization
-  gamma_path = "/content/drive/MyDrive/ColabNotebooks/img_gamma.png"
-  img2 = cv2.imread(gamma_path,0)
-  img2 = np.asarray(img2).reshape(256,256,1)
-  clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-  #clipLimit -> Kontrast sınırı
-  clahe_equ = clahe.apply(img2)
-  cv2.imshow(clahe_equ)
-  cv2.imwrite("/content/drive/MyDrive/ColabNotebooks/enhance/After_clahe_equalizer.png",clahe_equ)
-  #return clahe_equ
-
-#preprocessing("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png")
-
-def image_colorfulness(image):
-    # split the image into its respective RGB components
-    (B, G, R) = cv2.split(image.astype("float"))
-
-    # compute rg = R - G
-    rg = np.absolute(R - G)
-
-    # compute yb = 0.5 * (R + G) - B
-    yb = np.absolute(0.5 * (R + G) - B)
-
-    # compute the mean and standard deviation of both `rg` and `yb`
-    (rbMean, rbStd) = (np.mean(rg), np.std(rg))
-    (ybMean, ybStd) = (np.mean(yb), np.std(yb))
-
-    # combine the mean and standard deviations
-    stdRoot = np.sqrt((rbStd ** 2) + (ybStd ** 2))
-    meanRoot = np.sqrt((rbMean ** 2) + (ybMean ** 2))
-
-    # derive the "colorfulness" metric and return it
-    return stdRoot + (0.3 * meanRoot) # sınırı 24
-
-from PIL import Image, ImageEnhance
-def add_saturation(path):
-  clr = cv2.imread(path)
-  value = image_colorfulness(clr)
-  print(value)
-  img = Image.open(path)
-  enhanced_obj = ImageEnhance.Color(img)
-  if value<30 :  #renk doygunluğu iyi durumda çıkanları da bir miktar arttırmak için sınırı 30 yapıyoruz 
-    enhanced_obj.enhance((30-value)*0.1 + 0.75).save("enhance/deneme_sat.jpg")
-
-#add_saturation("/content/drive/MyDrive/ColabNotebooks/enhance/cikti2.jpeg")
-
-def unsharp_mask(image, kernel_size=(5, 5), sigma=1.0, amount=1.0, threshold=0):
-    """Return a sharpened version of the image, using an unsharp mask."""
-    blurred = cv2.GaussianBlur(image, kernel_size, sigma)
-    sharpened = float(amount + 1) * image - float(amount) * blurred
-    sharpened = np.maximum(sharpened, np.zeros(sharpened.shape))
-    sharpened = np.minimum(sharpened, 255 * np.ones(sharpened.shape))
-    sharpened = sharpened.round().astype(np.uint8)
-    if threshold > 0:
-        low_contrast_mask = np.absolute(image - blurred) < threshold
-        np.copyto(sharpened, image, where=low_contrast_mask)
-    return sharpened
-
-def example(image,name):
-    sharpened_image = unsharp_mask(image)
-    cv2.imwrite(name, sharpened_image)
-
-#s_img= cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/deneme.jpg")
-#example(s_img,"/content/drive/MyDrive/ColabNotebooks/enhance/deneme_sharp.jpg")
-
-#img2 = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png")
-#newimg2 = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/Output/nadam_image9.png")
-
-#psnr(img2,newimg2)
-#ssim(img2,newimg2)
-
-import math
-import cv2
-import numpy as np
-
-#original = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png",0)
-#contrast = cv2.imread("/content/drive/MyDrive/ColabNotebooks/enhance/After_clahe_equalizer_with_gamma.png",0)
-
-print(original.dtype)
-def psnr(img1, img2, MAX=None):
-    if MAX is None:
-		    MAX = np.iinfo(img1.dtype).max
-    mse = np.mean((img1 - img2) ** 2)
-    if mse == 0:
-        return 100
-    return 20 * math.log10(MAX / math.sqrt(mse))
-
-
-#db = psnr(original, contrast)
-#print(db)
-
-OUTPUT_CHANNELS = 3
-
-def downsample(filters, size, apply_batchnorm=True):
-  initializer = tf.random_normal_initializer(0., 0.02)
-
-  result = tf.keras.Sequential()
-  result.add(tf.keras.layers.Conv2D(filters, size, strides=2, padding='same',kernel_initializer=initializer, use_bias=False))
-  # Burada 2'ye bölüyoruz 256 --> 128
-  if apply_batchnorm:
-    result.add(tf.keras.layers.BatchNormalization())
-
-  result.add(tf.keras.layers.LeakyReLU())
-
-  return result
-
-def upsample(filters, size, apply_dropout=False):
-  initializer = tf.random_normal_initializer(0., 0.02)
-
-  result = tf.keras.Sequential()
-  result.add(
-    tf.keras.layers.Conv2DTranspose(filters, size, strides=2,
-                                    padding='same',
-                                    kernel_initializer=initializer,
-                                    use_bias=False))
-# burada da 2 kat arttırıyoruz
-  result.add(tf.keras.layers.BatchNormalization())
-
-  if apply_dropout:
-      result.add(tf.keras.layers.Dropout(0.5))
-
-  result.add(tf.keras.layers.ReLU())
-
-  return result
-
-def Generator(tpu=False):
-  inputs = tf.keras.layers.Input(shape=[256, 256, 1])
-
-  down_stack = [
-    downsample(64, 4, apply_batchnorm=False),  # (batch_size, 128, 128, 64)
-    downsample(128, 4),  # (batch_size, 64, 64, 128)
-    downsample(256, 4),  # (batch_size, 32, 32, 256)
-    downsample(512, 4),  # (batch_size, 16, 16, 512)
-    downsample(512, 4),  # (batch_size, 8, 8, 512)
-    downsample(512, 4),  # (batch_size, 4, 4, 512)
-    downsample(512, 4),  # (batch_size, 2, 2, 512)
-    downsample(512, 4),  # (batch_size, 1, 1, 512)
-  ]
-
-  up_stack = [
-    upsample(512, 4, apply_dropout=True),  # (batch_size, 2, 2, 1024)
-    upsample(512, 4, apply_dropout=True),  # (batch_size, 4, 4, 1024)
-    upsample(512, 4, apply_dropout=True),  # (batch_size, 8, 8, 1024)
-    upsample(512, 4),  # (batch_size, 16, 16, 1024)
-    upsample(256, 4),  # (batch_size, 32, 32, 512)
-    upsample(128, 4),  # (batch_size, 64, 64, 256)
-    upsample(64, 4),  # (batch_size, 128, 128, 128)
-  ]
-  initializer = tf.random_normal_initializer(0., 0.02)
-  last = tf.keras.layers.Conv2DTranspose(OUTPUT_CHANNELS, 4,
-                                         strides=2,
-                                         padding='same',
-                                         kernel_initializer=initializer,
-                                         activation='tanh')  # (batch_size, 256, 256, 3)
-# Build U-NET
-  x = inputs
-
-  # Downsampling through the model
-  skips = []
-  for down in down_stack:
-    x = down(x)
-    skips.append(x)
-
-  skips = reversed(skips[:-1]) # son elemani almadan terste yazdirir
-
-  # Upsampling and establishing the skip connections
-  for up, skip in zip(up_stack, skips):
-    x = up(x)
-    x = tf.keras.layers.Concatenate()([x, skip])
-
-  x = last(x)
-  model = tf.keras.Model(inputs=inputs, outputs=x)
-  
-  return model
-
-pre_trained = Generator()
-pre_trained.compile(optimizer='adam',loss=tf.keras.losses.BinaryCrossentropy(from_logits=True))
-
-from tensorflow.keras.models import *
-from tensorflow.keras.layers import *
-from tensorflow.keras.optimizers import *
-
-integer = (input_images[0]+1)*127.5
-
-LAMBDA = 100
-loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)
-
-def generator_loss(disc_generated_output, gen_output, target,total_loop):
-  gan_loss = loss_object(tf.ones_like(disc_generated_output), disc_generated_output)
-  # Mean absolute error
-  l1_loss = tf.reduce_mean(tf.abs(target - gen_output))
-  total_gen_loss = gan_loss + (LAMBDA * l1_loss)
-  if total_loop % 2 == 0:
-    array_Gen_loss.append(total_gen_loss)
-  return total_gen_loss, gan_loss, l1_loss
-
-ssim_results = []
-psnr_results = []
-
-def ssim_psnr(pre,target):
-    ssim_res = ssim(pre,target)
-    psnr_res = psnr(pre,target)
-    ssim_results.append(ssim_res)
-    psnr_results.append(ssim_results)
-
-def Discriminator():
-  initializer = tf.random_normal_initializer(0., 0.02)
-
-  inp = tf.keras.layers.Input(shape=[256, 256, 1], name='input_image') # lr
-  tar = tf.keras.layers.Input(shape=[256, 256, 3], name='target_image') # hr
-
-  x = tf.keras.layers.concatenate([inp, tar])  # (batch_size, 256, 256, channels*2)
-
-  down1 = downsample(64, 4, False)(x)  # (batch_size, 128, 128, 64)
-  down2 = downsample(128, 4)(down1)  # (batch_size, 64, 64, 128)
-  down3 = downsample(256, 4)(down2)  # (batch_size, 32, 32, 256)
-
-  zero_pad1 = tf.keras.layers.ZeroPadding2D()(down3)  # (batch_size, 34, 34, 256)
-  conv = tf.keras.layers.Conv2D(512, 4, strides=1,
-                                kernel_initializer=initializer,
-                                use_bias=False)(zero_pad1)  # (batch_size, 31, 31, 512)
-
-  batchnorm1 = tf.keras.layers.BatchNormalization()(conv)
-
-  leaky_relu = tf.keras.layers.LeakyReLU()(batchnorm1)
-
-  zero_pad2 = tf.keras.layers.ZeroPadding2D()(leaky_relu)  # (batch_size, 33, 33, 512)
-
-  last = tf.keras.layers.Conv2D(1, 4, strides=1,
-                                kernel_initializer=initializer)(zero_pad2)  # (batch_size, 30, 30, 1)
-
-  return tf.keras.Model(inputs=[inp, tar], outputs=last)
-
-discriminator = Discriminator()
-
-def discriminator_loss(disc_real_output, disc_generated_output):
-  real_loss = loss_object(tf.ones_like(disc_real_output), disc_real_output)
-
-  generated_loss = loss_object(tf.zeros_like(disc_generated_output), disc_generated_output)
-
-  total_disc_loss = real_loss + generated_loss #  0.5 ile de çarpabilirsin
-
-  return total_disc_loss
-
-generator_optimizer = tf.keras.optimizers.Nadam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, name="Nadam")
-discriminator_optimizer = tf.keras.optimizers.Nadam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, name="Nadam")
-
-def generate_images(model, test_input,step):
-  if (step%1 == 0):
-    prediction = model(test_input, training=True)
-    pre = prediction[0]
-    pre = (pre+1)*127.5
-    pre = np.uint8(pre)
-    name = 'image{step}.png'.format(step=step)
-    plt.imsave(name,pre)
-
-test = np.array(test).reshape(1,256,256,1)
-input_images = np.array(input_images).reshape(-1,1,256,256,1)
-real_images = np.array(real_images).reshape(-1,1,256,256,3)
-print(real_images[0].shape)
-
-def train_step(input_image, target, step):
-  with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
-    gen_output = pre_trained(input_image, training=True)
-
-    disc_real_output = discriminator([input_image, target], training=True)
-    disc_generated_output = discriminator([input_image, gen_output], training=True)
-
-    gen_total_loss, gen_gan_loss, gen_l1_loss = generator_loss(disc_generated_output, gen_output, target,10)
-    disc_loss = discriminator_loss(disc_real_output, disc_generated_output)
-  
-  generator_gradients = gen_tape.gradient(gen_total_loss,
-                                          pre_trained.trainable_variables)
-  discriminator_gradients = disc_tape.gradient(disc_loss,
-                                               discriminator.trainable_variables)
-
-  generator_optimizer.apply_gradients(zip(generator_gradients,
-                                          pre_trained.trainable_variables))
-  discriminator_optimizer.apply_gradients(zip(discriminator_gradients,
-                                              discriminator.trainable_variables))
-
-def fit(input_images,real_images,test,steps):
-  example_input = test
-  start = time.time()
-  step = 0
-  i = 0
-  while step<steps:
-    print("Step = ",step)
-    while i < len(input_images):
-          train_step(input_images[i], real_images[i], step)
-          if (i%200 == 0):
-            print('i= ',i)
-          i +=1
-    generate_images(pre_trained, example_input,step)
-    step+=1
-    i = 0
-  generate_images(pre_trained, example_input,step)
-
-fit(input_images,real_images,test,10)
-
-#pre_trained.save("enhance/pix2pix.h5")
-
-a = array_Gen_loss
-a = np.asarray(a)
-plt.plot(a)
-plt.ylabel('Loss Percent')
-plt.xlabel('Epochs')
-plt.show()
-
-pre_trained = keras.models.load_model("gradio_pix2pix.h5")
-
-#pre_trained.summary()
-
-#pre_trained.optimizer
-
-#path2 = '/content/drive/MyDrive/ColabNotebooks/enhance/landscape.png'
-#image = gray_imread(path2)
-#image = saltpepperNoise(image)
-#image = np.array(image).reshape(1,256,256,1)
-
-#prediction = pre_trained(image,training=True)
-#pre = prediction[0]
-#pre = (pre+1)*127.5
-#pre = np.uint8(pre)
-#name = '/content/drive/MyDrive/ColabNotebooks/enhance/pre_trained.png'
-#plt.imsave(name,pre)
-#cv2.imshow(pre)
-
-def result(Input):
-    size0 = Input.shape[0]
-    size1 = Input.shape[1]
-    Input = cv2.resize(Input, (256,256), interpolation = cv2.INTER_AREA)
-    Input = cv2.cvtColor(Input , cv2.COLOR_BGR2GRAY)
-    Input = np.array(Input).reshape(1,256,256,1)
-    prediction = pre_trained(Input,training=True)
-    Input = prediction[0]
-    Input = (Input+1)*127.5
-    Input = np.uint8(Input)
-    Input = cv2.resize(Input, (size1,size0), interpolation = cv2.INTER_AREA)
-    return Input
-
-#lst = cv2.imread('/content/drive/MyDrive/ColabNotebooks/enhance/low-sat.jpg')
-#r = result(lst)
-#cv2.imshow(r)
-
-pip install gradio
-import gradio as gr
-
-iface = gr.Interface(fn=result, inputs=gr.inputs.Image(type="numpy",image_mode="RGB"), outputs=gr.outputs.Image( type="auto", label=None),theme="grass"
-,allow_flagging="never",css=""" body {background-color: rgba(127,191,63,0.48)} """,title="Image Colorization")
-iface.launch(debug='False')