Menü Kapat

Üretken Çekişmeli Ağları Kullanan DLSS

DLSS Example 1
DLSS Example 2
DLSS Example 3

Bu makale size Keras kitaplığı kullanılarak yazılan bir DLSS Üretken Çekişmeli Ağı’nın genel çerçevesini sağlayacaktır. Kendi görüntü veri kümelerinizi kullanarak süper çözünürlüklü modelleri eğitmek için bu genel DLSS GAN şablonunu kullanabileceksiniz.

Kodun tam sürümü bu GitHub deposunda mevcuttur.

Veri kümesi

Bu şablon, herhangi bir RGB görüntüsünü veri kümeniz olarak kullanabileceğiniz şekilde yazılmıştır. Kullanılabilecek iyi bir veri kümesi örneğini Kagge’den indirebilirsiniz . Bu veri seti iki görüntü seti sağlar: 96 × 96 pikselli bir düşük çözünürlüklü görüntü seti ve 384 × 384 pikselli bir yüksek çözünürlüklü görüntü seti.

Bu veri kümesini kullanmak için, ayarlarınızı yalnızca kullanıcı tarafından belirlenen parametreler dahilinde tanımlamanız gerekir.  input_path indirilen veri kümesindeki LR klasörüne ayarlayın ve output_path’i HR klasörüne ayarlayın. Ayrıca görüntülerinizin boyutlarını da belirtmeniz gerekir, bu nedenle input_dimensions’ı (96,96,3) ve output_dimensions’ı (384,384,3) olarak ayarlayın. Bu durumda giriş ve çıkış boyutlarının uyumlu olduğuna dikkat edin. İki görüntü boyutu, yüksek çözünürlük ile düşük çözünürlük arasındaki oran 2’nin katı olduğunda uyumludur. Bu durumda 384 × 384 görüntüler, 96 × 96 görüntülerden 4 kat daha büyüktür. Bu uyumluluk, Upsampling2D’nin katmanları Keras’ta çalışır. Katman girdinin çözünürlüğünü iki katına çıkarır ve super_sampling_ratio parametresi, girdi boyutlarımızdan çıktı boyutlarımıza ulaşmak için modelimizdeki katmanı kaç kez uyguladığımızı belirler.

İki görüntü setiyle birlikte gelen veri kümelerini kullanmanıza gerek olmadığını da unutmamak önemlidir. Örneğin, yalnızca bir 256 × 256 görüntü kümesiyle gelen bu veri kümesini kullanabilirsiniz. Sadece ayarlama yoluyla, input_path ve output_path aynı klasöre parametrelerini ve görüntüleri doğru işlenecektir. Bu örnekte, output_dimension (256,256,3) olarak ayarlayın ve input_dimension’ları (64,64,3) veya (128,128,3) olarak ayarlayın ve görüntüler buna göre yeniden boyutlandırılacaktır.

Girdiler

Girdi [1]:
from keras.layers import Input, Dense, Reshape, Flatten
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import UpSampling2D, Conv2D, MaxPooling2D
from keras.models import Sequential, Model
from keras.optimizers import Adam
from sklearn.utils import shuffle
import matplotlib.pyplot as plt
import numpy as np
import os
from PIL import Image
import skimage.transform as s

Bu proje aşağıdaki kitaplıkları gerektirmektedir:

  • Keras (I use 2.3.1)
  • Tensorflow (I use 1.14.0)
  • Sklearn
  • Skimage
  • Numpy
  • Matplotlib
  • PIL

Parametreleri Ayarla

Bu şablonu özel ihtiyaçlarınıza göre değiştirebilmeniz için şablonun parametrelerini tanımlamanız gerekir. Mevcut parametreler, 8 GB VRAM’li bir GPU’da kullanılmak üzere tasarlanmıştır. Daha az güce sahip bir GPU ile çalışıyorsanız, evrişimli filtrelerin sayısını ve çekirdek boyutunu buna göre azaltın. Bellek kısıtlamaları nedeniyle toplu iş boyutu da azaltılabilir. Geri kalan parametreler aşağıda açıklanmıştır:

