add(CycleGAN model and ReadME)

Author: Simon Karlsson

CycleGAN/CycleGAN.py

@@ -0,0 +1,8 @@
+#### Directory structure on new dataset needed for training and testing:
+
+```
+./Dataset-name/trainA
+./Dataset-name/trainB
+./Dataset-name/testA
+./Dataset-name/testB
+```

CycleGAN/data/ReadMe.md

@@ -0,0 +1,33 @@
+### When generating synthetic images from a trained models:
+
+#### Put models in directory:
+```
+./models/
+```
+
+#### With names:
+```
+G_A2B_model.hdf5
+G_B2A_model.hdf5
+```
+
+#### Create directories for generated images:
+```
+./synthetic_images/A
+./synthetic_images/B
+```
+
+#### Comment row 242:
+```
+#self.train(…
+```
+
+#### Uncomment row 243:
+```
+self.load_model_and_generate_synthetic_images()
+```
+
+#### Then run:
+```
+python CycleGAN.py
+```

CycleGAN/generate_images/ReadMe.md

@@ -0,0 +1,112 @@
+import os
+import numpy as np
+from PIL import Image
+from keras.utils import Sequence
+#from skimage.io import imread
+
+
+def load_data(nr_of_channels, batch_size=1, nr_A_train_imgs=None, nr_B_train_imgs=None,
+              nr_A_test_imgs=None, nr_B_test_imgs=None, subfolder='',
+              generator=False, D_model=None, use_multiscale_discriminator=False, use_supervised_learning=False, REAL_LABEL=1.0):
+
+    trainA_path = os.path.join('data', subfolder, 'trainA')
+    trainB_path = os.path.join('data', subfolder, 'trainB')
+    testA_path = os.path.join('data', subfolder, 'testA')
+    testB_path = os.path.join('data', subfolder, 'testB')
+
+    trainA_image_names = os.listdir(trainA_path)
+    if nr_A_train_imgs != None:
+        trainA_image_names = trainA_image_names[:nr_A_train_imgs]
+
+    trainB_image_names = os.listdir(trainB_path)
+    if nr_B_train_imgs != None:
+        trainB_image_names = trainB_image_names[:nr_B_train_imgs]
+
+    testA_image_names = os.listdir(testA_path)
+    if nr_A_test_imgs != None:
+        testA_image_names = testA_image_names[:nr_A_test_imgs]
+
+    testB_image_names = os.listdir(testB_path)
+    if nr_B_test_imgs != None:
+        testB_image_names = testB_image_names[:nr_B_test_imgs]
+
+    if generator:
+        return data_sequence(trainA_path, trainB_path, trainA_image_names, trainB_image_names, batch_size=batch_size)  # D_model, use_multiscale_discriminator, use_supervised_learning, REAL_LABEL)
+    else:
+        trainA_images = create_image_array(trainA_image_names, trainA_path, nr_of_channels)
+        trainB_images = create_image_array(trainB_image_names, trainB_path, nr_of_channels)
+        testA_images = create_image_array(testA_image_names, testA_path, nr_of_channels)
+        testB_images = create_image_array(testB_image_names, testB_path, nr_of_channels)
+        return {"trainA_images": trainA_images, "trainB_images": trainB_images,
+                "testA_images": testA_images, "testB_images": testB_images,
+                "trainA_image_names": trainA_image_names,
+                "trainB_image_names": trainB_image_names,
+                "testA_image_names": testA_image_names,
+                "testB_image_names": testB_image_names}
+
+
+def create_image_array(image_list, image_path, nr_of_channels):
+    image_array = []
+    for image_name in image_list:
+        if image_name[-1].lower() == 'g':  # to avoid e.g. thumbs.db files
+            if nr_of_channels == 1:  # Gray scale image -> MR image
+                image = np.array(Image.open(os.path.join(image_path, image_name)))
+                image = image[:, :, np.newaxis]
+            else:                   # RGB image -> 3 channels
+                image = np.array(Image.open(os.path.join(image_path, image_name)))
+            image = normalize_array(image)
+            image_array.append(image)
+
+    return np.array(image_array)
+
+
+def normalize_array(array):
+    max_value = max(array.flatten())
+    array = array / max_value
+    return array
+
+
+class data_sequence(Sequence):
+
+    def __init__(self, trainA_path, trainB_path, image_list_A, image_list_B, batch_size=1):  # , D_model, use_multiscale_discriminator, use_supervised_learning, REAL_LABEL):
+        self.batch_size = batch_size
+        self.train_A = []
+        self.train_B = []
+        for image_name in image_list_A:
+            if image_name[-1].lower() == 'g':  # to avoid e.g. thumbs.db files
+                self.train_A.append(os.path.join(trainA_path, image_name))
+        for image_name in image_list_B:
+            if image_name[-1].lower() == 'g':  # to avoid e.g. thumbs.db files
+                self.train_B.append(os.path.join(trainB_path, image_name))
+
+    def __len__(self):
+        return int(max(len(self.train_A), len(self.train_B)) / float(self.batch_size))
+
+    def __getitem__(self, idx):  # , use_multiscale_discriminator, use_supervised_learning):if loop_index + batch_size >= min_nr_imgs:
+        if idx >= min(len(self.train_A), len(self.train_B)):
+            # If all images soon are used for one domain,
+            # randomly pick from this domain
+            if len(self.train_A) <= len(self.train_B):
+                indexes_A = np.random.randint(len(self.train_A), size=self.batch_size)
+                batch_A = []
+                for i in indexes_A:
+                    batch_A.append(self.train_A[i])
+                batch_B = self.train_B[idx * self.batch_size:(idx + 1) * self.batch_size]
+            else:
+                indexes_B = np.random.randint(len(self.train_B), size=self.batch_size)
+                batch_B = []
+                for i in indexes_B:
+                    batch_B.append(self.train_B[i])
+                batch_A = self.train_A[idx * self.batch_size:(idx + 1) * self.batch_size]
+        else:
+            batch_A = self.train_A[idx * self.batch_size:(idx + 1) * self.batch_size]
+            batch_B = self.train_B[idx * self.batch_size:(idx + 1) * self.batch_size]
+
+        real_images_A = create_image_array(batch_A, '', 3)
+        real_images_B = create_image_array(batch_B, '', 3)
+
+        return real_images_A, real_images_B  # input_data, target_data
+
+
+if __name__ == '__main__':
+    load_data()