Kullanıcı Tarafından Belirlenen Parametreler:

  • input_path: Düşük çözünürlüklü veri kümesini içeren klasöre işaret eden dosya yolu.
  • output_path: Yüksek çözünürlüklü veri kümesini içeren klasöre işaret eden dosya yolu.
  • input_dimensions: Düşük çözünürlüklü veri kümesindeki görüntülerin boyutları. Görüntü boyutları uyumlu olmalıdır, yani output_dimensions / input_dimensions 2’nin katıdır.
  • output_dimensions: Yüksek çözünürlüklü veri kümesindeki görüntülerin boyutları. Görüntü boyutları uyumlu olmalıdır, yani output_dimensions / input_dimensions 2’nin katıdır.
  • super_sampling_ratio: İki görüntü çözünürlüğü arasındaki boyut farkının oranını temsil eden tamsayı. Bu tam sayı, modellerde Upsampling2D ve MaxPooling2D katmanlarının kaç kez kullanıldığını belirtir.
  • model_path: Modele kaydetmek istediğiniz klasöre ve oluşturulan örneklere işaret eden dosya yolu.
  • interval: Modelinizi kaydetme arasında kaç dönemin olduğunu gösteren tamsayı.
  • epochs: Modelin kaç dönemin eğitileceğini temsil eden tam sayı.
  • batch: Bir seferde kaç görüntünün eğitileceğini temsil eden tam sayı.
  • conv_filters: Generator ve Discriminator’ın her bir evrişimli katmanında kaç tane evrişimli filtre kullanıldığını temsil eden tamsayı.
  • kernel: Evrişimli katmanlarda kullanılan çekirdeklerin boyutunu temsil eden grup.
  • png: Boolean flag, verilerde resimlerden alfa katmanını kaldırmak için PNG’ler varsa True olarak ayarlayın.
Girdi [2]:
# Folder containing input (low resolution) dataset
input_path = r'D:\Downloads\selfie2anime\trainB'

# Folder containing output (high resolution) dataset
output_path = r'D:\Downloads\selfie2anime\trainB'

# Dimensions of the images inside the dataset.
# NOTE: The image sizes must be compatible meaning output_dimensions / input_dimensions is a multiple of 2
input_dimensions = (128,128,3)

# Dimensions of the images inside the dataset.
# NOTE: The image sizes must be compatible meaning output_dimensions / input_dimensions is a multiple of 2
output_dimensions = (256,256,3)

# How many times to increase the resolution by 2 (by appling the UpSampling2D layer)
super_sampling_ratio = int(output_dimensions[0] / input_dimensions[0] / 2)

# Folder where you want to save to model as well as generated samples
model_path = r"C:\Users\Vee\Desktop\python\GAN\DLSS\results"

# How many epochs between saving your model
interval = 5

# How many epochs to run the model
epoch = 100

# How many images to train at one time.
# Ideally this number would be a factor of the size of your dataset
batch = 25

# How many convolutional filters for each convolutional layer of the generator and the discrminator
conv_filters = 64

# Size of kernel used in the convolutional layers
kernel = (5,5)

# Boolean flag, set to True if the data has pngs to remove alpha layer from images
png = True

Derin Evrişimli GAN Sınıfı Oluşturun