CycleGAN/load_data.py

@@ -0,0 +1,118 @@
+import csv
+import matplotlib.pyplot as plt
+import sys
+#from operator import add
+import numpy as np
+
+from scipy.signal import butter, lfilter, freqz
+
+
+def butter_lowpass(cutoff, fs, order=5):
+    nyq = 0.5 * fs
+    normal_cutoff = cutoff / nyq
+    b, a = butter(order, normal_cutoff, btype='low', analog=False)
+    return b, a
+
+
+def butter_lowpass_filter(data, cutoff, fs, order=5):
+    b, a = butter_lowpass(cutoff, fs, order=order)
+    y = lfilter(b, a, data)
+    return y
+
+
+def plotResultfromCSV(datetime, point_gap=1):
+    DA_losses = []
+    DB_losses = []
+    gA_d_losses_synthetic = []
+    gB_d_losses_synthetic = []
+    gA_losses_reconstructed = []
+    gB_losses_reconstructed = []
+    D_losses = []
+    G_losses = []
+    reconstruction_losses = []
+
+    with open('images/{}/loss_output.csv'.format(datetime), newline='') as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            DA_losses.append(float(row['DA_losses']))
+            DB_losses.append(float(row['DB_losses']))
+            gA_d_losses_synthetic.append(float(row['gA_d_losses_synthetic']))
+            gB_d_losses_synthetic.append(float(row['gB_d_losses_synthetic']))
+            gA_losses_reconstructed.append(float(row['gA_losses_reconstructed']))
+            gB_losses_reconstructed.append(float(row['gB_losses_reconstructed']))
+            D_losses.append(float(row['D_losses']))
+            reconstruction_losses.append(float(row['reconstruction_losses']))
+            G_loss = row['G_losses']
+            if G_loss[0] == '[':
+                G_loss = G_loss.split(',')[0][1:]
+            G_losses.append(float(G_loss))
+        csvfile.close()
+
+        # Calculate interesting things to plot
+        DA_losses = np.array(DA_losses)
+        DB_losses = np.array(DB_losses)
+        GA_losses = np.add(np.array(gA_d_losses_synthetic), np.array(gA_losses_reconstructed))
+        GB_losses = np.add(np.array(gB_d_losses_synthetic), np.array(gB_losses_reconstructed))
+        RA_losses = np.array(gA_losses_reconstructed)
+        RB_losses = np.array(gB_losses_reconstructed)
+
+        G_losses = np.array(G_losses)
+        D_losses = np.array(D_losses)
+        reconstruction_losses = np.add(np.array(gA_losses_reconstructed), np.array(gB_losses_reconstructed))
+
+    points = range(0, len(G_losses), point_gap)
+    fs = 1000
+    cutoff = 2
+    order = 6
+
+    # Lowpass filter
+    GA = butter_lowpass_filter(GA_losses[points], cutoff, fs, order)
+    GB = butter_lowpass_filter(GB_losses[points], cutoff, fs, order)
+
+    DA = butter_lowpass_filter(DA_losses[points], cutoff, fs, order)
+    DB = butter_lowpass_filter(DB_losses[points], cutoff, fs, order)
+
+    RA = butter_lowpass_filter(RA_losses[points], cutoff, fs, order)
+    RB = butter_lowpass_filter(RB_losses[points], cutoff, fs, order)
+
+    G = butter_lowpass_filter(G_losses[points], cutoff, fs, order)
+    D = butter_lowpass_filter(D_losses[points], cutoff, fs, order)
+    R = butter_lowpass_filter(reconstruction_losses[points], cutoff, fs, order)
+
+    fig_D = plt.figure(1)
+    plt.plot(GA, label='GB_losses')
+    plt.plot(GB, label='GA_losses')
+    plt.ylabel('Generator losses')
+    plt.legend()
+
+    fig_G = plt.figure(2)
+    plt.plot(DA, label='DA_losses')
+    plt.plot(DB, label='DB_losses')
+    plt.ylabel('Discriminator losses')
+    plt.legend()
+
+    fig_recons = plt.figure(3)
+    plt.plot(RA, label='Reconstruction_loss_A')
+    plt.plot(RB, label='Reconstruction_loss_B')
+    plt.ylabel('Reconstruction losses')
+    plt.legend()
+
+    fig_tots = plt.figure(4)
+    plt.plot(G, label='G_losses')
+    plt.plot(D, label='D_losses')
+    plt.plot(R, label='Reconstruction_losses')
+    plt.legend()
+
+    # Show plots
+    fig_D.show()
+    fig_G.show()
+    fig_recons.show()
+    fig_tots.show()
+
+    plt.pause(0)
+
+
+if __name__ == '__main__':
+    datetime = str(sys.argv[1])
+    points = int(sys.argv[2])
+    plotResultfromCSV(datetime, points)