Bu sınıf 6 yöntem içerir.

  • __init __ (self) : Sınıf, girdi görüntüsünün yanı sıra çıktı görüntüsünün boyutları tanımlanarak başlatılır. Generator ve Discriminator modelleri build_generator () ve build_discriminator () kullanılarak başlatılır .

  • build_generator (self) : Generator modelini tanımlar. Evrişimsel ve UpSampling2D tabakaları kat görüntünün çözünürlüğünü artırmak super_sampling_ratio * 2 . DCGAN sınıfı başlatıldığında çağrılır.

  • build_discriminator (self) : Discriminator modelini tanımlar. Konvolüsyonel ve MaxPooling2D tabakalar output_dimensions ila altörnekleyebilirsiniz 1 skaler tahmini. DCGAN sınıfı başlatıldığında çağrılır.

  • load_data (self) : Kullanıcı tarafından belirtilen dosya yolundan veri_yolu verileri yükler . Dan yeniden şekillendiren görüntüleri input_path olması input_dimensions . Output_path dosyasındaki görüntüleri output_dimensions için yeniden şekillendirir . Train () yönteminde çağrılır .

  • train (self, epochs, batch_size, save_interval) : Generative Adversarial Network’ü eğitir . Her dönem modeli, batch_size ile tanımlanan parçalara ayrılmış tüm veri kümesini kullanarak eğitir . Epoch, save_interval’deyse , yöntem örnekleri oluşturmak için save_imgs () öğesini çağırır ve modeli geçerli dönemde kaydeder.

  • save_imgs (self, epoch, gen_imgs, interpolated) : Modeli kaydeder ve kullanıcının belirlediği yol olan model_path’ta belirli bir dönem için tahmin örnekleri oluşturur . Her örnek, karşılaştırma için 8 enterpolasyonlu görüntü ve Derin Öğrenilmiş Süper Örneklenmiş görüntüler içerir.

Başlatma

Girdi [3]:
class DCGAN():
    
    # Initialize parameters, generator, and discriminator models
    def __init__(self):
        
        # Set dimensions of the output image
        self.img_rows = output_dimensions[0]
        self.img_cols = output_dimensions[1]
        self.channels = output_dimensions[2]
        self.img_shape = (self.img_rows, self.img_cols, self.channels)
        
        # Shape of low resolution input image
        self.latent_dim = input_dimensions
        
        # Chose optimizer for the models
        optimizer = Adam(0.0002, 0.5)

        # Build and compile the discriminator
        self.discriminator = self.build_discriminator()
        self.discriminator.compile(loss='binary_crossentropy',
            optimizer=optimizer,
            metrics=['accuracy'])

        # Build the generator
        self.generator = self.build_generator()
        generator = self.generator

        # The generator takes low resolution images as input and generates high resolution images
        z = Input(shape = self.latent_dim)
        img = self.generator(z)

        # For the combined model we will only train the generator
        self.discriminator.trainable = False

        # The discriminator takes generated images as input and determines validity
        valid = self.discriminator(img)

        # The combined model  (stacked generator and discriminator)
        # Trains the generator to fool the discriminator
        self.combined = Model(z, valid)
        self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

DCGAN sınıfı başlatıldığında, Sinir Ağının veri setinden beklemesi gereken görüntülerin boyutunu tanımlarız. Çıktı boyutları Tuple img_shape tarafından belirtilir. Girdi boyutları ayrıca Tuple latent_dim tarafından da belirtilir.

Her iki model için de kullandığımız optimize edici,  Adam optimize edicidir. Optimize edicinin öğrenme oranı ve beta değerleri ile denemekten çekinmeyin ve ne tür sonuçlar aldığınızı görün.

Generative Adversarial Network’ün mimarisi, her iki modelde İkili Çapraz Entropi kaybını kullanarak burada tanımlanmıştır. Kayıp fonksiyonu olarak İkili Çapraz Entropi seçimi burada açıklanmıştır. Diğer kayıp fonksiyonlarını denemekten çekinmeyin, ancak her iki modelin de aynı kayıp fonksiyonunu kullanması gerektiğini unutmayın.