CycleGAN/plotCSVfile.py

@@ -0,0 +1,82 @@
+
+
+## Generative Adversarial Networks for Image-to-Image Translation on Multi-Contrast MR Images - A Comparison of CycleGAN and UNIT  
+
+### Article  
+[Frontiers in Neuroinformatics - article](https://www.frontiersin.org/journals/neuroinformatics)
+
+[(Underlying thesis project - report)](http://liu.diva-portal.org/smash/record.jsf?dswid=-7667&aq2=%5B%5B%5D%5D&af=%5B%5D&searchType=SIMPLE&sortOrder2=title_sort_asc&language=en&pid=diva2%3A1216606&aq=%5B%5B%5D%5D&sf=all&aqe=%5B%5D&sortOrder=author_sort_asc&onlyFullText=false&noOfRows=50&dspwid=-7667)  
+ 
+ 
+ 
+
+### Code usage  
+1. Prepare your dataset under the directory 'data' in the CycleGAN or UNIT folder
+  * Directory structure on new dataset needed for training and testing:
+    * data/Dataset-name/trainA
+    * data/Dataset-name/trainB
+    * data/Dataset-name/testA
+    * data/Dataset-name/testB  
+     
+2. Train a model by:
+```
+python CycleGAN.py
+```
+or
+```
+python UNIT.py
+```  
+ 
+3. Generate synthetic images by following specifications under:
+  * CycleGAN/generate_images/ReadMe.rtf
+  * UNIT/generate_images/ReadMe.rtf  
+   
+   
+   
+
+### Result GIFs - 304x256 pixel images  
+**Left:** Input image. **Middle:** Synthetic images generated during training. **Right:** Ground truth.  
+Histograms show pixel value distributions for synthetic images (blue) compared to ground truth (brown).  
+ 
+ 
+ 
+
+#### CycleGAN - T1 to T2
+![](./ReadMe/gifs/CycleGAN_T2_hist.gif?)
+---
+ 
+ 
+ 
+ 
+ 
+ 
+
+#### CycleGAN - T2 to T1
+![](./ReadMe/gifs/CycleGAN_T1_hist.gif)
+---
+ 
+ 
+ 
+ 
+ 
+ 
+
+#### UNIT - T1 to T2
+![](./ReadMe/gifs/UNIT_T2_hist.gif)
+---
+ 
+ 
+ 
+ 
+ 
+ 
+
+#### UNIT - T2 to T1
+![](./ReadMe/gifs/UNIT_T1_hist.gif)
+---
+ 
+ 
+ 
+ 
+ 
+