Veri yükle

    # load data from specified file path 
    def load_data(self):
        
        # Initializing arrays for data and image file paths
        data = []
        small = []
        paths = []
        
        # Get the file paths of all image files in this folder
        for r, d, f in os.walk(output_path):
            for file in f:
                if '.jpg' in file or 'png' in file:
                    paths.append(os.path.join(r, file))
                    
        # For each file add high resolution image to array
        for path in paths:
            img = Image.open(path)
            
            # Resize Image
            y = np.array(img.resize((self.img_rows,self.img_cols)))
            
            # Remove alpha layer if imgaes are PNG
            if(png):
                y = y[...,:3]
                
            data.append(y)
          
        paths = []
        
        # Get the file paths of all image files in this folder
        for r, d, f in os.walk(input_path):
            for file in f:
                if '.jpg' in file or 'png' in file:
                    paths.append(os.path.join(r, file))
                    
        # For each file add low resolution image to array
        for path in paths:
            img = Image.open(path)
            
            # Resize Image
            x = np.array(img.resize((self.latent_dim[0],self.latent_dim[1])))
            
            # Remove alpha layer if imgaes are PNG
            if(png):
                x = x[...,:3]
                
            small.append(x)
        
            
        # Return x_train and y_train reshaped to 4 dimensions
        y_train = np.array(data)
        y_train = y_train.reshape(len(data),self.img_rows,self.img_cols,self.channels)
        x_train = np.array(small)
        x_train = x_train.reshape(len(small),self.latent_dim[0],self.latent_dim[0],self.latent_dim[2])
        
        del data
        del small
        del paths
        
        # Shuffle indexes of data
        X_shuffle, Y_shuffle = shuffle(x_train, y_train)
        
        return X_shuffle, Y_shuffle

DCGAN sınıfına eklediğimiz ilk yöntem load_data () ‘dır . Bu kullanıcı belirtilen yolları, içinde tüm görüntüleri için ön işlemeden input_path ve output_paths olacaktır. Her klasördeki görüntüler, buna göre input_dimensions ve output_dimensions olarak yeniden boyutlandırılacaktır. Bu yöntem, eğitimden önce verileri yüklemek için train () yönteminin içinde çağrılır.

Veri kümelerini döndürmeden, iki diziyi döndürmeden önce x_train ve y_train veri kümelerini karıştırıyoruz. Veri kümesindeki modelleri sıralı olarak eğitmek için train () yöntemini yazdık, her yinelemede toplu iş boyutunu artırdık. Bu nedenle, veri kümesinin sıralı olarak sıralanma biçimiyle ilgili oluşacak önyargıları getirmemek için veri kümesini karıştırmak önemlidir.

Generator Oluşturun

 # Define Generator model
    def build_generator(self):

        model = Sequential()
        
        # 1st Convolutional Layer / Input Layer
        model.add(Conv2D(conv_filters, kernel_size=kernel, padding="same", input_shape=self.latent_dim))
        model.add(LeakyReLU(alpha=0.2))
        
        # Upsample the data as many times as needed to reach output resolution
        for i in range(super_sampling_ratio):
        
            # Super Sampling Convolutional Layer
            model.add(Conv2D(conv_filters, kernel_size=kernel, padding="same"))
            model.add(LeakyReLU(alpha=0.2))

            # Upsample the data (Double the resolution)
            model.add(UpSampling2D())

        # Convolutional Layer
        model.add(Conv2D(conv_filters, kernel_size=kernel, padding="same"))
        model.add(LeakyReLU(alpha=0.2))

        # Convolutional Layer
        model.add(Conv2D(conv_filters, kernel_size=kernel, padding="same"))
        model.add(LeakyReLU(alpha=0.2))
        
        # Final Convolutional Layer (Output Layer)
        model.add(Conv2D(3, kernel_size=kernel, padding="same"))
        model.add(LeakyReLU(alpha=0.2))
        model.summary()

        noise = Input(shape=self.latent_dim)
        img = model(noise)

        return Model(noise, img)

DCGAN sınıfına eklediğimiz ikinci yöntem build_generator () ‘dır . Bu yöntem, sınıf ilk kez başlatıldığında çağrılır. Generator modelinin mimarisi burada tasarlanmıştır. Model özeti, bu modelde gerçekte neler olduğu konusunda size daha net bir fikir verecektir.

DLSS Example 2

Generator modelinin girdisi, bir RGB görüntüsünü temsil eden bir tensördür. Bu durumda, bir (128,128,3) resim. Bu tensör daha sonra çıktı olarak (256,256,3) değerine yükseltilir.

Çıktı Evrişimli katmanı, RGB görüntüsünün sırasıyla Kırmızı, Yeşil ve Mavi kanallarını temsil eden 3 filtre içerir.

Ayrımcı (Discriminator) Oluşturun

# Define Discriminator model
    def build_discriminator(self):

        model = Sequential()

        # Input Layer
        model.add(Conv2D(conv_filters, kernel_size=kernel, input_shape=self.img_shape,activation = "relu", padding="same"))
        
        # Downsample the image as many times as needed
        for i in range(super_sampling_ratio):
            
            # Convolutional Layer
            model.add(Conv2D(conv_filters, kernel_size=kernel))
            model.add(LeakyReLU(alpha=0.2))
        
            # Downsample the data (Half the resolution)
            model.add(MaxPooling2D(pool_size=(2, 2)))
        
        # Convolutional Layer
        model.add(Conv2D(conv_filters, kernel_size=kernel, strides = 2))
        model.add(LeakyReLU(alpha=0.2))

        # Convolutional Layer
        model.add(Conv2D(conv_filters, kernel_size=kernel, strides = 2))
        model.add(LeakyReLU(alpha=0.2))
        
        model.add(Flatten())
        
        # Output Layer
        model.add(Dense(1, activation='sigmoid'))

        model.summary()

        img = Input(shape=self.img_shape)
        validity = model(img)

        return Model(img, validity)

DCGAN sınıfına eklediğimiz üçüncü yöntem build_discriminator () ‘dür. Bu yöntem, sınıf ilk kez başlatıldığında çağrılır. Discriminator modelinin mimarisi burada tasarlanmıştır. Model özeti, bu modelde gerçekte neler olduğu konusunda size daha net bir fikir verecektir.

DLSS Example 2

Discriminator modelinin girişi, bir RGB görüntüsünü temsil eden bir tensördür. Bu durumda, bir (256,256,3) resim. Tensör daha sonra 252 × 252, 126 × 126, 61 × 61 ve 29 × 29’a alt örneklenir. Bu 29 × 29 tensör daha sonra düzleştirilir ve çıktı katmanına aktarılır.

Son yoğun katman, ayırıcı modelin tahminini temsil eden tek bir skaler sayı verir. Bu tahmin, giriş görüntüsünün “gerçek” olup olmadığını belirlemede modelin güvenini temsil eder. 1 tahmini, modelin görüntünün orijinal veri kümesinden geldiğini düşündüğü anlamına gelir. O tahmini, modelin görüntünün Generator modeli tarafından oluşturulduğunu düşündüğü anlamına gelir.

Eğitmek

# Train the Generative Adversarial Network
    def train(self, epochs, batch_size, save_interval):
        
        # Prevent script from crashing from bad user input
        if(epochs <= 0):
            epochs = 1
        
        if(batch_size <= 0):
            batch_size = 1

        # Load the dataset
        X_train, Y_train = self.load_data()
        
        # Normalizing data to be between 0 and 1
        X_train = X_train / 255
        Y_train = Y_train / 255

        # Adversarial ground truths
        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))
        
        # Placeholder arrays for Loss function values
        g_loss_epochs = np.zeros((epochs, 1))
        d_loss_epochs = np.zeros((epochs, 1))
        
        # Training the GAN
        for epoch in range(1, epochs + 1):
            
            # Initialize indexes for training data
            start = 0
            end = start + batch_size
            
            # Array to sum up all loss function values
            discriminator_loss_real = []
            discriminator_loss_fake = []
            generator_loss = []
            
            # Iterate through dataset training one batch at a time
            for i in range(int(len(X_train)/batch_size)):
                
                # Get batch of images
                imgs_output = Y_train[start:end]
                imgs_input = X_train[start:end]

                # Train Discriminator

                # Make predictions on current batch using generator
                gen_imgs = self.generator.predict(imgs_input)

                # Train the discriminator (real classified as ones and generated as zero)
                d_loss_real = self.discriminator.train_on_batch(imgs_output, valid)
                d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
                d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

                #  Train Generator

                # Train the generator (wants discriminator to mistake images as real)
                g_loss = self.combined.train_on_batch(imgs_input, valid)
                
                # Add loss for current batch to sum over entire epoch
                discriminator_loss_real.append(d_loss[0])
                discriminator_loss_fake.append(d_loss[1])
                generator_loss.append(g_loss)
                
                # Increment image indexes
                start = start + batch_size
                end = end + batch_size

DCGAN sınıfına eklediğimiz dördüncü yöntem train (). Bu yöntem, ağı toplu iş boyutu tarafından belirtilen artışlarla belirtilen sayıda dönem için eğitecektir. Eğitim tamamlandığında, yöntem her dönem boyunca her iki modelin kayıp değerlerini temsil eden iki dizi döndürecektir. Kayıp değerleri Matplotlib kullanılarak çizilebilir.

Kayıp değerlerini takip etmeli ve çökmeye başlarsa ağı eğitmeyi bırakmalısınız. Modellerden biri 0 kaybına yaklaşırsa ağ çöker.

DLSS Example 2

Generator 0 kaybına yaklaşırsa, bu, Generator’ün her seferinde ayırıcıyı kandıracak bir görüntüyü nasıl oluşturacağını bulduğu anlamına gelir. Bu genellikle Generator’ün mod çökmesi olarak da bilinen tek bir görüntü türü üretebilmesine neden olur.

Discriminator, 0 kaybına yaklaşırsa, bu, Discriminator’ın eğitim verileri ile oluşturulan görüntüleri çok doğru bir şekilde nasıl ayırt edeceğini bulduğu anlamına gelir. Bu, Generator’ün; kaybolan gradyan problemi olarak da bilinen, ayırıcıdan öğrenmeye devam edememesine neden olacaktır.

Ağımız çöktüğünde ilerlememizi kaybetmemek için, modeli her birkaç dönemde bir kaydedeceğiz. Kullanıcı tanımlı parametre olan interval, modelin ne sıklıkla kaydedileceğini belirleyecektir. Geçerli dönem tanımlanan aralığa her geldiğindesave_imgs () çağrılır. Yöntem, modelin o dönemde ne kadar iyi olduğuna dair bir anlık görüntü elde etmek için tahmin edilen bazı örneklerin bir görüntüsünü kaydedecektir.

Görüntüleri Kaydet

  # Save the model and generate prediction samples for a given epoch
    def save_imgs(self, epoch, gen_imgs, interpolated):
        
        # Define number of columns and rows
        r, c = 4, 4
        
        # Placeholder array for MatPlotLib Figure Subplots
        subplots = []
        
        # Create figure with title
        fig = plt.figure(figsize= (40, 40))
        fig.suptitle("Epoch: " + str(epoch), fontsize=65)
        
        # Initialize counters needed to track indexes across multiple arrays
        img_count = 0;
        index_count = 0;
        x_count = 0;
        
        # Loop through columns and rows of the figure
        for i in range(1, c+1):
            for j in range(1, r+1):
                # If row is even, plot the predictions
                if(j % 2 == 0):
                    img = gen_imgs[index_count]
                    index_count = index_count + 1
                # If row is odd, plot the interpolated images
                else:
                    img = interpolated[x_count]
                    x_count = x_count + 1
                # Add image to figure, add subplot to array
                subplots.append(fig.add_subplot(r, c, img_count + 1))
                plt.imshow(img)
                img_count = img_count + 1
        
        # Add title to columns of figure
        subplots[0].set_title("Interpolated", fontsize=45)
        subplots[1].set_title("Predicted", fontsize=45)
        subplots[2].set_title("Interpolated", fontsize=45)
        subplots[3].set_title("Predicted", fontsize=45)
                
        # Save figure to .png image in specified folder
        fig.savefig(model_path + "\\epoch_%d.png" % epoch)
        plt.close()
        
        # save model to .h5 file in specified folder
        self.generator.save(model_path + "\\generator" + str(epoch) + ".h5")

DCGAN sınıfına eklediğimiz beşinci ve son yöntem, save_imgs () yöntemidir. Bu yöntem, modeli mevcut dönemde kaydedecek ve enterpolasyonlu emsallerine kıyasla 8 süper örneklenmiş görüntüyü çizecektir. Oluşturulan örnek, DLSS modelinin kalitesini En Yakın Komşu Enterpolasyonu ile karşılaştırmanıza olanak tanır.

DLSS Example 2

Bu yöntem şu anda her 5 çağda bir kaydedecek şekilde yapılandırılmıştır. Bu, aralık parametresi ile ayarlanabilir . Modelinizi sık sık kaydetmek, eğitim sürecinde ağınızın kaydettiği ilerlemeyi izlemenin iyi bir yoludur.

DCGAN Sınıfını Başlatma

Artık DCGAN sınıfını oluşturmayı bitirdik ve Generative Adversarial Network’ümüzü eğitmeye hazırız. Öncelikle, sınıfın bir örneğini oluşturmalı ve onu bir değişkene atamalıyız.

Girdi[4]

dcgan = DCGAN()

Bu, Generator ve Discriminator modellerini başlatacak ve bunların özetlerini yazdıracaktır.

GAN Eğitimi

Artık DCGAN sınıf nesnemize sahip olduğumuza göre, eğitime başlamak için train () yöntemini çağırmamız gerekiyor. Bu komut dosyasıyla, genellikle eğitim için çok sayıda dönem seçmeli ve süreç boyunca kayıp değerlerini izlemelisiniz. Ağ çökmeye başlarsa eğitimi erken durdurun ve hangi modelin en iyi performans gösteren model olduğunu bulmak için oluşturulan örnekleri kontrol edin.

Train () yöntemi, eğitim boyunca iki modelin kayıp değerlerini içeren iki dizi döndürür. Bu değerleri g_loss ve d_loss’a atayacağız ve grafiğini çizeceğiz.

Girdi [5]

g_loss, d_loss = dcgan.train(epochs=epoch, batch_size=batch, save_interval=interval)
 
1 [D loss: 0.640689, acc.: 59.37%] [G loss: 0.967596]
2 [D loss: 0.575859, acc.: 73.34%] [G loss: 1.787223]
3 [D loss: 0.656025, acc.: 61.31%] [G loss: 1.042790]
4 [D loss: 0.656616, acc.: 60.19%] [G loss: 0.998186]
5 [D loss: 0.674997, acc.: 56.04%] [G loss: 0.893507]

Plot Kaybı

Girdi [6]

plt.plot(g_loss)
plt.plot(d_loss)
plt.title('GAN Loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Generator', 'Discriminator'], loc='upper left')
plt.show()
DLSS Example 2

Sonuçları Analiz Et

Memnun olduğunuz bir modeli eğittikten sonra, modelinizi çeşitli görüntüler üzerinde test etme zamanı gelmiştir. Bunu sağlanan bu komut dosyasını kullanarak yapabilirsiniz. Bunu kullanmak için önce birkaç parametre tanımlamalısınız. Input_dimensions ve ouput_dimesions’ı eğitim komut dosyasında yaptığınız aynı değerlere ayarlayın. Model_path , kullanmak istediğiniz H5 modelinin yoluna ayarlayın . H5 modelleri , save_imgs () yöntemi sırasında eğitim komut dosyasında model_path ile belirtilen klasöre kaydedilir . Dataset_path parametresini, modelinizi test etmek istediğiniz görüntüleri içeren klasöre ayarlayın. Görüntüler herhangi bir PNG içeriyorsa, pngalfa katmanlarını görüntülerden kaldırmak için boole işaretini true olarak ayarlayın. Sonuçlarınızdan animasyonlu GIF’ler oluşturmak için videonun karelerini dataset_path klasörüne yerleştirin. Son olarak, save_path parametresini model çıkarımının sonuçlarının kaydedilmesini istediğiniz klasöre ayarlayın.

Girdi [19]

model = load_model(model_path)

Görüntüleri ve Süper Örnekleri Yükleyin

Girdi [29]

paths = []
count = 0

for r, d, f in os.walk(dataset_path):
    for file in f:
        if '.png' in file or 'jpg' in file:
            paths.append(os.path.join(r, file))

for path in paths:
    
    # Select image
    img = Image.open(path)

    #create plot
    f, axarr = plt.subplots(1,3,figsize=(15,15),gridspec_kw={'width_ratios': [1,super_sampling_ratio,super_sampling_ratio]})
    axarr[0].set_xlabel('Original Image (' + str(input_dimensions[0]) + 'x' + str(input_dimensions[1]) + ')', fontsize=10)
    axarr[1].set_xlabel('Interpolated Image (' + str(output_dimensions[0]) + 'x' + str(output_dimensions[1]) + ')', fontsize=10)
    axarr[2].set_xlabel('Super Sampled Image (' + str(output_dimensions[0]) + 'x' + str(output_dimensions[1]) + ')', fontsize=10)

    #original image
    x = img.resize((input_dimensions[0],input_dimensions[1]))
    
    #interpolated (resized) image
    y = x.resize((output_dimensions[0],output_dimensions[1]))
    
    
    x = np.array(x)
    y = np.array(y)
    
    # Remove alpha layer if imgaes are PNG
    if(png):
        x = x[...,:3]
        y = y[...,:3]
    
    #plotting first two images
    axarr[0].imshow(x)
    axarr[1].imshow(y)
    
    #plotting super sampled image
    x = x.reshape(1,input_dimensions[0],input_dimensions[1],input_dimensions[2])/255
    result = np.array(model.predict_on_batch(x))*255
    result = result.reshape(output_dimensions[0],output_dimensions[1],output_dimensions[2])
    np.clip(result, 0, 255, out=result)
    result = result.astype('uint8')
                
    axarr[2].imshow(result)
    
    # Save image
    f.savefig(save_path + '\\frame_%d.png' % count)
    
    # Increment file name counter
    count = count + 1

Bu parametreleri ayarladıktan sonra, komut dosyası her görüntüyü input_dimesions ile belirtilen boyuta yeniden şekillendirecek ve modelinize girdi olarak besleyecektir. Ardından komut dosyası, modeliniz tarafından çıkarılan görüntüyü, En Yakın Komşu Enterpolasyonu kullanılarak giriş görüntüsünün enterpolasyonlu gibi görüneceği ile karşılaştırarak çizecektir. Modelinizden oluşturulan bu örnekler, save_path parametresi ile belirtilen klasöre kaydedilecektir. Bu örnekler, modelinizin kalitesini analiz etmenin iyi bir yoludur. Bir görüntünün modelinize girilmeden önceki görünümünü, modelinizden geçtikten sonra nasıl göründüğünü ve başka bir teknik kullanılarak süper örneklenmiş görünme biçimini karşılaştırabilirsiniz. Modellerimden bazılarının sonuçları aşağıda gösterilmektedir.

Sonuçlar

DLSS Example 1
DLSS Example 1
DLSS Example 1
DLSS Example 1
DLSS Example 1
DLSS Example 1

Sonuç

Bu makale, Keras kullanarak bir DLSS Üretken Çekişmeli Ağı eğitmek için genel bir çerçeve sağlar. Bu komut dosyasını kullanarak kendi veri kümelerinizle çeşitli çözünürlükler için kendi DLSS modellerinizi oluşturabileceksiniz. Bu kodun tam sürümü burada bulunabilir.

Memnun olduğunuz bir modeli eğittikten sonra, bu komut dosyasını çıktılar oluşturmak ve sonuçlarınızı analiz etmek için kullanabilirsiniz. Komut dosyası ayrıca size süper örneklenmiş video karelerinden GIF’ler oluşturmak için kod sağlayacaktır.

VEE UPATISING

Araştırmacı

Github

Veri kümesi

Jupyter Notebook

tr_TRTurkish