diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000..80213c8c65
Binary files /dev/null and b/.DS_Store differ
diff --git a/.gitignore b/.gitignore
index 2c77d23001..92459a9d2f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+recognition/s4481540_Zhuoxiao_Chen/data/
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000000..f56ad02b95
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000000..94a25f7f4c
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/algorithms/denoise/README.md b/algorithms/denoise/README.md
old mode 100755
new mode 100644
diff --git a/algorithms/denoise/denoise_tv_bregman/cat.png b/algorithms/denoise/denoise_tv_bregman/cat.png
old mode 100755
new mode 100644
diff --git a/algorithms/denoise/unsupervised-wiener/resources/astronaut.jpg b/algorithms/denoise/unsupervised-wiener/resources/astronaut.jpg
deleted file mode 100644
index 28677969a9..0000000000
Binary files a/algorithms/denoise/unsupervised-wiener/resources/astronaut.jpg and /dev/null differ
diff --git a/algorithms/denoise/wiener_deconv/tests/astronaut_noise.npy b/algorithms/denoise/wiener_deconv/tests/astronaut_noise.npy
deleted file mode 100644
index af04c3596d..0000000000
Binary files a/algorithms/denoise/wiener_deconv/tests/astronaut_noise.npy and /dev/null differ
diff --git a/algorithms/image/rank_order/main.py b/algorithms/image/rank_order/main.py
old mode 100755
new mode 100644
diff --git a/algorithms/numbertheory/number_theory/README.md b/algorithms/numbertheory/number_theory/README.md
old mode 100755
new mode 100644
diff --git a/algorithms/numbertheory/numbthy.py b/algorithms/numbertheory/numbthy.py
old mode 100755
new mode 100644
diff --git a/recognition/.DS_Store b/recognition/.DS_Store
new file mode 100644
index 0000000000..ae199051c1
Binary files /dev/null and b/recognition/.DS_Store differ
diff --git a/recognition/2021_ISIC_Improved_UNet/README.md b/recognition/2021_ISIC_Improved_UNet/README.md
new file mode 100644
index 0000000000..1cf9e51ec0
--- /dev/null
+++ b/recognition/2021_ISIC_Improved_UNet/README.md
@@ -0,0 +1,191 @@
+# Segmentation of the ISICs dataset using Improved UNet
+Published by the International Skin Imaging Collaboration (ISIC), the ISICs 2018 dataset
+was used as part of the Skin Lesion Analysis Towards Melanoma Detection recurring challenge.
+This challenge is an opportunity for participants to develop automated tools which aid in the
+diagnosis of melanoma. This project employs the Improved UNet [1] architecture to perform
+segmentation on the aforementioned ISICs dataset.
+
+## ISICs dataset
+The ISIC's dataset contains 2594 images and their associated segmentation masks. By default, the dataset contains images of varying sizes and aspect ratios. Data normalisation and resizing was applied to provide consistency throughout the inputs.
+
+
+
+
+
+
+
+
+
+_Figure 1: Sample image and associated mask from the ISICs 2018 dataset_
+
+### Data preprocessing
+As part of the pre-processing phase, all of the images (training images and masks) were normalised. In order to be run through the network, all of the images had to be the same size. The size chosen was (192, 256). The training images kept 3 colour channels: [192, 256, 3]. On the other hand, the segmentation masks were reduced to a single colour channel: [192, 256, 1]. The segmentation masks were also thresholded: pixels with a value > 0.5 after normalisation were set to 1, and the rest were set to 0.
+
+#### Training, Test & Validation Split.
+The Training, Testing and Validation data split chosen was 70 / 15 / 15. Some research was conducted on the optimal split for medical data. In general, it was found that there is no single correct split, however this percentage seemed to be the most highly regarded. For a dataset of this size, that means there was around 1800 training samples, and 390 training & validation samples.
+
+## Architecture
+Proposed in 2018 [1], the Improved UNet is designed upon the original model of UNet, proposed in 2015 [2].
+
+
+
+
+
+_Figure 2: Improved UNet Architecture [1]_
+
+The Improved UNet is composed of two main sections, the Context Aggregation pathway and the Localisation pathway. These pathways share information about the input images through Skip Connections from the Context Aggregation Pathway.
+
+### Context Modules & The Context Aggregation Pathway
+The Context Aggregation pathway is designed to encode the input images into increasingly compact representations as the network progresses. To do so, it is composed of a collection of 3x3 Convolutions (with a stride of 2) and Context Modules.
+
+The layer-by-layer architecture of the Context Modules is as follows:
+
+|Context Module Architecture|
+|-|
+|Instance Normalization|
+|Leaky ReLU Activation|
+|3x3 Convolution|
+|Dropout (_0.3 dropout rate_)|
+|Instance Normalization|
+|Leaky ReLU Activation|
+|3x3 Convolution|
+
+### Localisation Modules & The Localisation Pathway
+The Localisation Pathway is designed to increase the dimensionality of the encoded image representation to produce high resolution segmentations by means of Localisation Modules, UpSampling modules and image upscaling.
+
+The layer-by-layer architecture of the Localisation Modules is as follows:
+
+|Localisation Module Architecture|
+|-|
+|3x3 Convolution|
+|1x1 Convolution|
+
+#### Up-Sampling Modules
+Up-Sampling modules are placed after every localisation module in the Localisation Pathway.
+
+The layer-by-layer architecture of the Up-Sampling Modules is as follows:
+
+|Up-Sampling Module Architecture|
+|-|
+|2D UpSampling layer (2x2)|
+|3x3 Convolution|
+
+### Skip Connections
+Denoted by the horizontal dashed lines in _Figure 2_, Skip Connections are element-wise summations of the 3x3 (stride 2) Convolutions and Context Module outputs' in the Context Aggregation pathway. Skip Connections are concatenated into the corresponding network level in the Localisation Pathway.
+
+The Localisation Modules are designed to re-introduce these skip connections into the network after the concatenation.
+
+### Segmentation
+Segmentation occurs 3 times in the Localisation Pathway. Performing segmentation on multiple levels of the network allows for segmented information from the lower levels to propagate into the higher levels through an element-wise summation.
+
+Segmentation layers are 3x3 convolutions with a single output filter.
+
+The 'U' shaped dashed lines in _Figure 2_ denote the pathway that the segmentation levels take. Output is taken from the levels' Localisation Module and given to a Segmentation Layer. Lower (smaller) layers are up-sampled to allow element-wise summation to occur.
+
+## Optimizer & Loss
+The optimizer used in this implementation was the [Adam optimizer](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam) with a learning rate of 5e-4, as per [1].
+
+### Dice Similarity Coefficient
+The [Dice Similarity Coefficient](https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient) is a common metric used in segmentation problems. Formally, DSC is defined as:
+
+
+
+
+
+That is, the DSC is: 2 * the overlap between the pixels in the Ground Truth segmentation mask, and the model-generated Segmentation Mask. This is then divided by the sum of the total pixels in both masks.
+
+## Results
+For the following results, the model was run for 20 epochs. The `validation` performance follows the `training` performance closely throughout training, divering slightly towards the end. The distribution of DSC values on the Test Set evaluation is left-skewed, with few images attaining low DSC scores. Overall, an average DSC of > 0.8 was attained on the Test Set, with > 67% of images yielding a DSC score of 0.8 or higher.
+
+### Accuracy & Loss Plots
+The following plots show the behaviour of the model in terms of DSC and Loss over a 20 epoch run.
+
+
+
+
+
+_Figure 3: Improved UNet model loss_
+
+
+
+
+
+
+_Figure 4: Improved UNet model dice coefficient_
+
+### Performance on the Test Set
+After the model was trained for 20 epochs, its performance was evaluated on the Test Set.
+
+
+
+
+
+_Figure 5: Model performance on the Test Set after training_
+
+From _Figure 5_, we see that the average Dice Coefficient was 80.8%. Overall, 67.8% of the test set yielded a DSC of 0.8+.
+
+#### DSC Distribution
+The histogram below shows the distribution of the Test Set's DSC values during evaluation.
+
+
+
+
+
+
+_Figure 6: Distribution of DSC on the Test Set evaluation_
+
+### Output generated
+Masks output by the model were thresholded such that pixels which were > 0.5 were set to 1, else they were set to 0. Below are some output examples from the trained model, on the test set.
+
+
+
+
+
+
+
+
+
+_Figure 7: Input image / Ground Truth mask / Model-generated mask_
+
+## Additions and Changes
+The architecture described above gives an overview of the design of the model.
+During development, it was found that making slight tweaks to the architecture resulted in better performance. These changes were:
+- `UpSampling2D` layers used the `interpolation='bilinear'` parameter as opposed to the default `interpolation='nearest'`
+
+## Usage
+To run this network, ensure you have the appropriate Dependencies installed.
+
+Download the ISIC's 2018 dataset and place the training images and segmentation masks in two separate folders in the directory where the `model.py` and `driver.py` are located, named as so:
+- Training images: ISIC2018_Task1-2_Training_Input_x2
+- Segmentation masks: ISIC2018_Task1_Training_GroundTruth_x2
+
+Open up a commandline and navigate to the directory where `driver.py` is saved, and run it:
+
+`python driver.py`
+
+To ensure the data is loaded correctly, the Training Input from _Figure 1_ should appear on-screen, followed by its corresponding mask from the Training GroundTruth.
+
+You may change the amount of epochs that the network runs for and the `Adam` learning rate by changing the variables at the top of `driver.py`
+
+- `EPOCHS` denotes the total amount of epochs.
+- `OPT_LEARNING_RATE` denotes the `Adam` learning rate.
+
+Once the network is finished,
+1. It will generate `Loss` and `Dice Coefficient` graphs as shown in _Figure 3_ and _Figure 4_ above.
+2. It will then proceed to evaluate the test set, and some performance metrics will be output to the screen, as shown in _Figure 5_ above.
+3. A histogram of the Test Set's DSC distribution throughout evaluation will be generated, as shown in _Figure 6_ above.
+4. 20 images of the Original Image / Ground Truth Mask / Model-generated Mask will be generated, as shown in _Figure 7_ above. (_Note: you may change the amount of images output using the `local_batch` variable in the `generatePredictions` method in `driver.py`_)
+
+
+
+## Dependencies
+- Python 3.9.6
+- Tensorflow 2.6.0
+- Matplotlib 3.4.2
+- Numpy 1.19.5
+- Tensorflow Addons 0.14.0
+
+## References
+[1]: Isensee, F., Kickingereder, P., Wick, W., Bendszus, M., Maier-Hein, K.H, "Brain Tumor Segmentation and Radiomics Survival Prediction: Contribution to the BRATS 2017 Challenge". _arXiv: Computer Vision and Pattern Recognition_, 2018.
+
+[2]: Ronneberger, O., Fischer, P., Brox, T., "U-net: Convolutional networks for biomedical image segmentation,". _International Conference on Medical Image Computing and Computer-Assisted Intervention_, 2015. (Springer, pp. 234-241).
diff --git a/recognition/2021_ISIC_Improved_UNet/driver.py b/recognition/2021_ISIC_Improved_UNet/driver.py
new file mode 100644
index 0000000000..bf19f1e39a
--- /dev/null
+++ b/recognition/2021_ISIC_Improved_UNet/driver.py
@@ -0,0 +1,349 @@
+import tensorflow as tf
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+import model
+import os
+from model import *
+
+
+
+# Data loading and processing variables
+ISIC_DATA = "./ISIC2018_Task1-2_Training_Input_x2/*.jpg"
+ISIC_MASKS = "./ISIC2018_Task1_Training_GroundTruth_x2/*.png"
+
+IMAGE_HEIGHT = 192
+IMAGE_WIDTH = 256
+
+# Data managing variables
+BATCH_SIZE = 32
+DATASET_SIZE = 2594
+
+# Network variables
+OPT_LEARNING_RATE = 5e-4
+EPOCHS = 20
+
+
+def preprocessData(filenames):
+ """
+ Loads and preprocesses the images. The images must be:
+ - decoded
+ - reshaped to [IMAGE_HEIGHT, IMAGE_WIDTH] (chosen size)
+ - normalised (pixels must be between 0 and 1)
+
+ Image loading and decoding sourced from Tensorflow:
+ [https://www.tensorflow.org/api_docs/python/tf/io/read_file]
+ [12/08/2021]
+
+ @param filenames: the names of all of the image files
+
+ @return the newly processed images
+ """
+ raw_data = tf.io.read_file(filenames)
+
+ # Decode images
+ raw_image = tf.io.decode_jpeg(raw_data, channels=3)
+
+ # Resize the images
+ raw_image = tf.image.resize(raw_image, [IMAGE_HEIGHT, IMAGE_WIDTH])
+
+ # Normalise
+ raw_image = raw_image / 255.0
+
+ return raw_image
+
+
+def preprocessMasks(filenames):
+ """
+ Loads and preprocesses the masks. The masks must be:
+ - decoded and reduced to a single colour channel
+ - reshaped to [IMAGE_HEIGHT, IMAGE_WIDTH] (chosen size)
+ - normalised and thresholded (pixels must be 0 or 1)
+
+ Image loading and decoding sourced from Tensorflow:
+ [https://www.tensorflow.org/api_docs/python/tf/io/read_file]
+ [12/08/2021]
+
+ @param filenames: the names of all of the mask image files
+
+ @return the newly processed masks
+ """
+ raw_data = tf.io.read_file(filenames)
+
+ # Decode images
+ raw_image = tf.io.decode_png(raw_data, channels=1)
+
+ # Resize the images
+ raw_image = tf.image.resize(raw_image, [IMAGE_HEIGHT, IMAGE_WIDTH])
+
+ # Normalise
+ raw_image = raw_image / 255.0
+
+ # Threshold image to 0-1
+ raw_image = tf.where(raw_image > 0.5, 1.0, 0.0)
+
+ return raw_image
+
+
+def loadData():
+ """
+ Handles the loading and preprocessing of the raw data. Loads the
+ raw dataset from the path defined in ISIC_DATA and ISIC_MASKS.
+ Data is preprocessed and transformed into a tensorflow Dataset.
+
+ @return the processed (resized, normalised) raw data as a tensorflow
+ Dataset.
+ """
+ # Get the dataset contents
+ isics_data = tf.data.Dataset.list_files(ISIC_DATA, shuffle=False)
+ processedData = isics_data.map(preprocessData)
+
+ # Get the corresponding segmentation masks
+ masks_data = tf.data.Dataset.list_files(ISIC_MASKS, shuffle=False)
+ processedMasks = masks_data.map(preprocessMasks)
+
+
+ # Testing that pre-processing was successful
+ for elem in processedData.take(1):
+ plt.imshow(elem.numpy())
+ plt.show()
+
+ for elem in processedMasks.take(1):
+ plt.imshow(elem.numpy())
+ plt.show()
+
+
+ # Return the newly created dataset
+ newDataSet = tf.data.Dataset.zip((processedData, processedMasks))
+
+ return newDataSet
+
+
+def splitData(dataset):
+ """
+ Splits the dataset into the 70 / 15 / 15 split.
+
+ @param dataset: the entire dataset
+
+ @return the training, testing and validation datasets, now split 70 / 15 / 15
+ """
+
+ # Define the sizes for a 70 / 15 / 15 split
+ training_size = int(0.7 * DATASET_SIZE)
+ test_size = int(0.15 * DATASET_SIZE)
+ validation_size = test_size
+
+ # Use skip() and take() to split the data up
+ training_set = dataset.take(training_size)
+
+ # Training data is used up now
+ dataset = dataset.skip(training_size)
+
+ # Split the rest between the testing and validation
+ testing_set = dataset.take(test_size)
+ validation_set = dataset.skip(test_size)
+
+ return training_set, testing_set, validation_set
+
+
+def performBatching(train, test, validation):
+ """
+ Performs batching of the three data sets; training, testing and validation.
+ The size of the batches is defined in the variable BATCH_SIZE
+
+ @param train: the training dataset
+ @param test: the testing dataset
+ @param validation: the validation dataset
+
+ @return the original datasets passed in, now batched.
+ """
+ training_set = train.batch(BATCH_SIZE)
+ testing_set = test.batch(BATCH_SIZE)
+ validation_set = validation.batch(BATCH_SIZE)
+
+ return training_set, testing_set, validation_set
+
+def diceCoefficient(y_true, y_pred):
+ """
+ Defines the dice coefficient.
+
+ The dice coefficient is defined as:
+ 2 * (Pixel Overlap)
+ -----------------------------
+ Total pixels in both images
+
+ DSC Tensorflow implementation sourced from Medium:
+ [https://medium.com/@karan_jakhar/100-days-of-code-day-7-84e4918cb72c]
+ [25/10/2019]
+
+ @param y_true: the true output
+ @param y_pred: the output predicted by the model
+ @return the dice coefficient for the prediction, based on the true output.
+ """
+
+ y_true_f = tf.keras.backend.flatten(y_true)
+ y_pred_f = tf.keras.backend.flatten(y_pred)
+
+ # Get the pixel intersection of the two images
+ intersection = tf.keras.backend.sum(y_true_f * y_pred_f)
+
+ # DSC = (2 * intersection) / total_pixels
+ diceCoeff = (2. * intersection + 1.) / (tf.keras.backend.sum(y_true_f) + tf.keras.backend.sum(y_pred_f) + 1.)
+
+ return diceCoeff
+
+
+def diceLoss(y_true, y_pred):
+ """
+ Defines the dice coefficient loss function, ie 1 - Dice Coefficient.
+
+ @param y_true: the true output
+ @param y_pred: the output predicted by the model
+ @return the dice coefficient subtracted from one. This allows dice similarity
+ to be used as a loss function.
+ """
+ return 1 - diceCoefficient(y_true, y_pred)
+
+
+def generatePredictions(test_data, model):
+ """
+ Generates and displays predictions of the model from the test set.
+ local_batch amount of figures are displayed, which are a single row with 3 images.
+ The images are:
+ 1. The original image input to the network
+ 2. The ground truth mask for that input
+ 3. The resultant mask determined by the trained network.
+
+ @param test_data: the unbatched test data for the network
+ @param model: the network
+ """
+ local_batch = 20
+ titles = ['Input image', 'Ground Truth Mask','Resultant Mask']
+ test_data_batched = test_data.batch(local_batch)
+ test_image, test_mask = next(iter(test_data_batched))
+ mask_prediction = model.predict(test_image)
+
+ # Plot the original image, ground truth and result from the network.
+ for i in range(local_batch):
+
+ plt.figure(figsize=(10,10))
+
+ # Plot the test image
+ plt.subplot(1, 3, 1)
+ plt.imshow(test_image[i])
+ plt.title("Input Image")
+ plt.axis("off")
+
+ # Plot the test mask
+ plt.subplot(1, 3, 2)
+ plt.imshow(test_mask[i])
+ plt.title("Ground Truth Mask")
+ plt.axis("off")
+
+ # Plot the resultant mask
+ plt.subplot(1, 3, 3)
+
+ # Display 0 or 1 for classes
+ prediction = tf.where(mask_prediction[i] > 0.5, 1.0, 0.0)
+ plt.imshow(prediction)
+ plt.title("Resultant Mask")
+ plt.axis("off")
+
+ plt.show()
+
+
+def plotHistory(history):
+ """
+ Plots the value vs epoch graphs for the Dice Coefficient and Dice
+ Coefficient loss throughout training and validation.
+
+ @param history: the loss and coefficient history of the model
+ throughout training.
+ """
+ modelHistory = history.history
+
+ # Loss plots
+ plt.plot(modelHistory['loss'])
+ plt.plot(modelHistory['val_loss'])
+ plt.title('Dice Coefficient Loss')
+ plt.ylabel('Loss (%)')
+ plt.xlabel('epoch')
+ plt.legend(['training', 'validation'], loc='upper right')
+ plt.show()
+
+ # Accuracy plots
+ plt.plot(modelHistory['diceCoefficient'])
+ plt.plot(modelHistory['val_diceCoefficient'])
+ plt.title('Dice Coefficient')
+ plt.ylabel('DSC')
+ plt.xlabel('epoch')
+ plt.legend(['training', 'validation'], loc='upper left')
+ plt.show()
+
+def main():
+ # Dependencies
+ print("Tensorflow: " + tf.__version__)
+ print("Matplotlib: " + mpl.__version__)
+ print("Numpy: " + np.__version__)
+
+ # Data loading and processing
+ entire_dataset = loadData()
+ train_data, test_data, validation_data = splitData(entire_dataset)
+
+ train_data_batched, test_data_batched, validation_data_batched = performBatching(train_data, test_data, validation_data)
+
+ # Create the model
+ iunet = IUNET()
+ model = iunet.createPipeline()
+
+ # Compile the model, model.compile()
+ adamOptimizer = tf.keras.optimizers.Adam(learning_rate=OPT_LEARNING_RATE)
+ model.compile(optimizer=adamOptimizer, loss=diceLoss, metrics=[diceCoefficient])
+
+ # Train the model, model.fit()
+ history = model.fit(train_data_batched, epochs=EPOCHS, validation_data=validation_data_batched)
+
+ plotHistory(history)
+
+ # Evaluate performance on test, model.evaluate()
+ i = 0
+ lossV = []
+ coefficientV = []
+ under = 0
+ fine = 0
+ for test_image, test_mask in test_data.batch(1):
+ loss, coefficient = model.evaluate(test_image, test_mask)
+ lossV.append(loss)
+ coefficientV.append(coefficient)
+
+ if (coefficient < 0.8):
+ under += 1
+ else:
+ fine += 1
+
+ i += 1
+
+ percentageFine = ((fine / i) * 100);
+ averageDC = sum(coefficientV) / len(coefficientV)
+ print(">>> Evaluating Test Set \n Test dataset size: " + str(i))
+ print("Amount fine: " + str(fine))
+ print("Amount under 0.8: " + str(under))
+ print("Average Dice Coefficient: " + str(averageDC))
+ print("---- " + str(percentageFine) + "% of Test Set has 0.8 Dice Coefficient or above ----")
+
+ plt.hist(coefficientV)
+ plt.title("Dice Coefficients of Test Set for Total Epochs: " + str(EPOCHS))
+ plt.ylabel('Frequency')
+ plt.xlabel('Dice Coefficient')
+ plt.show()
+
+
+
+
+ # Perform predictions, model.predict()
+ generatePredictions(test_data, model)
+
+
+
+if __name__ == "__main__":
+ main()
diff --git a/recognition/2021_ISIC_Improved_UNet/images/DiceCoefficient.png b/recognition/2021_ISIC_Improved_UNet/images/DiceCoefficient.png
new file mode 100644
index 0000000000..31778e5833
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/DiceCoefficient.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/ExampleISIC.jpg b/recognition/2021_ISIC_Improved_UNet/images/ExampleISIC.jpg
new file mode 100644
index 0000000000..0f8e21eb2f
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/ExampleISIC.jpg differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/ExampleISIC_Segmentation.png b/recognition/2021_ISIC_Improved_UNet/images/ExampleISIC_Segmentation.png
new file mode 100644
index 0000000000..caa4c0a4df
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/ExampleISIC_Segmentation.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_1.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_1.png
new file mode 100644
index 0000000000..68e6e1e56f
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_1.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_10.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_10.png
new file mode 100644
index 0000000000..25416a3050
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_10.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_2.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_2.png
new file mode 100644
index 0000000000..1ce5619e8f
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_2.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_20.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_20.png
new file mode 100644
index 0000000000..a0bd688a04
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_20.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_22.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_22.png
new file mode 100644
index 0000000000..cecb018faf
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_22.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_5.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_5.png
new file mode 100644
index 0000000000..0b4d245792
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_5.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/Figure_6.png b/recognition/2021_ISIC_Improved_UNet/images/Figure_6.png
new file mode 100644
index 0000000000..446289cdad
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/Figure_6.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/ImprovedUNetArchitecture.png b/recognition/2021_ISIC_Improved_UNet/images/ImprovedUNetArchitecture.png
new file mode 100644
index 0000000000..e095163500
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/ImprovedUNetArchitecture.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/histogram.png b/recognition/2021_ISIC_Improved_UNet/images/histogram.png
new file mode 100644
index 0000000000..a5945521f8
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/histogram.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/images/modelMetrics.png b/recognition/2021_ISIC_Improved_UNet/images/modelMetrics.png
new file mode 100644
index 0000000000..a2ebb8bf2c
Binary files /dev/null and b/recognition/2021_ISIC_Improved_UNet/images/modelMetrics.png differ
diff --git a/recognition/2021_ISIC_Improved_UNet/model.py b/recognition/2021_ISIC_Improved_UNet/model.py
new file mode 100644
index 0000000000..4549ad2ce5
--- /dev/null
+++ b/recognition/2021_ISIC_Improved_UNet/model.py
@@ -0,0 +1,299 @@
+import tensorflow as tf
+import tensorflow_addons as tfa
+
+
+
+class IUNET(tf.keras.Model):
+ """
+ Improved UNet model
+
+ The architecture for the improved UNet is based on the paper:
+ "Brain Tumor Segmentation and Radiomics Survival Prediction:
+ Contribution to the BRATS 2017 Challenge" [1]
+ Available from: [https://arxiv.org/pdf/1802.10508v1.pdf]
+
+ """
+
+ def __init__(self):
+ super(IUNET, self).__init__()
+ self.padding = "same"
+ self.initial_output = 16
+ self.contextDropoutRate = 0.3
+ self.leakyAlpha = 1e-2
+
+
+ def contextModule(self, input, outputFilters):
+ """
+ Defines a context module in the system. From [1]:
+ "Each context module is in fact a pre-activation
+ residual block with two 3x3 convolutional layers
+ and a dropout layer (0.3) in between."
+
+
+ Pre-activation residual block sourced from:
+ 1: "Identity Mappings in Deep Residual Networks"
+ Available from: [https://arxiv.org/pdf/1603.05027.pdf]
+ 2: ResearchGate
+ [https://www.researchgate.net/figure/Architecture-of-normal-residual-block-a-and-pre-activation-residual-block-b_fig2_337691625]
+
+ - Batch normalisation was replaced with instance
+ normalisation, as mentioned in [1].
+ - ReLU activations were replaced with Leaky ReLU
+ activations, as mentioned in [1].
+
+ @param input: the input to the context module
+ @param outputFilters: the number of filters that this
+ particular context module will
+ output
+
+ @return the resultant input after being transformed by
+ the context module.
+ """
+
+ batchOutput = tfa.layers.InstanceNormalization()(input)
+ reluActivation = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(batchOutput)
+ convolutionOutput = tf.keras.layers.Conv2D(outputFilters, kernel_size=(3,3), padding=self.padding)(reluActivation)
+
+ afterDropout = tf.keras.layers.Dropout(self.contextDropoutRate)(convolutionOutput)
+
+ batchOutput = tfa.layers.InstanceNormalization()(afterDropout)
+ reluActivation = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(batchOutput)
+ convolutionOutput = tf.keras.layers.Conv2D(outputFilters, kernel_size=(3,3), padding=self.padding)(reluActivation)
+
+ return convolutionOutput
+
+
+ def summation(self, fromConvolution, fromContextModule):
+ """
+ Performs an element-wise summation of the two inputs passed
+ in.
+
+ @param fromConvolution: the first input (usually from a
+ convolutional block)
+ @param fromContextModule: the second input (usually
+ from a context module)
+
+ @return the element-wise summation of the inputs
+ """
+
+ addOutput = tf.keras.layers.Add()([fromConvolution, fromContextModule])
+
+ return addOutput
+
+
+ def performUpSampling(self, input, outputFilters):
+ """
+ Defines an Up-Sampling module in the system. From [1]:
+ "... This is achieved by first upsampling ...
+ by means of a simple upscale that repeats the
+ feature voxels twice in each spatial dimension,
+ followed by a 3x3 convolution..."
+
+ - A leaky ReLU activation was added after the convolution
+ - An Instance Normalisation was added after the activation
+
+ @param input: the input to the up-sampling module
+ @param outputFilters: the amount of filters the upsampling
+ module will output.
+
+ @return the resultant input after being transformed by the
+ up-sampling module.
+ """
+
+ # Upscale, repeating the feature voxels twice in each dimension
+ upSample = tf.keras.layers.UpSampling2D(size=(2,2), interpolation='bilinear')(input)
+
+ # 3x3 Convolution
+ convolutionOutput = tf.keras.layers.Conv2D(outputFilters, kernel_size=(3,3), padding=self.padding)(upSample)
+
+ # Leaky ReLU activation
+ reluActivation = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+
+ # Perform normalisation
+ reluActivation = tfa.layers.InstanceNormalization()(reluActivation)
+
+ return reluActivation
+
+
+
+ def performConcatenation(self, fromLower, skipConnection):
+ """
+ Performs a concatenation of the two inputs passed.
+
+ @param fromLower: the first input (usually from an up-sampling
+ module)
+ @param skipConnection: the second input (usually a skip
+ connection from earlier in the network)
+
+ @return the concatenation of the two input layers
+ """
+
+ concatenation = tf.keras.layers.Concatenate()([fromLower, skipConnection])
+
+ return concatenation
+
+
+ def localisationModule(self, input, outputFilters):
+ """
+ Defines a Localisation module in the system. From [1]:
+ " A localisation module consists of a 3x3
+ convolution followed by a 1x1 convolution
+ ... "
+
+ - A leaky ReLU activation was added after the convolutions
+ - An Instance Normalisation was added after the activation
+
+ @param input: the input to the localisation module
+ @param outputFilters: the amount of filters the
+ localisation module will output
+
+ @return the resultant input after being transformed by the
+ localisation module
+ """
+
+ # 3x3 Convolution
+ convolutionOutput = tf.keras.layers.Conv2D(outputFilters, kernel_size=(3,3), padding=self.padding)(input)
+
+ # Leaky ReLU activation
+ reluActivation = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+
+ # Perform normalisation
+ reluActivation = tfa.layers.InstanceNormalization()(reluActivation)
+
+ # 1x1 Convolution
+ convolutionOutput = tf.keras.layers.Conv2D(outputFilters, kernel_size=(1,1), padding=self.padding)(reluActivation)
+
+ # Leaky ReLU activation
+ reluActivation = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+
+ # Perform normalisation
+ reluActivation = tfa.layers.InstanceNormalization()(reluActivation)
+
+ return reluActivation
+
+
+ def performSegmentation(self, input, outputFilters):
+ """
+ Performs segmentation on the input. A segmentation layer is
+ often a 1x1 convolution with a single output filter.
+
+ @param input: the input to be segmented
+ @param outputFilters: the amount of filters to be output
+ (always 1)
+
+ @return the segmented input
+ """
+ # 1x1 Convolution
+ convolutionOutput = tf.keras.layers.Conv2D(outputFilters, kernel_size=(1,1), padding=self.padding)(input)
+
+ # Leaky ReLU activation
+ reluActivation = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+
+ return reluActivation
+
+ def createPipeline(self):
+ """
+ Creates the pipeline for the Improved UNet Architecture [1].
+ """
+ print("TFA version: " + tfa.__version__)
+
+ input = tf.keras.layers.Input(shape=(192, 256, 3))
+
+ ## Encoder
+ # Encoder, level one.
+ convolutionOutput = tf.keras.layers.Conv2D(self.initial_output, kernel_size=(3,3), padding=self.padding)(input)
+ convolutionOutput = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+ contextOutput = self.contextModule(convolutionOutput, self.initial_output)
+ sumOfOutputs = self.summation(convolutionOutput, contextOutput)
+ firstSkip = sumOfOutputs
+
+ # Encoder, level two.
+ convolutionOutput = tf.keras.layers.Conv2D(self.initial_output * 2, kernel_size=(3,3), padding=self.padding, strides=(2,2))(sumOfOutputs)
+ convolutionOutput = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+ contextOutput = self.contextModule(convolutionOutput, self.initial_output * 2)
+ sumOfOutputs = self.summation(convolutionOutput, contextOutput)
+ secondSkip = sumOfOutputs
+
+ # Encoder, level three.
+ convolutionOutput = tf.keras.layers.Conv2D(self.initial_output * 4, kernel_size=(3,3), padding=self.padding, strides=(2,2))(sumOfOutputs)
+ convolutionOutput = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+ contextOutput = self.contextModule(convolutionOutput, self.initial_output * 4)
+ sumOfOutputs = self.summation(convolutionOutput, contextOutput)
+ thirdSkip = sumOfOutputs
+
+ # Encoder, level four.
+ convolutionOutput = tf.keras.layers.Conv2D(self.initial_output * 8, kernel_size=(3,3), padding=self.padding, strides=(2,2))(sumOfOutputs)
+ convolutionOutput = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+ contextOutput = self.contextModule(convolutionOutput, self.initial_output * 8)
+ sumOfOutputs = self.summation(convolutionOutput, contextOutput)
+ fourthSkip = sumOfOutputs
+
+ ## Level 5: Bottom of network.
+ # Convolutions / Context modules as before
+ convolutionOutput = tf.keras.layers.Conv2D(self.initial_output * 16, kernel_size=(3,3), padding=self.padding, strides=(2,2))(sumOfOutputs)
+ convolutionOutput = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+ contextOutput = self.contextModule(convolutionOutput, self.initial_output * 16)
+ sumOfOutputs = self.summation(convolutionOutput, contextOutput)
+
+ # Perform upsampling
+ upSampleOutput = self.performUpSampling(sumOfOutputs, self.initial_output * 8)
+
+ # Concatenate
+ concatenated = self.performConcatenation(upSampleOutput, fourthSkip)
+
+ ### Decoder
+ ## Decoder, level four.
+ localisationOutput = self.localisationModule(concatenated, self.initial_output * 8)
+ upSampleOutput = self.performUpSampling(localisationOutput, self.initial_output * 4)
+
+ ## Decoder, level three.
+ concatenated = self.performConcatenation(upSampleOutput, thirdSkip)
+ localisationOutput = self.localisationModule(concatenated, self.initial_output * 4)
+ toSegmentLower = localisationOutput
+
+ # Perform first segmentation
+ lowerSegmented = self.performSegmentation(toSegmentLower, 1)
+
+ # Upsample as usual
+ upSampleOutput = self.performUpSampling(localisationOutput, self.initial_output * 2)
+
+ ## Decoder, level two.
+ concatenated = self.performConcatenation(upSampleOutput, secondSkip)
+ localisationOutput = self.localisationModule(concatenated, self.initial_output * 2)
+ toSegmentMiddle = localisationOutput
+
+ # Perform second segmentation
+ middleSegmented = self.performSegmentation(toSegmentMiddle, 1)
+
+ # Upsample as usual
+ upSampleOutput = self.performUpSampling(localisationOutput, self.initial_output)
+
+ ## First Skip-Add
+ # Add together the middleSegmented and lowerSegmented
+ # lowerSegmented must be up-scaled first.
+ upScaledLowerSegment = tf.keras.layers.UpSampling2D(size=(2,2), interpolation='bilinear')(lowerSegmented)
+
+ # Element-wise sum
+ firstSkipSum = self.summation(upScaledLowerSegment, middleSegmented)
+
+ ## Decoder, level one.
+ concatenated = self.performConcatenation(upSampleOutput, firstSkip)
+
+ convolutionOutput = tf.keras.layers.Conv2D(self.initial_output * 2, kernel_size=(3,3), padding=self.padding)(concatenated)
+ convolutionOutput = tf.keras.layers.LeakyReLU(alpha=self.leakyAlpha)(convolutionOutput)
+
+ # Perform segmentation
+ upperSegmented = self.performSegmentation(convolutionOutput, 1)
+
+ ## Second Skip-Add
+ # Add together the middleSegmented and upperSegmented
+ # middleSegmented must be up-scaled first
+ upScaledMiddleSegment = tf.keras.layers.UpSampling2D(size=(2,2), interpolation='bilinear')(firstSkipSum)
+ finalNode = self.summation(upScaledMiddleSegment, upperSegmented)
+
+ # Final network activation
+ networkActivation = tf.keras.layers.Activation('sigmoid')(finalNode)
+
+ model = tf.keras.Model(inputs=input, outputs=networkActivation)
+ #model.summary()
+ return model
\ No newline at end of file
diff --git a/recognition/44672139_topic_recognition/README.md b/recognition/44672139_topic_recognition/README.md
new file mode 100644
index 0000000000..015db7f694
--- /dev/null
+++ b/recognition/44672139_topic_recognition/README.md
@@ -0,0 +1,56 @@
+# Image Segmentation of ISICs dataset with Unet
+
+
+### Dependencies
+* Tensorflow-gpu 2.1
+* Matplotlib
+
+### Description
+The aim of the project is to successfully perform lesion segmentation on the ISIC dataset. Classifying each pixel either black or white, the following algorithm achieves this by using Unet. Images are resized so they are 512x512 in dimension. This particular size was picked because any smaller and completely black images would return a high dice coefficient which we don't want.
+
+The files are first extracted and then the data is split such that 80% of the dataset is used for training and 10% for both validation and test. A large percentage was used due to the fact there are only around 3K images in the dataset. Datasets for training, validation and testing are created such that it takes the tuple of all the images and masks files. The data is then shuffled and the filenames are mapped to data arrays. Masks are one-hot encoded and both images and masks are resized to 512x512. The model is then trained for 6 epochs using the dice coefficient as a metric. The Unet model was implemented following the article referenced below in References section.
+
+Below are the results of the model before training compared to the ground truth, the decimal values corresponds to the dice coefficient for each mask starting from the left, as can be seen before training it is relatively low and has high variance.
+
+
+
+
+### Training and Results
+The model is trained over 6 epochs, where a dice coefficient of 0.79-0.80 is achieved over the validation data.
+
+Train for 65 steps, validate for 9 steps
+
+Epoch 1/6
+65/65 [==============================] - 120s 2s/step - loss: 0.5389 - dice_coef: 0.6231 - accuracy: 0.7553 - val_loss: 0.4502 - val_dice_coef: 0.7188 - val_accuracy: 0.7475
+
+Epoch 2/6
+65/65 [==============================] - 87s 1s/step - loss: 0.4029 - dice_coef: 0.7321 - accuracy: 0.8077 - val_loss: 0.3928 - val_dice_coef: 0.7148 - val_accuracy: 0.7479
+
+Epoch 3/6
+65/65 [==============================] - 137s 2s/step - loss: 0.3638 - dice_coef: 0.7583 - accuracy: 0.8077 - val_loss: 0.3363 - val_dice_coef: 0.7822 - val_accuracy: 0.7479
+
+Epoch 4/6
+65/65 [==============================] - 68s 1s/step - loss: 0.3611 - dice_coef: 0.7643 - accuracy: 0.8077 - val_loss: 0.3308 - val_dice_coef: 0.7581 - val_accuracy: 0.7479
+
+Epoch 5/6
+65/65 [==============================] - 128s 2s/step - loss: 0.3421 - dice_coef: 0.7753 - accuracy: 0.8395 - val_loss: 0.3456 - val_dice_coef: 0.7562 - val_accuracy: 0.8724
+
+Epoch 6/6
+65/65 [==============================] - 97s 1s/step - loss: 0.3169 - dice_coef: 0.7933 - accuracy: 0.8823 - val_loss: 0.3091 - val_dice_coef: 0.7801 - val_accuracy: 0.9001
+
+Here below the predictions on the test data, we can see that we achieve better results than before training with some dice coefficients being in the 0.9 values.
+
+
+
+The average dice coefficient when using the model to predict the mask on all the test data was calculated and the average was around 0.8.
+
+#### Plot of the graph
+The results of the dice coefficient over 6 epochs
+
+
+
+
+#### References
+https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/
+U-Net: Convolutional Networks for Biomedical Image Segmentation :Olaf Ronneberger, Philipp Fischer, Thomas Brox
+Medical Image Computing and Computer-Assisted Intervention (MICCAI), Springer, LNCS, Vol.9351: 234--241, 2015
\ No newline at end of file
diff --git a/recognition/44672139_topic_recognition/driver.ipynb b/recognition/44672139_topic_recognition/driver.ipynb
new file mode 100644
index 0000000000..c7fbfe5728
--- /dev/null
+++ b/recognition/44672139_topic_recognition/driver.ipynb
@@ -0,0 +1,287 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Size of training set: 2076\n",
+ "Size of validation set: 259\n",
+ "Size of test set: 259\n",
+ "Dice coefficient for images left to right\n",
+ "Dice Coefficient image 1 :0.3022004507732194\n",
+ "Dice Coefficient image 2 :0.057424931078161094\n",
+ "Dice Coefficient image 3 :0.6161304236227432\n",
+ "Dice Coefficient image 4 :0.4241622309162261\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import tensorflow as tf\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import glob\n",
+ "import helper\n",
+ "\n",
+ "#Getting the filenames for the masks and images, sorting them so corresponding mask match corresponding image\n",
+ "masks = sorted(glob.glob(\"D:/ISIC2018_Task1_Training_GroundTruth_x2/*.png\"))\n",
+ "files = sorted(glob.glob(\"D:/ISIC2018_Task1-2_Training_Input_x2/*.jpg\"))\n",
+ "\n",
+ "#We split the data such that train data is 80%, validation and test data are 20%\n",
+ "train_images, train_masks, val_masks, val_images, test_masks, test_images = helper.split_data(files, masks, 0.2, 0.5)\n",
+ "\n",
+ "print('Size of training set:', len(train_images))\n",
+ "print('Size of validation set:', len(val_images))\n",
+ "print('Size of test set:', len(test_images))\n",
+ "\n",
+ "#We map the filenames and masks to data arrays and shuffle them\n",
+ "train_data = helper.shuffle_map_data(train_images, train_masks)\n",
+ "val_data = helper.shuffle_map_data(val_images, val_masks)\n",
+ "test_data = helper.shuffle_map_data(test_images, test_masks)\n",
+ " \n",
+ "model = helper.unet()\n",
+ "model.compile(optimizer='adam',\n",
+ " loss ='categorical_crossentropy',\n",
+ " metrics=[helper.dice_coef, 'accuracy'])\n",
+ "#Predictions before training our model on the validation data\n",
+ "#The dice coefficients is printed in order for each image\n",
+ "helper.predictions(val_data, model)\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Train for 65 steps, validate for 9 steps\n",
+ "Epoch 1/6\n",
+ "65/65 [==============================] - 120s 2s/step - loss: 0.5389 - dice_coef: 0.6231 - accuracy: 0.7553 - val_loss: 0.4502 - val_dice_coef: 0.7188 - val_accuracy: 0.7475\n",
+ "Epoch 2/6\n",
+ "65/65 [==============================] - 87s 1s/step - loss: 0.4029 - dice_coef: 0.7321 - accuracy: 0.8077 - val_loss: 0.3928 - val_dice_coef: 0.7148 - val_accuracy: 0.7479\n",
+ "Epoch 3/6\n",
+ "65/65 [==============================] - 137s 2s/step - loss: 0.3638 - dice_coef: 0.7583 - accuracy: 0.8077 - val_loss: 0.3363 - val_dice_coef: 0.7822 - val_accuracy: 0.7479\n",
+ "Epoch 4/6\n",
+ "65/65 [==============================] - 68s 1s/step - loss: 0.3611 - dice_coef: 0.7643 - accuracy: 0.8077 - val_loss: 0.3308 - val_dice_coef: 0.7581 - val_accuracy: 0.7479\n",
+ "Epoch 5/6\n",
+ "65/65 [==============================] - 128s 2s/step - loss: 0.3421 - dice_coef: 0.7753 - accuracy: 0.8395 - val_loss: 0.3456 - val_dice_coef: 0.7562 - val_accuracy: 0.8724\n",
+ "Epoch 6/6\n",
+ "65/65 [==============================] - 97s 1s/step - loss: 0.3169 - dice_coef: 0.7933 - accuracy: 0.8823 - val_loss: 0.3091 - val_dice_coef: 0.7801 - val_accuracy: 0.9001\n"
+ ]
+ }
+ ],
+ "source": [
+ "history = model.fit(train_data.batch(32), epochs = 6, validation_data = val_data.batch(32))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dice coefficient for images left to right\n",
+ "Dice Coefficient image 1 :0.1473380551548944\n",
+ "Dice Coefficient image 2 :0.9651427727894125\n",
+ "Dice Coefficient image 3 :0.8274132975263832\n",
+ "Dice Coefficient image 4 :0.732081946398545\n",
+ "Dice Coefficient image 5 :0.7173747817056261\n",
+ "Dice Coefficient image 6 :0.9800531523090612\n",
+ "Dice Coefficient image 7 :0.8014727575260506\n",
+ "Dice Coefficient image 8 :0.8584086478823321\n",
+ "Dice Coefficient image 9 :0.9776922987440527\n",
+ "Dice Coefficient image 10 :0.822964615514953\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAABCCAYAAADe1UtWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAADak0lEQVR4nOz9ya+uS5bmCf2WNW/zNbs97e3cPTwisrIhihQzQIIZTACJPwKYIpjU31El+BMYIAY1gQETRqikqsqszIiMzGi8vd1pd/M1b2cdg2XfPscjw6/vGyChkI4pjt+49+zms9fsNXvWs571LCml8Gl8Gp/Gp/FpfBqfxqfxafzjHeb/3x/g0/g0Po1P49P4ND6NT+PT+P9ufAJ0n8an8Wl8Gp/Gp/FpfBr/yMcnQPdpfBqfxqfxaXwan8an8Y98fAJ0n8an8Wl8Gp/Gp/FpfBr/yMcnQPdpfBqfxqfxaXwan8an8Y98fAJ0n8an8Wl8Gp/Gp/FpfBr/yIf7ob/86uq8bNqGVdPw5OoZP/+jP+XLr/6Ip9cv2Law3p7TrbdYYzHGABmWBcEgZIy1GN9jbANpIY/34Cy4Fki41SXiLEiBGMgZRMAsE6Y4xFowCUSQkkgpUVIkxQXfnRFDJo0DJc5gIadMwBNzYpoG9sPE+/2BX33zDf/Nv/1X/Ltf/CVvdzt5zIM5Pz8vwzAAICIYY1htL/jZn/6P+Gf//f8xf/wnf8bLr77k6uk1Z9s1287ReIuTjCNh80yJMyHMSF4gR0oBa4V4vGH3/a84vv8VKUeM8zS2gTQzL/ecv/indJunWGtZjgN+c0H77Cf4bktxFjGGLC1LtkzTwnGYuL098M133/LLv/oL/s1/8//mL/7V/4u722/JOVMKbLdb7u7u/uDc//L/8X8pJuyY776mJMPq6efgPObiBaVdYZtLjPHkaU883ODSHaSAnD0D3yN2jVl2xDhi2hVQkDBSSka6DSUHTLMmD28p44B0z5DmjByOyPIOlolpd49bX+IunpJyogx3WFcwQyYc35Bv3tNszwlpIAawrcdkg+3OCOsWEKQUUlgo88w//V//7//gvEXkg3+PQNevePn5z/jpz/4ZX/70n/D0yXMuzs84365Y9y2NBWcK3llcs6JgKSIgFgSdNwW1BcqUlCgFMCClUAoY+egXAjkncs4Yo2uMcfrfYibnTFgC47DncBzY7Xfc3N7w+u07vv76V/zm1/+Bt6+/IYTwMI1SyqP2+n/5X/4/y3p9BiUjQC6JnAOUgghQhJQzKSVEMo6A9S2+XXN6aMYYrDWICKUUBEP9Zv17cRQDJSdyTgimnhmFUhJgEIGU0u98Nms8uRRKyZSSybmQczmt2cPPz/n0HZnD4cj/8n/1P/uDc/+//V//78Vax2q1pm1bnHNYazFGMKVgSgJvQDwihhiTzk2EXDI5JZyzSImYlClSIGYKBYzBWEuR0+cE452uK5BzRoyA0eeUc8YZh1hPKbH+Hksp+v31RyBiyEX/qc8aMoaUAyLwL//ZTx+15uv1+uF8Oz3L0x8EnLU8ffKS/+Sf/Bl/8vN/zhdffMmLl59zcXHJqu9ovceWCZaZedwTQyAtCWsKsQR8t8J3K6zzFKBpW6TpsE1b94mh6EQQseQizCEyDDO3N7e8fvUd33z9NX/5V3/Bn//Ff8XrV18TY+Rks1VK4WPLrb7vGYbhD879//Rf/J+LbxxSMq5pMQgUkLp3jbVYayn1meQYMVYoKSOlIM5BKZgMpb7jiGC9o5T6jpMpdUOWUpACOUUEXe9SClkKxjqsacil6F4ppZ7X+u/6bkAKQedqhJILZQmUnMBYxrDwv/nf/W8ffaflnPjyJ3/Cf/pn/wP++Od/xE9++nM+++wFLz/7nL739F2DtQ7v7OkYYz4ekZRpthvEuDqvBCXo58lZP6sIkut7gMFYhyBIPc8Ker6Yuv5iDMYIJRsEWKYJsXqOpgzjMLHEwvE48v79LV//5mv+8s//Ff/63/5r/vzf/bfM4+FRd9p//p/9H8uTyyesXaZ1he31Z7TrMyiJHEaabo3YBnLQOdUzyNgG4xpKyrCMxOEOY93D+11SIBf9WrEGjCWXQo4BQ9LztM4zjgdSmBHXYdxKn0cp+jytJ6dIjguIpVgPQAoLISbmccRaR5p2FCxROv4X/4f/7O+d9w8CutZavDV0bc/19VMur56w3W7oVz39qsc1HiMCJYNYBAvoIYwxuvnrQpIi4ho9NJwB6/QlslBiQKzBSAHjdGMvEWsMmAI5kckIGSThGkeKA2I7RDJiCsU6jFhs8Ui7wa4ukG4kmPc8nwM/+fwz3ty8ecS21/E7BxzgfcPVs5/yxc/+E15+9hVXz55yfnnO+XrNuvc0HhwJR8KkSA4TZd4haWa6ec3+5jvEWs6unjEd7hj3bwlxQGIgJg9mgBQI45H9618zDTtKzDjT0pdEWgZWz3+K6Vc432Od4G2PNJaCI6aOp8sl4+Fzdnd/ys37bzkMNyzjAJSHefyhUY5HrFvIywgLkC05Cs52FNNAKcTliE0GCZk8RtLhBj8FysUTTJdIwz1WCmk6YLot2XSIg+zXEAbSdIRlxuaM8Y5oMuW4Q+YDEPAeGpOJ+3skJ2Q6ApFwv0Nai33xJWyv4e2vabqeLDP5boC1RfyKHGfs+pw8H+Af4LPonOPi8inPnn/Fsxefc3X9nPPLK862PeuupfUWR8RIBD5czlKkHrx6aZdSoCSQE7bJegWUrJexmLrXADGIAZMEyFAESqoHoMUImKaBsqZkQykQcyFkYZoXhvHIOB65v337AHgeOwxFLyvRoExA32v0PThdXNYIUOcoeoiDPAQ8+nf6M/R7eAB4hQQZvQzFPADdh59Hfliq00UtImQS8GE++rFyBTzmYV/rP057/AHd/eBwzuG9x3uLtQZrRD8zomA8ZyRBNlmfS8WP9Slgil7yOaV62UJJqX6uui8wFNGLWopAIxhb112veMhFf2PJGvCgIKBIxlAetgNi9A/l4ZmIGF0bazHlcfP+feMBeIphsznjJ1/9MT/72R/z2Wef8/TJM843K1be0lmDzQuSIsP+juPuDcu4J4eF+gPIOdCszmlWZ9i2IXQ9bbcl92tM24P1FdwWhIyzliIeMKRcSCmQY2QJM8O4YxoHbm7e8P8L31RjDA5BjEHDOKl/iv6fbmsFcaIg6vRsnBhSSYjo16Uc8U1TgYuHkkn1+0D3APUdMqIgqTgHKZGXgHEKIFPJCnBPawE1eMkQE2KEFPXnGoSskQLmR7zrxgir1Tmff/4lL1+85Or8gjK9Yd08oW1bmtZivae1FRaUop/bOQpRgQ0JsXr+EDU4Kzk/gCBKqcBWcL7R75WIMYYihmLqO2v0AeakZ0OJkbzMuLbFWI+xhtK25BLouobtdsv19ROePXvJVz/Z8eb9G159+4tHzXuzWtM1ntaDdyByAtupfoaANY6cI6TA6VwrInqKGUtxDbZpNWBHA1PEYsSh552eSdYajDTEsAAF57zOp4DxPZiWZR7wtlNwmBXs55z0vBcNBFOYQMAQNMAQh21axPQYaX7vXH8Q0Hnr8NZxtr3k6uKSs/WWvm3oWoeRTEmFlBLONVCyPhhrwApSUSZSo5gU9NLKBSsWtz7DNGtSCaQUFQxajQ6zc/qiWaCYuuAjkjNiIcwzkg2YjGkEYzoyhlwcLluyayjiaEthk845Hw989uwFXz1/8agNAPwOADLGsF4/4eUX/5zPP/85T59/wdXVFeerDX1j8QZsLgiBnBYkLZRwJM87ju++5fD+W/Zvf4tYIY1fkcrCMrxhun1FHgc9/EvErc4pIVKWiRAXbDHs7t/gt9f4s6ecH/Zsnn1J2Z7TbC6xvaVYh/cNXQfnZ2c8ff6S/W7Pu3fvePf2O958+zd6KDxypGVHOL6HecD2F5TlgD1/hnEtcUmI3WNqROFcQ7GOGI8cX39Pz4y0K0JKyBLIhz3N1edgG7g4h2VCQiIe77A+k9JIOr6C/hJxCzmAEU+ZBnI5khkwAWBBloCQSHHGtWfKBroVTEeSKZR4oG0/Z3Ie3zoSmWItpr949NxP675an/Hk6Rc8ff4F109ecHZ2znazYb3uadsGbwoOTykKSHIRDFaBGgriiigoUFGDXsClZMgVsNWDQeolkkuEnD8AoBIRPGKcAoEiiCu0tJR64S19rxHck6cM48jxcM80Hhg/Yl4eOeuP5m+wAojVw1pPbpwxD8GZMQ22MsUVknwEBkCMrXNQRk0Zhw9fe/r6nBUYikAhk1P+iPE7sVJJI+IaLJ4Yst8BffkE8MAa++jgRcGcx1qLqxerrk9dMhFlH1IkpYS1FjFO1zlEyjyTrYKtqB+OvCwYa7CmpWRBSkBCUpbGW0QakPYDw/Txq1mKUo3GVEbjBNwUHot8CDT/7uqV31nFHzc+/pkiQtu2fPbyK37ykz/is5ef8/z5c66uLtn0LT4HJESW8UiYBsb9e3Zvf0mc7ikhk+cBrMX1W+J0YDq8pzk7Zxl6wmqgCxeUfqVAr2kfWEox0JhS2ekeKZeUlJiXiWH4Ew73N4zjjnEcfydG+7EAr1QWWi+amhKqbCj1SRc0oCkagSjcKzwEIpILRXRfWpFKOADK91UwX2ogE5AoGGPrfkqYYsAarLPkDEucMN4iRRAU3J0gPyJkqyyuxKgMN5EkCVsypQaVjxneO548+4zPP/8pL56/4OmzZ1xsWy6uv8A3ltZ5fH1/StF3sRRdk1SiPp2c9DOUDKmCuWVkGe7IlY0jC5kC/RqCwXpPNhaMwzpPJmLwCEIqEescWcA6W9G0ZvdcZ2lKAbGs1oXt+ZZnLz5jfxh4/cVrDoe7R82769c0jcN5o8xjSaTpHuMazXaFWQNvCiUtlLRgbEOcD4j1iLFYIJdACUc0zWIR1yl4TUHBlzH6PEpCiGQMEY8pQhZDsQ3zMNBYU3+foRjBWA/SU8Kou6hZIb4j3L8ixIT4Fms9pVwDVs/i3zN+ENA5JzRtx+XlFRfnl2zWa9abS7zzCAljLWIbxFqE+EAjIigjZ8DEiMn5AbkbEiyJcijQBfxqjVufkYtGMzksiIHCQqboC18SeRmUISgWW6JGKMYqNZ0DYDDNihIixhRyWvDe0a9WrNdnXF9d8+Vn/zBA53zD1fOf8vKLP+b62WecXV2x3Z7Tdw1tY3AWTCkQI3k+kqZ78uGeaf+O2+/+ijDcEIZ3GIF9jLQXT0mpkIuQhpGSItI2yMqQlon5GHHTDLYl7t+xjDs2puF2d8P+7S9ZP/uKy6/+OdZ4xG3wxtA2nrJZcbFc8uTFS7746Z/y6vvfsLt5xXi8f/S8w+EtEiesbbGSmVNivX1Gsj0lzqQUsVbIKWJKJi1H8jIg1jEvd4gNlCLEZcS1hrDsYP0UnxokBOJwpGk2SI4s84TEPXk84J2jWE070jcgjnR3g/XnxNVKAd/SUu5ekYZfE69GON7DPEDOhP2RZb/HSCE3nUbYYaaY1aPnDuCbhqvrFzx5/iXXTz9je37NerNltV7TrVZ4a7CSIKXKTNdIkwo2KEgWkKTR/uk2OAGEUpmtUhDJHy72yjxBBXmV8dIUmNFLpv67z4UVhQiEDEtMDOPIfvcZ+/0ty/ztf5S6/KGhIE1/v6ZFpB5QQs4CWMTU9KvYygrZh+lbaz8AK1HpA0XTx4WizGSpjJRx9fI8AdxTiqY8AJKHV+8hrSb16yt9UgqmRvgngGdMPT9KfjSgc97gvcF5g3FG0yYpV3ZOU205ZSRFDVjniDRZL6t5Jg8T2YIVQ3FG98E8gzfkouejAdI06TZZBFd6DDykoQTqnkCZoALZKlAoujgP6/7h+UgN0hTkmfp3poKSHzs+BnTGGC4vn/Dllz/ji88+4+nVFRcXZ6xXK1oHlkwKkXG65/D+O8Lhjvn2FWkaQYSYF0qKMLxDdg5ThPbiGd3lNWE8Iy0TJV1iT+k267F1bwmWxhndT+j7FFNkWWb2+ztu7t7yzTe/Jsb48Hl/NKAjKtst+n4ZkSpvsDWw4EEqIfXrNGDIpJxx0py4UT3zKbrnSgVrqql42JdWWkoKH8Tqxiibf/p3Z3G5kJeAWKf3KidZgSAFTUMmTd8ZQZku9B0wj9zrAJvNJS9ffsXz5y+5un7C1fU1Z+sVTWNprNVncQooKyBNIZJTwhhDWurdHBcQSHEhzyPL3Xcc3/8W225pt88gGUJKsAyIFZCMsS2mXSOAdQ1utcW6Vp+VqMyExmjgai2C4Iyh6xT0NU3DZrPi+ukT7u5u+fLzL7l5ZMat80LTtvim1bvaW3KckeUAYkhYvLUadKYMRhAjmLYnhwmDwRhPYVJMkmPFOMrCqdKmAWcxpZDmPVIi3nVAoOBIywRF6DtHCTOI030Wdd0RAddR4kjJi/69afCtR1xLjglxnpjlo5PyPx4/zNAZw9n2gqsnzzm7eMr6/AlNt8W1FkvWw9lIfTm86t1ShmIgzZTDnrQcwHWIdUo5pkBeJkiJNN5jDh7Xb7HtCutagvWUMpNJxBhVf+c82TqYD9hui/GdUtYGSp4gLYhdo7mJmruuGiVvoO87zjZrnl1fP3bvA3zQzm2uePbFz3n+8gvOr5+w3W5p+gbfWJwDIwnSQokj8803HG++oRx3DHeviccbpt07cp6wq54w3pC9JQ73mBx1uc8vsM0aYywmawQYDweKHSjLRI4Th1e/wDcewsx8eE+JkfOQaa4/x7UbWm8ptGy3Wy6vr3j24gVf/uRPefXNL5in/Y+YdAbbYxpPWm6xVx34Vi9R11NKBCNYa4nDTBr2hPFA//Qlxa/JSQFuCjPFGOJhRKJAarBrj1v1RLfGxAV8oqR7zHRPtB5xmj4Sa4lTVGBEwcwHGBdcd4ZcXVFMIZhMaj2mv6IshfXlH1E2K5IsmGYLOeIocGKKHzGMMaw351xff86TJy+4PL/gbLNlu+5Y9yu8dbh6Mp+0UWKMZkdzrrqgugezsnSnuqMTM1ByrvjkI4BC1dOdLgKEkqNqSIvTC6OCLIzFNS3FWPpiCdmwxMz52cD19XN29+857G45Hh6/5iInUJk+gMuikzTGVgylaRNDAikPn0l1gaUyElkv29O1+JACLAr+gCJJNXFxUdZBTH0WuQKL+gw/vrA/ZqUqgCnlxKWcUsWnIKzw2DvOOYN1RsGsqWmgmj5SnJ6VjbH1OYRISQvkQh5HBeXOkcKCSYaSMmmZETzkTIqRTMZ5Rw5CFojzQhGDX/WaYjM8gHqpqdc064Upxqpu0VoqzH/YN8qcoEFFQUHyP6DE7e+yc32/4ovPfspXL7/k6fUTzi/OWbUNrQGXIvN8ZJ6OzOM9y/iO+f4t2ViW4Z6SMmE5kOOMcQbbNZqWnAbS4Y728hlxGcFEDeTLBsNJH5kqD2kxYuj6llLOiSkxzxP7wx1v377i7vY997u732Fofwyos8XqNWFPbK5RQCGVnTbyEXgzH8CMVCaFysQUBWWpxBqLaYZKNGGua3ECyU1Difr+i3MPDGBKCVv1kDgHAjFHnHHkUlmyUpTFqWdN/ig1W/iPNac/NK6urnn58iXX15dcXlyw3Zyx3q4wUnBWMFYUZJf6ZuWMpABpIeZMHo+UOJKXEbe5UPJh94rh+3/P9O435Cz0L/4U2z5hniJzZzEEUtjhmzXN2QuW8YZu84TV85+T2x7jW9WPemXCNEixiisQcIbOG8Kk9/j5xTlX11d89vwLXr35/lHzbpuWpmkQKWCsZgqtAww5BYxrsG0HcSHFGWObmiH0GFcJpRw1xe1aTYenAHkGssrHTgFmUg2ewSI1eLe5YBsPRYhhIS5HvFegpuC9Mq8pQC6E6YA1HW1/QUqBMB+RHCAHbDYk2/3euf4goGt8x9XlE87Pr+hXa5x1lVYsiDUPuhNi1NSq9eSsAviyfwfziJFCMS3ioKSoDJo1GsVZlKGaA+JvwbaYdoO1RsX/RbC+R6wh92c66Thg3EojnTio2NQYjPeqw3OOlKICEAzOFFpvWK10Lj9qCDhnubz+jOcvfsbVk5ecn1+yXvU03mCtHsCkAGmCZc948zW33/4VLiXidE+MIzFOpOEIziAJkr3FLqOmD12rhSMCy/178jRQMhjnSTFAzsRi4HjLcrfgfUsxjruv/w3jsOflv/if0ly3eOuI1tB1DRcXF1w/ecrzz77i+Rd/zLu3v350Psa1W0wOWNeylA7vet3oySD9hoLHSWYJe8J0oMkJ73tizHjXUxLE+xuGV9+BbTBi6ZsVpTsQdgHjV9iNJxUQs0KmkRQb8FazkMeJHEagwbiO8f4d4/d/zfr6ClsKZtUj2yd0/TkhzMQYaQykmKFrMZIxZgUukLOQzSMBnQiuabi4fMbl9XMur56w2Z6zXq/p+jXWOQwZFapLFbNb1T1gQCoLZQRiZZ9K1vQjNXVXQVkp+SHiPgnbT9+rTIzqsXTNCg/aqcraGePwRuhyZTBCYBoHLq6ecHX/gtvbN0zT49Oup/tQcDzUhlQh/geGrP6pz1MKmh77OEWcEw85pxOsO32/qDpPciGlGaICRDEfs5aoXAP7kGxU1v/0I07/T9UsZh5Yz491g4+94I0xD39O+rny8DwKkjI5RkrbUCrgk6CC+GQEs2rq1wtpHB9S7iUEUgSmkRyPLDbS+B67uqakiDXKRFsxkJUJjbmm2XJBojLAojc2VMG87qfyO8CucpcImiL/seNjNtNay/XVM16++IxnT645325Y9x2NgTzfM4wD87Bjng4sx1vC/Q1xd8s0HFmGe8I8EZYRQ8Q2PWaeME1DGGfyvBDGe5r5c7JY2vUVvt9iDdhsyGJqYBGVlbSGrnFsthsun1zz8vAFP/nJO75/9TXH4UAI4UeDOZ1vvdCxZAFTEq4GZVL3rRiDSR+eM2iRCPq3tThIKKZgsiBJgyKN0xJFrKYjo+i54Rqy078TESU8imBOWjVxqsIQMKaQSsGU029DASggkk+wXvXllb177Lh+9oKnT59weX7GetXRtp6uaytDWgPSj56nFE3v5uGeGGfGt79lvnsNJrN+8hOm/Vumd78g3r9iOd5gXM/4/V9T+ntK+5Rl2JHuf42UQvv0j5jub4jzLaP1kBN2c4XbXtGuznUtnD6ThzPQGiyCa4Smi+RS2KxXCuqePuXp0+ePmrf3HkPB5IIxHimZkiMpTIpF4kBJDUb0bAVlwE2YNJATQ16OCIJxHjG+BlsLKSScVR0oCHG8Jw53SLtVEmJ1Bt4pWC0gBHy3wTglSZxvidgaDIBxKscwzoNYTM4Y40lY1fmliPD70+w/COhWqxXn2zXbzZq+X+PbFnLSFJA5Hbl1RM2xkxYVEcaZEhekX2llq2mUXjQFrFWQViJ52Gu031plVtKCtCtctyLnoqkQI4jzJN9BqhuaRIyBFEZst9b0hRS9+1R8pwxbyrSNpW871u3vFxP+3XGKXNvVlmcvf86TZ5+xvbhke7ahaxsaIzgDkqOm9uYj4e23xPnAsnvFMg3Ydg1YTNdqdLUs+GaFiYEYIiDQeSRGsivkOKJvNpSqTYw5MO93BAFTLHkKxBAwOdOsLsn7Gzh7gnE9jbPkxrLqOrbnF1w/f8lnX/yM3/76BfP+cfS0M4YwTZDBr6+R/gxLT0GjbessBYP1HdbCNOyxfY/ZXoNrKfFIGAduX7/h7v17Li6vuLaOjoayTMj6ihQbbL9BnCdMM3Z7hb04I9x8Td7dIUYFqEvOuG6FlEg87hF3Tyoz3ZOfkq2npEjbQokTyVpsDsSyYLuelAuYBtf8/mjmd9bbCKv1lsvL51xdPeHs7JzNZkvf97S+wVnBGU8uHy78UjK5FI2e+HCgIyeJgepMS02xliqwPulEitRqL+sf9FRStWbGOq2AKmikl2uNmIaHGOtoWuhTYp5nVust5+cjl1fPuLx8yv7+/aP3uqlC5dOFdtr/+SH6P2kDM6WyppotzVrgdEod8EHfpgSf/qxcEZmcmMxSkJTIYVaxd9ZqMcHqJWf1UMUIJlft3kfs2wdAw8NBWkj1snOPvuSdczjnKvOoadaTwNtaq8LnFHE0GoBIrdTLGd+2lM5TlgXjHDkrW0PMpLSwLDOECSsLcXjL3bTj8qs/o+3OKV2rabRctXWA85aSSmVFFQhLLlg+Zh8r46Niuo+YSAHiB2T+iPF3tXgiQtevePH8c16+/IzLyyu2Z+f0fYf3QjhOTPM9+3e/paRMHA9Mt28IN+8Jy5EUolZy50KylrwsONeSraGUSBzu6HKvZ32KjBdPadsV7eYSI44kgn1gourcXKHrPGebLVeXT3j54jO++vLnvHnzirv79+SPihUeXfRVGV6T9VnnnAhpwdlVDRw0SJeHZ2we0qcUSPkEylRQT44UdI/npIUDGqSAs56SMsWkWhSg74YR83fWj3p/AbmmcgV9F6pgXgRSBZkqpi9gHi8vAHhy9ZQnV1dsNz2b7YZ+1WpxndeCAKFWV8agvzcFclwI057j679muv2W8fVfg+0I4y2uOyONB+K0Z97vyWXEtgHWAddPlGVPPNxRjGXJv0bCjDFKwMR5R3PxE7rrz9k8/Snt5gq/OUfa9QO7aYpiX2OUqIgh0nYtm+2W86sLrq+fPmreTdviGq9nTy3WtNZqpbEx5LiQpoOuT9JsW5oHXLuBRgmlU2BdKOQwkmOgiMG1K2XwliMYp3q3RjNZaTmSJSNljXErSlR9LbavaW3VIJqmQYzF2EYLg3Ku52Qii2Y2TRElwT4C9X/f+EFAd35+zfnFJav1hsY3eGMwOYGzqgE5iScFsAbJi6aO6gVnuxXiVjUgieroIE6r9fKMpFCLtpT5IGVyTBgz49qOYiqTVxkRsVrRia20ebAY3yHGa+VPmHQHxKpHsR5jHS5HGmtY9f2jNsBpWLFsz19w/fynnF9fsz7b0nQt3loaCzZHnWsMlPHA3au/JYz3kAslTBp1GxSExkROieQzZV4oxkDIlHDE2FZP9VyFkjlozr5kjQDEY40hRGV34nTE7j3dtOfw9muai5dIs8abnmIdfdtyfnbG1dUVz55/xrOnP+HVdPeoOecwQQwsZcHPLWUYMF3BeEOKCWsshUCeJpab74jLAbO9IC8j4hzzMrHMEzfv7jnc7Bl2E8O08PyzgXk/cf7FH9P6K+xaD1XbnePPLgklI1Mhi8df/wzbX9JPt8Rlj1lv8X6N9S3JW1Ka9WAzhpwWwnTQA9L12HZNshrhpJAp5XERrHeO8/OnWtF6fsW637DqOrqm0SrIE/NUEsZWXY0KP6GKhRF5AG8nu5iSY30Ra1q1vota/aaMsrGeUgylaOqnIBTRylOtZ5GaAkmVo9Lo3DcdRQzrGJhDYJrPuLi85OLyGTfvXz96n//dK+GUCv5gC1Iqjpz1kOVUju8goXs3TBTn9bOmpPPWkBPySWtETWtG1ZTkqQK1qrXzG3IKlBQxxiHOaoVptg+ap4/1I6e0KNjf0Y89FtBZY08cCB9bRiC1YCMpkJZ00u5RKzPzA/NorCXFpbKEmbwMzMN7lvEOiRNl3CFphHXPdHhFDkdK62nsNUUKZYkY78k01DyrfriUVI8IONzDZ6o442HVTil65PGg5u8bxhguzy94+fQZz64uODtTdrptGvJyYB7umKdb4vCGNCXCMDG9u1H9rLjKIs5QDG5zTg6JZQmEYaDzGmyHWTQ9LXDzzb8HA9scWPEM320oVshGWS3Viwlt61ivVmzPtlxdXfPZyy95+vQFu/09J3uXHzVEEKsifFNZ+ZLtByycCzkuqtE0jiwFq7S67gfRu6WkgBFIKUMJFXQVCHNlACuzbFSTVSojqAxgDXQqwDg9/1KKsjAlIaZa0RRlpnKOWNNodoCicqOSHy0vALi+vOJ8e8b52QVt6/De0fgGBJZ5rj8/UtKMhJk4HYnhSE4jy/CWMB2I45Flfgu+5eLZn5LEMS0L0/wdsfRaBLTc0O73OOcJ40SYR9LNLUKhaT1us2U5fEtzmJne/4bxu7/Grp/w8r/3P6FsC6w22NOeL6J3jvM0jSPEwmaz4uzykqurx2XcjNFA8pRGLilhjMU2G7WL4ahYJSUKBvGaddPMg4BYxK8/4J00Qpo1BZ/qucDprM8a9KeAuFrJXRJpvEWMgrOcFnI+2ZQYpCTNyjUdp2SFoJXi1vXkgtqficE4T47h9871BwHd5dUzthfPadsOZzSqFt+oSLdQBc165BuK+unU0lt8r/lm31HyRI6j0peuI0tlz6zBbTakMD5UxlH1NSXMSNOo1sY1CvisR+KI8T0iWnpeUqQUIUyjpjCKgKjYUsPfCHGmaSyr1Y8TyLum4fJBT3XNZrWic47GZowUUpixaYbpnvl4y+3bX1Gme5b9PSwzzieSJMT1SE0Bp2HEtA0GQwzKWOa0QIJSHDlGwhLovJBCwa7OkSYS9vcY65FiSHlhmWfmwx27t79i/eyPWK0vkL7BGo24VquW84szrp8849nLL7h798tHzbksA2ncs7q8pLgWcxjI8gq5eEH2liAZiUfKcgcctUw7JooNxGGHhEicBoZh4fXtzLKMrN4NvHm9ZzhM/NnqJS8/d5Qpkw4TstpC8XB8zfHtNzTPP6dsLklFo1ABuquXpGCQfo14ixmPBF+wTkvcpV2Tpx0pTNj1E2I97Iy3J0L3D46u33B59ZzL62dszs7p+56m8ThjHsCc3uGVpSkfletLBVslUk6aoLgoo5WSsnaUh5IHxJDDQhz2+G6NrM+qtsOSSnnwcSqS6n/XlO3HaUXjHAI429C2Pas+MvYzm80ZF5dPOb94XPQKpzRjeWBtPgADZa2kFCiJkhatRC3qoVVM9ZAriRJVN6jl9+VDkCaJWNMJipWEkmbKPEBZSFK1RbYFBoptMbbVz1FQqwTRisOiYrF6Cdb00AOr8iFdevIA+0PDSb2oc2X2K1oq1lSSVVky1QvqxZsoWiwxLRCUfSrTQgwTpSwc7r7n7s0vmG9fs91ukLTgvKH317rmbmEZbzC2xbaOsgxYt4FsNWA1dS4xYExB/ElDaesMI8pCfszaKYNgzI8HdKe1bpqWZ09e8uzpE87ONmy2Pd47yJFp3DGOd4x3r0i7W6b9gWUYWZbINM2I8aSUWVJgDhGz3NP1HSXGakHRYPuOOE6UmMg3t9j2a6arZ6zPnhDGPaaA69aUxj+AaxEVxje95/z8jCdPnvD8xXNevviC777/LYcfoRP9nfme3mcpSjB4tRs5BWm5ZHUbOulZpRYL5aLZJkoFCMrWlDjpXUiBFDUDldF95RtMVgJEtXFo5so1D9rPh32cNeVsjQVr9V7Qr+DkZyalkMtJc5WR/PiU6/nVFdvtGetNT9e1eO8fGOqcZmVSpyPL3WvKsmPevQUDpr/EnT1n/+57YtZix2HYsRp2+NU10l8gbkU4ToQ5aYWoc9gM4xxIacITKa4hzRlfenKMdPkOfxTEdHR+ze2v/zu6J1+xefknNKtNlSIUurYHa2jbhnlOdP2azSZz/kgJlWpNY2VeDZRIKQ5OmYGTLlEsKcw43yJ+hQH1UcwR8sypolWt1zQlWsKEuMpw2ipZMYJIqz6DvtXzsd5J2LqOS1SfVusqkaO4x5hMxjxU1+c4g/FImsB4clHQ+fvGDwK67faMrm1ppNA0LVYKtkSsaVU/Q6qEg9FKXuNAPCVNeqnVIoVSkn5Y12ppbm40aolB9QaiSLYss4qOrSU5i2kbrSgTU/PLnpI7/WcMmHZNCTPL8YipkY1tN4hryDGS00JZDpAWbCl4+/gDTwS6/pzL6884O79gvVqxaiytBVciLBHJM2W45/Dd3zAM7ynLxPjuFZSMxbEMA0LEnnnc9Uu4ucHlmZySfr4YsU7IBvK8ICWTloAVQwgz2IZmfY0tQh4myjKSaom/61bkkjnefM/9m7+mu7zGOo9xPdahVUHrjerpnn7G5vxxegPTnJHMLVGg6x3zssDhDTYV3JMrsu2QaYBhjy2FxTlKu6U0HdO7d9h+xeHdHYjl7jBzfztzeeaYU6JtNjTNCkIkGU05m8Yzx0Q83mPTQIPHjHviEuC4J6eRRtYkZ2F1jnQrlt0t5nqLM55xf4/bdLheU3dpGTC+x7meWD5Ew39obLeXnF8+Y3t+zWq1pe9XtE2LcwZTAoIni7IyJacK1iIlqhY054USg7I1YSLNe03RxIBIwTV9BRrKPKRlYrp/y5AS2xc/w3ZbcI2yNZWNAlH9TalGpbWqDnF6ocSsLINt6NqerluxXm0rs/54QCd8sPpQsX01v622BJKzzrn6TpEDORuKsTUNW6tVQ6LEoKzcqSBEc68PZsUihhSOpGGHEU0laXXfhCFhnYaoubgKZBPiGvVjMw6DPBQT6OX84bPnh/D28Ro6FS79bupRwVFWu4hG0945ZbWoAFKuoqYUyXEixYkwH9nffcfdq7/h/fffEHbvydcXdKsWH1vYvac7ixRJiLdY17MEgeWAC/c02yeU7hxDlYV8pJGTE/Dkd9nHD4UBVDbh0Uv+0Vz1+zfrDc+ePuP6yRPOzi7p11vapsGUhRInJNVCn9ZjloYyDPVsjQzTSErCkirIiZHjdKB3jtWmgyTYZPBtrxemg+Isy7BnPN7hml4vwpwhxFq0YFFzZoO3ln7Vc3Z2wZPrF7x8+RUXv/obhuH4oyyZfuf5pVOJ9ikAqLYw1RC3nHCfRmv11cuUqKSDMZCXkTzt1c4iZigRUsQ2nb4fCI5CMQ7BgVjsyQkix2qBA6UkTaObWl1KVr1wtf9QoK6gPaX4sL+NtRjz+EU/22w4O9+yWq1omoamaTCiINGipsB5OnL8/q8I+1dKwqyf0nXXGH+GWz9lvn2txRxp5u71r9i8/FOSwEKD9/qZU46Mw0SOkLJhnAOOiPctrikwjpAXZhY9z/c7TVdSGA87VtdfkNuekkUBTaNabN942jYTQqFvter1McPUzElJCzlEXLd+kMcYEYpzCsr1eCcsM85arG1r+twArupZPSKaMShiSDlpoF1Es4UpYLKyXEbKQ/CAGPV2pWD7K3BNjUUTaTkipkXdBPS/iYgG90AMc5V/VNNj/w8silj1PY1vce0K03RIiZpejBNFGlTeIohXHVAOQRmFbChpIlMr3vICpZDirJG7GR4icGO0I8TDIZmTGqdOAqut+tmVoEAvzFCEEir7kVVA63xLXmYVL54QNIJIRFB3+3ptPWoDAKqp2l5xdfmE7XbNetXTNloQIHHEpiNx3DPdveL23a9Z5p2m/mLArDbVP2yGZBGzwq0uNAU43JGPB+Zhpwdx09CcXRDLrPpBL5raRIWQuWTECtkLBDDoBpqHAPmWnBe6s2vOX/wpq26DdS2ddSwm0ncNZ2dnPLl+wsXTx1m2mM2WlX1BSpnj++9oL14iw0wcX+N7AXOlVlntGTnOtJtEth2Ixa82jMeJb//2a26PE8adIe6O84s1MReeffnHrK9fgmvIratsTUZiwY6Fu+++JcY1288dxQhSNVbBdiTb4ljpoR9n0rBjSnu1LswtuJWmgucBWWZKC9JskUde7tvzJ5xfPGGzPaNfrej6Ht80D1VfOWVKrYgUDOpkkdQ/LiRKXsjTkftv/j3DzbekoJoK321YX7zgMB3UysV3WOsZ929ZxiOu29BdfQbNSn2mOOlADRhHmbNqO+JCibUAyLWk6MgmYnyjBrnO0rUdfb9hsz1je3b56L3+O+k7+WBdoKbCNbKsQnCqDk4d9M2DJiiGQdNMcaGgpfgpKZNAViF5zguSE3E5Ekc1jXbGYrse255hQiFLJMd70qKCemM9JvWkOCO+A9drBExNk0mmFFPtG/RStvaRWllTU6gn1qboZSrGKPuBULynhKQueFYvPamZiTjsmZaJMh0Zb7/j5vu/4fbVb3j76j0lDhiEZmdZr1fEtLBMO1bnT3BtS4wTJhvSNHCcv2dbiiqY+nPsiXjEne5xrYDNWS09ykmXWBnP2onEPFJecPq+07DWcnF5xZPLay63l2w2Z7SN7qs8T6R5Zt7fgjhwPdnNVDc0ppCZ4unzCXNJOGsIMVMksRxHNt7SloQVod9sKUUtX5b7twybK5pmQ9Ot1dZChGK0o45eZxljMt4b1pstFxeXPH3+gidPX/DmzTcsy/L7J/l75n0ygD3JHzTVaUk5KlYqRbNQtvrK4aqy4iOJBZmUIzHM5DhhSyblRTuFpFAlRInUZq2WNA04ld1o94iTt2Cu7CAPHRQArao06sumRIYy38okmwcgWx55vgFsViv6lQI555RNKqXKZw63ZG9Ixzvm229Y3v8asQ1WNsy7e8J8JOxviCESA2AijDvuXn2NTBPeN8TxSE6FYdJgXcRiCbQkliWR48jdGDDHQmcyZxfnqh/e7UAMzjX03YY0D5T1RZWjtPrIrTK2beOYnKNxQt897j3XrhtaSVwQTamLVO3yKZGnBr62W1FipBRD9q1iHn3SVY6hwXQuesaVtFDijPg1KVYbk1rIpX16apawAru0TEin52KJ44OURtyHLjLkqBaJaBFHY4RsnXZKMYlTt46/b/wwoDu7ouk2+P4c61o9sMNU8+xGLUXIOqlTWoaCiKYRtS3KRMkBFZHqASoZTDVtzHlGSgMYjHH6MIMieO4K9voFcclIWiBG9YTC1zYjUfPJqWp0jFVxc1zAGPWasRZJYG3BuccfeNZ5zs+fc3HxhNVqQ9t4GgNeFmS6Ybz7nuHuLcP+HcPt17VE2WDalVKt1mP8isREzln9l3IhjCMmJRprSVnbmSGC7zekWaOJnCbCsmil6e4t1jequXOWZZmZxoW+s5ATTWuYd6/Yv/0t7cVTLRCRlqZR/clms+Hy4oKrq6tHzTu2BUtPGxzz/gbrOlLJ+PU5aQkwz+B7rHdAIMVRNQJLQPo1u1/8ijfv3rMbErujZXt5zvXza4YhsLl8Cv0GWW8Qb9XCZpxVWG56zs5+So6JMAyYTa/Hpgi0LW13QXSONN0gJlPme3JIBDE0ziOtgzTCdET6c+b7tzRPz8jlcV4O5xdPOb+4ZL3ZsNqs8W1XqXejB31lbnIuVSOm3QNIkZIXShgZXv+Cm1//d4z7t7jqHp/WZ7R9z7h7w7R/r4ec8RTJrDZP6LZPSGHALj1iE1K8Ru8nEFkDlzjsSPNITpnVky+xfq0/a7UGv8JaQ9t6+r5n1a3Zbs8fvdcfksEfgTmgVvtBJlFQ4+OyTFU/5KFAyYFUU88pzZBqoGW8ah1jIC2BGBfCPFHSwjzstI1OKfRnW5p8QWNaJMyqSc1R510ixVpl99utappsxNQCnVO68dTNQi88eWAY/9CwrrYx4gOA5fQM+KBxUqxYkBSwKZNCIOfA8e2vWcY7chK+/9v/mvu7W96/fcd+N5JSJEx3XJ219G3DsN/TloB1nma8xHd7pnBAUsIaWKY9Oc804w63eVklJhV01RTkw3o9VB6fmLnK5D16xXlYbwDfdlxfPuP64kqrH5sG54oGmGSsbzH9iuXdb4nDRI7KDqdUmJaFIaCFItYQIxyDrp+l4HPGZI/xBpqGGAbavtNuESLE4x3L+pIwbfHdBuf6WuiSFNAC1jpsm+k2LeuzFVdnFzx98oK2XxFObbF+5LwLCqCQ07ob1WnWSuFTsKlFFGpJo3rKSMiL6rLCCCTyspDSpOdCLWYTsRRHDRAs2bYoRvMf1i3MlQn8kAY+VSqbarhsimgdomjLKWurhrPu1fwD6be/O1brFf36DOe9tl9DsCLMcSGHmWUJLLdvCLv3jPd7pLFYXjPubghxYb75nrivBtKmxYbE+OpXSFDfUvDkOLAsAW8dlERWARvOqFwizDWgc4b55o6zZYWVwGYesc6DdcyHW9qL54DDeQ8UxQyifpHWG3zT0faPY+hKDspEugZxHXHcQ9FCFeO0CEHTsIIk7UhlrFCWPdkYUoxYScriUc3Fc9CWo1VOY0yiIKRlIRdN7Ypzao9iLSZlcghI0cr2hyII6zCpvs8n/fRJcC3a/Up/HxgWJdR+IOv0w7Yl/UZbVySl+3AWaVqKOHKckDxjfKPIt/qTkVQYnJcBaVewqADadCts06lWJi3ayitnnUwa1dWfDvJMDgM57JHlDmk9uE79YsSQw1iNAbVtiqB6JcHgG0cMiRwXxDQY14MpmDw/VK49djTtirPzp6w25/TrLU3TqlVQWhjff8fdN3/O8eZbxEDYv6NZndFdPiWUQpoPgCWHpE7TYmEYtFWQsVos4QWmhJFa0mwceTwQxgFbVGCblz1pEYptyHGhBJhGTfPEKLjGIKZlGY5M+/ek6YhZbcGq9qT1nn7VsN30XJ8/zoPPrZ5i2GNtojdCtg1yvSZ1Z1rR6FuKdYh4jPQkU6AEsoMYCksyjGbN/XjgGIVGVuzHhqbZMu1HpsMdcnWONyvViqQFbCKFQXu8+pY0Z3LckwjYszWuVYbGth5sQ04GSZNqcnxDWAdcMOy//QXGgt0Exv2e9uwl7fpxQPbs/LJWta5ou46267DeVba8ekvliLawSvpC5wRxJg/3jLe/5f67v2Y53pPmBecdpmkpJTIdb9GyUNWfxCWol1zJhOXI8N0Nm6uf4PxKxbnWYp1n2b1l3L8jzQNxGgjziHUdzeocs/FK25cMecEYh7OGpm1pu47V+uzRe/3Uw/LBpLRW2ZWTtiNrD+WyTORlUK2cBCRr39G8jBQpCvhjYhmPtUhAZQ9hmViOR6bDAWuEedizjGMNsAzGbzExUqYR4xuM1EsQqwEeprbDOqkQpR586AV86gmLemA+1r5DTin0Uyr7VPiQtUUb1ipgN5oKyWlRVpZCSZE43XL/zZ/TbJ4x7W+ZD0cOw8x+ShznRGEBC5fPwVrD4f4eROjPrznwte6dZcav1mraLYbYndH0V+BWmk4TqT55H/RWkpVBeuisk1W3hf3xRnQiwrpfc315zdnFhTLUrccjpGkghrFepg6xPSXdEY874jwTU8KhjO0xJtoihKipahEtJPLGsoTCnASTCilDwupePgp5fUmYRsI8kudZ2ws2ViUFJiFZGRQrhsZ71us1Z5sNT66esN2ec9jd/8gZnzz8PjaUBErWyleBLLYSEx+B5vo1aiUVQBJl0QIyS2YJASmZuCx6V+HABVpWRAHXrDBRtNjFNQ/vmko4lXktKQLaUgpq/RCnBnHKVqq28EQt8sDoPWa0bYu3vtpzqBXSyUBZxDG9+5rx5luO9zuG/Ugugfj6vVY1x0xaRsiRpu1hEqJdCPsdUhZmYxjHSEgKimNcQBrEt0whkhByCoSgfaFd8YSke6db9/gls0wj5nDP/ttfsn3xJ2QvD0TJacLGaPsuYwxN80gmXtSsOIcJKQnfr8hhrDo4lTNY3+vvKWoirl51QIlag5mN9mHFPPjGaTcbo5kDqc4eadYiIdEevSFGrNV+rbiekgek6fDtmjQftN+4pIf3mxzUj850+pmTFkgihpTBNP0PrvkP93JtOppuhW07jLOUeNRI5lTlFaNG7jQU3/PQSoWiWqCorFSRanVhV1olm6geT4sWSJgGkwsp3NWDw5GGPWm8UQuTixeqwaksYB4PFKttM7RypFCMVa1eDuR5RHzR1jJZsI2alzoeD+j6bsP5+RWbzYaub/AeXJkgTuR5x/j+t7C/JZVQrRa8FoCsrsjzQBp2lGXGrVeU8cB0PCitX9SBOi1J2YeUKAGMM+p5Val46zswnpISYRz1WeEZjiOSFppaEROWjJ0D4+133H/7C65XZ7h1TzaCc46maeg6z/bscdGMvfqS0t6Sdt9TcoMZR7IIpllhmjOKyRD2BHGUdoWhIxz3FGM43txwHA3BbJlJtJ1lmITv389sNsIYv6f55X/gi1XH6uwJMu6RMmG95fDNL0h37+muviIPI03TUHwmeyGIw0mmHDNJMqXpMb6nO7+EmKCx2JLwcWY+DEjJ+OIo+7fM4XGtcdabM7rVmqatKQlrsAZKDOTaaxhSjeaygro4k6Ydx3e/5v7VX6umNCemUY04fTtrq5uYCPPEMi9aRGJs7d+XMcdbjGvYv41Y19KfP9Nij6ZjPr4jzTuON2+YjwdSCnTrc9JyoJSLh/6IYLBiadqWJiTafsWqXz96r2ungRNgUNCU04LEUfdnnGuKSNMJOReIgRSnWomrFiRhnojzyHLck0Mk1OpPSmE6HDjs9rVlUGAeJ7pVixz3mNVWfZtcD+Xk16QNyqXaPWgVoeWDZKjU6lkdUrtpnBi7x44HP7ta3YpQ02pQbfFVy1fnj7UYZzV97BtCnBhe/ZpxGLi9uyfFwhJgjMKUM/dLYpoSLimzG0Mg7PfYeWKaDpQc6PI5crjDNSu2/VpTeK7TdL9oDbA8sFDyoKs7cXZqgP5DZgY/MH8RzrfnXJ5fsllvVGrQ6kmZSiKMB/Y33zPt3hKPe7BeNYPV5iE7A4t6uYWSmXPCIBxiYlUcU0pYgbAfaNYrDdiWyLTcIKng1zvk8tSXt7aHq0txujALBinaQaLvOjYX55xdXnJ2dsnr77/5UTq6k3k1QCFRiqZVM6n22BVsEb1LKvBLUd97yUkzRSWR4sAy3CNAnEZKTMQwkpeFXNu2ed+z5EQrnjQNkAVxFoqhWE0tY6zekdVcmfrcjXdoWzxljGMMKleq0gJTg8xTX9LHDO+9dkQ4eTsmzXDF4ch08z27179ivn3F4d0rhv09pQjDErg7ZI7Hma4R2s5jD3uafaJdHRHjKXnheNyR5gnnW0rILItKfkI4EsOM8T2h6Dudw8ASLSVPhOBYn1/QGEdaFvUpdYY47DG+IYvH2JOVTO2+UbtHPZagEetJuXa2EkFKxLpGTYA56STVpkWMfASYFF+UGGqsZFlmlY1ZQW2nbKP6PDEPrgfiLR/6FGtHjRAiBY9vOvK0w5iCWvgutRd0qs4hXlPBOZJDRPyajIJJ35u6V/6BPnReDF6kWilQXZIF4yyEkTIfUFFyFf9R+w/WlzDHmYLFeoczPaZodzOxwBzI0wjOIY0DaaHMFLRkW6ypvmsD6XiL2Z5TksbmZThqZWDWKNW0K3IOipzTrHYAKSDLDL7V/qAl/qgqsHZ1zvbsgtVmTdN4vERsisi0Y9rdadXpshCXEdOumG++V7GoWWF9S44zWYRlv69A12KaFX7VswwLYJStizPz8QYwLMOxRk4OYxrCuKcUGA/3TNNMwTEcJ0yJiD1QcFivDtPLN3+DW11y8cU/wbZbxPdYa2m7ln6z4WyzfdS8mySkpbBk8O2KNM6YlSW7AGVievcKWxay75GzZ9gI83jLu+/e8vpvv2bcv0FyovWGvm8YhsQcInaamOeR9pvfkFPk2cuXhN0Nq/MVXb/leLODZSG+/Ya333+H7c64ul6T3luu/uifUpyFecGdbbVVXJ4opiUt70nzayiJGCdsXCjLhG02jLvXeP84Y+HV9oy2P6VatVqYFDVomSdMV73iiqaDSBPx8Ibjm18z799SSkQEXNuyvjgjhkBOSbsExIVlnBiPR5zxbK7OAMFaT6opyJLe4NqOnGdWZ89hPrAcbxgP7xl3b0ghYVyDMTAd32OaDhuOODJ2/URZvVzw1tL5hr57nP8efNBjnVocyamgQYQcR+1VWP3jMB7jDCmMLMcb1ZqJauTm447h/o5lHBAKKUZiSgjCOAV293uWeaZtXGUyEjiHP+wR1xNtDzHRuAZnDM5ksghWGnIqmBRVJ1kMuFLbIrmq8yvVjPlDOvIPjYdiA+Hhe07VtKdetFqQdRK1OU0/CxpY1CbkYdwTl0XX3wptU0hLovOWVbcmLJFYmYt2SQy7u7qPAjhhvNNAbn1+RVqOxGmHcR0le0z5cESXqu/C1p63WT06lWmRH59zRb34NttztpstnXN4MiZlomjhUjGJYiM4PWvT7UG1wEAOQVNqRnClkLDMJdIjzLkwz5qqv2ocFGFXdpBm3NUZ1kHJkXC4ZzrcsHnyuT5PUZa1FNViYwSsgnUnjqbv6DdbLi6uuLx4ql6dH7UC+0PjZGKty64p19rqhWI/MEFS27CZug9STlgKIWlwk5Lq4SxFtXTLSJ5Hpv2efrMll6w6wlxoupk4HTRQlxXWZnIqWNOgra4qmBWLIasPXUqkbDBW11y70thKJJ9giLbcfOxomgbfGFzrMVZqFiiwHG/Zv/5rDq9+yeHdK+YhEhd9D2IwTGNgmAq2bSmyZry/g3hPs5po+xU5TExjwuTMqo941zLMCyGOZDRgtCWyLNrwHmmYS0tIC2vnSEtgzAtt6wjHe+a77zl8++84b/4lprl+SEEaCqZ2r/EScY8Es5re9Gp9VpK2rbSGuAyaxrVGqZ6SVP8vhhJGBXYVM6ijwYzJQYPaMGFdD9arvr9WyqYimBQx2BoggM0Lpuk0CxeiAveStYjCNxAPFIx2m5KM9Rto1PNURK2gQgrEecL6pp4df//44V6uxuiFtsxI3z+0xJBa4VFK1JdOGhVwV+FmKZDCQloixgsiDbKM5DwhTosfjNXDJJ/Y5FJAGkq8B0QN+mpKJs8DpusR0+iGTlGNV6liXGcAbePiuzVGZsKswkYrTiPZGIHHRzPd6pzV5oyuV8NeVwL5cMd08xv2d9+ScyQuB1IOmClow/rVSC4TxhhCCLr5MJQYySSSseQgpHGvB8tqxXK8Jw8zGENKE7bfahQTtaXMskwM48g4BVofoAQSwjwlnB3BRYQ1ZRg47N6wTHvadA7OYYwoQ7c5Y719nEg+SVbGK/bkkDHbNdH1SBHS8Zbw/jVBEjRrvPTcfvc1X//bf89339+Tx5ntueH8XFPnXVvom8L9/Y4yGZwvHN/fcJ8Tt9/+ApMDq77hiz/+M7rtFftvbrh79Yr/+s//miFk/uxf/JQ//rP/lCULeV4wYaIVIQ4e+kTrLaZoin7eH4iHAZsX0tGoIa13uPw40XS/2uC9p7EOZ2ztZpLBgO08p7ZQVDFrGG4V0MSpArmOnBa2z78ip8C4v2E+7ihxIaaMs7Xfbi6Muz2+169PKWt7IQFyYtm/pSxHEPVQpGR825HCAciMh3uW8FdMwx2byy9YuQbbrqpZptpP+Laj/VGeiyeG4EMPypPOSNmyRC6LBnPGVWsVRynCMh3BwLwfGA/3hHFkOh6gpkVTiixLZJ4iy7yQYmLOmVhbpPXFYoz2gx7DiCkNIYItGaZJWQjjOD/bsBIDrdOABqPeZyrkU0BTx4/pmJDLae5A0QpaydpLNRlBslBCVNBU20RBJi17jrvXHIe9CsXnQl70wumMYdtYLjcNm9aRixoEi29wvmOeR+Ky4G3tNmBr+tI6lsM9abMjtz3MIK4FY09ZZR4sPUxlLdR5FeDRoObj4Z2vJtobVtstvl+pFZ7UlkSAa3pmuVMttHFqnpy12jek8pAUnGPW/tSl0LUtjsJ348zaFzpgTomYA9N8pFlfkUvE9GswjrioxZH1LaboSW2bGlgUZYY1zdayXm/YbrZcnF/StPo8HzskZWV5pVY/lqSXfS6Qk1pzOa83RSmqD63ygZAmff5xIox7wjwxp5kcZ+I8Q9T7JcwzRntCktBiAILTAptcGZ2UySYrYy+VlTPUTJb2bi0kQDNP6j2p7cWssR8skH7E0K4omr7WHugLaT4w3n1DOr4ljnccb99yu5tABGcc99kxVmeGab/gkxCzIMXx9i5Q7u9YnV3R+UIedwzjQtM74uqS+3HB50DjG0KS+q4ZOteSxdKtWmyJHHd7QmMQNHC0LuOblvXLP6E5v65JPw28jNGWfUJQGdgjRg4LPBiPa+HUqQpZJJNirl2mWkqpmsmSqoQsYHxXtXH1fSxJ7UhAA140k6OyXkOOibLsoe2UZUwZpLYNrENTtg4RPR9I1dCzdhaSkrG2Ohxg1d6qRHJWDPD7xg8COmO9VmtW41vtPmQ/5JmtVmYY2+hf1gKJHCZSDOS8YM0WQgJZtD2XUCNrAy5j5qiC+tVKNRNougcB43vVyuRURdAZkaSsW9NAmmsOXA0YjTiKb4kxYtuGlDOmqPlvXo6UH9EOabU6p+tW+MZrvWkpzPevufvmLyEPiLcUErZZE+Yjne/wfkOYh5q5EVKYgIKzhhJmwvEdZRC1dxDBtx2SIktQj5xSIskGMFlBXRFCWMhZmCctllmCmi3Oc0DkQNNvGMYjfWMY7t8z7N7SXj3Tg8qoI3bb9rSrxzF0ZbqH6Z4w3OJti7v6HGIiHHe8/ov/lul+x/bZE+ihW37D93/xr/n2L3/Ju31ExHF+/hnbVYc3mfW6IefI1cUakxNxmdgfZ27f7hjinrNVoxVQh1tu7m5488u/5fWbe359N3MXIvN/+A399Vdcp1cMt99j05EnX33F5U//CCkd02FH3N8jLiMZ2vUZ83igEcc0TrTbjVabPmK0bUfjHN4avLMKsEyq3RKq4XOatQIpTpSgLFTTb8lpxhshRYdtN1jbIWKJ0xFEewYiFp+L9vJLiTRMrLbqdUTRnpHWwHzcE8Yj3eYJh3evcH2PdS2uCZRccN5qH83vjuQYiWFhNY10119g+iustTSNo2ke38NWDYs/pHO0MEI1ZMUCMamlQQwUaUnLwjLsqsZOCMOR481bbm/eoy2oInHRnq/OGqZh4XCcKDljSBi0aXsuEJfI8f4OY2H7fK3vdQFJkZQW9WDCU5KnpF7PHfNBRP5QEHFSGpVTY/PHTJwPLbZOCdus4vdT2q8IlBC0uMob4rxox7fats1Iw/FwzzQHDiEo4BVYe+HZpqPzqr9rOk+zWmth0zwwDwtjyTifaRqv4v6zRTswHN6DdbRGyP0FRppKz3Gi6VTAffLaLPVZPHrFP4ym7diuz1ivVjRdR9utoKhTfg4LIRyZj++J9+9I80xIIzEHivNklJnVtKWynU4Mh6KN3IdSfVeL4GrWJqbMMs7EsNCtNkiBtATmw1vWZ5fVvqNeJyIPawDUdJulbTtW/Yqz7Tlt37HfnVirRwyj6XvDhwIYtRKqnoo5UdDenCc/w5ISEhMlqIVLDjMSI2k+Mo9HbQsWI3mJxJgoZcYb1RBaseoxmqu2O8zYdoUpYEokxwImI67VlmIGqB6Lp89YpGDFqrG0UZarKpse69CjU6+tO40ot1eWmendd4Sb71iOd8zTzDhrhWoImdx6xHRMaWBGcKkgx5FoHFMRhqTAp1kC2RWWYiELU2oQ79gtM860bPBEKdhGwc0gAs7RecMwTNweJ842PY0X2B3wuyP91cg83NPn/DDHlAtiayV7BVuPGWKt+h/GWdfb2toCrPrhGq1yFXNi+a3q3tHAQtKiViJGyFlUI2e06KMk3TcJeOjwkHMtoqkWS6J9esV1Nc1bjehBbdbGgwYNpfZ/zYt2jEB73uPXpJJIaOWw+N+fav5hQGcqzZsS4rXVUtbXWMW6foVtmops44O/WpqPpBQV6GWjBQ5r9XQR2yiNHAOlLIhJmAxkr8GYU2fyGkLVFjnVSDNFijHYjTJGJVMnlx6ErVIizlmSsUg2xPmoy5JnrHv8kdevzmi6DuctrQeTJg77t4TdK9K8r+lko7oB68F43OoC064Z3vyWEuaHDRTqpZNzUasGa1nCQtq/V8GvOQG3Qjoc6LoeujXGd7RdIidIi3AcZsal4Kwll8A0ZkSOpOyw3tLvbrl9/TXnn/8prrdE43Cu0DYN/pEC0unrv8bmmZJHZrHQXpFKId6/57f/9t/wm998z/M//jk/++d/xsyB+XhgYgEbGKbE+5t7zs8a+r5jfXGtzY7NkWUaKabQFMt4mFnmSH95zf1hR/rFv+Pdq9e8uZl4c4CbAPcR0s1I+a/+Fan8K3I8cmESX375S/6H//MV65efkZtCe3GJBYI9QhGazRk5LvhlIc+BH9j7vzPapsF7R9vrmoMeIJAoaar7eFDLnjBXPQdAxvmOZC2uXSNWU+UpDLTrLWmZyKnguzWwA4E0TYj3gCHFBRGh26xZxpEwz/huRVgGxsMdLYX+7JKYDyzDQB5mUi44M3N4950ePDlScmD9+QprVzjraJofwdDJB12WrTqTmDJkgzE9xWpbp5OFQElZ++Qu+s6Pux3DfscyRXKasM4wTwspZnzXEmIixAWTMtY1hFQe3NuH3YGSIt4ZhG/otuf4psW2nXamkIw1RqPyatwpoua+VPH9Qy9YNI32aKaqGsmeLJSgpm5T1Cp5CtmoVURaJkyxqv01iRgS4/HIuN8z7PeMS2DVeLxxZDyhZJxrcE1Pv7b052es+o5pHKCIMlxLTZeVQNN6sIZUkuoQxwOhBDarc7xrKLZqpx5mWlSeojdFXcYfC+mEvlux2W7pN2u6rlPrhmKJCCkESsoYcerzmTJlmgnHPTkktIujI4bIUiyZgreG9zFDjNxF7SgyxcRghYuuo4hW1aYpkdaJOM/Y43tC1xIXtbrCNlinGZdSWUmdmmrtnHPqubje0nfrB0b5MUMt4CK29RQyTpwCg+r1Vqwl56zenyljnEqGWA4U1Nw7h4m4jBCV7YvTrH1CRfSqAUyGuCxY41hE3Rac7ShmhLjWwgdxQCGGmca1Ot8aJJ0CFZ1XpqC+pWIqI1v1nuZHrLkRMJzecQjTkfHmN8x335DDSAyRkly1dMnEJWrwOAXmZPBi6EpRsX60ZIeSFikQjWOIGbEWvyz4nPG+09ZVXQ8xsJ8XhuHA5XbDqumY5pmAZ2FhiQtD7mjMmiU3LKFQlqC6ct/woV5LQa3vNzi/e9yanwqnjIeaaCEvWOe1m0OaycVSjKeURBjvcU2vwNtpWr5Yj0mhtmWzxDARwwJZHTFIqWpdIU8zKSowtrnR35ujSssQ1V7ngGk3iNG0rVStcSm1T7WoW0eu94N1LeK0MMLa3w/bfjjl6lsVElpbaTXtzJDzrMyCmNqrUsGVIs9ImUcoEdNeKStmIsV0OpkUSGHQRt5pqtVcqEVB8WTTIM2Gshw08s6BQk11GWo/NK+CVmOQnLXCq2jJeF1BRDxJMaG6WzedpiceOfquUydtaxFXyNORNN6CBK3iDYqe87Jgm44injAdMZJrJaBg2xVpOugO8orOOYFhsYRpIsaAdR98hcQksAbbrrQoYp60GrQkrKmtSIrQGkcOgTBNeHGQVngD626jDOAcoPXaeNy6R2vJfBixDkIuhDjRHN8T4sLh1Wveffee9++P7NP3uPYpL754gWs6jHM4lyll5s3bV/TdC/rVCuNamm5FmWfGQ+Td7YHDoRCWmW0Hcxx49faWjc28vxn5bszcLIkhFwTDkgv/9vt3zBRaMi99S9O84fj6a1bPn6iwtVhCXLDA4fYdWTLbF5/R+A3Fb2F9/qh5N87Teo+zrrINStGfRP0pDpT5QImzpkqnkRQmwnxQ80sxGKfVTsZ5CkKzOifZpqZuleIPS8D6Ftc0pBBJBTbnF2pfAyBCyom4jLSrnnbds7p8hus67l9/pxdKqSSVrXo66yhi6J/9HNtsqy/d4xk6ORkZl0KqPo4lLdqaD6PP0TQqoh4HrcoT9RqbhwPzODCOEznOjMNMyKoRSqngQmYY1brHCcQQqx4IGm8Zp5lV7xiqvi6HhfXlFcaonxdeSFW3RBVDc+pkLqI+gOWUkTE/Kgv1cYuzBx1e0Y43zhpM1aqkxpLHUSt9KYRwZNm9wpTEPBwZhpH3h0TKhav1mk3X0phM43tM04IVvOu1Aj8XpimTovr6ueJYhpmmbQjzTBcSZVqYl+/YvPwJEhct/DGummR/3GeUmi5Wn83yA9qav3/doe061qs1fd/jG4+zKhMxRkAyYT6SjjsIAyZNxHkPkklZSBhiKsyhsKApKotD4oQRoTHCtnFYY5hj4TBPtLZlPBxo7BZKquktrYzNJZBTqV5w1P+Rh4IQrVuxWGs1+Gpa+q7/kUBWU3cFMFmDg5QTzpxkFQWJ6v0o9ZcKqpfMaamFa7CMB4bDDlMKcZ4pGZyzhHkhZcH7BrIwM9AZyzIL1nVkEfI8YLsVp2pK5zwC2r5ODOkke0A/DynXAsAP8xTRBvLxR1B0anau9w95YRluWI7vIAyE44G8LCzLyJIcgQaM4f3xQLKW4iz7Ykhe8LbBFsHlhc5qq79kdE2OSbA5YvCqBXeuFm4FGifEticU4TDO5GkC5/HNilISMUKcBtI4qAOG7eBBYmCrXlT3vWv8g+3QHx6igMqqSbh1XnVzrlHHjVK0J7tpCUnlFiKnwphYLU+8GgNXGQJxRsJIEaueoCmRxhGimhcbY0jTsXrUeYzRHtWldrnJhZrxUHGKpl0D1hitbFZAhW03H2oDqp2V6ur+/vHDDF2cMY2vL1ft3boMTHevtNltmGkvntVWq7XBN+qvIxjEdNhGajWKmnXaGEnjDiFrv9I01wvFwZLBNEh7XgEbemgvI2k8IE2jC5OjgrxagUIYFIFnBYbGrdTNQDJ4h0lUlPz4A69pOnzjFNAVjZyWwzvKfCAtkzIrGXAdBSEue/LdK9qu5dSg3TiPNxvCsCeFEe8bkqj2R4rgTcE6RwiBsNTIw5sq4rSEmEixmjIWYQlCEQU6iNDaFtNo1c4yzqQszMM9YR5wlxrBiQjOd7SPbHsWQmSJM936Stu1CIy3b3j1y79kDAemGLh9c4v/q79ld/OGlAaeffFzUkr85pe/YXd7y83NLatNry+ysRwOO+7udtzvjhxHoWtbLp49YUoTr3cTozccs2VXYJcSWQyd92CFu3FgMcIKw67AnDy3N+9Z725p3RZnwG82hOGernMsxx3j+/ekM0t3/YySH1cc4Jz2yyXnCtBUr6LNsYMKVnMghZE4HRTQxalWVquoXRA1EUVoV2c1xWgJ85GSCkasmgLjgCqqtqZGjHpw2co4GytaJm91LzSrM1z7lhRKtfIQxnGhFc/GWbZPPiOHEZsi3jmcf+xhBycUlPJCTrFqBaMyYadXpmpjtfegEMKgfya1KIkxMo0Tx3FGEEIAMULKM+SMNxCyvpNSBFJBzzjHPAdiEBgXDT5az7i/JefA+skzum37QedUqiFsbcFGqcUR8ruX3WPGyQLk5IqgRSFJjbyVGIGUtUuCzRAiOcwMh2/Yf/833L/5juMQmYIQI+zmgjGRrvNIPe+KFJz1WAM5C04EZw2RgrWOFDKu6bDFEu4HYjuSm4AYTdnMwy1+dQVZGZ1itfXUyUhZU8xqivpjAZ0xhrZtabsW23hc1yAOSixVb9XiTMdSCmleyFNUe5ks1XBVWOJCqji6sYabWX3htl0LS6ABetGUZmMM99PIeeeYa9P5MB4QUdsOa1tiWjBl9ZFOUFm+uvkwRlTrWsFc3/44QCelPFRHijG1u0gFytSK4g9fXZkSrV5PMRGDplyJ2hUixFA7qMD+cNT7CMtSi2QQMJVJVauttkqItCLSOO2UVCobGPKCGM+pXqecKmyto5jT3paq7SsnuvZRIxxutHtBzqozTZoGHg87jne33N4tvNknlgxJCo03FNfRimoJ+9YitmGaJryzrFsLwTKlgI+CNYYzb/EIYYnYbk3JC0sqWCv4AuebjXaPSIU5LrTGqtecEXzWf7dlJo335DCRU6zFSWohZYypekPtg/2YkaYdeTxg2g7XXyk4tLVTA8rYGuO0A5N3GOnIOWIW9ZvEOkiVG/daGEpaVNbkVF5zqs+I86SND5wlASV7CIuap1eGsIjDNJ1Wr2LVCN1Uz8NmhWvX2tp9mR/6YeekXp5iW1zT/t65/uATsdpVDGMFk7XnWZ6O3H33NxhTuPzspwq6UJ+eEoP6QpFV+yIeayLGqFkfYmsz4xpRgupAbI1GYkFQ3ylsSw4HjHekMCOT+rhZr35LUpKmY4GcFz3wcJqKTQmpokZNoSRI8qDFeMzw3uO8InlTCq5r8K5nOA7VSDVTloi0nhgLjSQ43jMdwTnR1HFUNga7QB4/EmtrBGCsp/EtOR1oGj1KsvFM04SxE3NYWKaBJBbTbWDcsyyTbshssZ0DWxDbYtoWGji8+Vu2n/0RqxdfqSy9/h77yBRc2/fMqSDOksaBZuM0/ZQWnr88534W7t8M3N68IU7vGWLmXz7/OU+fXjKOsL87EmIixplw3BGtEJaZGDNn508xHfTrLdurp3zzza85BsMcEkMs3C2JqQgdjmNI2k5HHLYkNp1nXgLf3WRudgNfxZl4yMiqg7ymSGGJM9lrR495/xrXtZRHasms0yqoXCIlFZCsflPkms2PesDEQA4zKR7JQRvJl5xJYSTMB6zrq9Qg1ZSearTCdCTPMw61Qznej+pBVDJ2P2IbR9c2WOdxjaVZbfD9Br+6wPoVLBPN+oJ5v9PDw3icg7Prl1x8+S9YP/85pt2S8EjMOP9IjyaAcnKoF22dJqImqymTqzAbqKndSFgOpHkizjPTcWJ3d884joQQyDGTCixR3fdzURNtAUJQ64C+c5jKDo3jhEFIZsY4y+HunhRGrDO4tsEfDqzPn2t0Sq2SM1JPDwtEitgHd3Y56YseMQRID4Lkug+spUTt23mqKlVGUUFFHG5hGiDMjPd3DPsjh3FhTkISSOVDP9CUMw2OGDLTNNF1ymYfDwFXrRHEGKw1NZgQ0jyRwp727Cmu2+jhXvQcPk3r404eJ8uSH5N2fJi/CG3T07YdvtHKYiPqMBCtwXYe41vs+hz2b0j3o7JHRgHvktUsvrWWWAr7JTGnTMiJGBPeCLGmkaxR/ZwxMMfCKgbiPMKqx6yfknIipInea4pKjHvo5ypFsOSaatSf0bYNbdfi29WjjaQBdfgXMNQ9b4ymsaWytUkLZDKl6q+r5q5oEY9k7axQKiA63B/1bhTDPIbK5kW60LJETanPzaT3qPNIivgToANSWjBuhZDJRZvGy4m1rAHGKTAXqEBX38+M6q0eO9YXzzWblNOHjk9kcjEalIZA7wxTEA5zhGg561piTJx77QgzTQPLvDDPwlmnXms1tND+5jGwXzLNqqNfrSE3HEPCmI6m0VZgxQhNKdBuaJqO3hZW1tC5Cev07i0pMO/esZqOD20uRYz+PtGsk2q3HrHmKSBOu0IoE6ZaZBGtxDfNRnVrMWIpmvHTlkCYorUBYlTTXuJMiUkbBcRAZsbYXgsf5yNlGRFxxGmoLd/0vcwlg79D+95l1f83G8RlcpqAaoEiQk4zJxFvwWgXopIhTtp3Nv7+u/yHIa7Xnqvao2xBSmHcv2PYv4cSufz8j7QoounqpR9hHrURvW2RHFWfUCbVCxSrLvKVYRK0CbG4VrUsXlM5MSVCyZxkvjnV1l8RxPdqRuu0gXeRUg/bytBJVk+mcMSanpgijkIII8U8Pg3lvde0Q3Wsnw93JDLGerr1mjwtDDdvsMuMuIaUMn69pSyRGEd89TQy/YomZ6blSF4mNQdse90c1qlJr9XNVcikCO3mTBnMpALbEiHOEWMKK++ZUiGJkDOsvKPfrjn77AuazRYkE5eq36tl8UiqPmp/eMQcsN2WWEbSYUc+v2J9ccnTzz7nsD+whExCuLvfsYyO5DuOw8hm2+HXK0y7JpE4HiJtO5GtEIJjc/WMZy9+xvv9zP2U2M8LCSFk2Cc4hMic9JIuRgXAMwUs+Cz00gCJ1gvTfCS5hvX1F/jthQL6fqsVsFm1S9avQQTX/f5o5uNhrJavG6N6Ha1YAi30mclhrPswEJeRMB00UocqSzDYrFVPOVVzSNF+pHGZGe93LNPE4TgzhcgUEo2Dxht8LqxWLe169eD3lnOhWV3g+3MKmpJfX77U6Hp/oN1esLn6jO2zr1g9/SlufamRfhaMmRWQPXKcLBOc6zG90Z6rRUXEanmUKctcDyytjFuOd4y79yzjkTDNOCPMCN5ZwpJZQqJvlE0aFgVyqWixxXFKdI2wRJVNpKzq7rjMUCI5LzSt57zrFDAH7ZXqVue4U/9XqRIPo7oUY+xDyvTH0BalFEzKnLot6Pmthsq5ipwxAt6R73ek40SaDkhWb7RljsQkzDESEnhJSDFkMRpwlvKQ6lnmBVtNgeMCxIzbNmh23GivWFEAEZaJZdlj5Uor+StLpbo5U1uWqW2JLag+1z1+zU/r7pzHORXwkzOlisONVfG8axtlADutpDauxbiENQknCYwlhMCYM8NSiNUAWMSQUmJE6ACphQgOAeM1RRUWkoB0Habx2jopf2g9/iAF4EM6/MTOqsRBpSQ/xlzX4JHycToV+AgsP2j2DOSSIGowZyiE6UhcJlJSCYGxFt+2hHFQwy5Rns967cGaYsSUzDIccGRyt1FRfExKCLgaNBgouRDDiPdd1Xmd9rEy+yV/SBWfCmPI6T+e4A+M1cW1CvoFTSGXgnGraoWB9oMxjlTTkK4YrHPEVJ+VgDNF37WUmZeFAjRGKzQsasnhyHRYWrOQrCUOB7xYzGpLXALWtRAzvu2Jy0xKmSieWaD358zDiH/zGw6Xz2jOLnGbc2z1diu14Ems5bF9uo3r1UjYNpALKQykk3wjhaoJDNo1ggLFKpnkmlp4UfVtKdY/iwa3IYA0xOmW8eYN+zev2VycK6ivwZVkX21OAuVwg11tK1ADsEhYkKaHChhtyQi2pqm1SCfXgAHjicVif4CZ+kFAJ0k1GtSWJplEs9qyuXxCng8Y36u2BhVKUyDNA6pmqdVY9QEUp7ljquizpFDp7VbBqO84uemXRdMe4jy5JKTpMLamXeobcOoraZsGooq0y0mjN+9J8x5psupqrK8P+fEpCWMszhq8ydg0Md2+Ztm9wzYtxVrmcY+rCDyJge6M3F9Tyl5F79OCAMuww1mHa1qWQQ0Kx2lgtTpXj62m1d5wKRJP1io5kouCQaYdaZrIUSuAW+dwNoJkbM7MIdNStAomLcQhqC3KMmP9VqMn8/joPS0TxnUY2+HXF8QlYfo1Z1/9nBfZ0P1qj7nPtF3DcTgQU+Tr3/6WGAeKtORsmIbAnTkSoyC+p2kv6fs1q80Z+zAThpG7YeK4WMQ0tE4Y4oHeW2IRUtJ0hS2w5EwshTfjkTWQTYt4S/IO6S8p7SV5eodfn2PbBjMthOMByULY7ejam0fN21qDtaKXr1JyGsnmWE2AtVtCWkb1GAwzYT5gbEMKamWhsoJQ00QVYMSFvEyEcWSZA2EJpFxonOCcIWbovLb1OaVdbNOwOnuC69YYr/tj8/RLxHb0Zy+qPu8C323w6wtMd1bp+xPza2v/wscNax2uzjuJKIjL4HxHQf3iUhWq5ZyJMTAedqSQNHIULaByvmEKCyGjsgFTcGIhF0IuZJShdwLLbLlZJhpvwQsxqgO+EUtKETHCcX/ArzZQCs55kHrx1ksXI5gqLOekdwROrcweNQR9t0QwVhmAUgGm1HRrrqWWKY4UBuJwR4pqQmqr0XAokbW3tFWrWihabT8vBFtZBRPxArb1arYbAjY7bBGMbSlzIo6R2R2IzGzCF0jmQwVnFbXXX6AFaukDA2B+hHE6UItgHNYI5hQIl6rvq/qtEBe1FRkO5LAos9qumOZFm7GHyJwzc9S0aYqZ3rdkhGMJhFxwjdVLyTYccyGGxBPbYrC4fotrN7TNGt/06jn3YJ9TNBuhH1ZJgGpfYp2tLRZ/pJF0vTdSjlisMugiZGsx6FlpEE21CaoZTwspBn32MbEcj6rvNobGO8Ik+lkaWJYFk4W1c/gmE1KgSMItTlv3GU9ZxQdQZmvlaYgTViDFgG1sxbHmAbyePrdzWpxyukPj8njnBqnZhlMFUIozruuwvsN3PU0HsiQal9hYoYinACFFdWXIGYewsoapJGIRWi9YlI0vJdBYoXcthazFdWKRZc+SLZRMSpl22yHWsJ8XlmVg7VcUY/BxwUfDpm2YSYzHHbvv/pz18y/wzUuy6Nob5OF5PGbYdgMUxLV6LkkhBrWNkHJq9aakSk6xCiytWlJRoGR1Nig1E6k/DdtfkJeZcP+GXPXz4XBPigu2bTUAygFjO+2AIhlxE+J7snUPmslc5TbOd+rRa1Q+UWpLRSNCNg229raN6R/oQ4e3VbQaFVjlgO23XLz8CufX2P5M0WRUI1/CQp72tb/lhJGGtIyIDZQ5q6dKXLQfa8mUEpTuNkLJCyAQFlgybtWT6wM2nTbkLmFE2nOM7xRdVxq2GPWGISvwXG6/IQwjbhsxm2tNxfgG+yMOerHoRs2FOB1Yju81Fz8dIXnKMmjqISSSQZtLN2uW44E4DsgyYr2HYknG45oLrFsTFnWJB5AimKahjNrSiRwwRkGDpSVbr+aWesQQU8DbTOu0Ai+WzLxEjoeB9jAjMSBeGN5/zXy4wa+uEFEzSvvI3W/6Da670NR1ZzCuIRiHPX/KxeeFqyd/y1/96oZihCyeISR+85vfMhyOXFy9oO87xv2edbfi/n6H7y0LLfvxCPY9+6VlN2TSZDHmirPzmd24p3ELrW0JueDFcRxHJtR9PgMTYI3hdSjsFyGNM+Fwi5QZGd4Rxhts40nDTBzuccbRbM7xj6xsttbirMNah5iEpL8DErLqaLQw6FTY4iAlwnyo6XxRoa2cdMeahk1pwbWe3XHCOMPaW7YXmypsTnRdQ7c5x/VnNP0Wkdr8fQ4YD351QXP2DIyn2T7DWBXhSqlO5imCidrKxpw0mI+/5ErRAgZjTGV/tI2N5FTPNiE5VxmnBec8/dm5yh1ITNPMMk4KxLIaknatqyyA4cF132pBh/VWm5GLYE0hpEgIicZ5vI+0bYM1Ht+ucK6hYAjLiMsBtRTQ1GCpLB0UZVPkIybnEeOUxlJGRnW+WnMUVVuXslbyCppmXwaO998wT/eAwVjHdtUQpLCbvR78JTNH7SKRQiDMmiIuxtA4i/GW9XZNuD/ie4O3lmWKSFG/T9d1QMTKpqb75KHwQTAPYn1NRZYHs3QrRj/zjxgiJ02WAmnrG5wXBEdMRb0NjdRiCYttfLXzVA1TypklR3Yh0jlXCyIWDIU5JmIubLzDigYtzmZa2yASyWJIghrojgMhLLq26GWZT5XQVQivoEaZJf1XUSnQD1T8/X0jh4kUFERlqNopZfi0MC1hjadaqlKqVjCVDCdrE+MoYcagLKM1BmM8zhtyzIyTSg/EWHLM+HWn8w2B3GVSCUiayMnirK/vhgLKrKhdsRwGm83/h7X/erJku9I8sd/ayt2PCpWZVwKoAlBd1XKGZqRxHkjrB/7hNCOfaByznh7r6S4BdXFVylBHuftWfFj7nEhUE7ciMeMPQN7MEMfV3mt96xOUFgF3+oyCCiSMszj3vAmE3m9tWqz1ylNev2S6/R7nA852rLrMsZvp3cCU4YeHiTwmrFT2sTLFmWWweOMbRUXwTm3FSoXQDXhrsM4Tj2NDl0qrgETBHLGUmMg5E+PEPE/01WAxzPXAtl8yAKRKv7ujXF0wPrzHrV5QjcUZcx7xnqIA/8XDOoxfgJjzmNmFJSULNUastOeoJuUvgiZPZdNEJDQrElWd1jRrU5kj8/ZWS49YKNPEw3FPmme6IdCvVth5RvwC6ZaU4kC0kZAUydUgZMzyWpMn4h4IChjU+mTXVjXXeZwi4i32J4Cpn34bRBcok2bt+KvBiMWtX2pckGSokTK3ZMWSOcXxlDRhiNRqARU2KFrU0iQwaqHUYEw5+7rM2Gopc0Q6JSIq8VeDosUPtJA1RT9KptagkRhti5nu3zPt9iy7C5ztKNIIyHl63gMAZ5RGTYT095c863PZYFI39MTtlnncU3cPFOuJ4w6yktpziqQy47uC6zpMN2gObbkl5aTcoXFExFPqCBS1QCHow5pnckpUZoxUhhAI3jDPEzaIqqNqhjyTxj3LhaJUYjWOJpRCFdtGx89d7JXwyfoGEzP0y8ZdqiyvXvFv/93f8c23b3j9fktMlq4PWAvb2zsG50k5Qdoz7Q3GCsuVZz/P7HcTqXqK9+SSmLLhenPN9ctr3r3/Hv/m9+BWxBzZ7e5w1XAVOko8QtVRcNfgmViFEAakGo7f/yOSt+S7D4hzuG5Jng90119gNi9J5ZleRcJZSXaKG4KGjnwkKT/1ZyUrh9MYT6UyTzusC6p0RQUSpaF7xnvckLm4XuK7oBtn1+HCglqT5tS6wGLzkm71kpKPiLH0F59h+yU2LDBhgXV9M7asbfxb9L1pBpW0zd4Y8+xxxOlQjnZ5KlStU3KvqEjE1EI1HivNK0kMw3JNmo50XUdeFOa8x7hKB8xzxErFGsE6wxyf+KPeeGJNiBRigZwKzlq6YOiCw3koNeFDICwvsP0C57vWRT9ZOiipWVMLbOtqSy0899SlcQWrOaE87f6r0yu5FOX3VqBExv1r4nyH84HpqMKvxWIgzQc6K7w9FEyJvJGZV5slw7IjxaIFohS6zaYVjrllNBZmVOQxz0ccit6HiyXGevI8ImX8k9Fj283OI+JGHOScevFJh6YAnQpD44yuH20N9z7iw8AhHrGLHj9tiEfN9rRtnNw7y2AswRqOuRBrZYwzU2Ocr72lcwZHxUgmpol1b0hl0k2TCA7lE3dDuz6N9tBUyKd7BU/8yDNAc1bAPu/cS8nkGDWD3HJ+jkz7obUqeldq1n+pJ36YNE89HUePhwitaBPRxmeeErUYln1HjDPOOXLR6LhUIr4JqE5FdK1V+eDGYKWjtKxn4WRNofzI3FBEPYGTKltHc9Y8PxHGNKWosQbTL6jLa3y/xljNRQ1h5GrpKKZj9huO9ZYy7phKpUfIOBUpALEIwXd4a5hrZcqJhVs08/RE9Y4alXvYG6tNZgHrHcYU8nGHnY50OZMQxgJIpH94yzH3rEIP845y3GsGK/VP3vtSKiU9jz9Ysxr3n9BYY7yaZOeI1EiNpQn42gA+K7/wZCaOyDlhosSRMivnjTgTdw9Qsorl5pH9dsc0zizSQM4Q/Ij4EbeM2MWSmg90TmsBReEijFvE99iwpDbOpliHdIszRxugD5ZiYN7/ebuWnx656tk1gVGbveeMCR3lcKtdvDsi3QqqLg7GDwiFcrhXxan11KL8GxEwPlARJY4DGIVCdV4bFWa3ojfAOgza3SunSYvAs29QqdRilNDa3gTRt455nFjUqg7OzX25zM/b3OE8xNEcNjkw5Z2S5GPE9QvMoseiOZ1uHMnHA+S31MOjRhRJpdRILjOmGubpAMlqNydCTpnYvGuM67QIm3QRKQlcMKQmmUYMfdcClTHEaEA61ssNKT6w6D29a4aRbsB3a7rVitKIvideyLPOe/9IHBPD9TU2Ox1fOo+zHRHh5a9/xf/1f7rjP/2//mfux8IuzYyxkID9dosTuLxcMSx6LlYbfv7Xv+KHD5HD+CNzgr4TLhaebZ1YLoSrV19QRajjPSkVUp5Jk6UUT+csbj5Sa2VlHUsDF9bx+PaWh7tHTFjA9k675pJwdiBJJhirgoNxj3+mVU1jPOhzUmnFvKJWCX2+bBjUVy90uLpWb66SsdYTrG88Lh2F1KJ5gbLYMI9bHD1hoXwVE3qMDcTxqH5FpWKsxxiPcQHrO2zosWGF9QtMGPQZcQEwbVH2TZ1lwfbKD2mb/WkDeu6hyETzSTRaEFbrVGdUSuPYeYrJajJuHd53jOOENZ5hGHS8eFCunwIKliyVOeUzL9AZwUphmo/a3VuLlIqzQioV59TOxPuA9YZ+saBbrHD9Sj3a5oncq3TftTFUrZxRqhPt6LQAPuPEdRmRZiJbMtUKplG1TB/UpiLOlHlWtFuEmhLzYYtpVknHOTPnqhYOVhjnzG6c2QTDol/gRSAVUpxZX94wHbekrF5nlajKy05JKqHrtABIM9v7b6Hrud58CVU5s8ae3ATaE3tGrp7C5J97qEWL8gV1/VV+nrFqm+Cdx/rQGoolYu4odSJLwTqv2aA5cjUEHuZIrMJglRfrjbD0gd5aeiNMKWscWK181vUsN0qIr7ngpGBcK0yt+n4pp9WeuUinnNNSNHYrxUjKUe1+GuftOYcRwTW+pRZxcLIA0WZBPT5LKZq9bYQyJahZQYWG5jlnGceJw37k/nFi2Y3EIqSYWfWBnCsima7zDb1XrrdY2y51wtaqCkraONV3nB0VqyYrlFMhk9o+mDKofy+cuJTPPT4qko3zmG7ALS8VZOCI9Y6VKNfV1ZlLG3mXMjEWvDV0XpiLxXUDddRUnhibers22g+ekuAwjir0KxVHZo5QJOHb82qMMDg4Zm18DykjwRJToo6PMBdyucF0F1i/aM2zjtxLaU12GZ912rUpZQVRIUWrZWBqMCznfknFLrPmKfuBkpRCVtu/GdOkonEmjwdKqaTpqLxjUeHIYghq5zPrJMfWo1I4rKbP2HGL9w7sSp93IyqYMU0EkZoAqNHVxHodwxaNRf0pgeNPI3QlQguMBR39lXFHtSvAKupWtIiotSLeIc41dZzBdR1iHCYVqujPKscDUCE4NP1cjRrFWjQnNmBsjxQlBhYRRSB8h1ivVXnJMCwwpxMX5TOYVkVb7xk2l9hw6uqDfr5PsC1RxK/JpFMk10rxgbR/xOWE5Ii9/pw4J6q5x1CIjx+UXJkn3WidxrmUCofDTtU7zrVN25DHk7Q962fFkGJL2iiheZMVbOjou4FaZlKe8cGQamU87hiGwLC6oLu6puRIniKpNA+1NCtvqRSeG2Cd80gIHRweYSzUPJLMjPRC6DbUF2tefvVHXl33dElYR8fr2y27+UjdPvD5asF4HPmbf/XX+H6lRb6FftnjQ0fXFVbestlccLlZ0V2tmO3PwMN0/5403vPwuFWlXEwcS1I/QZxyeqaZ+t0HvvvNb7m6eYF0F6wuXzDt3tINHdEW6uODekY93OOuntfBSq2YkiGrXYeue0qYEDFaQAHGBly/xnZrTYKIo36NcQ1lpsXAGMQZvO90IRchTXtcv8F2C+Wc5gjFkGJk2t4R+g1+uCCsLzVmz4bG6VNCbK3qaq6bgmBaUr2iccp70rpd34fnH22sR2kxgQJYTWpJMyJqRVGNA+dxYUk0+3O3nnOGAtMUcaYVdQKxnooGITgPogKIXNFRFIa+M8wxEYw2OWEz4IMjLBb0m0u69RU2DKpOdF65tPLkTXZCp0qzL+ETihpTK6k8RZ6plYSQ59QsBAJSRD2n5gMpPlJTYr99YHd/R5orOWnCRyKTBDzCTe+hZg4xUQ5HzOBZD0s6b/HOk4yhFB0xF0kNzfH4rjvbZnShQ8KgdJLTvWz7mI7TT8iU5sn+pQVdTjoWK/mEQlfNwrZKHwhhoF/ekKYDfvOCbk6wO/D47g0G5UQNfcc2JWosdNYw5cJlr5tmKplihGNWvfTVEFhYHTESOvzqAvELnHkyEz6pVk8t6AmVPYNU7Z6VohmrpdafJIp/fKQcNS/T6Hr7ZImiv6daQ40nFKhFbllLtf6M1pSs42/TBsTOCIdDxAUhE9jNla4khsEqsb5WnOu0OcxaLLryEeLf6Bq5FKzVJpGqPmjW+rM4R6oWpGfbE2OoPxED9c+PE8XgVECKC3QXnxE2LxH5J4IXphQ5HCfmalh0QPOAHXNl1QeWnZrYL4cVrmYetpOmd4RATZloJtI8nu8PovFmMil4cWTCxJGwWjGEFdu4V/5ugjmO5OWK0Ak2XNLd/A391c8x/fL8PLRpNBrZ9sxxszEIjUdfCjkf1JopHlQQUrJOJBqCqhwlp0WgC5oW1KaIpcz63swjOSXEd5Sa1PlCKsuVJlVNuxHDgF6CSDYWlxO2v9D7e25UlF8bdx+0LLr6qtF6JkQ8Yr2KLpNaQ5UyMU9/vpD9yYJOFV4qIQdadbjWrrBbkeet2mkY7cgxaEGHGvnGElXdUis2rDHScvGmY4OeT4TmSC2zzrFtoAaPFIPxLf5CDGK8EhNDQFxAqm3+d7ZFkAllmigpEdavcIuC6TotyH1oTs7P3+Rq4/lZ5+jsmtRfMndvyNZAjrjhhloy8fBASSOhG8jpiBWHC2v1keLQNhynSSGNKL24uNYpXqykPEJOGLfEBEV5pEUN5SmpWgyhiKogQ030a1WJUaNm4vYdpupYNxOZH18z7+5w/SW4Dt2wn4fQ2cVAtoUct2Szwi4uIM3qt7TIGOlZLC+5fnXFizDw+zc75g97tgmSRP6qt1xfLpnHLSUX3r95x+22cnHz19huYDF4lpsVvrMsN1fUbkWyUQm4c2TwnqvNjtvxBx5TYqZSKBxKUYTQdlgH//Tbb/n1f/j3XH/1S+wiECgURrrFimIvyNO9dvPPtC2pFb2mqQWRy5mpoekmwejG7o6tW45M+3uMdaQ46pjBaPFXRU1ENT6m4DCUNGqShJZ6zPOB+ahh9iVG+uUFKR7AgAvLBsEPqjB3Qd85lMMjxTQvJeV9tTM4F59nJPv5TztQ9JTPakI1sDQWisJYuml2Qppb0kUL+M45kWIEKilHHd9JxhZNNkii3CAp6rsnRtERawp93+Gselj53p03Auc8PvRYt0BcRxeWVKdNnfEn1KNtwvV07p84dTz9jFMB4dVurtisdiZVe8V6OHB8/JH7N7+DODMd9qQUiVFIIlQDvcBchRlhEFh6hy2GOM8cXWFV1dpg2u0wpdB3HQJaUNXCsDz5fbaECgyh23Dx+S/bPa7ncy25KCIlpRUl7brxSTdd1+KSyRiKsSQRijEtkF63Tu97hvWlCgPmPcPlJYjg7h2SjyyDMBtYOCFnDckrNTP4gTlGDqmQsxCspbOGqyHgrcC0Jx6Vu2Sc1yZH9H2jjb8qNA+2PxV7iOgYUgU66ZMEIco/TRiTKEm5xWcHgFqxRZszGwwlxSb8aSNeMU1AMKrfGBUvlWUvlH5gmgtVMnMFZzqqNA+9dt9yjjjRMaoajafzJKCWVuTqq9aoE/6MHFqnfDyaL5/UqvvyJyh8qbXZf+hnsM7jhjXdzdf06wv2728p84hXO07GeORyEAYRpgJT0v1m2TkW/QJMJUVhN0WdSOXCNGVMVcrJYWpUksWSUo5s56hTPVOxsSMZi6TCOhhm6ShGG9IxW4rRIS8YjVU7+WOKir/U2ux5zXrNiZL2CGpWLKeYUr3KOsYtFRs6ijGQDVJss0WpwKwCBU4hCplcC6lx4K0zOhZ3ArOKFxdDwPVGrUtsh/NBEbbWjJUYKaE9H26pkxirVBcjS0XqqnrZVnHU0sSmxuGHzZ89139h5KoLq/VdMwPVoFpDAmtxqxdY36sfi1QKGel76jwisqJOk3oyFYMpM1U05NqEFnOSZkVDii5QVRSNEmc110yMjniqQo1SrI5JbNCRUkMwxFjO4em1ElY3mgPpulaMNoPK0wr+jCMndQVPueJWK3y34RDT00aZInG6I48PiBTyvEcsBKfEXtP11KiO89Z12GrOcSBznAluoFrNMay1YsoRFzZaWNQMNeMMOD9gquC7TlW1UjDDkvG4R7IQgqOIJ4vRfDvrKXni8PCe1cWXVKPdd8nPHLl2C5xYYq74ZUd2BrFLbNZifjpGOh/46udf8/BwJE93HI4HYk6IWKoN/Pyvf4WYxB+/+Y7jIYJbUfOR4Fdc3lyxvNjQLXq65QVjhNVwZP8oGAuPd/dk4zimwiFHalMyZtQz7BhnzHLFP/zuR/71//z/YX3zFWURCNdfIWnPPI0Mm0vKPmNzaZyc59zvVsyVglTboHi1caDqy19zVdTMzBzufiCOjxjxzbuuIK6Q86gZul75QFIrWeYG1wNZPevStEMEFpsrSspY3+P6FdZ35Bzphg327LLeECkpima7Bcao1L3KCSdASdicytBPOXIb8+g5n75XrFM7lmxJkhQFsyeSj8H2C9LuTo2xJy1qu751kzGr0t1ZNcQXlARcK95WDKoqLmWm7wLGWLw39H3HerNhffWCsLzCdQHX9bgwgO/BBW3gWsENNNUfKC/p+Sh8gaZoNWBP2Z0V4x016j0tOTdFvgaH3999YJ4r05SZx8o8ZaaU8cawcFClqvcajiSFVQh4I9RcCNaTDgecE8IQmMaRcUz0ix7fBeY0g1XbHTP0dOsrjHFnJAg5CVek3aeP/OdakfApR62ZOUZSqs1z3apIIEdMyVQB2w94ZvpyyfF4RU5HePjAmCt2fckqJw5zIgZPLIZdLCy7nlwrc07kWgnGsgyWrnMsgmvcSkfXFNwubHCdqlzFOH0W7Qk9k4+ELoVaLaVWci5M08Q0aUYwz1R1G+u1wW62L7pRt8YgF+VTts20omIZUysYR+hXzMZh5wljt6SmwL+7O3D94ophAZu+Z5wOrclfEmPBdu1+CY1Pl/DGYHyva39b82vh6T7KyXeuIa9ykkyYxttt/nGfAFJocQgVzd81Vsen3fKK7voLyjhSxok6TRST6AdLsZ4hZB7Hgk06aVkvlkgtpPmAmIpHmMaRXITgVDGcc1K7opyxVkeevTMko4rNOSkyOVh1xPDeQwgUyYwxEWNk3B94/PH3+M7TX72CftCGUxqA9MxzL3k8i1eqzJysW8TodKTmCW9nasw63mwj8ppV6ZzT3ApRq6N/H8hHSzVq+GyNIVhHNK753BX18DUVu1qpwNCov2NNkep6FWn2S6hVOZ2hb1X0FuMXSq8RpQ6VuKfagLH1DAr9ueOnR6621+pQbIvZqFBVwWOsw3UrRcbyjJBV/WEMtRuoZa9oXVVuBlajU6zz1ObvUucD1TnsYqPcOfnIp7sRvaU0v5mSML5T7p3CKfp1tSB49U8S9cxDNFxd3ADGEWfFeeTZUSGQUiLlzJwy2BXD+iWHxSXT/VtqhXg8NFKqcpqcqeRuQHu+rFF9EiixMh221KrjKR8G8uFIGtQ4M2eNv4nzETGdxvwgOJOpnceJp+9WyLBgPu7VUHI6qC9gyxb03mODZzo80i+X1PFAHg/UFugc2wvynCPOe0y1uM0LJEZsdcjqghrR7i4fcQ7mnPnuzWvePd7zmGeqGBKG+/1IzJXlMCDGsLm4wHULxjzSDerh54eeZCyrxZJ5f8SRkGlH5zw/zpYf3n/gEBOz0U7PVJhrJdaKKUK93WEq/Pbbt/zN3Y+srzZIv6TuJlxJFHG41RXMkVSeueA1iThpbnEuR3LcMj28UW4chml3Sxp3ymusutnv7l6z3x5YXlzhvOew3bJYbzCi3nSm+aT5fqP8j5RJ0z3d8gIRixsuyPOItYF+/ZKwusYNG0zXa7dmNfP1XGQZe+ZR0XJXlRwDiuLoxvZJQNWZh6U+caexlzb/umnYMEApxMO9juL6DSUm4nLLtDvQD54pqlH2cT8RjRrrAgiCrRXnNEOys4Jzgk7drC7mpdB5QwgO3wWwFt8PilI24Ye19ukdbjYWJ9+5WpvdSNuIn33u5mQNoYhVPmW7ijThi0E6jw8D3fKa+vYt0/7A4+NRERvncVKVAyhG7Y4MxJrZ+IGLziOm0llLmdSPz3gVBTgvhNCx2Wjx77xluVyoPUFVLiI0CxpjmqDsdEX138A0VPLTSnjQ+32cJ6YYSUlbAXOKUUx6HZxxJNdhQocfBuKhx3pP38Hx4Z4iA8NmBRZyPpJrZOkDgcggjmPK9EYQKWyGgJSIC4HgeshgcRjfxq3G6cSlFa0nMZagCt4iUEoizZHpeGQ6HDke98+ePgBQtFDMH9WAOefzmLeUTEWVtMZ6XUNFkNpRAwQstZ9woSMETzrqpbeqSWLROZwbSHPBOcikVjw4rPXKqXIt9eCkgDCtcEVFOkaekGdjDNZoQhIiZCpFWjFfVd387EMUkTrfZ6MG+HRL+qsvydsPpOPIVMHnop+FylQL10vPXC3GKjUA64gHA4etjpqlksdZgRjAdR5fDakI97s9i0GTeEouxGpwxuAExuGK23mmmzNXfiK3ZqZkiPfvmIPj8c1vWX31S8JqQ7VV0XNO+b7POe+AOENtzxZUpcqkqM2L80Bh3r7HDStMaK4ap4Y+q3VTTWrfkkvBdkucGZXHH0ekJMKwooqnROXhucUC0y81xswIMmwwweJXF9jhEumW1DhCTdSaKCKN19ns3ZqliZoit2QsTslb//+Pn6xwckm6yJcWUp2TypVPC2bJquQrTXJudO5MLSp+KBWKpaIZhs73KoUnN0WaVtrGBkQKIqruAGmVrD/Dq4LVyrW97GWeMV4z1nQB9ki/0RtVUMgSQ46JGicIvVbfzzzGeWTOmWwd2ToWq0v6i1fU7TuYIjkb0rQnxwlnvJo/lxnwDP2qkXiVKFrSTK0G5zpNDZj2ys/Ks6IAopyjOU7M4wFv1J8O6WBSzoW3TjNfxwPWaJZtkcI8TwzOK0qRIjVVynwgxSMYT6nq/TXH5ymCfOg1scMa0uOPmBd/pR1RcJhSmOZHbDDEXPiHP7znN/c7IpbB95BmtuOR4/GBmy9/xV/97d/hTcc4HXk4FIaF17EaqIowRspxC2XCmcRhfGA+bpmmHb3VMdJkRBf0mjApk61lVwoL43n74YFpGlmOe8Ra4u4e9h+otidcvmBKj7j657uZjw8lvWqmXgXi/pbj7bfEcUuDLxi37zhuP+C8RsO4MDAeRubxyLg7MKfKMATieMAaCKHTRdEGbDcgxlPrRI4zrl8Shgv88koRXNdhuwE3rJFu3eB+q9GlFMSpea4Rq7xQowtzQc5FnI4dpQFtzztvoMUfob5I1mlzZVqWYVG0GIHqFAkyvsMNK+y4xWAJXce4NwTjmMeJGCPeW6ZUoKhZuLO6OZc24nJW8EHd/heDhVzw3rBcNiWwFRWzS1FDwlOZ1sY5J16iCnPN+X0DwT4TpDMV5Uw1aybNL23WJUVzqvULLcUUbBfAOYwVnLWknLE2Mwyeq1g5JC0sO6vxfF2n72wInt4LDrRANBZrhVoMRnIzpa1Y1+n3WaHMO1KZlLdjrHKnjJyXXj3TkwpEN1H7iSrXUgrjeOQ4jqTW9JWiimM39NRaiPOEzYHQr+mXN8T5SJcK6+PMvP8d+8c7wnyg75dc3VwxHA+Aetk537E7TkwFht5APuBDYOgHfNfRbS4VAfReN6lT4kWL5NKxYitY2pgw56x2KfPMYTxwPB4+qaATY6CNXa05JYxUYoy4c/JQxAXdV6hVkR3rkTy359c3Yr9htzvy6tUlw2JgHI/EZjauFkj6Xrqhw9qAG/ozb6+VJEgGbMXaoNMEOdlyyBmRrbW0DNnaoq+0kbdWx5TPPU7iONO8/ErRyMN+eUG+/Ip5+54wjiyrZbc/Mk5HKoZx0sSj4D3BO6QkUkuFSjnhfNv3vcV628boirYdppnpOJEijFUY51ntetylZqbGzByPiPU8ZscqWOrqiuINOU/kksEF8rRviQ+ujT3LWSjzL593bd5uzQO3TfKM6zD9Srl16ajKZ07XqBW8NesI9oTaGYvvPHgok202bTOlgutXiAvEXKhVzvGLxltcv8QuN/oc+e5cWJaSdV2MR6xxbdxekbCAImqXUhKQyOOBJA7C+s+e608WdOVEHqBxanxQma1UjPFIrurNMh+V6xM6RdNqy5ssFUkgYYnknT6wtVDyjIbNG02UkMYRcR3YDuygvkxim6p2aFXridpkQLx6xkh78ayqkcT00BAy4y8paWxj2gE+wZtrHCfmtsBhDP7yJS9//X/mzXHLw+//c/OpSnTOateUI7WC9yrFVzGFKmDylMlkUiqYpLFlZX+PDcqzKrmQ0gTO03VLre7dQCoJjMLkKc8Y46gSSDVSjMOSEFc0juSo96EsFmQ7ENYvAXtWhU3T8yxb/OoG49cUa2E6KDkzao5pTBM5TYh02GHFw2FiN1e+Xq+5Wa/58OE9q+DpFxuWwwXL7pJqPOXuR/oy4lxEGHW0geewfWCaJgoGQ+bdmz/y9s1bvDFsBLpSuS2RYrQrMkbaxkWzQkhs3/7A1cuXjNOedPeGhx//wGUVhbMRjsfnnXephWKU86DweCDPU1Mo74jHB3KKzPstU90iziHHkZQTx3Fmv5/QYU3B2gW1RErRZqXUhCm6aNtVTxjULTzHI/PhFhfWMFic84owG+2EEUPNuRlPSyPFF5zrQZy6KtbTgLW2kYBSGHL6BBf52lA+qU8/r574aBUjRcfKVRGmEg+ao2hFbYaMxYeO6BMxZ3ywTM2mRJvphLiAkcpy0WPF4G3FB0MYerplR++NcsuWqgTuFkv1cTSio+u28Z7QC+rJwEAPjUKqSv145muuC7eo8Kp9k2m2SmKMxvmkFu3W4sG6riN6h/fKRXJiqN5w0UOIgWOMVOBqs+JiORCsJXS+IfET0+FAqAHKRBHDsBjo+x7bWd0QQ8AvVuQK/fIVxp5snprwgXZP2kauBXy7/58oigA4jnt2ux37w54UM/OUML1TXzsBEzy2RMxsCctLhpxI00zoB3wn+GDUF6sc6UymW3UUEXIJGp/oHHaxZjAZaysuz/je0V9e465WhKvPsL5vjUq7r/VkB6LnVesTQTKXwpwi4zyy2+8+GaETq0iNNG+/8tF9p42yT3j4Odu3lpZMYNTw3tIyei3rywuctRgDzhuQjK0W67XoK1NCcsU4XcO6pRrOykkt1viA9jRmNU4LDlEKkRZhOn06obMnsUahPlvsBpyfIx2te0QSxan4yXUL/PqGGiOlfstx3LEYNqRcSHMhp0I/LIHCcTpyOBzw/YAxOnkalr02Op1lf5wh69oVSkaGXlmgKVFK5XjQWCy7uqSS6F3LvrXCoqi/YSqJuRhiOWpDaRuSXnVUW8rz/SZVHTxR0ojpFg2ZS8ovn49NPeso4ihJ86RrbD631kMDlqgn1FIZeCZ0IBmTjtii+7+YoMi6UbWwoWKHFXaxpmJwXU+1yrkztWBcUP/ONiHQjkKtbUpM1DRShOaDqlY45Sf8dH+6oIuTwol22ew2DPV40LGBsRQytWrWp+kW52xVPY3YFKkRCR6JXvNG46EtmALeN8WejorELiCsqbQqvKqZHzmAa8gEGhpteqdjzJL0QtpO+XYlqt2J03ExyWC7tc6tPwGdno4H5lENT1OuFG/oNzcMFy/ZekM87JBSsQgpjZqn2oJ2rbekeNC5verfyFGVLSVqWHecI3bO+KC+OMYE9ePD4twCEasiYJP0es0R6wIleFUIDgPeB4SoHb+3pNoT40zoBmy3JOOYc2IcJ8bxeYWNLC5brNGMXV9hw4I4jhixxMOWvuuYtzNX6yU3i8DtMfP12vD1C4/ZF/71r3/Oz/7q13RmoQVG37MYR1LdYvJMuntLNgHpL5nGCevVdNOaQo17RCoWCKayMJYxJvZN1aVKy0rAsJbK1xdrunHHdPcOt+ypVlheX1OOD6TDA9I39/lnHEV0oa+Nw2P7Df3VV6SD2qLE457D3WvG/REReHg8MI4qwjnOiRACq4Vnc7Fmc/WSfrlW4Y816k9nPaBjvFqy8uNqpUwjxnTUqobSfom+EyINMRMKUb2PjNVQ55y007e+jWugVXvkXMmlfsQre8Y9Fy3mtPhSnk6pqU01FaGveW6m2lGD2UtWwvzlNSnNLNdrtBG2PD48Ki9QKll0lJdrofeB9XJFLhGnYATOqWgiDAOOSr++wLiA7xeqanXKeaqNB1vJrbkrurAp6VTNyaVqo/XMwqY0eyTBYKo9iwpqBVMqpmZyVcPmbnXFuP2eYbEgTxOC53A4MB8TMVa6viPWgqWnWIsPjs6rMW9wBQqKXkom1agNiVduzWEeqRkurq/wPhAWF2xe/Svs8iVIwNAybKu0tfN0y3Xjrw2SLJ/IoYPKfDyy3245Ho+M09hGzgaRSim60bmwUK6WNdR5ZOxWhNWK1cWlJiokfeZSPlDThAs9w2IFNdO/vFaqTBmhTNQxke0BMxj86hpjvXIGbdB7ULT50Xlim6hIAeyZvTPPkePxyPbxnnn8NISulIopT5SEUxEsRseYJbfhdVFv1Sr654o0Pq7amfhhQU4z69qTpoxIwXtHjDPiLGKl+coJtc7kVHEhnCcAPnRN0VpAIiI6VtNJFTqCO5man8QMtSgNSeSM1MknqFxrqWQMSYSA/gyxFr9cExeXuG5BsmCsTlNq7ZiiJsHEww7vRsR5fMm4UKm2MIVAtZ7V1UvM3TtsHxiuPuP+7pFpemQsWZul4Fl2Fu8D23FE8twy1yvBBUVIncN2Hc5ZqhGmbsmyX1DqrNzZM82i3ctnI3QgXq2izu9Ns7oSCrhex539EqLaZGkBrcb62lC061zUaFyaUr1ahwxrHafnZj5clKdoXaC6AdcvdXw6j9Q8KS9WHNbSDOKjgmdZwxVKPGJyQsJAiQ86yTQWEwYdy//E9OWnVa7Gqcq1qfWoKFyIjloRHXcYq+ozMYIUJfmr95RoCK3pwFrKvMOIem5JnqlWrUtqPKoapCyQnE8Mb3LcUWkcB4eStJubOLVS44zIgHivSEhRNYrxvS7/1WNLbqowHas899jt7hnHI/McKViqMVDkTKC1xhDnqTm3yzmWw4cB4zswlTge28NQcU7HKmmuZHRR6hc9/eqSPM5Yqz5VNU/a4Y4VgiPXjHOeai3FCkYE74ISWkOHFUeOs/orDT12uWZx9TXd5qUKCdp44rkInfWetD/A/o65FoxsifuoPlRWqH4BYSIMA4ves2AkHo788OMRoXBzfYHMe+IhYv2SKgEptkn9tZA3cyTFe8Y8s7z5nOAWdF1gYQy9NxxipjOQRHkWQwVjKqlYAkLnDX/z+QWvvn6JD448H+mWnoSSb9/94Q9cy5LFl7/AX3/xrPMuuVnTNKhdXE+3+YywvGaX/pF5/iOH/Z4cMxcvXvG7P77nbnfgcuhY9oGryxUXN9cMmyuc789G3NKirNL8gPE9cd4jVNKUiMfH1qWDbxl/CDr6qY0LV5uS23l1ZI8z5IoJ+rNPOZYn64oKTVH3CeKAms8ZiebEMWnjGRrJVxc5dPxYwUjF+0C3viLFiUke6XNmv9vjnKHzBqmFozbUeCOUmkh5xnUO5yxewNTMfNwxDx3deg1hwHQdtusxpqUvpKOqfvHaLJ4QDHlCLU/qN+WUPW+D16gvzs2CMS38O2ZVrRnN963DglCvsd0a33X4EMjFsA6Obd6RscxzwrcCrnOOVdfjUYuR/SGR80xvNMIs10qWFvPkMt545f3agPgev7zGLK517HIap594c9KKujNW15pj4BPqmnbOEOeZh4c7dvs943Ei5wQM1I/yKDFWN/LQkxaX9Msd4+qS4eKKnGbm8YjMBeudxr5R6Bah8aINadpCHBFTcV3PcPGKcPMFYXXBsL5mWL/A9itOCkIrOsmRiooE2rNdCqSYGA8H9tsdj48PzPMnmMW366XNinkCIExLphD9e0rjZgpKb6lCram5YzmyCH7YkOeJMh1wnZBzwRqH8ZYUo67TfaAYVEDoelxYYL1rzZzVsaE0EUaBKomcFNyoZ9X5CT1XEY+ppaHIJ33m8w8VcdAQ3RYTKBbTLekuX3F8uEIWK8xiRZczccwM/UL5lfNRqVLStYKm4kQYgqO6nhAscnOjqG5/wTFCmiNzqZSk8uexKZ1fLNUSZ54POBxTiqz7AR88w2rNZuExXlh//gsuv/ySYbXE9zpmrA2Zy82D9lmHNH7tiaJiHHXaY7BI0Jg6Yz1GqhZoArV5DpY4ckK/iy7GnOkfRnSNd6GJbNo4N06c0mfEeRKQUiS4k+F7S4EQdOoZj5CS1iw5URkx3RHjm0jJWH1uszazMf6FtiUFUSWp0agealKX+JOk32ihY7q1Vr9l1tzWip681bl1lZlqLXlWBZk0g1zKHtIE4toL5tRUD6sh2fmI7daq8qwGkxJmuQKrNiQiHeDUo6xWRHoNuhW0m2mcBOOV2Fri88dQ4/6e/eGBeR6ZYyFlTyrK/TPeMh5y674qphq1aHBqrmzRYGZpIwIA5x0lq0K0oMhklYIJDsmJFBO5JrJ1YAp1PkA2Op5OgLOUfoFfrpCScRZKnlTOnWaSFOzFEvqlxkP1ayK6uIzHI8fd9lnnPe8fkDlRD/fkOjEfd5AWyFKQmvClAxtYrzf8D//2F4zH33KcCotFzy9eGa5WM/fv/gmTelY3X+DDgnGemaeJDnT0UCvHux+gW0K+JE87Li/WvPriZ3z39j+TKRwTjGQKwso4XjjH7ZQZMPy7L674v/8//iNffHlNvnvNdP+GMt6pynSccC6Qx4n4uKe7eZ5XkY5XSnvRVHwjYYWUSHf1JVcIYnvGx3fElLm+umDwwsXFgvXFJSEEutWafv2CsNgw7z+QpgljhOmwp5aM6xYcd3d450hJbSB8v2p8MIPvl42HKufxiyrnK8V1SFFekUL7T1YLnCgLov+ttO7nH7VZQCjn5+TJdrY4bRt6h+0qeT5qGsd0QJgbGrPBpEqaRkKnhscxav5taKMSZxoaUiLed5h+oPeoGqyJEWzocCHgFhvc8ko5LU0AJY08XooS161osaVW3DqKPHXNz61sqnyUmXgq6nRp09FyAebUxrkOHxb4fsHiomD9gcN2hwuBlbfcpy25Vi7XA6YI3jj1g4yRw3FEDPSDxznBWcdyvWK7e8D42jpwvedhucEvb3DdCuN6vc9GN3TaZqDcssYtlhOXsPF+PvGIKXL3cMvD4yP7w4F5nsmlIFYwThEkMRYnkEskLJYMmwumwyvS/p6FsYTDjjiOlBiZ50SJE7YWwuYFUjMyLDHDgO0X1Brxiw1+fUW/eYkPS+VcnYrnUigxqmVVaQhZ86jJOTONI4fHB+7v7ri9+3C2y3nuIaDnVrWYV+BRfcpqVpPnUhNSnCKDBkqNmKqealUE6wMle8JiTS2ReTwgSQu+6oJyrEolxYmuW2BsoF9f4ZcXavfjOlzoGm+3tCbpSehwzhyvjb7b9lqxOparJxoUTwjjc4455Taq1CtRm2m4s5662LB69SvifKTkonYusmWcEiKRVArznDAm4rtAnCdimvHGYpwh77fkbom1gemwpcQj1YBvcYQpV+Z5poaeoV+xn45M84HB91wHjzcV+qC51tYw3HzBF7/6H7j+8ueY3J6HNoWgZZ/+VKbpx0eOkzpqNPeBeTwoLbdUnDhV46eRNO9bJFxRqpHzSnOqWkyVeFSksCo4odMWLfwV6NIgA0SZ/1J04uadwZnmHlCS+uvSU5Jat4lxVFOfHDRKocx7XcfS2IIR0M9kO8xPPO8/LYrIMylOZKkYCtQZa/25m5da1f/HPsUO1TYCwaj4Aduh5DcHfqGpDi5gxJPjpF1wt1BFremoeHWpnx8Bi8kFd1KO1oysVIUnJWOHZXuuTx5O6s2jmWsJCU29R+ak5Hvusd/fs32853A4MM0zqQRKtbjlBueXePOo1ihGWuGK5rrWI6RCjhGBs4lgTC0fsipfzgpInUmT/rlUcDY0noBQa6QWp6bE+0eM7+hFEJM1e26xIE0TzjpKSdjlQLd5xeLzX9JtXoEJ5Gp0PHE4sN8+r6CzoafkiTxNpOmOdLzHLV6BKxzv3mNKT12ucJuX/N2//zeMuz1vH2ZeXK94ed3RrxzjoTJOhem4w/sd++lILZpBO+3vifsj08N3XH71r7Emk6e3+M1n/PLf/B2v377jwz/9hjFbxqoiCOOEldUYppfLwP/0f/q3fP7rX5H27wHwmyXjYUc5HPDOs3n1inl+oB4Dtuyfdd4xRVLK5+DrU3A5ztNff01Y37C4+Tnj/WseX/8T28dH+k64fnHN6vpL1FpHPYI0MFsYLl4Rxz1xeodx+lzWNHHY3mm+qw/IYBWdCR02DE02b5o4iLZptzGQPG3gDbLWxbk5qCuK0fy5PoFbUz4eabesTE5FUiOpg6XYgJGJUgUxHuMdphiNjAq+LVhqhu2DZ6hG0yxQjqux6nHWGWGxHjgcR3oKaY4cZM+VvML0i7PSTHzQDlUMYoJODNoYuFSVPX2s8q3Q+CXPfNFFR5lnY2K9GCANqRQAo7xhEuPje6xV3t9x/0gtmWG5gOIYpxlTMy9eXDDtJzUcb42dlcLQBVJKuCAMw4BzFe8NvnP06xuKVEy/ZLj4imH9Gcbr9a1GFYlFzrjAU0Pdzl2bEXn+ef/JvS/cP3zg/v6e/X7POI7EmHSE1DzLNCS8UKvBu8CwuGBcbkhXnykNZDOT9nv2t2+QuoOwImwu6K42Z1TLLV/ihpVSKqxluXnJcPkCawes75o9jz53JWteqqJ0hmoqpgolRsb9I9vHe+7uP3B390FJ859y3tagLDlBctHpU6k41PWsinyUSuAUKWvK76xKCDWGt4EsDu8X2GoornnEGUsqCXFCPVRcWOCHJcarz17o1ljbaRPiHLQc9NJypM+3uChyLrm2a9H+snkPViyFQqnPL+LzlFqWrSd7S3PiRv31FnSbz1i92GNtx7FU4DUpP0AzzkUyeR5ZXlzg8qxcOWewveX+fs/j9oAPHaHvCf3ANM7aeNhCJWnWe55JDFTrGYLDOQcWxFZ88PhyJNee9Wc/4/LLv6K/eIWgJsK2iWVKgZx49hSi1ko5efflWekeYqjpoOrlpE1hTRmCNCFYpX7kXSvGKcffmMYB10ADcaLPhwuaVT+3nHYRsKhnJqigqZVi0lDfk7r+VA/VNKnVmusoueKCJvbUnKgUTSaKSvP5c8dPFnQpt8q0JCgj1KyGhD6ocrSqjFxKBOk5Cxdw+PFRY7tM8/CqFbEtry4LUgRxGhmGXyB+CU5jwUo8tllzwFYab0BvADkpX8447Waqkjx1U9MLn0vkZB6o2Yxef+9PhNr+82M87ni4u2W7feA4HkllCd4z3HzB+NnPyGUkYpRgaZXbR1ElVimxbcCq9pFasdYzHQ/Kk6jqLh68w1bdQHKZCK6jVkFMJSfU20wMvg+ERRtvTA0BRfBiSHEk9D3u8gr6nrC6YfPZL5lNzzQldvcPHPZ7Hh/vn3Xe1g0QINx8gdmp8GIqiaG3DBdXlGKxnXINVlcb/u4//Jq/NQs6a7A1E2UiTncccyJu98jhj4g4rK2UemQcR17//vd4l7j+4shSIi5UbBjpw8xf//VnfPfuW97cJixCEMfFsmdRJ64D/PwXL/jy51/hbIEyE1YL6qYj3LykjDPWVfq+4/juLWInxsO7Z513jDMxZXKVM3VYY3kqUj0mGLwNGO9J4wNf/OKX5KhmlSkeNPJl/YJuecG0zywuX1KLph+YriOOs4aRG6vw+9DhujV+WDNsXtKvb3SQdi6gOKNOrYrh5Javi4kW/idiNY3zkWtWPtNPvPT//CiFMzH3VDCapiKlluZUn5XA1Ion2njXlIx1HrGGfrXkMl2w31qcC9y/f2C/Ta1QAuMNzuuI2aaZaVSV+Jwqi9CdN1nTUjRK8tjON0PhZq5sdYPP+clt/aniLedr9JxDmkUEVCymEcxbdmsFql7znApiOxZXP2N6+JEU32OswwZLnYWYonpQGo9xFt85UsvynGPBO005ESOEoSN0Tps0Y/DdwOrl59RaGFZXLF/8TJHh5rlnlIGvH7iezpMWAyZt49GR83NVf6fjNJre7x55//4D9w/37LY7LjYbus5jsJQTTeWjwlmcZ3nxOZTK2G9Ih0eSvaMQGW8rfrVhuP5KyfAu4FocYb+51kZJBB8G+mGD8QEfmmG0PvA6AnOBU3avWi9F9rsdjw/33D/c8u7dD+x3d5/EnwNFo6W9T1UKRnTilFszZFrRJu2dEhxiC7XMijT7JaUmbC64MGLIZKeFRs1Zp0LTCFZR9Qa/KiporCYeOUf1Xr/WFUw9JWMoPUfEgOFcaDSWnypoJWPdgLEfNSHPPGLKKnJIiTjPCnic7qmADQOLq6/JqVCOD9SY8LGwGB4p40gqYL3Qd4F4tEiZ6F0HwRCCMMSImROdS9TSt7x3yAVWVrB9RzIeWzO7MbLqPX3vKXPiUGZW8UB1Hc45NheXhMUG0/eqhj2JIkBNfUsh5ec97zlHHalS1eLPOaRALYYcj1jfQ202NRWlOTgt6LWob4Xviexg1Y+0ItQ0qwq16mRR1ymPqKeMAiTiVTjaaDMYD65XJXi/ADIlbtX27eQ76jrE9ZoNHkcoUdOP4gT8ebeOnyzo5nkmxhFfj3jX5vhpbAq83GBMXfw1O9KCCYCo8pKECUvqNKGbkkrGa6kU0QzKWgzGryEEtRBIE1UyxnVYBFNQ7hwG6dbNGFKr45IKplsqD8Er168AYiLin8iTIk7VIuPuWQ8AwDwdeLx7x3675XDYM04bFt4RFjesXv2SmiNH+yPMO9I4QdQIIBElseMcve9AIB41YN45zzQlnDM476lSmOOBYdg0vhD4EKi1kOqMtYaUEmFYkxHmlAhhwHrtbGqLqQK0+A0bli9+DosXJOmZjkfGKbLdbrm/v3vWeafDhJdKWV0gkiAdsdNMno5U8fjOUedH5sMOycLF5Uv8+nPicYsAXVeopqfIHdgeawP7MuCCpWy/IzjD3IjHIgeWgyGEFblOZIl8+VngP/5f/g3/63/9nj++/kCQwr/9cs0XL79gGTyvfvYF6+uetH9QKwdXIU8srr+ES+06c5xZbwr7t69xi5fPvN8TKWdybSa7voM2jhNEeWvGUX2gW10hNZHGHWk+Qkm4fkm3eUFYXdNtrjV2rZzsPwrj/p44qSBo8+pLcjxoYdMt6NYvsItLXLcEUT4VDWY/G8f+iaLHnF/8U5enC5Gc3fNTfn5B16oXzmNbPuLPnT6D0RFUadwjwWFqILfPYQRC1xO6npKV7xScxSwXGotTK8UUHd3FxLzdUeOECZ5+6Fiu1upF5nxbNiu1Rkq2jUbx0fkb1SGWpugFnqYGufDsLFcal6gKtYC6bmmMmaa+nZIghJo9i8ufE4+PhH7PcnOJGMt8LOR6xHdavMUYsaLd/u1uy7BQscecIt0Q8L0n9N3pBcD1SzYvfkG/viHVhB+uNXJMPEreaEVbqQ2tVOlGyeWpyAcdD/4FCB3AeDzw4cNb7h8eebh/4HK9oet7+l4NnzUCyWkDmSKeCotCFdRH8SIxH+5xFy8Im3fYbsCEDdZpuomxln61YbG+1tEh4ELAd4NSdqxvyHRR1OiEnJkToqEK0XmaOOwPPNw/8u7tW6bx+PSsPvNQHnVtqRQ6eTqNukqtrcDjaeKEUodKdVqgGEFKxXiP7QfEVkq0La83616kbHf65Y0qta3BDQu1BLIO44e2T6IFXONfYUTNrlPCWnvm8bVHpY3d1N6LBlh8CnFySuo3mHNpcZCcrVrUCshihxX9xecQD6Q402OoOakYZcrsjhGOM7E6TNeTBWQ8crHsMTjutwem+x1j3FH9QHCQkyGmhHOBzgVKhXWoWEk6thW4HnpsGcF4utXAMKwxYcD5gDvXF1of5yrkCvGZTWsuGeM75FS5tmsp3ULzgvXB0MLbNB/GEhtvsrX3bVRtvFJizutOVS0BRpTT73v1DKwnEZcirSUnbViairmWBDkqX9TQ1r2lii5yRhjJYXiiv2SdHlVx5J8o236yoDvu7phdpuuNKnRch4hr1aioHYixTwaJqNO2aUiEPqSqzGOeoCSsDWcnbLzX1IjliloLOU8IGrdljEfGEdMPaltymlW7DjEegm8h6BNiAmQD3kPOGNuDKIfBmKojkwr18LwwX4AUI/f3b7i/vWX3uOV4dU1c9oR+zcWXf0NOszpTzjNpe8v08B6ZFAs2VpibR09pCJyxqNVDexGtE4wPTPNEjgXnO4hHctTxrOs0IUPjdDtVFqYICU3n8L7N560qgMPA+tVf01/9jOwGYrLMVTjkwsPDI/d375913lWkiSkSmEqxDtdBGUdMUB+19HjAtuvrHdjpHkQwyw1x2rJY30Dy2MWKEAz7yZBS5t2tdtmdK1xcdAwLhw1QcyA/viEsNrwIn3GxuuaLlz/j//v//n9y3B34cqj88ldfc3FxTVitkc6wDAPzY0RSZR4nfNxT8FjXYfoNJmX6GDGr62ed9zyPyguZZvJQKK55TUmlWjXErbmRamtVqwXj6dcvlePlA93mFW6xVgS7jcVKnDQE+/41NUUdZVGZth8IwwVhda2doBgwQQt763Xkd9poWiaixoqdRBAniw05TeAouZBjJsbI/EwRTPsNT4UjbfOo531Ne1NjlNcq6gl5NlHwHTJPuG4BCMvLF7iwp6SMN8J+vyPGRC1CyhOFzHJQH0WSsHnxilg9F9cXhH6J9aGNKUrz5nII7szLNf8MlRDUm6zBO09jyWccJw5TPWUrCpB1Ez9RNFzfkWMm7TM1Q5pnqniM71isLEZ0RJl3lThHdo+P2KpB3H3f4b1AKlhvGIaelCLVwOL6mloLdnGJX1wSrr5k4XqstIQRMWfk9YSIKnpznr9zcvNQdPYvK+dUQJN5/+EH3r//wP6rrzlMM6s5E4I6gKrPXQWDmrDWgjWJEC7wQXOJ03LDvHnJuPlSGxWrBYuxDiM6euz6Nb4blNzvLDYsVIRhwplErglAShw7mevWKsRUOB5n7h8e+eHN97x5/8MnodB/crTC0cjJmPokEGjPvzVn9Nc001+xipbXktEox54aoooc5kiMR/WS9J5SBvI4Ynyv1lTeYcNS90LjVbhnWzpH1eQI1w1NsV7P9+R8/mjCkAuBlA35xPUUe+ZoP+c4HA7MU6RkTd0pjatrrG1NS8aIw/me7uIrpMBjKpTDPeaV5XD3gVK3+MHRB8e4L+ynTK0Tl6sluRrudkfGrHy9YWER17P9cEcWT8mVTiKDydxcLjkeZw45EkJAEGwIDJ3HW39eX9Qzr5lMV6UwpJiJKTPPz7v/xvVNXKDm3EJB0qTKaqOTP23cq/L4a5Pgl6mlRTjEBWosjb8foR7bu6n7e8lRx6XSkY8PWCtN5DRgcsQ6p+JOJYpo850jJU2NF10QMiVNFGnWWWnG2g7xS6rtkEmdNcxPeMr+ZEE3HfdMHQxG42tM4xfUPLfw8AJ5bD4tGk6rrsu0KIuEcR0iai1CHKlxUrStzaOlU8lwKSq4MNZg3AJJBVzFNEl7lRb/ZZtBsHh9CMushZy0uJY2K1dOt6WWSXk1rqdubp735KML/fbhLXfv33LY7hinmbkUhn5B71+xebVXr7jxwCEm4vZOPyMas2XyRB6Pmsfn7Nl8sVsEUpqhOnJJBN9hnMcveub7zHTYEdOM21wpLO4dsUTqdFCEJIGputH5qxWuhb+vXvyaF3/9H2Dxgmw981w4Hie22wfu7t5y9+G75z38oUfqhJkOpFLwfU/ZPRKGRXvQMsJEmTMYcFTG7Y/Y5TVlEhhHwsUrpBpy34MFH++Yx0dCsLDqMEfPzRfXXN58jjEF5xz9558jy1eMH27Jq0rfbfkf/9VnUDzXr15y8/XfYMVQZMIaR44HTGfAL3FZyNOoRqFWc1ZLyfj1BbJ83j2fDnviNJGyoizB++Zery9tbaan1vf0V1+oz1xqFgvoyMsOa4wfGplWOW3iOnq0CM/zkTweiOMjixc/Y3n5pS76i0vEt9gjY5uXe+vYmxACMSfAX+kF55hqHQXQiLupZOaYPqmg036s6DuIQG1O9lY32NK88M61kmmjqGQwzuH6QXn7VYswF3pqynRdT7dasb+/BzEYe6nkbyuEYWDc7gnek0tgdXGN6wKQFNVpnnzSLTGuV5EVlZLrGZzUj9PQxdZjntGOZxy5FkzVDFSx9iyOECOKfNeChICtnlw10m159SXz4ZZSM/N0S6ojuc4IlWmauX3IjDnxxfXAwjeDZCzFCH4IeA+IJQwrDadfXoHv8P1l49Ho6AZxZ9TGVDBY6slaRkQzIU+orPAnBflzj5M9QymF+/sPvH7zA3cPv+Dl8cA8T6TU4W1Dsqyihcag49CgljwVHVf5siQsM6vNS212W1MgThtTi9PNSRyhG1oOsHIqjXUNHTmd0ukenlIdZqY4s91vub2/4/Xr73l8uP0kD7Y/Pe/SlLT1afxa9XmvWRHaAi0d6ammBuW2Gpmp2ePsQBaDMxrTBCDOIMlgO9ui8zpsWOg1Mx5a7q5Gd9VGx7HnWC79fU/l+emeVgAjWFRlXmprOj7BquZwODBOo0ZPJk9xtFx6afQN4TS1d92SsryiW11iza85fnhNzoVkA5df/Q3TfoffP2Du3jHPKlaZjxFHpubMenD4OpMyBAPWGpwIkvZcr1Z0i04zVo+j5vx2PdZWNquBdVCOvFT1glNzMHRcXCoxJeZZ7aKeddgWoWjUFod4QNIRwqDcuZI02hQgT019rCjMqZAsANZT86xiUKucYbEntLTx6PNReZguKA/4FDGXM6UY6knB3cbvUNoEsmuetwFrve4F84HaW8QOQFUbOKd7/587frKgOxyPjL0hdoa+zEisWkyVA9iJs09cW+DVRV0LFzmZRdI85mhvq6N5RbWur2ZqVtTDWCVn6tgpYp3yavRCR/37gpoMGoNIDwS9MGf/KQ0mL1HHnLUU5eblSjpbADzvOB4eeff+R+7u79ntdozxiqE6Or9gef0LQtgwPrzlePstZuiIOUOK5PGgObApqo9YrcSY6YalVvgGTDW4KlTpwIBfXFBi4XA84DpHiYVaKtZbRCKlZqwzWG9UVJEjfrkgV0O3fsnw6q8wi1dEG4jFMMaJx92Wh/t7bt/9yP7x7bPOWcKavD8y7e/weWYeVdBSvFqnODuQxkdSKizWL6kP7wihozpDdj3h1SvM9TXSWeYcoVamaYs1E+vVwBSFzmy4uN5gg8V7QULAhAChQzZrqghpKfy1+3fY2iHe4BZCtYYOD9USM4T1gHGO7Yf3mLBRBZmp5LNNgme8ffOs8949fmA8fsY0jcQ8nADhNnqxnBIYxHXYhWZsljQhOUKZdXxoHOL8k0ioCiIOt7TYYaPmltNWF2LXIVW95EwYGmeoCR3QV8XYRt6WE32goQa1Oc3X3BoZfS1iKcQ4M41Hpun47Odc85Z1UbPGns1WaWOpUvJHYynRz9j4JeYkVPABcdeU8YgLKu4xvsfMC6zrkVOzZ1R2v7h8Qeq2rG4u6UvF9gtcCMpv6dZIt4SwQNzQRryKzOX0ZCgqTdRgpKkjS0Fci8p6xiGptIgrjzGKWljnIKugwZiGiPoBE1p03+KalA/IUQvXcveBPB2xNTPNidfbkTkXLheOwXpNyBGh73tNDrGZEALVWNaXXxIuXrG8+lqnDBgdbDRT3Y+xRlXj6r+d4uTyP8tzff6o+b8/juOe73/8htdv/5pXL19wsVnTdQHpe5yTp3W4URKkX2Bz443po0JJkRoKJxuVUlqclbEaf3QqQKwikCduNY23Vk1VP67WpDTNNSkl9vs9tw/3/Pj2NT/88D3TOLbrUv/k///Fey56LiUlNfNtNkWmKsm+1IJF/cG0QZQnVXmp+jmLFmHV9FCFYgvOhhYhJsCkr6oVnUAZC+JbgWfbe3VKOlCq0pNpNH9SqJ5QutO/iWnrSjXngvy5x2G/53iYmOdITpmT1ZFec3WgoFZo6l3p1Ars8PY3uODpO4uYNS6slFdaE97C4f49+92MzROfXfRseoP3HbVWxjFzsJUqmXXnyH3H9VdfQkxYmVn4QBKDMZnFYmCxGFguFtRpSx731OVGkz2aVUlMmXmamA5HDvvnCf3yfNS9oToMhZImTJ4xtW/qYaMecG3KSE1atGFIOeuUJWjxXShPdJiaoZQzoqs1oW2TQ/XIxeraZ516jaaUONm7qZgzU8UpNa1aYFQqSYw4Y5A4IdZrniwq2PipR/0nC7rdfsu4CsxZVZsxbhUtCAPl4Rbbr/VCoXwTa4LOio2oL531TVmiqh9Eu2CpqCVBy2YUo5YQujBpDBACpht0I0nKizEmUOcjajrZ6RjK9XAiGpwq6hipRdQJmghiKDkR4ye4alcdoXx4/x23b1/z8OUXXO2uWS0GsrOEfk2wjpRHzLDQDc0n4jRjugX9eqA7HhjnEaFoykKOeOdw3uNKYpoSFEUUmSeqc/TrK3J8hJwoRTMwS4wsLjbEnHChQ0xGyKoYvHrF53/7H1l89ivqcEGqjjEmDvsD28cH7t+/5/2P3zHuH5913oI6W3f+r0jvviWsPFglXucaMUm/JvQduEq1QFnTrV5hLl+RbUcsE26hRst5HOkXlnisLFeXzGniUA+UOgIz07Rn0Xc47ylSsKsFaTrQiaNeXmAYcDUy/vg9/ddfI97hTEfoF2psTWRxeUM2hvjwgXi8oxhD51ckHPu7D886793+qOaqxyMprcmlkDFqaSDSkBO0iGl2EqckJhMCtVuqMtX6xjtSUiztuRWEbFqRY6yaA7e4vKeGR5sa7fiMqttKUr6UeeJTndJKFaVrXLc2ppliYpwmjuPz6QWVeh7fqWowN7m+csrOStJmN1TEYMRTfMCUGRMWLe2jUH2nXl05YfoV/bQnLdeUPKvlgxvIUig2cBEuWG0GrLWYbqVqzppx/QrbrRW1tLo+NDYWxjXLAD5yij/taW1c9Wzkpi3giog0NbE5/ZOhiDsLI1wIVCPkfFCBh7GIsewfj+zutlQc5EJOiViF41yIfWJhBzrvcL3DeotfDvqMuEC3fkV39TXSrZQDDBgbyDQzZzStlVIwRccyxatnGUbpEeU0gS0CnyiKOKM/VfnI7958z3fff8eXn33O5eU1y8UlrgNvbJtIG+U51wQpq02KdcrvoWK9OSOciLRxbYX8xBMTp4UNcjLqbWhza8atAZrDWkWIMbLb7bi7u+Pdu7d89/0fefv+x3Nyx6ceak2jBX8pqpRG6lntbDRv7sz/U1PhlihSdUxrnObzgsNUh8RRR8slU/NECIPGZjbzb3Fe0wcadeHkgWdKownUinWt0DtxttDn2LTivpyf7VmBDVR1/Cn8wd3DI/vdlnnaqI/baY1BrV80hhOUuxmQ0MPVl8y791TzR2wY6ILBWmH92a853v3A/od/wIXA5trCuuO4OyibqtcCd552XAz6nJiSuby6Zn1zRR4Ty84xj48ksZTxyOZiQVgMUCMpPp7nD8qEEEqFOEemceTh/R95/8Pvn3fixirCn2dOo3xsp/MOo82gih00a1fXZfT+GUuW2mgopfF2Fb03TdV88v/UGK/mwuFCCzrQtQUTMM4SjCM3jrRxfcuNDZSs63dpYtMaI8Y3UVRRcKeKO6t8/9zxkwXd4/7AGK9JxZJNR7e+1CLMWNJ4UCWcu2gdiL4IRjTi5+TyLS1/UuM7CjXOWni5AZx5IvXSZtjtBReno0hyVf7CsFH4vkRoSzpGED+Q4qSLofgWnjtqSoTzLYIpknIiPjPPFPTFryWzvXvN2zff8eXdX3Gz3bLerBn8Am89zhWs1fiuOieNyu5XdNefI5KZ3n+PSer+3IVFGyeIooU0gyFTKTWT4wEp0C0vmA8ViaMiI0bHU1jLELyGDA9r/OICs7hh89W/YfH5r2C4oRhLipVjLOz3M/e3j7x+8wPv3n9zzhj8l45SBfwKu7rBGY+JE9PuA9YV8jRSpkcECJ1jPLzHSGa4+RlzWIFVPyFzPFBsBeMQIl1vYCpYW1itlszvUX+deMA4T64RUiJbg+tXeMnED3eExQJnB6btlv7qBYvrV4yPt5QaqflIzhHIirDUzHH3gXq4g8WKbAe6vqP3/bPOe7vbsj+qRc00qy+gDx7TCi0FyHQBEPFtvNdTTTNQPWUqtjzQc+PcjM0EsEYXi4pgz4rKJ5NYqZWSoo6gjKr7KoI0o2yasrNiz9FPtRTIEzHOzFNiPOyY5ondM7tXaOjGaZzHaaOvrUDQSs80bqU0o9fSFJcqSOoaYV/IpiGVtSB2pFiNPaqlB+ubesvx4X7H9edfELz6OtnQNaPfCmGN+AXGPSl4z+MxY/RzlSdkpoKuJbUVDc+MhCmlYBsn7aSaPasbjeWUY32+TlRs6HH9mni8J00T2+3Ifj9xedURgqr6elMJHkIQQtAUFCQhvmK7BX64Ynn9c/z6M3xYtSzrhlLZllxxIus3I1VzRgBOdLoW/3UqtutHz+Az7/mfIJ21sts98O0ff8/Pv/oFN9efsV5f44eO4EzT4bTJCE7fi6LIC1RspRUg2tzT4tp0lll1ra5ZjZxLgTbON96dz12Lm1NSgipbD4eR7eOO29tbfvjhR7795ncc9rtPVrd+dOKUmrVYOO09Z5SwcadOdi3//Nlr9amaAIsyHrLBhRXGVEwuHHfqZGBCwLhBuYQNlZPaGjNpz6oxWBxVSkMuld5wuh9qTs6ZJ1eKFrFCJZdMrUbH2888Hh4PPD7uOBwTi1kIqeBcxtpTvmylOnu+LlIF1pesPv8l6fhADj12cYMZXupUYLqj3rwg5YIbVuRxJH7zj1rY1gmp0PcO3y/OhsuL3uHzjJWKGXqWF0uEmVLWmG5gePElvu9ZXH+NX162sT6klFV0lIUYK4djYf/4PEsqrRvm87tNtSBBEyKMgLSsamN16kLVBr6NS41TgVwpWekn6Ki3isF3C528VJ06IoJxtXl7zgpQlUJJjTrjA94FinVUcdSGzOc8E8cDZZ4w4uAUNxgjVrz+3pyVN/kTz/5PFnT3j4+MqTBXR6w6ZjHWIiSMG7Qa9R00BKLmrKTPNmdWc99WtEmn5jE0pI6WJiEWkVMQsyIWrpn06UuUtTispXH1VDUkNYFpHXzrYAtq5Kd2E1p1G9eTp0LMMMXnx6SAVuTH/SPvfvwj796+5eVnn3N1+YJxWCrHqs4IBR/W+OWaKb5HnFDinhwjOVfCMLQiLpPnGVLC+o6CoVoIzmvVPY0Usfje6/ixFnqppBqxfc9idUlOI3XoWbz8OZef/yu65Q2Ll7+g9hdU55lTZUyFw2Hk9u6Wd+9e8/r737G7f4OX5y2AdrlA4gTpSLaWebunTKPmTFqnGZOrDYfDXmXgfkHqA2Z9he964vaDgjleORII9GEJXUSyEnIXlxvm/R1p/0Dne5wVyCMSD1BmzPqK4bOfM+cZM0UW/UjywnzYU+JIuL4i9QOhjfFrnMnbWxbLDff7dwwm0/UdU56Q/s9LvD8+dts7dttHjoc94+HIuFjgc4d1ro1erXblRiNeyOpVJE5HjloE6KandC8VMZwFBjVj8Nr1Vc4+c43tr5tdPKoFRRgw/eJsjl2RZq7bVFi0TaVtRNVYUoFxHDkcDuy3j2wf7j7xWW/jnKe/aZvrE1oAtA7UNoaDV2S6ZMR02oW391uFUprRW53yQ8QaTFiRSkXCzLC6agVuxTgNMzdiW8xPu46o4aYBSuuUtRfSIuFEbC+ltngsWnHwLx+mZC2iMkArBK1+vxqwiiLlNZ83dSte+cHG8PjhHTmP9IuOYTFg7w94Z1laYd0HLtY91hlc6OlXA/3lDcvNZwzrVyxufo5bXqhNEM1B3ui1kypUK7ou5qKm7E8KCABKMU+j2VqprWj61ONjlC6nxOvXf+T33/yeFzefsVhv1F7HCH1nceHE2WqWUJyeD80jrS1K6kQ1kDayR0STYsSfgh9UrdhQtiJPat1TcHpBmKbIfnfg9sMdr1+/5g9/+C1vXn9LTp+2jn98lFopZIzYxo0qOGlcOesVJW9pRyklvA8455qtj9BeXh31G5BqWyFkNIe3zKR5pyN0MUpNO6WrOI14LBSk1KaoRMPZyynNqDbCXG3vQCNgtPrxNCalVi0in0+h4/bunofHR7a7A6uLmSENpKTJHM4aRNR1rdon4VUNPf3Vl7xwS+L2LUU8YgZyGSHvEVupxuH8ivHhHZdf7FnnSJwj4+GIn0ZEPNYozQAKval0Ny/UfH9YYHXezRwnrr/6WxbXnzO8/BmuH8AaUlG7lVwqMWf2hyMP2wOPh8OzzjvOB7wxDezRwttY0f2p8R/Fh1bIxZbLXpAUtRg3VpWrLb+9FM2WFYQ8H1WlXRKlKBDgXPMHdc1vENH1vuifa63Kfe82amkyHYjHnY6+bU/MmtVrnUbulappG6U2QCD/eXDmJwu697fveNh+zdXFzLLrOI4/Ypcr7Ooae/0lxlmV6bbOiqxKsFoydhigKDqlfkKWSm4qvkYMRGCOzVhQMEV0fFXSeWNQbkhzX3YO67wKIUpEZKPBxzlTa6bOe6oNYAc1aiqqUKliifPMcfd82xJo04KUeP/2G17/8C2vvviSq8sbVqslnfc447DdJVevfsnxwx8Q99CIng/NiDOi5oOBsLpm//ZHjA345VoTHtDMzVrRayWeeNyDZMKwpBtWTHGPXSyQiytCGFhffk64+oqXf/XvMf0Fpt+Qu8CcKtOkSrDt4yN37295+8P3vPnhN8zHPX7xzEzTvIV4hDRrNqQ5Eoaekys99gZsoHMWmSckC5gETijiEO+QYQV5xqSM6zfUZBk+3xAf7/B9YFhdsX37BzqrSRjzcUfo1lAycX9P9/JLSAWfDRZh2hVsEWyZIXiKMRivsWe1wJwiiYTvB1Y3L8jTDGnGGKFff/as894+3rJ9uONw2DKOI9M00/UJ55wicLW2bkuj6U4xMMoRUjsDYw21BTLXU0cPbYLyRNYX8zEnCRB1x69ZDX7necI6j/NPqtbTeEqhElqjpD9gngpzFo7TzHGc2O13PD7ePvcx18JMfNugT3/XPis69jjtMR+jRBjlB+U049oIUmP3dDxn3ExhQHLWAq9lLN/efuDq1Rea8WmVNyhoUgDWtnM+kca12Kk0aKRIs+w4g5/tEzbURJ4/hiri2vmVj7p3va6FiKBB6AbITsdnVQzD5Vccd7cMqwUvP7umVIf3HuM+MHjhZj1wc71meXVB6BeEEPDLDZdf/gpM19JEbpqfptVNpipd5MSdq1U0X9Irl4cTB5kTx+xUiLXzl3p+vj7l+O9Quu093/z+H3jx4gWr1UDXO6wkhBUKIllKbVo90bFfEVG+WOMdinjKmQNY1HNUTp9T0TjXiu+TLYOu91owlirEmDiMM7e3t7x+/T1/+OYbvvnDb9jvt5/Mm/v4OFEoSvudJ1EICM4kqLahcPoulJLAePWTNDruVoBCR64auF3OCF/YvMJOK+VdnVTpJ85c0W8hFVWqWkcRTRNyRtFgqbp1nbzwKkXtqRqPrJTcQJWTbdHzGlaAd+/f8v79W66ur+nsTN/9Em+WGGOwpp5R/9Nx8gFMdcBfdZiF5jVLLGQKftgQ7r/HGh0nm6CCRT+smUdVgd59/09q+N6vGV58QYkz48MH7LDEe0/oN+CdGhZ3KzY/+zcsrl+qSMk0vvSsQsM5ZcZx4vEwcXd/z/vb561xOResdWelawEtiMXolKeoKbQ5qYypUHJbsjW3vrbrUeOs62FRIZXSYbRhrzmqaKZRvxQEsIi4hmYbzZs2FglLxAUsjqk4chGwnhxnUtZnTcJC0UWawbFUctZ94s8dP13Q3b/n/e1bbq6uWNqKmT/QSSUsN0i/4eSXxTmqZNZF2KiHkooYIqoOUlSilIhUixiv6hIa8U8cYnt9sU0b11qPpKS5ata2uCztCCiJWiNlFiUhxi152iLdWos4G7TjSYUUE9M0sd8/r6L/+Ki1sn18zw/f/YbPvvoZ1zcvWG5WWG8wnWUYNnSXn7N68Uslxs474uN7mEdi1GiuznpyzVjv6NYXuOsbpg/v1PLFWOZ5btYUiWoM/XqJXV4wXH1Fl2ck9Fz+7F9j/ILl5gX9zdeY5QtFPoyQEaYEhynz+LDn9v0t73/8nh+/+S3b9z9oPtxzF7+kXIJaJqQWjUP3HRAwQfBikTwTH3aUw55gPfnhDSFsKOtAFoXwjVjKmIiAWw5Ek7FygfE9oVsSDzvK4VGLoRqRYWBYbBgfbgH1AUrH9xS7gpefI91Cu6T7W3I6UPdqiVBsh/eVaArZCqZcUc1EtULOR6b5eRy67eMtD/cfFKW7OjCOR4Y+kINThTIWamqbavNTbN2ztAQH7Z4bkqUPD9AwlRN8D20k2HhwrSgR1yGDqt2cGKzrWkNjziMhEdssNk6jSEMumVgKc4pM88w4Hthu73m8e56hMqCjL9M2Jp42d3OKnDqhQ8IZSZKiI2ElejmmlPCihrCmfe5qqlI0ytzc+R2HlLA+MAwXaOSfb19LG0edUDe9iMpNOXFY/lkkWftTaR+9tpSH5xd0Am3selY7NjWMjjWVrFaNetEZqloJFGF58Yrx4ppuuYHqODx+4OZ6g3GOzXrF5Ytrrr74Ss15c2T14iv6q6/w3SWEDoxyTKsRrHGcrZxEy2cFvmwDw7SIOzMnT2PlZoKtyJz9S+q5PznULiPx+u23/O73v+X66iXDcsXQLVSF6D3BOmrVrFsjVYUDxjQfTW1I8kn0ZppXmghi8vn+CabxSPVeKiilzUpBG7T94cj9wyNvP3zgux++5ze/+a+8ffPdX25V0o6nZJGqHNcTwhtHagRxK8SU88hTxFDS6ZlrxbQIOc/Y9t4XabFrzcTe9Z5kducCvJ4RyhYXpR38mW9oTlZEpbRrocVGaUgcDblrpUajA6lF2Kfc9NdvvuOzt5/z6uUXLDvHcbuncxZnFXn2tHVATtnN+pxZpx6p1gXlkOWKKTpmtYsNVB0PlgpYz+rlL8lxJM2jWjYZT7d8gRkGxHSUPOOHDTb0ECPxuMMtV4SLl4T1BcY5jfUrqmzNuTDNiWkc2e0OPNw98OH9Le/fPk/wFmNU1KygxVVzxMilaLa8sU9r9QnxrpUaM6YKeT7oOmY9NgycaI5PvLuqok3jsTZgjE4GsR01zlQy2IW+686Cc1QMtRr9vrjlMM2UeY+3jiJGhTklYdGEmUprQDWD78+e67/Aodvz9v07vnj5GRfB0BnPHCPdfMD5AQmBk99cSXMrUJqxcDkVdu2lzWpXYk6bWcs5E2/UW8Vpt1rmERNW4Huo6awWET9o9VxA/KI5NBe9WDlpuPq01U3T9GBV9RVj4rg/sN/v2B6fN3P/+FAux8y7H37LD3/8OS9evGK9WhFCwJkFtgsMy5e8+tv/G4cPv+f2u/8CZDVI9oHj7TssoqHqPmD6pZKivUWiV6uXWkhFcwT7ZcBfvcSuNtjlJevLF4TFFZsv/w43bKBbUsMAzrZUCkOOlTnCvo1a37z+ge++/Q0//vF/Yzw88PEG+C8dbvMZedzp+HCOhPVLxAeoPVUC5EQ8vsaKZtVlrNrM1ISxmYqQDzuKKYirlHlSb5+Ym+LLcbj7QN7tmfcPrF5ek9MEtjDNe3I+YKcttrvExzV+cUU2A8711O0D0dziXIfpFgr7u0ja7zANEu+WGya3U0GJ65kPD8867/3+gfuH9zw83HG5fWC5WLLoPJ13eLfSl76ocbGiVK2DLqpSkpaDelKsUXKjFDyNRqUZZFYBSsNY5CMETEQtshqaddpDnlh29WmM1TbHlGGOiePxwH6/Z7tTz8GH++cXdGfOHP89YsPpX3KBWv7k3zWnOtEteu4ejty9fsdnX36ti1ZFLVjCgJiNPivNCuizl59rg3aaFxmUM1gVAqxWVNRUT/Xkk2hDBVFPRGHaFIzz1zzfvqO2OL7qbOvYRaMJW3khqJVFBu2YT55TVvD9Bd3NX2kc36yqthefJ5bXicXVZ1xc3tD3C6QKSWaGm18Q1q+wrqd2nSrc0fPWxT0rAvzxPRHTno38z+7H0+drX6zXrf7lKtfTBl4rHI97/vCHf+Dq6obV+oJ+WGKDbwiDIYQO64Kq/Dgho83K5nzT2s9sn/dkBi1YRcFKOz+hCYcMqQjzHNntDzw8PvDmzWu+//47fvvb3/DNN//EOH16Q/7fnWf73zMSKq1wL4kiBif6/ok9qcuLCnw+Hn/CGQlWU31HFa/Iz3mzfcK2jTE4VxFsa64LuSZtfKs7F3G5iSAauK9CGGOhmuaTZp6sVTih/c8/99vbN7x584Yvv7zn6uoFh8PMYjnj5ye6w1kUdB7Fn2sdLXAr+syeOJiNYiIls/zyb1m8+mXb94U8Hhk2n2kYgesxi5VSM4xorF9LbyhxxviA9Zq0IlbX1pQLpdlIzVPieBx5fHjg/bu3/PDmNW9ef/+s845RPRWd6P4kRf9fi2Jp9K+WJ20dYoKuDcZTYkRo+dAnTq3vMU55bdigwFLV9cT5AWMdElb6tVaaXU1HSVHFnO2alZTUgD7PdLawK3A8bFkMA6broRbipIh0ybllwBpwiz97rj9Z0I1p5u3te96+/Z6Nh37VE82GJA5vlC+jcOSJL6TQpPF96zJ1hFHFQpmUmFiT8oR837pz5VvpIq1Ge4iS0avubpjFhapGSlKxg+1bC+00f+3EeTg+Yk0HfYWayGlmPE4c55n9ceL+4XmbO/D0wAJU2D+857s//D0vXnzOermh65VH553HtA52GQIxzRxsoDLC/Y+UeYQ5Y6kY35EP99QSyVOklpEE9KslRTQeLLz8is1X/5puccVw8RnLl19j+gU1bJB+pailCFiopjBnOMyV3X7kcbvl9t1bfvz+G/74h/+N2/e/I+e5vZTPRC2KeuwwFkqN2LAiloh3ASMLxBTSrDmTUcB1vUaBmRlJB4xAqU01RcGmSI0VK0JJhbBw1BDobq64mz8Q91tCt1DfOjJhOVDThFsFoumY5yPSDUTJmM7iVxeYEskVpFuBmQnrV1ANJkfGNGkHNOmLuNxcP+u84zTxePeOuw9vub68YbVas1x0dEOHiz1daIaQbeaotYh211KLZjIKZx4UVk1Iqc037bQZi6rnait6KEXfn5bEIN6iRK5TpXIq/FQy9FRQqY9anGbG45HD/sBh98jj3R0PH97y+PD8gk43B/0ctOzKKubJP7wNeE5ogCJhVe91EVKMrDYX6uUXI65f6UZX1MKoigUyd6/fcP3qc/WpE+14a9sgzj++WQDYppQtzfoHhFpN23B0bHfituk3Gx2NGzilp/xLR46p5UMqYd2YZo7S+GAanK5oThHRsbJ1iAFTC+sv/i3kSj7uqH4B/luulxuWN1/TDUvqeESqobu8pg4rNR71XWuQTiCrVbNqI0+KxpMQ4iP3lVMc2ynBoqDmsif7j3N38L/z0M2jcH/3ln/8x//CsLjAOdcKF6tmzxScrbiWd6ujOc6FnHp6GaWclIY2mdMNftonTiHzYioxF2Iq7A4H7u7vePfmLd9/+y2/+ce/5x/+8T/zeP/hTwQqf+mhFJfm+l/gZKtluwVtFkctei9OYIS0zV+sPTcOqvA9oWiodZFRTritysEUFIFTD7NwLuAlJZ1gFOVjCYZqtGEq7WvyCSWWFr9mpK0djQZwMiOvz1ez7x/v+eH77/j8i59zc/WCq6trFssB7xPOZqypSLLYBhacOLRPOc9FCfsi7d0D6/zZaqaaQnUOcZpkZEOHrDfkHLVZsU6VxTaoGb4IpqopuFivqk7b1qJqSGkkjSPTITImYft44Pb2jndv3/DD93/g/YfXzzrvFBOloOtQnql51glIiWA6zdhu744W75YiTgtO2ymw1LxGjdN89TxHLbCK8ugRj+k8xg1Iy+Q+caK1eEw6dRoT4izSrTR44HhHnkeojuVyxdAFcsrnBh7bU+e9UrRsAOf4KZnrTxZ0uRTuHu/54cdvufQw1FcsLm4YcsWXDHlCjfEMiFNUxIfm2VPOUnV9e9UcsMYR44Nmnp0l06gT8zRDU3iQTyHhKrwQ68jjrFJg2kjG9wiJEhs3ri3uJU5UJ0zTpMH0u0cet/d8uP2UTU4PaZ8/pcjbH3/PN797yWZzzbBcsuh7glcTQAmesLji6hf/nourz9jefkeMiXB5JN3f4/qekooiicdHXFgQo2Nx/Qo6z+byJcYvufnF/4i/+Iz1zddIGDD9CjE9EhZ63UQ74ERlmoX9VNmOid1x4u7DPW+//4Hvfvf3vP7mvzGPe86r7DMPU4BcmXePVDNhrCf4HqmWYpIKA8pMyhHpF7jlpfLtpkf1Iewu9SGsExwOxMcHjOl0tOoN8yHjNtdESSxWF6TdI4hGLA3LNdPxQcdaRohkTCkwHon3bwmdp0QBSRoMEi4Rb8jVI3GipB3sJ1IqmJIoJeqY9hlHzoXd4y33t2+4v3nF+vKSxWpJGAasnzDW4o192lTENoSimf+KdtMncU/lY6RIENN4WqdRSa00FQVtZ9aCBaHWk68YJ5hIX/CKLv5tNJhiZByPHPZ7dtstjw8P3H14y/3taw67T2lecivm4IQs/MmID+UJ1uZHV6p6aBkjuuA13tTVi6+4f/eG4eK6Za4q0Zha+PD2HYvlmsVyA5zQmicxgMaLtWK4fQxToJiGpLQy5jTy0lrAPEXwnDbe+nzbklKLTgmqqGk1J0RQi43axmGSVDxRqIjvCDiyMdiuJ84z1ViWQ8/y5mvNePXqqcci4fueai21xT4pMumaDZMiW5ogcOLFPT0zem9OXmP1XAQpB4zG6zw59NWPvvcvOz72Ncsp8vr1H+j/YUnXhWZ+m8k5c3V1zTCoObAxNPTqtNKcbEgANBEkpUS15jzCl3NxB7UKsRidpIzKjXr37h3ffvst//Sbf+C//f1/4u3rb8npT2kjf6nKNedMSWpSr8jo6ecYcIZSIgZHzgUxLQdUWvPQ7Gp0TCzQ/Butadyoqs3EeVyrn5ScC8ZZfd5O96sarAnkRkk6jZ9LLSosbKjdSQB0RuXlhJ6reCTn51+HaT7y5s0f+eH7r3n18hWXV1cslgNd53HOYp3GbHmxp9AKalXPPaoQ08mrrfHPam0CgEpp9KHCya7PIkHZxJYeQRX9pWSMa+/BeWs6dTf6DJeiSU1pnjnu9swRDsfM/cMD79+95/sfvue7b//Abnv3rPMexyPBW2zxlPEe13X6/lgdvdLi7axVv9pcG83DNGTcWM1OVpMbcpzJKeJCr4ipGNywVg6x7RHXU9rIueYKJFI1mHpsVmw6iSzGQZoQY7FuoZZvFLzvzo2AUJSPWnQKKSWSJfzZc/0XC7pxnnhze8+riys2yzWbDIsMoapZpFhpcTwncqhps+VOuw/fn0cE4DTCrvGJKBnj2oerUI3HiPpyqUN00S6hZKjSlEMWMEh/pS+kZLAdpoJbvqSKp1YhpcQUM4cpqcP43Xt+fPvjsx6A0/Hx6KbWyri/57tv/p715WcM6zV9P+C8xxiv0m8/0C00mHxtHK5bcLj6isOH7xgf31IPe8QZrHW4sECGwOqLv2H94pfs71+zvP6Cm69+DcMKG66p3mPbQyNGIX1jtIubo3CMhv0xsX088v7te15//3v+8Ie/54+/+1/Z3r0+Wx58ypElkucHrG/ddIxaYHi0GJ13lMMOpkgXHCZPQGY+PBCGC9RSY1CZdsrYKWOGAXO1ospEPewg7umC42AEbFUuDjPj/VsFaEJg3v5ITiMmebqbAWMnSiywWCFugXO2oTTKvLH9kuOD5rtKmkjHO/URy8/LcgXNtLz78CO315+xubpmWK3xXY9rgdHGd9QKzrXnV542UuVVK0qkvm6tHJLmFtfGgjQkWy0mVJ2oRZpVr7UWtK6gS/M8QuXq0pStGqOVmcaJ42HPbrdjv9/z8HDH3YfXPN69Jc7PtzPQWLFWgJ5mm62oOQ2OTgu5gmjSFFeiSIGqmjDdgHWWeRrpF8szavR4r1Y3m8ur87jGNksGQdGbs1BEPlrjEV10S9Fn2bQhVm3j1pMispSGYH7akVICMdiGtvDRPTuPXUWexBolIy4ABdM2PRoRnBKxGYx32G6BmKoNqA9k0Ego9NkWTmOl2tSST8X/OYqqoV/nIkueOI7QblFRC47aLthz7Vqec9QK8zjy3R//Ad8QulwTpZm7bi6vWPa9FgNo2gt/sl4CqN2JqXIWJmuNou9IRtGTcTyyP6ilxocP73j9/Q/89ne/5b/91//E93/8LemjZ/kvtitpx9nTsCixvxSj40brqI0TeBrJxqiB6DoVqahQR9RyhIrBNq1KacrehsRgFeFNuZleJ6Rq5J+aLdeWoaocNS3OAJFzrnA9XcSTSuIkmmjil5LauszzzfJLLjzcv+e7737Hy8+/5PL6JcuLS/re45xgrPrvWamEhga2q4ZOIxy5FLzTgtOaUxWvGL6zKtQoYonjoRk3N14eKN8yiZo1cxLyaFP3JDTRIjVnIWXDnAy7/YH7hz3v33/gxzdv+OO33/D2zbekZ7pWHA4HdaUoicEvMP0SoSpAckLdW7Gp6CCIs+1+5Wbmm5W7b71aS9UMJSEk/XsGKJlSZ/Jxq2uCseTxAaoKicRWahyp1pHiRMoJKy2rmtwoVGq9Zpyah6u3nVWz9ZZOlMOfFzj+ZEFXaiWVzN3hwI8PO65fZK7nmeU008UZ0/c461Hbv0pt8UFWRE/yhFaUpJYj1iKlZbDWgtigMLLRgsU4Of3ipgLNiOuoqVIdkEVJgVaVqxWdW1Og0iH+CvGBaj0Zy5QO7Hb33D984M271/z45odnPQCn42O+EOgLcf/+B775zX9hsbygCz02aGdizQbNueoI/Uvcdcdm/YKLL/4V0+Geu2/+C/m45xi3eNPhrSc7w9XP/z2Ly8+5+vrvFJFbXoDzGL9WGNoaxBV9tUohF2Ge4TjDYUzsHkfubh95/fo1f/zdb/jDP/4vvP3hn8hxfOLcfMIiWOZHZHoklQjHHdYnjB/IGIwdlLSPo0QhjztiesBdXeMuXmG7DSlHqIKXBcVvMH7GL6/Il9fU7Y8QeuKHd+y++z02bbEXS1JMmFRYrlakeSLbQCqTJkkselh4bP85tsxKno+Z7Bw57bHSKdztO/puSS0Qt3ekacSvbhDpnn2vU0483r/nw/sfWF+/ZLG+pOsGgg8477BiCU55QkUaEqGVz5NlyWn0JRpYT80tpkda0LOGmtNGr4K0QqWpGK1V78VyituqTR13KiCFlLKaR08zu92e7XbL/f0tt+9fc/vhe/a7u08cT33sSab/3chNIFbHe63IqFIAq2pzWoFlnwqSbrkixRmRFQCHw5797oHPv/jiCYk7UQCqonJS26Z1Qi+aJ5aKXU/j1tK0Vy3VohWfJ9Sqnigen8Chy7m5thuhEp6ugTVIPtkqqR9ZbU2r2Ao8icGs81p8zVE3ueBxXaCmCEF5xFZQzzHndO3K7VzbTFXO178VdVYL20JDYxoiWc+FX/MlM008UZ82zf8jjic+XeV42PPN7/8rFc2YznNR8c2cuby4ZNF3DEOH9wXrrQoFTiRzATCKsp75Z2oHkooh5onpqKrs+/s77t6/5/Xr1/+/9s6st43kCqOnlu4m2aJEyYZnBgHylP//V/I4wQSxR0skWaRFUtx6qSUPt5qSMfFAngQYCKjzJoCAmt3Frlt3+T4+fvwXP//8d65//Qdts/+q/eVlL+EfQSud7qPYS2mt00aukz/qi7WjxKlHpCwcpiyTF7Nch/diT6W0PR5UQhQ5EemDFV058VxO8hVxKMFFUW/QQ3k33XcUMXrJggepiChE40+ljF1UCu97rKpS3vb19F3D57srri4/cTF7x+m0ZlJorJVBFV1YmUlUCjskzlJvpTGG0CcRXYYMV5TDnOY4pau04dBsieUIO5o8T8+mtQzIIQmFdwdi6DHVCcO7LQQJppump+lhvd3y5fELn+/vuLr6levLf7LbrCjLb2eqXrLZ7SmMoTq/INhxaiGJIluCkmpSjCKrFp1UStK7hAgRR/ROZFaMF5kSLdaE0XfErsENgz7BSZLD9lJZMRbX9bIelJX7Fkm6coFYioYnvk3rQovbUMoex9DJAGkEFcDrZB36DX4/Q5fS+m3fcf/4yIf3P3DxtGM8OaVqe0wxoogRU1Ri5+X7NKWaeme8kx+O6IiLkB5ihm2SgrZGRtVj30iKNzipMkVpHldlLY2UpIZl/WyQ7H0HShNUKQrLlGAszgUOTSq1rlfM57fc3t+wfmWKFmA2mx0XzFcbhIaumbOcf2L1fsbZ2YST8YSqkincsqhk8y3fYdUM5RqKkxnV6TluucK5hup0Rr99Qo8Lyou/oqoaqwuUKQkqNZ8qJdlHlSbtSE3wSZ6k7SLNoWH/tGazvGX95ZrF/CPt0zX12FKX58dLjjFS1/Wrvnc9qWhbizY1PkTs7ARtKqye4IPGlu/oQ0ffRgoucG6HPv2J0V/+hvKKGFpcSM/v9IxeT7GzmWjUFRGDhXhJt7hnOj1nNHuPPnlP9e5H0IYqOnRxAtWY0G0JLlJMz7F2imt3IvhYi4EzbglexuV9V9HoiLMVqu84O/8BVZ6iR6/P0BHh0Ox5XNwyPf/AyemM8WgsshNFiTUyfaWT0v2xbDpksIap0GNGCzlBD43SqRwTg/TMiW5aSB9/ETToSOhSudg1smEYsc3yEXrvaQ979rstm6c1T+sli/kdi4d/s3q8/y4fV4DH5ZxDc5Dq3zEgkiBqCBSk3yWInZ2Px1P10BittUyq6hiJOA7zOTEEPt/d8eGnH3lcbVB6Jxuo98dtyGh77L869hhJqzTRJSHPiGQxSKVWpb7a2EPKKg7XtNu9fvhJen8lC2fSYIsYeEsQGzTSD5kuUKXJSNlg01CA1UQjPX+mKtFlQTAGq0tpR0nrQZlhwg4pU5vne/viiiTg0DqV8r8OTs0LWzMJvDSDvNP32EDVdf2bz3/r7xgDD/efMFrhupbNdsVmtWJ5Ic4543pKVY0pCo01RhrbpVAvBhbRo9IhPShw3uFdpGn30i6w27FeLlksHri5ueHy0y8sHq7QOjKZTH4TwP23gG48fp0s0+7Q0Dux9cL34uAQowx5qHQo805Ep3WSzAleqhNNS1FKCVYOWiKqbG2JUpoQg7yvdSnPt+8lkDNKBqeGQ0gamCKCT562KayX/x+SMC3uqOkXtRJ3mRAZPEkVjuY7pn7ruk6l84b5wxXXVxdUpaJvNmzW55zNpozHhvF0SjWaYIky/PYiOezTfTkeNiTief49JnmOZv8ESlNWo+ce2eOzU6ndSol1qIqgHnEupG4rJdZeTcduu2exeODz/QPXl5fc3nzksF8yGo1e/cybwx43mdC7gPMe4yKFFRkYkxQDVOpnxHuULcQeLPmkG6VwbSOH8GKS3nHD4a9KTrMyLasVBC+ZU9+1uK4FFGYQnDfSPqa9x7u9DEwM1Q5THt9zse+IrmUQ3A5R4hxVVPTb1Te/q/pfU9iZTCaTyWQymT+X/1+ePpPJZDKZTCbzp5ADukwmk8lkMpk3Tg7oMplMJpPJZN44OaDLZDKZTCaTeePkgC6TyWQymUzmjZMDukwmk8lkMpk3zn8ANbuhjffL5/sAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Predictions on the test data\n",
+ "helper.predictions(test_data, model, 10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "train_coef = history.history['dice_coef']\n",
+ "val_coef = history.history['val_dice_coef']\n",
+ "\n",
+ "\n",
+ "epochs = range(6)\n",
+ "\n",
+ "plt.figure()\n",
+ "plt.plot(epochs, train_coef, 'r', label='Train Dice')\n",
+ "plt.plot(epochs, val_coef, 'b', label='Validation Dice')\n",
+ "plt.title('Train vs Validation Dice')\n",
+ "plt.xlabel('Epoch')\n",
+ "plt.ylabel('Dice Accuracy')\n",
+ "plt.ylim([0.5, 1])\n",
+ "plt.legend()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "9/9 [==============================] - 2s 211ms/step - loss: 0.3530 - dice_coef: 0.7590 - accuracy: 0.8926\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Testing our model against Test set\n",
+ "results = model.evaluate(test_data.batch(32))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.804764514561205\n"
+ ]
+ }
+ ],
+ "source": [
+ "#We find the average dice coefficient for all the images in test data set using\n",
+ "#our model prediction\n",
+ "helper.average_dice(test_data, model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/recognition/44672139_topic_recognition/helper.py b/recognition/44672139_topic_recognition/helper.py
new file mode 100644
index 0000000000..749849e8dd
--- /dev/null
+++ b/recognition/44672139_topic_recognition/helper.py
@@ -0,0 +1,152 @@
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import numpy as np
+import glob
+
+
+def shuffle_map_data(images, masks):
+ data = tf.data.Dataset.from_tensor_slices((images, masks))
+ #shuffling data
+ data = data.shuffle(len(images))
+ #we apply transformation to our dataset
+ data = data.map(map_fn)
+ return data
+
+def split_data(files, masks, ratio1, ratio2):
+ num_images = len(masks)
+
+ #The number of images in our validation and test set
+ val_test_size = int(num_images*ratio1)
+
+ #array of files that contains the validation and test images
+ val_test_images = files[:val_test_size]
+ #array of files for the training images
+ train_images = files[val_test_size:]
+ #array of files that contains the validation and test maks
+ val_test_masks = masks[:val_test_size]
+ #array of files for the masks images
+ train_masks = masks[val_test_size:]
+
+ #The number that will split validation and test
+ split = int(len(val_test_masks)*ratio2)
+ #perform same as above except on the smaller validation and test
+ val_masks = val_test_masks[split:]
+ val_images = val_test_images[split:]
+ test_masks = val_test_masks[:split]
+ test_images = val_test_images[:split]
+ return train_images, train_masks, val_masks, val_images, test_masks, test_images
+
+#Converting image and mask files to data ararys
+def map_fn(image_fp, mask_fp):
+ #reading data from file and decoding
+ image = tf.io.read_file(image_fp)
+ image = tf.image.decode_jpeg(image, channels=3)
+ #rezising all the images to (512, 512)
+ image = tf.image.resize(image, (512, 512))
+ image = tf.cast(image, tf.float32) /255.0
+
+ #reading data from file and decoding
+ mask = tf.io.read_file(mask_fp)
+ mask = tf.image.decode_png(mask, channels=1)
+ #rezising all the masks to (512, 512)
+ mask = tf.image.resize(mask, (512, 512))
+ #one hot encoding
+ mask = mask == [0, 255]
+ mask = tf.cast(mask, tf.uint8)
+ return image, mask
+
+#metrics used for model, smooth is used so we don't have a value of 0 for overlap
+def dice_coef(true, pred, smooth=1):
+ #true mask
+ true1 = tf.keras.backend.flatten(true)
+ #prediction mask
+ pred1 = tf.keras.backend.flatten(pred)
+ #Pixels that overlap and are equal in both images
+ overlap = tf.keras.backend.sum(true1 * pred1)+smooth
+ #Total number of pixels in the image
+ totalPixels = (tf.keras.backend.sum(true1) + tf.keras.backend.sum(pred1))+smooth
+ return (2 * overlap) / totalPixels
+
+def convolution(inputs, filters):
+ c1 = tf.keras.layers.Conv2D(filters, (3, 3), padding='same', activation='relu')(inputs)
+ return tf.keras.layers.Conv2D(filters, (3, 3), padding='same', activation='relu')(c1)
+
+def unet():
+ inputs = tf.keras.layers.Input(shape=(512, 512, 3))
+
+
+ #Contraction path
+ c1 = convolution(inputs, 4)
+
+
+ c2 = tf.keras.layers.MaxPooling2D()(c1)
+ c2 = convolution(c2, 8)
+
+ c3 = tf.keras.layers.MaxPooling2D()(c2)
+ c3 = convolution(c3, 16)
+
+ c4 = tf.keras.layers.MaxPooling2D()(c3)
+ c4 = convolution(c4, 32)
+
+ c5 = tf.keras.layers.MaxPooling2D()(c4)
+ c5 = convolution(c5, 64)
+
+ #Expanding path
+ c6 = tf.keras.layers.Conv2DTranspose(32, (2, 2), strides =(2, 2), padding='same')(c5)
+ c6 = tf.keras.layers.concatenate([c6, c4])
+ c6 = convolution(c6, 32)
+
+ c7 = tf.keras.layers.Conv2DTranspose(16, (2, 2), strides =(2, 2),padding='same')(c6)
+ c7 = tf.keras.layers.concatenate([c7, c3])
+ c7 = convolution(c7, 16)
+
+ c8 = tf.keras.layers.Conv2DTranspose(8, (2, 2), strides =(2, 2),padding='same')(c7)
+ c8 = tf.keras.layers.concatenate([c8, c2])
+ c8 = convolution(c8, 8)
+
+ c9 = tf.keras.layers.Conv2DTranspose(4, (2, 2), strides =(2, 2),padding='same')(c8)
+ c9 = tf.keras.layers.concatenate([c9, c1])
+ c9 = convolution(c9, 4)
+
+ #we use sigmoid because only black and white pixels
+ outputs = tf.keras.layers.Conv2D(2, (1,1), activation='sigmoid')(c9)
+
+ return tf.keras.Model(inputs=inputs, outputs=outputs)
+
+def predictions(data, model, num=4):
+ image_batch, mask_batch = next(iter(data.batch(num)))
+
+ #input images
+ plt.figure(figsize =(11, 11))
+ for i in range(num):
+ plt.subplot(2, num, i+1)
+ #plot real images
+ plt.imshow(image_batch[i])
+ plt.axis('off')
+ #prediction using our model
+ predict = model.predict(image_batch)
+ plt.figure(figsize = (11, 11))
+ for i in range(num):
+ plt.subplot(2, num, i+1)
+ #plotting true mask
+ plt.imshow(tf.argmax(mask_batch[i], axis=-1), cmap = 'gray')
+ plt.axis('off')
+ plt.figure(figsize = (11, 11))
+ for i in range(num):
+ plt.subplot(2, num, i+1)
+ #plotting prediction mask
+ plt.imshow(tf.argmax(predict[i], axis=-1), cmap = 'gray')
+ plt.axis('off')
+ print("Dice coefficient for images left to right")
+ for i in range(num):
+ text = "Dice Coefficient image {num} :{dice}"
+ print(text.format(num = i+1, dice = dice_coef(tf.argmax(mask_batch[i], axis=-1), tf.argmax(predict[i], axis=-1)).numpy()))
+def average_dice(data, model):
+ image_batch, mask_batch = next(iter(data.batch(259)))
+ #Prediction on all the images in the test set
+ predict = model.predict(image_batch)
+ sum = 0
+ for i in range(259):
+ sum = sum + dice_coef(tf.argmax(mask_batch[i], axis=-1), tf.argmax(predict[i], axis=-1)).numpy()
+ #average of the dice coefficients over the test set
+ print(sum/259)
\ No newline at end of file
diff --git a/recognition/44672139_topic_recognition/resources/beforetrain.png b/recognition/44672139_topic_recognition/resources/beforetrain.png
new file mode 100644
index 0000000000..adf7b38229
Binary files /dev/null and b/recognition/44672139_topic_recognition/resources/beforetrain.png differ
diff --git a/recognition/44672139_topic_recognition/resources/plot.png b/recognition/44672139_topic_recognition/resources/plot.png
new file mode 100644
index 0000000000..0b148cbdb5
Binary files /dev/null and b/recognition/44672139_topic_recognition/resources/plot.png differ
diff --git a/recognition/44672139_topic_recognition/resources/predictions.png b/recognition/44672139_topic_recognition/resources/predictions.png
new file mode 100644
index 0000000000..81a94b3d33
Binary files /dev/null and b/recognition/44672139_topic_recognition/resources/predictions.png differ
diff --git a/recognition/44776859_StyleGAN/.gitignore b/recognition/44776859_StyleGAN/.gitignore
new file mode 100644
index 0000000000..943e8d14d3
--- /dev/null
+++ b/recognition/44776859_StyleGAN/.gitignore
@@ -0,0 +1,329 @@
+# Created by https://www.toptal.com/developers/gitignore/api/windows,intellij+all,python,jupyternotebooks,pycharm+all
+# Edit at https://www.toptal.com/developers/gitignore?templates=windows,intellij+all,python,jupyternotebooks,pycharm+all
+
+### Intellij+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn. Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Intellij+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+.idea/
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### JupyterNotebooks ###
+# gitignore template for Jupyter Notebooks
+# website: http://jupyter.org/
+
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Remove previous ipynb_checkpoints
+# git rm -r .ipynb_checkpoints/
+
+### PyCharm+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+
+# Generated files
+
+# Sensitive or high-churn files
+
+# Gradle
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn. Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+
+# Mongo Explorer plugin
+
+# File-based project format
+
+# IntelliJ
+
+# mpeltonen/sbt-idea plugin
+
+# JIRA plugin
+
+# Cursive Clojure plugin
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+
+# Editor-based Rest Client
+
+# Android studio 3.1+ serialized cache file
+
+### PyCharm+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+
+# Sonarlint plugin
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+doc/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+
+# IPython
+
+# pyenv
+.python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+pythonenv*
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# profiling klines
+.prof
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.toptal.com/developers/gitignore/api/windows,intellij+all,python,jupyternotebooks,pycharm+all
+
+checkpoints/
+/output/model_checkpoints/
+/output/progress_plots/
diff --git a/recognition/44776859_StyleGAN/README.md b/recognition/44776859_StyleGAN/README.md
new file mode 100644
index 0000000000..67763d0942
--- /dev/null
+++ b/recognition/44776859_StyleGAN/README.md
@@ -0,0 +1,164 @@
+# **COMP3710 Report**
+The goal of this project was to use Tensorflow2 to implement the generative StyleGAN
+model and train it separately on the following datasets, in this order:
+1. MNIST Digits[1]
+2. CelebA Faces[2]
+3. OAI AKOA Knee MRI's[3]
+4. OASIS Brain MRI's[4]
+
+This order of datasets was chosen as it represents an increasing order of difficulty,
+and iterative improvements to the model could be made as the difficulty of the datasets increased.
+However, emphasis was placed on the OAI AKOA Knee dataset.
+
+>## **Dependencies:**
+- Python = 3.8
+- Tensorflow = 2.5
+- Tensorflow Datasets = 4.4
+- IPython = 7.22
+- Matplotlib = 3.3.4
+
+>## **Problem Description**:
+Of the available 7 tasks I chose task number 7:
+
+
+StyleGAN1[5]
+was chosen, as opposed to StyleGAN2[6]
+or StyleGAN3[7], due to its relative simplicity and greater accessibility to beginners such as myself.
+Both the brain and knee datasets were attempted, though the OAI AKOA Knee dataset was the focus, due to the higher variance among the samples.
+
+>## **Algorithm Description**:
+The implemented StyleGAN1 model architecture is based on the structure described in the original paper:
+
+
+The main features of StyleGAN that separate it from other GAN models include:
+1. The addition of a mapping network that takes in a latent vector *z* and maps it to an intermediate latent *w*.
+The purpose of the mapping network is to disentangle the latent vector space to represent a more uniform
+distribution.
+2. Each latent *w* has a learned affine transformation *A* applied to it, wherein each feature of *w* is scaled by
+a learned weight, to give us style *y = (ys, yb)*.
+3. The output the 2D Convolution layer is passed to an Adaptive Instance Normalisation layer, which also receives
+scale *ys* and bias *yb*. Each individual scale and bias value is applied to each individual
+feature of the convolutional output, thus applying the style *y* to the normalised convolutional output.
+4. A gaussian noise input is added to each convolutional output, at the dimensionality of each block.
+The noise is scaled by a learned per-channel scaling factor _B_, before being added to the convolutional output.
+This results in greater fine stochastic detail in the final image.
+
+The original purpose of Generative Adversarial Networks is to generate unique samples that closely resemble
+the source samples but do not overlap with them, i.e. new samples in the style of the source. Through the aforementioned
+changes StyleGAN gives us finer control over image generation, allowing us to combine and manipulate styles
+in order to receive images with specific characteristics. It achieves this by using a mapping network to
+disentangle the latent vector *z*, retrieve intermediate latent vector *w* and transform it into style *y*,
+and apply these styles to each block, wherein styles applied to earlier blocks affect large scale features and
+styles applied to later blocks affect more fine-grained detail.
+
+The fully expanded synthesis network structure as used in my implementation can be seen in the appendix _a_ in
+image form, as a result of calls to the Tensorflow `plot_model()`
+function, and also in text form in [driver.ipynb](driver.ipynb) as a result of calls to `model.summary()`.
+The discriminator network can be seen in appendix _b_.
+
+>## **Data Split**:
+When training a GAN, samples of real images are passed to the discriminator along with fake images generated by
+the synthesis network. It is the job of the discriminator to identify which images are real and which are fake.
+The discriminator is trained by its losses when deciding between real and fake, and the generator is trained by
+the inverse of the discriminator's loss when deciding on the fake images.
+
+Due to this approach, there is no need for any training, testing or validation splits in this task.
+Where possible, if multiple splits were provided, they were combined into an all-encompassing training set, in
+order to give the model more data to learn from.
+
+>## **Evaluation Method**:
+The simplest method of evaluating GAN output is by visual inspection of the fake images generated by the network.
+To that end, I have visualised the generator outputs throughout training so their evolution can be inspected,
+along with the following measures:
+
+### Adversarial Balance
+We can evaluate whether the generator and discriminator are diverging by observing their relative losses.
+Ideally we want their losses to remain in the vicinity of 0.5 to 1.0, and if one exceeds these values in either
+direction, then we can say that either the generator or the discriminator has become weak relative to the other.
+If this trend continues, and the losses continue to diverge, then the adversaries will stop being able to learn
+anything from each other in subsequent iterations. To show this, I have introduced a measure called
+Adversarial Balance, that comprises a weighted moving average between the losses of the generator and
+discriminator.
+
+We want to see this balance remain in the center, and not move too far up or down.
+This can be seen in action in the animated versions of the output graphs.
+The implementation can be found in `_update_avg_losses()` in [model.py](model.py).
+
+### Generator Variance
+Another measure I have implemented here is the variance among the generated samples.
+First, a measure of the variance in the source data is obtained. Then during training the variance among the
+generated samples is obtained. This variance is then converted to a fraction of the variance in the source
+dataset, giving us our generator variance percentage.
+
+
+Ideally we want our generator's variance to remain close to 100% of the dataset variance throughout training.
+
+
+If our variance drops too low, it is a very strong indicator that the model has undergone mode collapse,
+and further training will not improve it.
+
+Live examples of these can be seen in the animated graphs, below. The implementation can be found in
+`_calculate_variance()` in [model.py](model.py).
+
+>## **Output and Performance**:
+### MNIST Digits Output
+[](https://www.youtube.com/watch?v=3I84iE2FjPg)
+[Click here to view the animated version of this graph.](https://www.youtube.com/watch?v=3I84iE2FjPg)
+
+Excellent results were achieved for MNIST Digits, with good balance and variance maintained throughout training.
+
+### CelebA Faces Output
+[](https://www.youtube.com/watch?v=zU0e2sPdgKU)
+[Click here to view the animated version of this graph.](https://www.youtube.com/watch?v=zU0e2sPdgKU)
+
+Excellent results were also achieved for the CelebA dataset, though due to time constraints only
+5 epochs were trained. Good variance and balance were maintained throughout, which demonstrates that
+further training would have continued to improve the output.
+
+### OAI AKOA Knee MRI Output
+[](https://www.youtube.com/watch?v=RTc3cfCKPXE)
+[Click here to view the animated version of this graph.](https://www.youtube.com/watch?v=RTc3cfCKPXE)
+
+Good results were achieved with the OAI Knee dataset. However, while balance and variance were maintained,
+it appears that convergence was reached as early as epoch 20, with further epochs only continuing to reduce
+the gap between generator and discriminator loss. Due to this, further training may not improve results,
+as there is not much more that the adversaries can learn from each other.
+
+### OASIS Brain MRI Output
+[](https://www.youtube.com/watch?v=ORD4px9rJyE)
+[Click here to view the animated version of this graph.](https://www.youtube.com/watch?v=ORD4px9rJyE)
+
+Mediocre results were achieved with the OASIS Brains dataset. While high variance and good balance were maintained
+for 20 epochs, after epoch 20 the adversaries start to diverge. This resulted in a weakening of the generator over time,
+and eventual mode collapse, with the generator variance going as low as ~13% towards the end. We can visually confirm
+mode collapse, as all generated samples begin to look the same when the variance drops.
+
+The implementation of this graph layout can be found in `_plot_gan_progress()` in [model.py](model.py).
+
+>## **Appendix**:
+#### a) Generator Model Architecture
+
+
+#### b) Discriminator Model Architecture
+
+
+>## **References**:
+[1]: http://yann.lecun.com/exdb/mnist/
+[2]: https://mmlab.ie.cuhk.edu.hk/projects/CelebA.html
+[3]: https://nda.nih.gov/oai
+[4]: https://www.oasis-brains.org/
+[5]: https://arxiv.org/abs/1812.04948
+[6]: https://arxiv.org/abs/1912.04958
+[7]: https://arxiv.org/abs/2106.12423
+
+- StyleGAN1 Paper: https://arxiv.org/abs/1812.04948
+- StyleGAN2 Paper: https://arxiv.org/abs/1912.04958
+- StyleGAN3 Paper: https://arxiv.org/abs/2106.12423
+- MNIST Digits dataset: http://yann.lecun.com/exdb/mnist/
+- CelebA Faces dataset: https://mmlab.ie.cuhk.edu.hk/projects/CelebA.html
+- OAI MRI dataset: https://nda.nih.gov/oai
+- OASIS Brain MRI dataset: https://www.oasis-brains.org/
+- Introduction to StyleGAN: https://machinelearningmastery.com/introduction-to-style-generative-adversarial-network-stylegan/
+- StyleGAN - A Style-Based Generator Architecture for Generative Adversarial Networks: https://www.section.io/engineering-education/stylegan-a-style-based-generator-architecture-for-gans/
+- AI generated faces - StyleGAN explained: https://www.youtube.com/watch?v=4LNO8nLxF4Y
+- StyleGan | Lecture 71 (Part 1) | Applied Deep Learning: https://www.youtube.com/watch?v=hfFAUFsglLc
\ No newline at end of file
diff --git a/recognition/44776859_StyleGAN/driver.ipynb b/recognition/44776859_StyleGAN/driver.ipynb
new file mode 100644
index 0000000000..714ec5f260
--- /dev/null
+++ b/recognition/44776859_StyleGAN/driver.ipynb
@@ -0,0 +1,1005 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Driver Script\n",
+ "- Ensure all dependencies listed in the [README](README.md) are installed.\n",
+ "- Update all `dataset_paths` to your local copy of each dataset (excluding MNIST, which uses tfds).\n",
+ "- Change all `batch_sizes` to what your hardware can accommodate.\n",
+ "- Change all target image dimensions to what your hardware can accept (ensuring not to exceed input dimensions)."
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": true,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Tensorflow version: 2.5.0\n",
+ "Tensorflow CUDA is available.\n",
+ "Tensorflow set GPU memory growth to True.\n",
+ "Tensorflow is executing eagerly.\n"
+ ]
+ }
+ ],
+ "source": [
+ "import model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# MNIST Digits\n",
+ "Dataset is downloaded automatically using tensorflow_datasets (tfds) library."
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "MNIST Digits dataset loaded.\n",
+ "Sample from dataset:\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "MNIST Digits hyperparameter presets loaded.\n",
+ "Generator model constructed.\n",
+ "Discriminator model constructed.\n",
+ "\n",
+ "Model: \"discriminator\"\n",
+ "_________________________________________________________________\n",
+ "Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ "image_in (InputLayer) [(None, 28, 28, 1)] 0 \n",
+ "_________________________________________________________________\n",
+ "convstart (Conv2D) (None, 28, 28, 32) 320 \n",
+ "_________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 28, 28, 32) 9248 \n",
+ "_________________________________________________________________\n",
+ "avg_pool0 (AveragePooling2D) (None, 14, 14, 32) 0 \n",
+ "_________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 14, 14, 32) 9248 \n",
+ "_________________________________________________________________\n",
+ "avg_pool1 (AveragePooling2D) (None, 7, 7, 32) 0 \n",
+ "_________________________________________________________________\n",
+ "conv_final (Conv2D) (None, 7, 7, 32) 9248 \n",
+ "_________________________________________________________________\n",
+ "flatten_conv (Flatten) (None, 1568) 0 \n",
+ "_________________________________________________________________\n",
+ "classification_out (Dense) (None, 1) 1569 \n",
+ "=================================================================\n",
+ "Total params: 29,633\n",
+ "Trainable params: 29,633\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n",
+ "\n",
+ "Model: \"generator\"\n",
+ "__________________________________________________________________________________________________\n",
+ "Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ "const (InputLayer) [(None, 100)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "const_expander (Dense) (None, 3136) 316736 const[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "const_reshape (Reshape) (None, 7, 7, 64) 0 const_expander[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale0 (UpSampling2D) (None, 14, 14, 64) 0 const_reshape[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in0 (InputLayer) [(None, 14, 14, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z0 (InputLayer) [(None, 100)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 14, 14, 64) 36928 upscale0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise0 (Dense) (None, 14, 14, 64) 128 noise_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "mapping_network (Functional) (None, 64) 35584 z0[0][0] \n",
+ " z1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise0 (Add) (None, 14, 14, 64) 0 conv0[0][0] \n",
+ " noise0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale0 (Dense) (None, 64) 4160 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias0 (Dense) (None, 64) 4160 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in0 (AdaIN) (None, 14, 14, 64) 0 add_noise0[0][0] \n",
+ " scale0[0][0] \n",
+ " bias0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky0 (LeakyReLU) (None, 14, 14, 64) 0 ada_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale1 (UpSampling2D) (None, 28, 28, 64) 0 leaky0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in1 (InputLayer) [(None, 28, 28, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z1 (InputLayer) [(None, 100)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 28, 28, 64) 36928 upscale1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise1 (Dense) (None, 28, 28, 64) 128 noise_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise1 (Add) (None, 28, 28, 64) 0 conv1[0][0] \n",
+ " noise1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale1 (Dense) (None, 64) 4160 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias1 (Dense) (None, 64) 4160 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in1 (AdaIN) (None, 28, 28, 64) 0 add_noise1[0][0] \n",
+ " scale1[0][0] \n",
+ " bias1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky1 (LeakyReLU) (None, 28, 28, 64) 0 ada_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "image_output (Conv2D) (None, 28, 28, 1) 65 leaky1[0][0] \n",
+ "==================================================================================================\n",
+ "Total params: 443,137\n",
+ "Trainable params: 443,137\n",
+ "Non-trainable params: 0\n",
+ "__________________________________________________________________________________________________\n",
+ "\n",
+ "Model architecture plots saved to ./output/\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan = model.StyleGAN(dataset=None,\n",
+ " dataset_path=None,\n",
+ " dataset_name='mnist digits',\n",
+ " target_image_dims=(28, 28),\n",
+ " epochs=100,\n",
+ " batch_size=512,\n",
+ " z_length=100,\n",
+ " save_progress_plots=False,\n",
+ " show_progress_plots=True,\n",
+ " progress_plot_batch_interval=10,\n",
+ " save_model_checkpoints=False,\n",
+ " model_checkpoint_interval=20,\n",
+ " save_directory='./output',\n",
+ " print_model_summaries=True,\n",
+ " running_in_notebook=True)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan.train()"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# CelebA Faces\n",
+ "NOTE: Please update the path to your local CelebA Faces image folder."
+ ],
+ "metadata": {
+ "collapsed": false
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loading dataset from C:/img_align_celeba at (64, 64) resolution.\n",
+ "Found 202599 files belonging to 1 classes.\n",
+ "Sample from dataset:\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAARgAAAEYCAYAAACHjumMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAogUlEQVR4nO2d269WV9X/B561B0DYbDbthrKhxQ0FdjEWKCUarTaNUaOJ3uiNRk3z+sYLb97ExAvjhXkvTervDzASbdQYW208V9mlB6Rll3IoFPbuhn2AFo/U8+m9ItnjM8ezxnyeOtPkl+/nbjzPWmvONdd8Ztb4PmOMuWxoeOzfJoQQDXjVK90BIcT/v2iBEUI0QwuMEKIZWmCEEM3QAiOEaMZrur78f/f9r7NfeuklZ69cubI457e//a2zb7rpJmevWLHC2b///e+dfeONNzr7ypUrRRuveY3vNq/5m9/8xtns9/nz55196dKlog1e4+9//7uz3/zmNzv7T3/6k7P/8Ic/OPvixYtFG7z317/+9c7+17/+5ewzZ850tsHzzcz++Mc/Ovtvf/tb5znLli3r7MOf//znoo1Xv/rVndfI7Kjf/IxtEF7zda97nbNf+9rXFueMjo46m/No+fLlnfbExETn92bl+A0PDzv7TW96k7M5F8fGxpzN52lmNjs76+w1a9Y4m79J/n44DtFvjvfG57F95x3FOWZ6gxFCNEQLjBCiGVpghBDN6NRgtm3b5uwXXnjB2ZEGc/311zubPii1DPrav/71r51N3zq6Jn3MV73Kr5t/+ctfnE0f841vfGPRxqZNm5w9PT3tbGoZ9FGpuVAvMSt1HtrUOzh2hFqTmdm//+0DtbPnwe//8Y9/dH4ffUabfeAzZRtRv3gOv6fGwjavueaaog3ONeoKq1atcjY1GrJhw4bis82bNzub8533ce211zq7Ri9kv+fn5529sLDgbM7tgwcPOpsajZnZ5cuXnb19+/bimAi9wQghmqEFRgjRDC0wQohmLOvKpp56atLZv/vd75zN2A+zUt+gHsL4EfrW9JWj+Idjx445mxoL26Dfyj7RXzcrtST268EHH+zsA9t87rnnijaosVBDoTZBnYE6UKRX8d54Dsf3n//8p7MzTSaC/WAf2GaNrsO4lje84Q3OZjzJX//6184+RZ9Ri8virdjHLVu2FG2Mj487+9Zbb3V2Ns8yPcus1Pf4O6VWynk3MjLibOpAZqVWtG7dOmePb7u9OMdMbzBCiIZogRFCNEMLjBCiGVpghBDN6Ay0Y7AYExEpCJqVQW8UqSjwUXC6cOFC5/dmeRAWAwIZAEWx9LHHHivaWFxcdPb69eudTYGb16CYGgniFOw4ntH49vO9WR4ol9mZYBvBY7JzokRE9pvj2W8AZyTyZm3S5tzlfUVBcLwGn9n+/fudzURFCv9RUCgD65hEy/HdtWuXszl21113XdEG5y/b6IXeYIQQzdACI4RohhYYIUQzOjUY+oMMZooK0/AYBifRb/3FL37hbAYN7du3r2iDgUQzMzPOpg7E459//nlnM8nQrPQ577//fmfTr2WgHe+TgWJmpT/OwK5My8iC5MzyAlJZsSj65wxSjM5hP6hDcI7UFLGizWtmSZ2RBsPxZnAeg/moy/GZ8nyzXLtjETGOBXXPKAjune98p7OpYzLQjmNFXSdKzOV4UhPrhd5ghBDN0AIjhGiGFhghRDM6NZisYHQU20Ffjf/j069dvXq1s+mfR0WWsuLjPIfxPDyebZqZHT58uPOa1HWowdQUVeq3MFOUFNh1fs05GVHxIZIlSBJqFZGuk8Fz+o0hqmmXz5SxNZzL0VhNTU05m8mOHKuhoSFnZ3PCrNQQ165d23kOtVPGtES/h0gnq0FvMEKIZmiBEUI0QwuMEKIZnQ42/UPGtER5EZmvRi2CeQ+8JmNazPJ4EeojL774orPpc/J4s7IgNHWfrKARxy7SBPothp3lFUWaQtYG+8VrcKwjTSzrR6bjRNoR+5XFblAfZB8iDSwrnkXNhW1kcUnRNRiDxecxNzfnbG5cGG3gx/HlXKXmwt8c53K0uRtjfrIC6FfRG4wQohlaYIQQzdACI4RoRqdzzBwf5iZFukKWH0M/lgW66RdH//tTMzl9+rSz6ceyTgf92EjnYWxBTRHppdTEL2R5Pln9kSw/p6ZfGTXXzPrJOZBtVB8dQ7Jr1swjahdZDRpqF7zvKC6MWh5/Q9xYjdfkhn7Dw8NFG/wsy4ujxsJ5xzbNyt9p9Mwi9AYjhGiGFhghRDO0wAghmtFXHAzjSaL/wvkZa1Owjgrr52bnm5mdOHHC2fQpeU1qNvS1o03j+Rn9dcY30P9mG1EsCMeCvnBWe5jUbC6WXSOr0VuTN5TpPNlmcGbl2GT1SHh8pgOZlc8k0xU4z3h+TW3hc+fOOXtiYqKzjSNHjjj7zjvvLNpg/RbmM91www3O5rziby56HtR1anLUzPQGI4RoiBYYIUQztMAIIZqhBUYI0YxOpSYTf6ICxBScWLSYiYYMcnvkkUecHQUvMVBuenra2RR5KZwx+SsSAJlMx2PYL4qKFEOjIkw8JhNkBxF52UbWz2yjtZrAO14zKw4VjU0WSFcjFHddL2qXIi/b7HeszMo/C66//npnM9Bu27ZtzqYge+rUqaKN3bt3O5uBctkzz+7LrBwrBhD2Qm8wQohmaIERQjRDC4wQohmdGsw111zjbGoZUWGaTHtgEiH1lNHRUWdHxaAY8MdzWPSK/aSOEAVIUWPhfdHnzzYwq0kMzTZaoz+eBZdF/eA5/Ragiooq9RuMxzaia2aJnbSzQuORrpDpSwwmG0Sf4jncvC3T2RjgFmkfs7Ozzr755pudTZ1zZGTE2TUFwvi7jZ5ZhN5ghBDN0AIjhGiGFhghRDM6NRj6Yox74X/6ZqXPSP+PhZv4nz03fVpYWCjaoMbCmBX64/SNs03no2MybSKLUYna4GccO5L5vdGGWdkmZ5nOUJO0yfHO9JEsvsSs1Lgy3YbXjIqTk6xQO+8906MGSTa9fPmys1ksjRu1cbM3szLu6+jRo85ev369s3kf/I1FSZ+8VyU7CiFecbTACCGaoQVGCNGMTkeKmz4xJiX6Tz7beI0xLCwmzFwL/v9uZvahD33I2QcPHnQ286Hoz9PXjvqc+dc1Rb272jTLdQL6uZkGE8VhUJfJNlJjPxkLRduszC/jeFI3qMnTygpO8V4HiZPJYoCy+B5+H+kSmd7Ea5w5c8bZzOXbsmVL0QafIe+DOg81S/7Oo7lMfTDL/bqK3mCEEM3QAiOEaIYWGCFEMzo1mKeeesrZGzZscDZ9N7OySPfk5KSz6S9yM3AWKN65c2fRBmNrpqamnM38pkwvifxJxgKw39mmXTUaDY/J6pFkfWQhcrNSy6A+km3sNUitkJMnT3b2i/pIFAfDfmYbz2cxKpEGk2koNflk2fdZDhvhWLHodzRW27dvdzY1MWounDfsU83zqEVvMEKIZmiBEUI0QwuMEKIZfcXBML6E2oeZ2bp165y9Y8cOZz/77LPOpq5DTSCqOfPggw86++zZs8UxS8liPWpiVLL6JCTLv4mukbXBmBbWweHYm5V1lel/019nvAM1magOM58RNTJuGs82opw2xktRq6NOkNX4qdFgaGcbyJFIu+i3rjJ1HMaecVzMzFatWuVszhs+M+an8b75/MzK3wNryvRCbzBCiGZogRFCNEMLjBCiGVpghBDN6KvoNwthR8E3FJAoSlHEJUzuYqCeWSnqUjTMimXXBMFlBacIhbIsMM+sTALkMRR1KbpTQKdgHrVBkZdt8PmxT5EgS5GX84KiIceGCa9mpTidFb/OnnGNAFuzqVzXNWsC7bLvOY94TRYNNzObn5939p49e5zNhOGskFwkbrMfUeGrCL3BCCGaoQVGCNEMLTBCiGZ0ajAs/kQ/d2hoqDiHvjH97/Hx8c4O0Z8/duxYcQyvSf+QOgLJ9BSzPOiK/vogGkBWUPuWW25xNgPWbr/99s7zzcpEN2ob1CGYbEfNJroPBoNRR6N+Qv9948aNxTWp9WTJj4RzINJXMi0u+z4rdh5dI0vCzAIGo/vmb45FwFeuXOnstWvXOpsJyiwSblb+ZqJgvAi9wQghmqEFRgjRDC0wQohmdGow9IPp69VshM7YDOoI9N+feeYZZ0eJjFEC5FLoL2Ybr9UktWXxCpm/Huk+1DcYD8I4pF27djmb/nkUm8ACXnxmfMbZBmdR7BP7OTEx4WxqMFnBI7My5ofPnEXFGG+VzYEW1MwjHkPdjN/X6IuXLl1yNhOKqXFxLjMWKipcxmd8+vTp4pgIvcEIIZqhBUYI0QwtMEKIZnRqMPx/nBrB6tWri3OYr0Qfkv4hfXxuPMWNuc1K/YOFsDJfOCv6E7WRaS7ZJl1RjAr1jKxf1FOoK0R5QtRpsrgW6jjUR6KCU1k/qLtRZ9u7d29xTcZZMJ4n01SyIuFmdfOgHwbRYBg/xefB46lZmpXFuLg5G4tDrVmzxtncmC3SPfkM+Tx6oTcYIUQztMAIIZqhBUYI0YxODYZ+F2HBaLO8NgjPoT/I+IaoDfqpWV2ObAPyKEYl88/7jWeI4hfYj/Pnz3f2ixtsUROLNBjmoVCToZ0VM4/Gip/RP2du0pNPPunsBx54oLgma5jMzc05m7pbvxuz9fpsKS+3CHgNHO+sRk00Lxmfxvow1LNYk4kxLtRezcpYpuh3GaE3GCFEM7TACCGaoQVGCNGMTg2G/jn1kkijoc+Y1QM9fvy4s6lDRHkq/Kwm5qGf76NjXq7/XROHwftgDNBXvvIVZ7Nux9jYWNHGpz71KWczx4dxMYxjon8exWHwGidPnnT2gQMHnH306FFnR8+YY/PSSy85m/NskFywaDO2pVAfyXLYaur+ZvFT2X1FGhnHj21S/2Mc0rZt25wd3Qfzk6ir9UJvMEKIZmiBEUI0QwuMEKIZWmCEEM3oFHmzjdYo7pmVIhTFOV7jypUrzmZQUI3IS1EqE8oGoUWQFaE4lwmVDD6LCjEzke1LX/qSs1lsiM+PAVWRMMpiT/fdd5+zWYQ6C+YzK4XJLCguE1Oj87NnynvNns8gyZNZG9nxZmUQHMeOQn220Rr/CDAzGx4ednYk9kfoDUYI0QwtMEKIZmiBEUI0o1ODYZHpEydOODvyF+nrMtmOwXnUYGhHOk/mn2eaDIl88X433coKBUVk18i0pKiIFaEu861vfcvZn/jEJ5zNBMqsCLWZ2dTUlLOpubCfTIakhhCRaRVZgmtNoGOm29Rck2TaUfb9INrf7Oyss6mXsAg451mke547d87ZLGLVC73BCCGaoQVGCNEMLTBCiGZ0OvGPP/64s6mPUF8xywtKZXEw/J5xNGalL8xzauIsXi79xkBkvrZZrjNkCZjZhvBmZk8//bSzWayIcTEsAh7dB+cJE+OoAdSMBXm5ulqkZWQaS3b8IAWp+o2VqdF9qD/xN8MicCw4RaJiUixmxmLlvdAbjBCiGVpghBDN0AIjhGhGpwbDnIVo0y1Cn502fbfFxUVnR8WxCTWXbLOwQei36He/eUTRMVkBpKyN6Pmw4BdjULgRHuNgGIfEjdbNSh2H409dhxpBzdhksU7Z2NToI4zXyTbfywpSRWTzIisCHumLfEYsiM64JOawsXhUFOPCfmZz9Sp6gxFCNEMLjBCiGVpghBDN6NRgtm7d6mz6elEuDGMeeAwLWTPHgcfzP3yz8j95tsk4jP9ELRf6nByLzP+ONJ3M5++38HgUG0JdhvrVE0884ex9+/Z1XpMbrZuV+U68ryynis8rOofaHAvSZ+Nfk4vU7+Z5NbVcsmP6jcWJnnF27yzCPjo66mzGs61atarzembl+PdCbzBCiGZogRFCNEMLjBCiGZ0aTJbTE2kw9N/o81NTyTZRi/JWeA368PRJs//wo//0M1+YY8Ox+E/ERPDeeZ+ZZmBW+uz0nRkHwzrMNZoYz2GsU7aBe6QrZLVvOK8yfaqmdhGfKe8j009q5lGm+xDeV5QDxPFfu3ats5lbxFwkxslEz4Ob/K1YsSLuMNAbjBCiGVpghBDN0AIjhGiGFhghRDM6FSaKihR/mFRllie2MTGO16RwFhX9ppiWFb/pNzGu5hoUo7m5FcW7qLB11g8KshwLCoBRcS4GUVFI5vN49NFHnb179+7OPkb95DONChgtJRLyM0E1SwrkfUbCJecRk2azwllsoyagk/3gPGlRaJxjxSJwnJtR4COF5CNHjqT9MNMbjBCiIVpghBDN0AIjhGhGpwZz6tQpZ9M3i4Jt6M9dvHjR2dRosuLNUbBfVvgnIysWFX2WBUht2LDB2SzMFOkM9OGpAVDbyIoPRfdB35k2kyEPHz7sbGowkZ5CHSfTxDh2kc7GwlhZIbIsMC+aIxwLwvHnNdmnQYrNZ4W0auYq9UAWGaPmwufDwLsokfHy5cvO5lzthd5ghBDN0AIjhGiGFhghRDM6NRj62/T/mCRllusG1B2o2dDnjBLI+o0/yAo5DbIRGH1QJpjNz887O9IZ6LNnPj/J9KvomCw+h8+UsU5Rm1nhLOo81C6i50edgM+I458lsEa6EMc/ix+hBllTcCoj02BITUIln9HQ0JCzN23a5OwsWdisTGJmobhe6A1GCNEMLTBCiGZogRFCNKPTyWduC2NYajbipn8+MzPjbBYwyoo7m+VFqrKC0OxTTRwMoa7AuA36wVHMEIsmUQ/JimfTrtEZeE2ewwLejGOibVbqIZwXvM+ajfHYb57DDeLYJscyitvg+PEZZlpdFrNiVmom2dzLcvOiWBvObz5TFsnn3OXxkV7ImCFu1tYLvcEIIZqhBUYI0QwtMEKIZnRqMPRz6UtH0A9lDY0TJ044O/vfP6qjQj81i4nIfOcotiPLK6GmQt862/DMrBwrxhqwxgzzm/h8GO9gVmoq9Nd5TY7Fdddd52zmtUTnULtjrssNN9xQXIMw/ob95lixzayAullea4VaBOcZdYkofiTLiarZ3H4pNbFP1DGvXLnibG7ExudBLcqsvI8sj+sqeoMRQjRDC4wQohlaYIQQzejUYKKau0uJ/i+v2ahrKZl+EsUWZLkTWT1X2lGsDa/JY6hNcKwYMxTF1XBs6F/v2LHD2cwTYmzIxo0bizYyDSbTIfg8eV/RZ7zGyMhIZz+5GbuZ2dTUlLM5/twI7KGHHursA/Uss3K8OZ6ZBlOjn/CzLCarZjM3wnvlfVGDOX78uLM5r2qeMWvO9EJvMEKIZmiBEUI0QwuMEKIZWmCEEM3oFHmzxMOoIBITpxgox+LYLBidCZlmpfiWJTuSLMEsOoY2RcMzZ844mwJuFJhEAZDBYt/+9redzeA9Cm8URqM2oiCqpVC8rhHdOf6cN3ymLCA9OTlZXJPBXxQqn3zySWdz7LKN8sziIM6ua/CZ1hQuy+YRRd8sSDQSkvmbYxsLCwvOZtAn52ZUSI5zT0W/hRCvOFpghBDN0AIjhGhGpwaTbb4ebYbFY7j5Ov07Fhanr1zj8w9SbLlf6OeePXvW2Uwa5NhF/nm/QVXUGbLgPrNSX6LuQJ+evjWfZ9RH9otaRaZ1RBpYlkhIm3OCYxEV46KGyPvIij9lhc2ia2TjmRVprwkKpU39is+c8yjSV/hbrwkANNMbjBCiIVpghBDN0AIjhGhGpwaTbX4VJTvSN6MvzDiMLKEy0i7YRs0m8P22kfnCc3NzzmYBJOoOWfyJWTmema6TFRqP4DXoW2eFnmq0DLaR+es1G7pnRcZoZxvMRQwPDzs7i2WqKfpNsoLnWcGpqI1s/md6FWNcopitrHBWL/QGI4RohhYYIUQztMAIIZrRqcHQr802IDcr/TvmttAmLKbNvBWzUqvI4gDok9b8h5/lO3Gz+7e85S3OPnbsmLMj7YL5TOzX6tWrnR3lfi0lipGgdkH/moXDs43ZIjg21IaoZVCXq9HZsuLw7HcWX2JW6k/Mf2J+GfWPmjwtQu2iJp9pKTU6G+H85++WhfmpyZiV98qYoV7oDUYI0QwtMEKIZmiBEUI0o9Op5wbX9Lsi/zzbcIy5SNRkmOMT/d/ebyzBILlK9I2pG3AsuOkZxyHasIzFsKmhcNPyqHD1UqK4pPPnzzub98Gi4NQlbrrpJmez4LqZ2Z49e5xNfYo+P8eKulvUD9YNom7A+B3qJ4wpMivnJvU+9pvzjvM/0keoXWRFvgcpAp7FqDBGi/e9fft2Z3PeRe2qHowQ4hVHC4wQohlaYIQQzdACI4RoRqfIu3nzZmfXBKxR/KTYlolFFFejIj4kC15imzWiL6/BADUmxh09etTZu3fvdvb73ve+og1egyJtVuAoKxpuVhb8OnfuXHHMUihOc+zGx8eLc+69915ns8DR8uXLnc1AvCj4ks+dzyN7PhSFGfhoZnb//fc7m8XP+DyyhNVormaBdNl9kSgQL0uCHRsbczZ3ZZydnXX2zTffXLTB3ThnZmY6+3kVvcEIIZqhBUYI0QwtMEKIZnRqMNRPGOgVBXYxGImBWvTvvve97zmbPn8UzEc/lMcM4scS6hv0c5nAR61j69atnX00KwOkaNOXzjSYKECK/WRyI3UHahWZthFdk4FbfB7UZKJgyqwwNecJC0pxLKPAsPe+973Ofvjhh51NrYJ94vyPilq93OJnDN6LdE+2wfFmACE1GQZPUns1y4vF90JvMEKIZmiBEUI0QwuMEKIZnRrMhQsXnE2/K9IVmMjGokn9blxfEweTFZji91mCmVl5b1nMCb+fnp52NmNezMpEw3Xr1nX2k/fBNpnEZlaO58GDB5391a9+1dl8Prt27XJ2pCn88Ic/dDb99U9/+tPOprZETcYsL7rOeUOtid9HxeUXFxedzWfO8WaMENuMtL9sLmYxXLSj8We/GYfE76kXMjn14sWLRRtsN0s4voreYIQQzdACI4RohhYYIUQzOjWYzMePigNnm5aTrHBNTcxKplXQf6zxJ7MNygi//+Uvf+nsaKwmJiacTW2C+hX7zfiF6D6oZUxOTjqbsTMsfP3Zz37W2VEuE9v41a9+5ewDBw44++6773Z2FFORFe3OCmUxXofxPmblWHC8X3zxRWezMBY1mEiT5DziXM3iZGoKiWfHcGw2bNjgbGpgUZ+ozTGWphd6gxFCNEMLjBCiGVpghBDN6NRg6D/SD4uKHDOWg9pDVh8js83K//nZr343s4q+571l8QiM/aCG8NBDDxVt0MenNsFrsAg7iYqCs1/79+93NvPNOBbf//73nU3dwazUZTh2zD9jwW7mMpmV4837oM7GuKPTp087+6c//WnRBjUX5s3Nzc05mxoLY6GieURdLKv5k20KGLXBfmVtbtq0ydmsx8PC8GblfI9y0iL0BiOEaIYWGCFEM7TACCGa0b2bOqCvxpwGs9Lfo039hDAuJqqxQfqtc5r5uWalj089ij4p438+8IEPOPv5558v2mC8yHPPPefsD3/4w519ZPwCN9gyK2Nl3v72tzubcTCHDx929ne+8x1nR/VzyV133eVs1oepiUPK6r0sLCw4+9ChQ84+fvy4s1kj2azUC+fn553NZ0ptiTbniFl5r1HeWxc1c5ef0WYM0IkTJzr7dMstt6T94Fzthd5ghBDN0AIjhGiGFhghRDO0wAghmtGpOLEQDQOToqCfTJSlAMXkOib8MRjNrEyOo0hI0YptDrK5W5ZAyaAritvRxmtM2ONGYF/72tecfc899zh77969zo6SBhk0xYQ9Jlzye45/VNTqXe96l7MZXLllyxZnU1iOEkkpuFIQ/+53v+ts/jnwkY98xNlREOKlS5ecTSE++zOAom50fDbX+MyyxNwouJXtUtjnnzHsA38/jz76aNEGxf1oHkToDUYI0QwtMEKIZmiBEUI0o69kR/pdUYAUfTX6udwEigFQ3/zmN30Hg8CkLOApoybQLvOFqT8xgJAFp6JiRNu2bXP25z73OWdTZ+AmdUeOHHH2F77whaINBuOxH/yezzTTT6JrMICN+ggLcHOOmJl9+ctfdjbnzcjIiLOZKErNhYF3ZqXWQC2I8z3b+C7S8jjX2EZ2zex6ZvkGftTRqDVRW6UOZ1bOi6iAWoTeYIQQzdACI4RohhYYIUQzOjWYmZkZZzNmhf+3m5Ubhp86dcrZ3ICMPigTzCKdhzEm1Ef6jXuJ4nmyc6gr8Hj6udQQzErdhnEt73//+51NraJm4y/GkzDOiIWvuYka+xQVaWdRKm7W9ta3vtXZ1AiiTek++clPOpuJnMeOHXM2dR0W+GLxKDOzjRs3Ovv8+fPO7reYfJTsyLmYzT3aNXoj2+D4ciO1n/3sZ86+9dZbnf2e97ynaINFwRj31Qu9wQghmqEFRgjRDC0wQohmLBsaHuu5a9OhSe+PUzOgP29W+sI85oUXXug8/vOf/7yzI+2C0AelbpNpNDXQN87yUBgbEhXxYfFrakvUIYaGhpzNvK/IL2axIWpDjz32mLMZA8Hzo7ikrEA342LuvPNOZ7PYtlmpVXDuTU1NOZsFp/h8duzYUbTB8Tp48KCzGbNSswkaybS8bGM2xi1FGgxjZ6iNMjYty1UaHR0t2vjMZz7jbM7nnbf5Z3oVvcEIIZqhBUYI0QwtMEKIZnRqMPMXnnV2TR0V1jihn8v8jmeeecbZX/ziFzuPNyt1Afqx2aZpmR1B7SHzpUmkwTB/hvlLjF9gHFJNPRLmO3GTNMY3UHdgPRnGOZmVPj11NWpNvI+o3zyH/WIb1HkYixNpF4yV4XizX9Q6qI9E95HlFmX5TDVzk+1yc3vGuVAjYz0fxkaZlbrmxz72MWf/13//T9g3vcEIIZqhBUYI0QwtMEKIZnTmIlH/qIkfYR1f5s9QN2A+DX3lSOfJau72C+NkzPINrzLfmfE/Z8+eLdoYHx939sc//nFnUyPgZmPUPj74wQ+mbczOzjqbGhg3NWc8TxQHQz2EcRe33Xabs6lHRZu5cXMw5hKxX9SS2Kenn366aIN6IbUJ6k+MU6rRJDMNJqs7lB1vVv5mGOvEZ8p5w7GMcsNYe4gxQ73QG4wQohlaYIQQzdACI4RohhYYIUQzOkVeikFMVGTAm1kZEEUBicFMFB0ppEUbr1F8o1DMa2RFf2rIxLgsoTIqzsXNxDZv3uzsu+66q/MaN954o7PXrFlTtEEBcP369c6m0MnnxecTjR2TFfl8KBpSAI8KibMYPIPFpqennU2BluL1yZMnizY4b6LN2ZbCuc3ExEjQZYAahWH+6ZH9uVBT4D4ryMaxunDhgrOjomIU6jlveqE3GCFEM7TACCGaoQVGCNGMTg3m9OnTzs427TIrA7GoMzz88MPOpv+XbXYV9aNmg/Cl0HeOEsqyJDO2Qf+7JmCQfiyTHVl8mUmCHP+ozxw/brK1Z88eZ3P8JyYmnM3CT2blM6eWQZ8+K8oencNgMbbJwDwWm6d+YpYXd8o22+PYRm3wuVMfyRIoOTaRlsfxzDZ7o+bF5zU2Nla0wbnKIuy90BuMEKIZWmCEEM3QAiOEaEanBkPoy0W6wiOPPOJsxr0wDoObXWVxA2alb0y/Ntpo/j8N/dyseHOUJMh4EBZzYiHrffv2OZsb03Mcon7QZqIhv890CLNyXvAZ8nmwCFm0uR6LvXOecJ49+6wvjjZIsXLCfmXaRgQ1Fo4nx4Y2z48Se7NnxHtnvBS/5+aHZqX+V1OM30xvMEKIhmiBEUI0QwuMEKIZnRoMc11YyObnP/95cQ5zPngNFqDK/Ngov6PfwshZEZ8a2A9qLmyDfYrukzk79K9ZNInFmJkDFBUWZ8xDlkOVFUSP9BL68NkG7vw+GhvGvTB+ipoMdYMs/iTqB8/JYlSysYuO4b3ymWdFrSJ9kePPGCLGznBOcEO/KKeNzyPKV4rQG4wQohlaYIQQzdACI4RoRqcGQ7/r8ccfd3ZUq4W5R6wnQpv+eRYHYJbXc8lyjbKaG9FnWf5MtvFa5LPymjyGvjXH6oEHHnA2N8Myy4uT85rUDKKC3IRaEfOVsoLpUUzFj370I2efOXPG2ZnuluUZmeU1fDJ9JNOWomOy+CmSxdFEn2X9Zj7axo0bnR3FwXADPxX9FkK84miBEUI0QwuMEKIZnRrME0884WxubhXV5GX9EMZNULdh/g19zqj+Ba+ZxblkmssgGky/8SRR/EjmO3MsWP+FNZK//vWvF228+93vdjY3xqNuwD6wbi3ruZqVGgq1I2oAi4uLzo7iqY4fP+5s6lMcX/arZjM+6h+0eY2sjWgecnx5H/3mEUX3lemBPIdxL3werNFkVsbOMIarF3qDEUI0QwuMEKIZWmCEEM3QAiOEaEanyMtiwDUFuSkEM+hq//79zmbADo+PhDO2y8Agfp8lR0bCWZbAR/GZY3Pttdc6Owr0ygRW9oE2hbco8PEb3/iGs0dGRjr7yTYo5kXCPu+dom620VcUaMcAP14jSyblWEZBcJwXmQDLeUXhPkrazApGcbw5r9jv6M+CTIxmG3xeLCbFQDyzcq4xibkXeoMRQjRDC4wQohlaYIQQzejUYLJAJAZ6mZU+/datW53NBEoG/WSBeGalX5sl9NGXrkkgi4pEL4W+MH3nLBDPrEyEyzQXFglnm5EmRn1qbm6ur35G2gXheFNv4vdZkqdZ+Yw4FtQZ2M8sMTE6J0sSzPSUQeYR4TWol0TPg+dkOtrevXudvXLlSmfzN2lmdvbsWWePjo4Wx0ToDUYI0QwtMEKIZmiBEUI0o9NBpI9Jnz8qpEzfjL4vN1674447nM0NtKJkR16TPjz91qho1VIiP5m6AftBnYH6RxaLEH2WbRiXaUlRAlqWtMk+ML4k01eifmQ6Qvb8omuQrIgYz4+KlGVFqWhnm9hFfWa/eO8cuyyeJyKLlaEuygJh/B1HWt6mTZucHcVchX2rOkoIIQZAC4wQohlaYIQQzejUYOib0T+kb2dmNjY25mxudM5clp07dzqbOkJNoSa2QZ+evjT94ppYD5IVAa/ZmCorXp5pG9RPIt+ZbWS6A8e7puAR28g2MGM8T1b4OjqG/cx0tuj7TG/K5klWlD0iazObi5HOk+k0/H56etrZ8/Pzzt6zZ09xjZmZGWcz57AXeoMRQjRDC4wQohlaYIQQzejUYOhTUh+JNr+iLnPo0CFnX7x40dn33nuvs9/2trc5+8c//nFXF82s9IXp12axHlGMSpanwrFg3Atr6dRoF1kOD8nqlUTXyPJtslo6EdQ3GPdC7S7TZMxy/YP9pl2jbbBf1M14jazOTaTBMH4qy5vLiH5zvCafIfP/WBOItXfuvvvuoo0f/OAHzq7NsdIbjBCiGVpghBDN0AIjhGhGX3EwrMtJnSE6hnEu73jHO5xNzYb/wVPDMStzKejD07fONkqv2TCLfi31Et5HFjNhZnbp0iVn0x/nWNJX5vcR1AD6jcOo0Qg4flmcS03NmSzGhLoDN5Sj1heNf7ZZHseXMVzZHImo2fRvKVlto6gfvA8+j6mpKWfzN8p5aVbWFeJc7IXeYIQQzdACI4RohhYYIUQztMAIIZrRKfJmhYOi4kMUrdatW+fshYUFZ2eJcTUBatkGcVmhppqiPtk1KIhzA7moDV6D48lCyxQyGewXJfQNksi5lJpgvqz4NQXWrJiUWSlU8t74zPk9kyEp+pqZLV++3NmcN3yGWZGxCPaD59QUDu+XbPM2/tEyOTnp7HvuuSdto7afeoMRQjRDC4wQohlaYIQQzehLg8l0CDOzxcVFZ3NztgMHDjj7ox/9qLMZwLNixYqiDW7GxiCgrNAyfemoeDnPiQpfLSUrps0+mpX+OAMEV61a1XlNjgM30DIr/fF+i3zXbJLGscoKcFMTiAq7s6g0g8U4nrwG9aqoOBr7PT4+7uzDhw87exAtieNXU5Tq5cJnyHnxk5/8xNk7duzoPN+sLDBVoz+Z6Q1GCNEQLTBCiGZogRFCNGPZ0PBYdyagEEIMiN5ghBDN0AIjhGiGFhghRDO0wAghmqEFRgjRDC0wQohm/B/5yMC8cEHGCQAAAABJRU5ErkJggg==\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "CelebA Faces hyperparameter presets loaded.\n",
+ "Generator model constructed.\n",
+ "Discriminator model constructed.\n",
+ "\n",
+ "Model: \"discriminator\"\n",
+ "_________________________________________________________________\n",
+ "Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ "image_in (InputLayer) [(None, 64, 64, 1)] 0 \n",
+ "_________________________________________________________________\n",
+ "convstart (Conv2D) (None, 64, 64, 64) 640 \n",
+ "_________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 64, 64, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool0 (AveragePooling2D) (None, 32, 32, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 32, 32, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool1 (AveragePooling2D) (None, 16, 16, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv2 (Conv2D) (None, 16, 16, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool2 (AveragePooling2D) (None, 8, 8, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv3 (Conv2D) (None, 8, 8, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool3 (AveragePooling2D) (None, 4, 4, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv_final (Conv2D) (None, 4, 4, 32) 18464 \n",
+ "_________________________________________________________________\n",
+ "flatten_conv (Flatten) (None, 512) 0 \n",
+ "_________________________________________________________________\n",
+ "classification_out (Dense) (None, 1) 513 \n",
+ "=================================================================\n",
+ "Total params: 167,329\n",
+ "Trainable params: 167,329\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n",
+ "\n",
+ "Model: \"generator\"\n",
+ "__________________________________________________________________________________________________\n",
+ "Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ "const (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "const_expander (Dense) (None, 2048) 1050624 const[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "const_reshape (Reshape) (None, 4, 4, 128) 0 const_expander[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale0 (UpSampling2D) (None, 8, 8, 128) 0 const_reshape[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in0 (InputLayer) [(None, 8, 8, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z0 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 8, 8, 128) 147584 upscale0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise0 (Dense) (None, 8, 8, 128) 256 noise_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "mapping_network (Functional) (None, 128) 66112 z0[0][0] \n",
+ " z1[0][0] \n",
+ " z2[0][0] \n",
+ " z3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise0 (Add) (None, 8, 8, 128) 0 conv0[0][0] \n",
+ " noise0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale0 (Dense) (None, 128) 16512 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias0 (Dense) (None, 128) 16512 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in0 (AdaIN) (None, 8, 8, 128) 0 add_noise0[0][0] \n",
+ " scale0[0][0] \n",
+ " bias0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky0 (LeakyReLU) (None, 8, 8, 128) 0 ada_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale1 (UpSampling2D) (None, 16, 16, 128) 0 leaky0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in1 (InputLayer) [(None, 16, 16, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z1 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 16, 16, 128) 147584 upscale1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise1 (Dense) (None, 16, 16, 128) 256 noise_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise1 (Add) (None, 16, 16, 128) 0 conv1[0][0] \n",
+ " noise1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale1 (Dense) (None, 128) 16512 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias1 (Dense) (None, 128) 16512 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in1 (AdaIN) (None, 16, 16, 128) 0 add_noise1[0][0] \n",
+ " scale1[0][0] \n",
+ " bias1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky1 (LeakyReLU) (None, 16, 16, 128) 0 ada_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale2 (UpSampling2D) (None, 32, 32, 128) 0 leaky1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in2 (InputLayer) [(None, 32, 32, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z2 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv2 (Conv2D) (None, 32, 32, 128) 147584 upscale2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise2 (Dense) (None, 32, 32, 128) 256 noise_in2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise2 (Add) (None, 32, 32, 128) 0 conv2[0][0] \n",
+ " noise2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale2 (Dense) (None, 128) 16512 mapping_network[2][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias2 (Dense) (None, 128) 16512 mapping_network[2][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in2 (AdaIN) (None, 32, 32, 128) 0 add_noise2[0][0] \n",
+ " scale2[0][0] \n",
+ " bias2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky2 (LeakyReLU) (None, 32, 32, 128) 0 ada_in2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale3 (UpSampling2D) (None, 64, 64, 128) 0 leaky2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in3 (InputLayer) [(None, 64, 64, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z3 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv3 (Conv2D) (None, 64, 64, 128) 147584 upscale3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise3 (Dense) (None, 64, 64, 128) 256 noise_in3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise3 (Add) (None, 64, 64, 128) 0 conv3[0][0] \n",
+ " noise3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale3 (Dense) (None, 128) 16512 mapping_network[3][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias3 (Dense) (None, 128) 16512 mapping_network[3][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in3 (AdaIN) (None, 64, 64, 128) 0 add_noise3[0][0] \n",
+ " scale3[0][0] \n",
+ " bias3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky3 (LeakyReLU) (None, 64, 64, 128) 0 ada_in3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "image_output (Conv2D) (None, 64, 64, 1) 129 leaky3[0][0] \n",
+ "==================================================================================================\n",
+ "Total params: 1,840,321\n",
+ "Trainable params: 1,840,321\n",
+ "Non-trainable params: 0\n",
+ "__________________________________________________________________________________________________\n",
+ "\n",
+ "Model architecture plots saved to ./output/\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan = model.StyleGAN(dataset=None,\n",
+ " dataset_path='C:/img_align_celeba',\n",
+ " dataset_name='celeb faces',\n",
+ " target_image_dims=(64, 64),\n",
+ " epochs=3,\n",
+ " batch_size=32,\n",
+ " z_length=512,\n",
+ " save_progress_plots=False,\n",
+ " show_progress_plots=True,\n",
+ " progress_plot_batch_interval=10,\n",
+ " save_model_checkpoints=False,\n",
+ " model_checkpoint_interval=20,\n",
+ " save_directory='./output',\n",
+ " print_model_summaries=True,\n",
+ " running_in_notebook=True)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan.train()"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# AKOA Knees\n",
+ "NOTE: Please update the path to your local OAI AKOA Knee image folder."
+ ],
+ "metadata": {
+ "collapsed": false
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loading dataset from C:/AKOA_Analysis at (64, 64) resolution.\n",
+ "Found 18680 files belonging to 1 classes.\n",
+ "Sample from dataset:\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "OAI AKOA Knee hyperparameter presets loaded.\n",
+ "Generator model constructed.\n",
+ "Discriminator model constructed.\n",
+ "\n",
+ "Model: \"discriminator\"\n",
+ "_________________________________________________________________\n",
+ "Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ "image_in (InputLayer) [(None, 64, 64, 1)] 0 \n",
+ "_________________________________________________________________\n",
+ "convstart (Conv2D) (None, 64, 64, 64) 640 \n",
+ "_________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 64, 64, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool0 (AveragePooling2D) (None, 32, 32, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 32, 32, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool1 (AveragePooling2D) (None, 16, 16, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv2 (Conv2D) (None, 16, 16, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool2 (AveragePooling2D) (None, 8, 8, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv3 (Conv2D) (None, 8, 8, 64) 36928 \n",
+ "_________________________________________________________________\n",
+ "avg_pool3 (AveragePooling2D) (None, 4, 4, 64) 0 \n",
+ "_________________________________________________________________\n",
+ "conv_final (Conv2D) (None, 4, 4, 32) 18464 \n",
+ "_________________________________________________________________\n",
+ "flatten_conv (Flatten) (None, 512) 0 \n",
+ "_________________________________________________________________\n",
+ "classification_out (Dense) (None, 1) 513 \n",
+ "=================================================================\n",
+ "Total params: 167,329\n",
+ "Trainable params: 167,329\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n",
+ "\n",
+ "Model: \"generator\"\n",
+ "__________________________________________________________________________________________________\n",
+ "Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ "const (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "const_expander (Dense) (None, 2048) 1050624 const[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "const_reshape (Reshape) (None, 4, 4, 128) 0 const_expander[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale0 (UpSampling2D) (None, 8, 8, 128) 0 const_reshape[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in0 (InputLayer) [(None, 8, 8, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z0 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 8, 8, 128) 147584 upscale0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise0 (Dense) (None, 8, 8, 128) 256 noise_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "mapping_network (Functional) (None, 128) 66112 z0[0][0] \n",
+ " z1[0][0] \n",
+ " z2[0][0] \n",
+ " z3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise0 (Add) (None, 8, 8, 128) 0 conv0[0][0] \n",
+ " noise0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale0 (Dense) (None, 128) 16512 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias0 (Dense) (None, 128) 16512 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in0 (AdaIN) (None, 8, 8, 128) 0 add_noise0[0][0] \n",
+ " scale0[0][0] \n",
+ " bias0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky0 (LeakyReLU) (None, 8, 8, 128) 0 ada_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale1 (UpSampling2D) (None, 16, 16, 128) 0 leaky0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in1 (InputLayer) [(None, 16, 16, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z1 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 16, 16, 128) 147584 upscale1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise1 (Dense) (None, 16, 16, 128) 256 noise_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise1 (Add) (None, 16, 16, 128) 0 conv1[0][0] \n",
+ " noise1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale1 (Dense) (None, 128) 16512 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias1 (Dense) (None, 128) 16512 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in1 (AdaIN) (None, 16, 16, 128) 0 add_noise1[0][0] \n",
+ " scale1[0][0] \n",
+ " bias1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky1 (LeakyReLU) (None, 16, 16, 128) 0 ada_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale2 (UpSampling2D) (None, 32, 32, 128) 0 leaky1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in2 (InputLayer) [(None, 32, 32, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z2 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv2 (Conv2D) (None, 32, 32, 128) 147584 upscale2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise2 (Dense) (None, 32, 32, 128) 256 noise_in2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise2 (Add) (None, 32, 32, 128) 0 conv2[0][0] \n",
+ " noise2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale2 (Dense) (None, 128) 16512 mapping_network[2][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias2 (Dense) (None, 128) 16512 mapping_network[2][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in2 (AdaIN) (None, 32, 32, 128) 0 add_noise2[0][0] \n",
+ " scale2[0][0] \n",
+ " bias2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky2 (LeakyReLU) (None, 32, 32, 128) 0 ada_in2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale3 (UpSampling2D) (None, 64, 64, 128) 0 leaky2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in3 (InputLayer) [(None, 64, 64, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z3 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv3 (Conv2D) (None, 64, 64, 128) 147584 upscale3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise3 (Dense) (None, 64, 64, 128) 256 noise_in3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise3 (Add) (None, 64, 64, 128) 0 conv3[0][0] \n",
+ " noise3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale3 (Dense) (None, 128) 16512 mapping_network[3][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias3 (Dense) (None, 128) 16512 mapping_network[3][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in3 (AdaIN) (None, 64, 64, 128) 0 add_noise3[0][0] \n",
+ " scale3[0][0] \n",
+ " bias3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky3 (LeakyReLU) (None, 64, 64, 128) 0 ada_in3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "image_output (Conv2D) (None, 64, 64, 1) 129 leaky3[0][0] \n",
+ "==================================================================================================\n",
+ "Total params: 1,840,321\n",
+ "Trainable params: 1,840,321\n",
+ "Non-trainable params: 0\n",
+ "__________________________________________________________________________________________________\n",
+ "\n",
+ "Model architecture plots saved to ./output/\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan = model.StyleGAN(dataset=None,\n",
+ " dataset_path='C:/AKOA_Analysis',\n",
+ " dataset_name='oai akoa knees',\n",
+ " target_image_dims=(64, 64),\n",
+ " epochs=60,\n",
+ " batch_size=32,\n",
+ " z_length=512,\n",
+ " save_progress_plots=False,\n",
+ " show_progress_plots=True,\n",
+ " progress_plot_batch_interval=10,\n",
+ " save_model_checkpoints=False,\n",
+ " model_checkpoint_interval=20,\n",
+ " save_directory='./output',\n",
+ " print_model_summaries=True,\n",
+ " running_in_notebook=True)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan.train()"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# OASIS Brains\n",
+ "NOTE: Please update the path to your local OASIS Brain training images folder."
+ ],
+ "metadata": {
+ "collapsed": false
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loading dataset from C:/OASIS_brains/keras_png_slices_train at (64, 64) resolution.\n",
+ "Found 9664 files belonging to 1 classes.\n",
+ "Sample from dataset:\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "OASIS Brains hyperparameter presets loaded.\n",
+ "Generator model constructed.\n",
+ "Discriminator model constructed.\n",
+ "\n",
+ "Model: \"discriminator\"\n",
+ "_________________________________________________________________\n",
+ "Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ "image_in (InputLayer) [(None, 64, 64, 1)] 0 \n",
+ "_________________________________________________________________\n",
+ "convstart (Conv2D) (None, 64, 64, 256) 2560 \n",
+ "_________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 64, 64, 256) 590080 \n",
+ "_________________________________________________________________\n",
+ "avg_pool0 (AveragePooling2D) (None, 32, 32, 256) 0 \n",
+ "_________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 32, 32, 256) 590080 \n",
+ "_________________________________________________________________\n",
+ "avg_pool1 (AveragePooling2D) (None, 16, 16, 256) 0 \n",
+ "_________________________________________________________________\n",
+ "conv2 (Conv2D) (None, 16, 16, 256) 590080 \n",
+ "_________________________________________________________________\n",
+ "avg_pool2 (AveragePooling2D) (None, 8, 8, 256) 0 \n",
+ "_________________________________________________________________\n",
+ "conv3 (Conv2D) (None, 8, 8, 256) 590080 \n",
+ "_________________________________________________________________\n",
+ "avg_pool3 (AveragePooling2D) (None, 4, 4, 256) 0 \n",
+ "_________________________________________________________________\n",
+ "conv_final (Conv2D) (None, 4, 4, 32) 73760 \n",
+ "_________________________________________________________________\n",
+ "flatten_conv (Flatten) (None, 512) 0 \n",
+ "_________________________________________________________________\n",
+ "classification_out (Dense) (None, 1) 513 \n",
+ "=================================================================\n",
+ "Total params: 2,437,153\n",
+ "Trainable params: 2,437,153\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n",
+ "\n",
+ "Model: \"generator\"\n",
+ "__________________________________________________________________________________________________\n",
+ "Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ "const (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "const_expander (Dense) (None, 4096) 2101248 const[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "const_reshape (Reshape) (None, 4, 4, 256) 0 const_expander[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale0 (UpSampling2D) (None, 8, 8, 256) 0 const_reshape[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in0 (InputLayer) [(None, 8, 8, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z0 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv0 (Conv2D) (None, 8, 8, 256) 590080 upscale0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise0 (Dense) (None, 8, 8, 256) 512 noise_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "mapping_network (Functional) (None, 256) 74432 z0[0][0] \n",
+ " z1[0][0] \n",
+ " z2[0][0] \n",
+ " z3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise0 (Add) (None, 8, 8, 256) 0 conv0[0][0] \n",
+ " noise0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale0 (Dense) (None, 256) 65792 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias0 (Dense) (None, 256) 65792 mapping_network[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in0 (AdaIN) (None, 8, 8, 256) 0 add_noise0[0][0] \n",
+ " scale0[0][0] \n",
+ " bias0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky0 (LeakyReLU) (None, 8, 8, 256) 0 ada_in0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale1 (UpSampling2D) (None, 16, 16, 256) 0 leaky0[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in1 (InputLayer) [(None, 16, 16, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z1 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv1 (Conv2D) (None, 16, 16, 256) 590080 upscale1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise1 (Dense) (None, 16, 16, 256) 512 noise_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise1 (Add) (None, 16, 16, 256) 0 conv1[0][0] \n",
+ " noise1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale1 (Dense) (None, 256) 65792 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias1 (Dense) (None, 256) 65792 mapping_network[1][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in1 (AdaIN) (None, 16, 16, 256) 0 add_noise1[0][0] \n",
+ " scale1[0][0] \n",
+ " bias1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky1 (LeakyReLU) (None, 16, 16, 256) 0 ada_in1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale2 (UpSampling2D) (None, 32, 32, 256) 0 leaky1[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in2 (InputLayer) [(None, 32, 32, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z2 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv2 (Conv2D) (None, 32, 32, 256) 590080 upscale2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise2 (Dense) (None, 32, 32, 256) 512 noise_in2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise2 (Add) (None, 32, 32, 256) 0 conv2[0][0] \n",
+ " noise2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale2 (Dense) (None, 256) 65792 mapping_network[2][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias2 (Dense) (None, 256) 65792 mapping_network[2][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in2 (AdaIN) (None, 32, 32, 256) 0 add_noise2[0][0] \n",
+ " scale2[0][0] \n",
+ " bias2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky2 (LeakyReLU) (None, 32, 32, 256) 0 ada_in2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "upscale3 (UpSampling2D) (None, 64, 64, 256) 0 leaky2[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise_in3 (InputLayer) [(None, 64, 64, 1)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "z3 (InputLayer) [(None, 512)] 0 \n",
+ "__________________________________________________________________________________________________\n",
+ "conv3 (Conv2D) (None, 64, 64, 256) 590080 upscale3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "noise3 (Dense) (None, 64, 64, 256) 512 noise_in3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "add_noise3 (Add) (None, 64, 64, 256) 0 conv3[0][0] \n",
+ " noise3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "scale3 (Dense) (None, 256) 65792 mapping_network[3][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "bias3 (Dense) (None, 256) 65792 mapping_network[3][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "ada_in3 (AdaIN) (None, 64, 64, 256) 0 add_noise3[0][0] \n",
+ " scale3[0][0] \n",
+ " bias3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "leaky3 (LeakyReLU) (None, 64, 64, 256) 0 ada_in3[0][0] \n",
+ "__________________________________________________________________________________________________\n",
+ "image_output (Conv2D) (None, 64, 64, 1) 257 leaky3[0][0] \n",
+ "==================================================================================================\n",
+ "Total params: 5,064,641\n",
+ "Trainable params: 5,064,641\n",
+ "Non-trainable params: 0\n",
+ "__________________________________________________________________________________________________\n",
+ "\n",
+ "Model architecture plots saved to ./output/\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan = model.StyleGAN(dataset=None,\n",
+ " dataset_path='C:/OASIS_brains/keras_png_slices_train',\n",
+ " dataset_name='oasis brains',\n",
+ " target_image_dims=(64, 64),\n",
+ " epochs=30,\n",
+ " batch_size=32,\n",
+ " z_length=512,\n",
+ " save_progress_plots=False,\n",
+ " show_progress_plots=True,\n",
+ " progress_plot_batch_interval=10,\n",
+ " save_model_checkpoints=False,\n",
+ " model_checkpoint_interval=20,\n",
+ " save_directory='./output',\n",
+ " print_model_summaries=True,\n",
+ " running_in_notebook=True)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "gan.train()\n"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "name": "base",
+ "language": "python",
+ "display_name": "base"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/recognition/44776859_StyleGAN/model.py b/recognition/44776859_StyleGAN/model.py
new file mode 100644
index 0000000000..a6c38bd152
--- /dev/null
+++ b/recognition/44776859_StyleGAN/model.py
@@ -0,0 +1,709 @@
+"""
+StyleGAN implementation.
+
+@author Christopher Atkinson
+@email c.atkinson@uqconnect.edu.au
+"""
+
+import os
+
+# Suppress tensorflow logging:
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+import tensorflow as tf
+
+# Set tf memory growth, verify version and cuda/gpu functionality.
+print(f'\nTensorflow version: {tf.__version__}')
+print(f'Tensorflow CUDA {"is" if tf.test.is_built_with_cuda() else "is not"} available.')
+gpus = tf.config.experimental.list_physical_devices('GPU')
+if gpus:
+ try:
+ for gpu in gpus:
+ tf.config.experimental.set_memory_growth(gpu, True)
+ print('Tensorflow set GPU memory growth to True.')
+ except RuntimeError as e:
+ print(e)
+print(f'Tensorflow {"is" if tf.executing_eagerly() else "is not"} executing eagerly.')
+
+import tensorflow_datasets as tfds
+
+from tensorflow.keras import Model
+from tensorflow.keras.layers import Input, Add, Dense, Flatten, Reshape, LeakyReLU, ReLU, \
+ Conv2D, AveragePooling2D, UpSampling2D
+from tensorflow.keras.initializers import GlorotNormal
+from tensorflow.keras.layers.experimental.preprocessing import Rescaling
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.losses import BinaryCrossentropy
+from tensorflow.keras import backend as K
+
+import numpy as np
+from numpy import average
+import itertools
+import matplotlib as mpl
+from matplotlib import pyplot as plt, gridspec, colors, cm
+from matplotlib.ticker import FuncFormatter
+from IPython import display
+import time
+
+# Colours used in plots.
+dark = '#191b26'
+darker = '#151722'
+cream = '#b3b5be'
+mint = '#67a39a'
+
+# Setting matplotlib to dark mode.
+mpl.rcParams['text.color'] = cream
+mpl.rcParams['axes.labelcolor'] = cream
+mpl.rcParams['axes.facecolor'] = dark
+mpl.rcParams['axes.edgecolor'] = cream
+mpl.rcParams['figure.facecolor'] = darker
+mpl.rcParams['xtick.color'] = cream
+mpl.rcParams['ytick.color'] = cream
+
+
+class AdaIN(tf.keras.layers.Layer):
+ """
+ Apply instanced scale and bias to normalised input.
+ """
+ def __init__(self, epsilon=1e-5, **kwargs):
+ super(AdaIN, self).__init__(**kwargs)
+ self.epsilon = epsilon # To avoid dividing by zero.
+
+ def call(self, inputs, *args, **kwargs):
+ """
+ Normalises x, then applies individual scale and bias to each channel(feature) of x,
+ for every element in the batch.
+ """
+ x, scale, bias = inputs
+
+ # Reshape (batch*len) y vectors into (batch,1,1,len) to support batched multiplication.
+ scale = tf.reshape(scale, shape=(-1, 1, 1, tf.shape(scale)[-1]))
+ bias = tf.reshape(bias, shape=(-1, 1, 1, tf.shape(bias)[-1]))
+
+ # Normalise input to be centered on 0 with standard deviation of 1.
+ mean = K.mean(x, axis=(1, 2), keepdims=True)
+ stddev = K.std(x, axis=(1, 2), keepdims=True) + self.epsilon
+ x_norm = (x - mean) / stddev
+
+ return (x_norm * scale) + bias
+
+
+class StyleGAN:
+ """Tensorflow 2 StyleGAN implementation."""
+
+ def __init__(self, dataset=None, dataset_path=None, dataset_name='', target_image_dims=(64, 64),
+ epochs=999, batch_size=32, z_length=100, save_progress_plots=True, show_progress_plots=True,
+ progress_plot_batch_interval=50, save_model_checkpoints=False, model_checkpoint_interval=15,
+ save_directory='./output', print_model_summaries=True, running_in_notebook=False):
+ """
+ Initialise generator and discriminator, and read in dataset.
+
+ :param dataset: (Optional) pass in your own dataset.
+ :param dataset_path: Path to local dataset. Path should lead to a folder of images.
+ :param dataset_name: Key words to describe the dataset (eg. 'oasis', 'knee', 'mnist').
+ :param target_image_dims: The desired dimensions to reshape the input to and shape the output to.
+ Dimensions must be square and must not exceed the input data dimensions.
+ :param epochs: Number of epochs to train for.
+ :param batch_size: Number of samples per batch. Lower this if training fails due to OOM.
+ :param z_length: Length of the latent vector z. 100 is sufficient for MNIST Digits, but larger datasets
+ require ~512 to avoid mode collapse.
+ :param save_progress_plots: Whether to export progress plots.
+ :param show_progress_plots: Whether to show progress plots (only set to true if running in jupyter notebook)
+ :param progress_plot_batch_interval: How often to generate a new progress plot.
+ :param save_model_checkpoints: Whether or not to save model checkpoints.
+ :param model_checkpoint_interval: How many epochs to have elapsed before saving a new model checkpoint.
+ :param save_directory: Path to save progress plots and checkpoints to.
+ :param print_model_summaries: Whether to print summaries of models upon creation.
+ :param running_in_notebook: Whether this is being executed in a jupyter notebook.
+ """
+ self.dataset = dataset
+ self.epochs = epochs
+ self.batch_size = batch_size
+ self.z_length = z_length
+ self.jupyter = running_in_notebook
+ self.save_progress_plots = save_progress_plots
+ self.show_progress_plots = show_progress_plots
+ self.progress_interval = progress_plot_batch_interval
+ self.save_model_checkpoints = save_model_checkpoints
+ self.model_checkpoint_interval = model_checkpoint_interval
+
+ # Set up output directories.
+ self.save_directory = save_directory
+ self.plot_directory = save_directory + '/progress_plots'
+ self.checkpoint_directory = save_directory + '/model_checkpoints'
+ for path in (self.save_directory, self.plot_directory, self.checkpoint_directory):
+ if not os.path.exists(path) and os.access(os.path.dirname(path), os.W_OK):
+ os.makedirs(path, exist_ok=True)
+ print(f'Created folder: {path}')
+
+ self.max_graphed = 50 # Number of loss values to use in progress plot.
+ self.colorbar_norm = mpl.colors.TwoSlopeNorm(vmin=-1.05, vcenter=-0.1, vmax=1.05)
+
+ # Whether to use MNIST dataset from tfds or read in dataset from provided path.
+ if dataset is None and dataset_path:
+ self.dataset = self.get_local_image_dataset(dataset_path, target_image_dims)
+ elif any(name in dataset_name for name in ('mnist', 'digit')):
+ self.dataset = self.get_mnist_dataset()
+ self.check_dataset()
+
+ # Determine image dimensions
+ image = list(self.dataset.take(1).as_numpy_iterator())[0][0]
+ self.image_size = image.shape[0]
+ self.num_channels = image.shape[-1]
+
+ self.start_size, self.num_blocks = self._smallest_by_halving()
+
+ self.params = self.get_hyperparameters(dataset_name)
+
+ self.generator = self.make_generator()
+ self.discriminator = self.make_discriminator()
+
+ # Determine number of trainable weights in each model.
+ self.num_gen_weights = int(np.sum([np.prod(v.get_shape()) for v in self.generator.trainable_weights]))
+ self.num_disc_weights = int(np.sum([np.prod(v.get_shape()) for v in self.discriminator.trainable_weights]))
+
+ self.gen_optimizer = Adam(learning_rate=self.params['learning_rate_gen'], beta_1=self.params['beta_1'])
+ self.disc_optimizer = Adam(learning_rate=self.params['learning_rate_disc'], beta_1=self.params['beta_1'])
+
+ self.checkpoint_prefix = os.path.join(self.checkpoint_directory, "ckpt")
+ self.checkpoint = tf.train.Checkpoint(generator_optimizer=self.gen_optimizer,
+ discriminator_optimizer=self.disc_optimizer,
+ generator=self.generator,
+ discriminator=self.discriminator)
+
+ # Common seed comprising input z and noise, to be used repeatedly within progress plots.
+ self.progress_seed = self.generate_inputs(batch_size=8)
+
+ self.g_losses, self.d_real_losses, self.d_fake_losses = [], [], []
+ self.g_loss_avg, self.d_fake_loss_avg, self.d_real_loss_avg, self.d_loss_avg = 0, 0, 0, 0
+ self.balance = 0 # Adversarial balance.
+
+ self.start_time = 0
+ self.iteration = 0
+ self.num_batches = len(self.dataset) - 1
+ self.current_batch = 0
+ self.current_epoch = 0
+
+ # Determine variance of dataset (within shuffled sample).
+ self.dataset_variance, self.dataset_variance_sum = self._calculate_variance(
+ list(self.dataset.take(1).as_numpy_iterator())[0])
+
+ if print_model_summaries:
+ print()
+ self.discriminator.summary()
+ print()
+ self.generator.summary()
+ print()
+ self.output_model_plots()
+
+ def get_hyperparameters(self, dataset_name):
+ """
+ Retrieves the optimised hyperparameters for the named dataset.
+ :param dataset_name: Key words describing dataset.
+ """
+ dataset_name = dataset_name.lower()
+ print()
+ if any(name in dataset_name for name in ('mnist', 'digits')):
+ print('MNIST Digits hyperparameter presets loaded.')
+ # Tested at (28,28,1) image size.
+ params = {
+ 'learning_rate_gen': 0.0002,
+ 'learning_rate_disc': 0.0002,
+ 'beta_1': 0.5,
+ 'gen_filters': 32,
+ 'disc_filters': 16,
+ }
+ elif any(name in dataset_name for name in ('celeba', 'faces')):
+ print('CelebA Faces hyperparameter presets loaded.')
+ # Tested at (64,64,1) image size.
+ params = {
+ 'learning_rate_gen': 0.00005,
+ 'learning_rate_disc': 0.00005,
+ 'beta_1': 0.5,
+ 'gen_filters': 128,
+ 'disc_filters': 64,
+ }
+ elif any(name in dataset_name for name in ('brains', 'oasis')):
+ print('OASIS Brains hyperparameter presets loaded.')
+ # Tested at (64,64,1) image size.
+ params = {
+ 'learning_rate_gen': 0.00002,
+ 'learning_rate_disc': 0.00001,
+ 'beta_1': 0.5,
+ 'gen_filters': 256,
+ 'disc_filters': 256,
+ }
+ elif any(name in dataset_name for name in ('oai', 'akoa', 'knees')):
+ print('OAI AKOA Knee hyperparameter presets loaded.')
+ # Tested at (64, 64, 1) image size.
+ params = {
+ 'learning_rate_gen': 0.00002,
+ 'learning_rate_disc': 0.00001,
+ 'beta_1': 0.5,
+ 'gen_filters': 128,
+ 'disc_filters': 64,
+ }
+ else: # Default
+ print('WARNING: Default hyperparameter presets loaded. These may not work well with your dataset.')
+ params = {
+ 'learning_rate_gen': 0.0002,
+ 'learning_rate_disc': 0.0002,
+ 'beta_1': 0.5,
+ 'gen_filters': 64,
+ 'disc_filters': 32,
+ }
+ return params
+
+ def get_mnist_dataset(self):
+ """Retrieve MNIST Digits dataset from tfds. Normalise, shuffle and batch the dataset."""
+ dataloader = tfds.load('mnist', as_supervised=True)
+ dataset = dataloader['train']
+ # Cast [0,255] images to [-1,1].
+ dataset = dataset.map(lambda image, label: Rescaling(scale=1. / 127.5, offset=-1)(image))
+ dataset = dataset.shuffle(self.batch_size).batch(self.batch_size).prefetch(buffer_size=tf.data.AUTOTUNE)
+ print('MNIST Digits dataset loaded.')
+ return dataset
+
+ def get_local_image_dataset(self, path, image_dims, make_grayscale=True):
+ """
+ Retrieve dataset from provided path, before rescaling pixel values to [-1,1] and converting to grayscale.
+
+ :param path: Path to dataset (must be a folder containing only images).
+ :param image_dims: Dimensions to scale images to.
+ :param make_grayscale: Whether or not to convert images to grayscale.
+ :return:
+ """
+ print(f'Loading dataset from {path} at {image_dims} resolution.')
+ dataset = tf.keras.preprocessing.image_dataset_from_directory(path,
+ labels=None,
+ label_mode=None,
+ image_size=image_dims,
+ smart_resize=True,
+ shuffle=True,
+ batch_size=self.batch_size)
+ # Rescale all [0,255] images to [-1,1], as our generator outputs with tanh. Also convert to 1-channel.
+ dataset = dataset.map(lambda x: Rescaling(scale=1. / 127.5, offset=-1)(
+ tf.image.rgb_to_grayscale(x) if make_grayscale else x))
+ dataset = dataset.shuffle(self.batch_size).prefetch(buffer_size=tf.data.AUTOTUNE)
+ return dataset
+
+ def check_dataset(self):
+ """Retrieve and plot one sample from the active dataset."""
+ print('Sample from dataset:')
+ batch = self.dataset.take(1)
+ image = list(batch.as_numpy_iterator())[0][0]
+ plt.axis('off')
+ plt.tight_layout()
+ plt.imshow(image, cmap='gray')
+ plt.show()
+
+ def _calculate_variance(self, images, epsilon=1e-7):
+ """
+ Calculate pixel-wise variance among all permutations of image pairs.
+
+ :param images: Array of images to use.
+ :param epsilon: Small value to avoid dividing by zero.
+ :return: pixel-wise variance, and sum of variance.
+ """
+ diff, count = np.zeros(shape=images[0].shape), 0
+ for x in itertools.combinations(images, 2): # Compute all permutations of pairs.
+ diff = diff + np.abs(x[0] - x[1]) + epsilon
+ count += 1
+ if count > 500: # Short-circuit if the sample is too large.
+ break
+ diff = diff / count
+ return diff, np.sum(diff)
+
+ def output_model_plots(self):
+ """Write image of model architectures to directory."""
+ tf.keras.utils.plot_model(self.generator, show_shapes=True,
+ to_file=self.save_directory + '/generator_plot.png')
+ tf.keras.utils.plot_model(self.discriminator, show_shapes=True,
+ to_file=self.save_directory + '/discriminator_plot.png')
+ print(f'Model architecture plots saved to {self.save_directory}/\n')
+
+ def _smallest_by_halving(self):
+ """
+ Get smallest round integer by halving the input repeatedly.
+ This becomes our starting generator convolution size.
+ Also return number of halves performed.
+ This becomes our number of generator and discriminator blocks, to
+ return us from the reduced size to the original resolution.
+ """
+ x, count = self.image_size, 0
+ while (x / 2) % 1 == 0 and (x / 2) > 2:
+ x = x / 2
+ count += 1
+ if x >= (self.image_size / 2):
+ raise ValueError(f'{self.image_size} may be unsuitable for upsampling, '
+ f'as its smallest common component is {x}, '
+ f'which is >= input of {self.image_size}.')
+ return int(x), count
+
+ def _disc_block(self, x, size, i, reduce=True):
+ """
+ Modular discriminator block
+ :param x: Input matrix.
+ :param size: Number of filters.
+ :param i: Which numbered block this is.
+ :param reduce: Whether to apply pooling.
+ """
+ x = Conv2D(filters=size, kernel_size=3, strides=1, padding='same',
+ kernel_initializer=GlorotNormal(), activation=None,
+ name=f'conv{i}')(x)
+ if reduce:
+ x = AveragePooling2D(name=f'avg_pool{i}')(x)
+ return LeakyReLU(0.2)(x)
+
+ def _gen_block(self, x, w, noise, size, i):
+ """
+ Modular generator block.
+ :param x: Input matrix.
+ :param w: Latent w vector.
+ :param noise: Gaussian noise matrix.
+ :param size: Number of neurons/filters.
+ :param i: Which numbered block this is.
+ """
+ # Affine transformation A:
+ scale = Dense(size, name=f'scale{i}')(w)
+ bias = Dense(size, name=f'bias{i}')(w)
+ # Transformation B:
+ noise = Dense(size, name=f'noise{i}')(noise)
+
+ x = UpSampling2D(name=f'upscale{i}')(x)
+ x = Conv2D(filters=size, kernel_size=3, strides=1, padding='same',
+ kernel_initializer=GlorotNormal(), use_bias=False,
+ activation=None, name=f'conv{i}')(x)
+ x = Add(name=f'add_noise{i}')([x, noise])
+ x = AdaIN(name=f'ada_in{i}')([x, scale, bias])
+ return ReLU(name=f'relu{i}')(x)
+
+ def make_generator(self):
+ """Construct generator (synthesis network)"""
+ # Process all inputs - const vector, z vectors and noise matrices.
+ const = Input(shape=(self.z_length,), name='const')
+ z, noise, size = [], [], self.start_size
+ for i in range(self.num_blocks):
+ z.append(Input(shape=(self.z_length,), name=f'z{i}'))
+ noise.append(Input(shape=(size * 2, size * 2, self.num_channels), name=f'noise_in{i}'))
+ size *= 2
+
+ # Mapping network
+ latents = Input(shape=(self.z_length,), name='z_input')
+ w = Dense(64, activation=LeakyReLU(0.2), name='w0')(latents)
+ for i in range(6):
+ w = Dense(64, activation=LeakyReLU(0.2), name=f'w{i + 1}')(w)
+ w = Dense(self.params['gen_filters'], activation=LeakyReLU(0.2), name=f'w7')(w)
+ map = Model(inputs=latents, outputs=w, name='mapping_network')
+
+ # Start block
+ x = Dense(self.start_size * self.start_size * self.params['gen_filters'],
+ use_bias=True, activation='relu', kernel_initializer=GlorotNormal(),
+ name='const_expander')(const)
+ x = Reshape([self.start_size, self.start_size, self.params['gen_filters']], name='const_reshape')(x)
+
+ # Generator blocks
+ for i in range(self.num_blocks):
+ w = map(z[i])
+ x = self._gen_block(x, w, noise[i], self.params['gen_filters'], i)
+
+ # Convert to n-channel image with values bounded by tanh.
+ image = Conv2D(filters=1, kernel_size=1, strides=1, padding='same',
+ kernel_initializer=GlorotNormal(), activation='tanh', name='image_output')(x)
+
+ model = Model(inputs=[const] + z + noise, outputs=[image], name='generator')
+ print('Generator model constructed.')
+ return model
+
+ def make_discriminator(self):
+ """Construct discriminator."""
+ image = Input([self.image_size, self.image_size, self.num_channels], name='image_in')
+
+ # Start block
+ x = self._disc_block(image, self.params['disc_filters'], 'start', reduce=False)
+
+ # Discriminator blocks
+ for i in range(self.num_blocks):
+ x = self._disc_block(x, self.params['disc_filters'], i, reduce=True)
+
+ # Output block - was the image fake or real?
+ x = Conv2D(filters=32, kernel_size=3, strides=1, padding='same',
+ kernel_initializer=GlorotNormal(), activation=LeakyReLU(0.2), name='conv_final')(x)
+ x = Flatten(name='flatten_conv')(x)
+ classification = Dense(1, activation='sigmoid', name='classification_out')(x)
+
+ model = Model(inputs=image, outputs=classification, name='discriminator')
+ print('Discriminator model constructed.')
+ return model
+
+ def generate_inputs(self, batch_size):
+ """
+ Randomly generated latent z vectors and noise matrices to use as inputs to the generator.
+ :param batch_size: Number of samples to return.
+ """
+ const = tf.random.normal(mean=0., stddev=1., shape=(batch_size, self.z_length))
+ z, noise, size = [], [], self.start_size
+ for i in range(self.num_blocks):
+ # Latent z vectors.
+ z.append(tf.random.normal(mean=0., stddev=1., shape=(batch_size, self.z_length)))
+ # Random noise matrices.
+ noise.append(
+ tf.random.normal(mean=0., stddev=1., shape=(batch_size, size * 2, size * 2, self.num_channels)))
+ # Double the size of noise matrices each iteration, as each block outputs an up-scaled image.
+ size *= 2
+ return [const] + z + noise
+
+ def _update_avg_losses(self):
+ """Compute weighted moving average of loss values, to show adversarial balance in colorbar."""
+ if len(self.g_losses) > 10:
+ weights = np.arange(1, 11)
+ self.g_loss_avg = round(average(self.g_losses[len(self.d_fake_losses) - 10:], weights=weights), 3)
+ self.d_fake_loss_avg = round(average(self.d_fake_losses[len(self.d_fake_losses) - 10:], weights=weights), 3)
+ self.d_real_loss_avg = round(average(self.d_real_losses[len(self.d_real_losses) - 10:], weights=weights), 3)
+ elif len(self.g_losses) > 0:
+ weights = np.arange(1, len(self.g_losses) + 1)
+ self.g_loss_avg = round(average(self.g_losses, weights=weights), 3)
+ self.d_fake_loss_avg = round(average(self.d_fake_losses, weights=weights), 3)
+ self.d_real_loss_avg = round(average(self.d_real_losses, weights=weights), 3)
+ self.d_loss_avg = (self.d_fake_loss_avg + self.d_real_loss_avg) / 2
+ # Balance is the difference between the weighted average of generator and discriminator losses.
+ # Negative balance implies a weak discriminator, while positive balance implies a weak generator.
+ # Ideal balance is 0.
+ self.balance = self.g_loss_avg - self.d_loss_avg
+ # Bound the value between [-1,1] so we don't draw off the edge of the bar.
+ if self.balance < -1:
+ self.balance = -1
+ elif self.balance > 1:
+ self.balance = 1
+
+ def _plot_gan_progress(self):
+ """
+ Plot sample generated images over losses, balance and variance during training.
+ """
+ if not self.jupyter:
+ # Matplotlib does not automatically close plots outside of jupyter.
+ plt.close('all')
+
+ self._update_avg_losses()
+
+ # Generate generator sample images.
+ gen_images = self.generator(self.progress_seed, training=False)
+
+ # Calculate pixel-wise variance among generated samples.
+ sample_variance, var_sum = self._calculate_variance(gen_images)
+ # Convert sum of variance to a percentage of dataset variance.
+ var_percent = (var_sum / self.dataset_variance_sum) * 100
+
+ fig = plt.figure(constrained_layout=False, figsize=(14.5, 11))
+ fig.suptitle(f'Trainable parameters of Generator: {self.num_gen_weights:,}, '
+ f'Discriminator: {self.num_disc_weights:,}\n'
+ f'Epoch {self.current_epoch:03} / {self.epochs} | '
+ f'Batch {self.current_batch:03} / {self.num_batches} | '
+ f'Time elapsed: {round(((time.time() - self.start_time) / 60) / 60, 3):.3f} hours',
+ size=15, linespacing=1.6)
+
+ # Parent container gridspec.
+ gs0 = gridspec.GridSpec(ncols=1, nrows=2, height_ratios=[2, 1], width_ratios=[1], figure=fig,
+ left=0.045, right=0.955, top=.925, bottom=0.035, hspace=0.1)
+ # Top gridspec (images).
+ gs1 = gs0[0, 0].subgridspec(ncols=4, nrows=2, height_ratios=[1, 1], width_ratios=[1, 1, 1, 1],
+ wspace=.05, hspace=.05)
+ # Bottom gridspec (losses and balance).
+ gs2 = gs0[1, 0].subgridspec(ncols=3, nrows=1, height_ratios=[1], width_ratios=[5, 0.7, 2],
+ wspace=.1, hspace=0)
+
+ # Create sample image subplots.
+ ax = []
+ for i in range(2):
+ for j in range(4):
+ ax.append(fig.add_subplot(gs1[i, j]))
+
+ # Create subplots for losses, balance and variance.
+ ax8 = fig.add_subplot(gs2[0, 0]) # Losses
+ ax9 = fig.add_subplot(gs2[0, 1]) # Balance
+ ax10 = fig.add_subplot(gs2[0, 2]) # Variance
+
+ # Plot Generator sample images.
+ for i in range(gen_images.shape[0]):
+ ax[i].imshow(gen_images[i].numpy(), cmap='gray')
+ ax[i].axes.xaxis.set_visible(False)
+ ax[i].axes.yaxis.set_visible(False)
+
+ # Plot losses of generator and discriminator.
+ ax8.set_title('StyleGAN Generator and Discriminator binary cross-entropy losses over time', size=14)
+ ax8.set_xticklabels([])
+ # Truncate loss lists to only keep n latest values.
+ if len(self.g_losses) >= self.max_graphed:
+ self.g_losses = self.g_losses[len(self.g_losses) - self.max_graphed:]
+ self.d_real_losses = self.d_real_losses[len(self.d_real_losses) - self.max_graphed:]
+ self.d_fake_losses = self.d_fake_losses[len(self.d_fake_losses) - self.max_graphed:]
+ ax8.plot(self.g_losses, c=mint, label=f'Generator loss')
+ ax8.plot(self.d_real_losses, c='purple', label=f'Discriminator loss vs real')
+ ax8.plot(self.d_fake_losses, c='#ff884d', label=f'Discriminator loss vs fake')
+ # Put loss value at tail end of each loss line.
+ ax8.text(x=len(self.g_losses) - 1, y=self.g_losses[-1], s=f'{round(self.g_losses[-1], 3):.3f}')
+ ax8.text(x=len(self.d_real_losses) - 1, y=self.d_real_losses[-1], s=f'{round(self.d_real_losses[-1], 3):.3f}')
+ ax8.text(x=len(self.d_fake_losses) - 1, y=self.d_fake_losses[-1], s=f'{round(self.d_fake_losses[-1], 3):.3f}')
+ # Allow room for text at the end.
+ ax8.set_xlim((0, int(self.max_graphed + (self.max_graphed * 0.04))))
+ # Force y axis tick labels to have exactly two decimals, to stop graph width jumping.
+ ax8.get_yaxis().set_major_formatter(FuncFormatter(lambda x, p: f'{x:0.2f}'))
+ # Force 1 tick mark per value.
+ ax8.xaxis.set_major_locator(plt.MaxNLocator(int(self.max_graphed + (self.max_graphed * 0.04))))
+ # Show background grid. Draws lines from each tick label.
+ ax8.grid(color='gray', alpha=0.2)
+ # Move legend to the left after lines reach the halfway point.
+ ax8.legend(loc='upper right' if len(self.g_losses) < self.max_graphed / 2 else 'upper left', fontsize=13)
+
+ # Plot adversarial balance colorbar.
+ ax9.set_title('Weak Generator', size=11)
+ ax9.set_xlabel('Weak Discriminator', size=11)
+ cb = fig.colorbar(mpl.cm.ScalarMappable(norm=self.colorbar_norm, cmap='rainbow'), cax=ax9)
+ ax9.set_yticklabels([])
+ cb.ax.yaxis.set_ticks_position('none')
+ cb.ax.set_ylabel('Adversarial Balance', fontsize=12, labelpad=2)
+ cb.ax.yaxis.set_label_position('left')
+ # Plot acceptable midpoints.
+ cb.ax.axhline(y=0.15, c='gray', linestyle='--', linewidth=1)
+ cb.ax.axhline(y=-0.15, c='gray', linestyle='--', linewidth=1)
+ # Plot actual balance line.
+ cb.ax.axhline(y=self.balance, c='black', linestyle='-', linewidth=7)
+ cb.ax.axhline(y=self.balance, c='lime' if -0.15 < self.balance < 0.15 else 'red', linestyle='-', linewidth=5)
+
+ # Plot generator variance.
+ ax10.set_title(f'Generator variance: {int(round(var_percent)):03}%', size=14)
+ ax10.imshow(sample_variance, cmap='viridis')
+ ax10.axes.xaxis.set_visible(False)
+ ax10.axes.yaxis.set_visible(False)
+
+ self.iteration += 1
+ if self.save_progress_plots:
+ plt.savefig(f'{self.plot_directory}/step_{self.iteration:08}.png')
+ if self.show_progress_plots:
+ plt.show()
+
+ def _disc_loss(self, real_output, fake_output):
+ """
+ How well the discriminator can distinguish real from fake images.
+ :param real_output: Classifications of real images.
+ :param fake_output: Classifications of fake images.
+ :return: Loss on real images, loss on fake images.
+ """
+ # Compare predictions on real images to array of ones.
+ real_loss = BinaryCrossentropy(label_smoothing=0.2)(tf.ones_like(real_output), real_output)
+ # Compare predictions on fake images to array of zeroes.
+ fake_loss = BinaryCrossentropy(label_smoothing=0.2)(tf.zeros_like(fake_output), fake_output)
+
+ return real_loss, fake_loss
+
+ def _gen_loss(self, fake_output):
+ """
+ How well the generator can fool the discriminator.
+ We get this loss from the discriminator, and pass it to the generator.
+ :param fake_output: Discriminator classification of fake images.
+ :return: Loss of discriminator on fake images, inverted.
+ """
+ # Compare discriminator decisions to array of ones.
+ return BinaryCrossentropy()(tf.ones_like(fake_output), fake_output)
+
+ @tf.function
+ def train_step(self, images):
+ """
+ Conduct forward and backward pass, updating weights of each model
+ by their loss.
+ :param images: Batch of images (either real or fake)
+ :return: Losses, for plotting only.
+ """
+ # Random latent space input for generator.
+ inputs = self.generate_inputs(batch_size=self.batch_size)
+
+ # Track gradients of each model.
+ # ie. Track what happened in what order during forward pass.
+ with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
+ # Forward pass.
+ generated_images = self.generator(inputs, training=True)
+
+ real_output = self.discriminator(images, training=True)
+ fake_output = self.discriminator(generated_images, training=True)
+
+ g_loss = self._gen_loss(fake_output)
+ d_real_loss, d_fake_loss = self._disc_loss(real_output, fake_output)
+ d_loss = d_real_loss + d_fake_loss
+
+ # Backward pass.
+ # Calculate gradient for each models trainable weights.
+ gradients_of_generator = gen_tape.gradient(g_loss, self.generator.trainable_variables)
+ gradients_of_discriminator = disc_tape.gradient(d_loss, self.discriminator.trainable_variables)
+
+ # Update generator and discriminator weights with gradients.
+ self.gen_optimizer.apply_gradients(zip(gradients_of_generator, self.generator.trainable_variables))
+ self.disc_optimizer.apply_gradients(zip(gradients_of_discriminator, self.discriminator.trainable_variables))
+
+ return g_loss, d_real_loss, d_fake_loss
+
+ def train(self):
+ """Training loop."""
+ self.start_time = time.time()
+ for epoch in range(1, self.epochs + 1):
+ epoch_start_time = time.time()
+ self.current_epoch = epoch
+
+ for i, image_batch in enumerate(self.dataset):
+ self.current_batch = i
+
+ # Start training step, tracking losses.
+ g_loss, d_real_loss, d_fake_loss = self.train_step(image_batch)
+ g_loss, d_real_loss, d_fake_loss = g_loss.numpy(), d_real_loss.numpy(), d_fake_loss.numpy()
+
+ # Update output graph every n batches.
+ if (self.save_progress_plots or self.show_progress_plots) and i % self.progress_interval == 0:
+ self.g_losses.append(g_loss)
+ self.d_real_losses.append(d_real_loss)
+ self.d_fake_losses.append(d_fake_loss)
+ if self.jupyter:
+ display.clear_output(wait=True)
+ self._plot_gan_progress()
+ if not self.jupyter or not self.show_progress_plots:
+ # Print training progress.
+ print(
+ f'\rEpoch {epoch:03} / {self.epochs} | batch {i:03} / {self.num_batches} | '
+ f'g_loss: {round(g_loss, 4):.4f} | d_fake_loss: {round(d_fake_loss, 4):.4f} | '
+ f'd_real_loss: {round(d_real_loss, 4):.4f} | '
+ f'Time taken: {round(((time.time() - epoch_start_time) / 60), 2):.2f} minutes', end='')
+ print()
+
+ # Save model checkpoint every n epochs.
+ if self.save_model_checkpoints and epoch % self.model_checkpoint_interval == 0:
+ self.checkpoint.save(file_prefix=self.checkpoint_prefix)
+
+
+if __name__ == '__main__':
+ # This is used for testing. The driver script is where you should execute training.
+ gan = StyleGAN(dataset=None,
+
+ # dataset_path=None,
+ # dataset_name='mnist digits',
+
+ # dataset_path='C:/img_align_celeba',
+ # dataset_name='celeb faces',
+
+ dataset_path='C:/AKOA_Analysis',
+ dataset_name='oai akoa knees',
+
+ # dataset_path='C:/OASIS_brains/keras_png_slices_train',
+ # dataset_name='oasis brains',
+
+ target_image_dims=(64, 64),
+ epochs=999,
+ batch_size=32,
+ z_length=512,
+ save_progress_plots=True,
+ show_progress_plots=False,
+ progress_plot_batch_interval=10,
+ save_model_checkpoints=False,
+ model_checkpoint_interval=20,
+ save_directory='C:/stylegan_output',
+ print_model_summaries=True,
+ running_in_notebook=False)
+
+ gan.train()
diff --git a/recognition/44776859_StyleGAN/resources/adversarial_balance.png b/recognition/44776859_StyleGAN/resources/adversarial_balance.png
new file mode 100644
index 0000000000..9a7a589f27
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/adversarial_balance.png differ
diff --git a/recognition/44776859_StyleGAN/resources/bad_variance.png b/recognition/44776859_StyleGAN/resources/bad_variance.png
new file mode 100644
index 0000000000..f2073d4330
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/bad_variance.png differ
diff --git a/recognition/44776859_StyleGAN/resources/brain_output.png b/recognition/44776859_StyleGAN/resources/brain_output.png
new file mode 100644
index 0000000000..1260b5d19a
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/brain_output.png differ
diff --git a/recognition/44776859_StyleGAN/resources/celeba_output.png b/recognition/44776859_StyleGAN/resources/celeba_output.png
new file mode 100644
index 0000000000..1e876e33ac
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/celeba_output.png differ
diff --git a/recognition/44776859_StyleGAN/resources/chosen_task.png b/recognition/44776859_StyleGAN/resources/chosen_task.png
new file mode 100644
index 0000000000..e29ff60796
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/chosen_task.png differ
diff --git a/recognition/44776859_StyleGAN/resources/discriminator_plot.png b/recognition/44776859_StyleGAN/resources/discriminator_plot.png
new file mode 100644
index 0000000000..848743c874
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/discriminator_plot.png differ
diff --git a/recognition/44776859_StyleGAN/resources/generator_plot.png b/recognition/44776859_StyleGAN/resources/generator_plot.png
new file mode 100644
index 0000000000..75e45a2d0a
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/generator_plot.png differ
diff --git a/recognition/44776859_StyleGAN/resources/good_variance.png b/recognition/44776859_StyleGAN/resources/good_variance.png
new file mode 100644
index 0000000000..50c80b2b0c
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/good_variance.png differ
diff --git a/recognition/44776859_StyleGAN/resources/knee_output.png b/recognition/44776859_StyleGAN/resources/knee_output.png
new file mode 100644
index 0000000000..269fa92dd4
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/knee_output.png differ
diff --git a/recognition/44776859_StyleGAN/resources/mnist_output.png b/recognition/44776859_StyleGAN/resources/mnist_output.png
new file mode 100644
index 0000000000..474bda8a96
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/mnist_output.png differ
diff --git a/recognition/44776859_StyleGAN/resources/stylegan_architecture.png b/recognition/44776859_StyleGAN/resources/stylegan_architecture.png
new file mode 100644
index 0000000000..fcc9ce28b3
Binary files /dev/null and b/recognition/44776859_StyleGAN/resources/stylegan_architecture.png differ
diff --git a/recognition/44802020_facebook_gcn/README.md b/recognition/44802020_facebook_gcn/README.md
new file mode 100644
index 0000000000..02326841b8
--- /dev/null
+++ b/recognition/44802020_facebook_gcn/README.md
@@ -0,0 +1,178 @@
+# Facebook Graph Convolutional Neural Network
+
+**Name**: John Parsons
+
+**Student Number**: 44802020
+
+**Student Email**: john.parsons@uqconnect.edu.au
+
+**Task**: Facebook Large Page-Page Network Dataset (Task 2)
+
+* * *
+### Contents
+* [Introduction to the Problem and the Dataset](#Introduction to the Problem and the Dataset)
+* [The Algorithm](#The Algorithm)
+* [Project Structure](#Project Structure)
+* [Running the Model and Dependencies](#Running the Model and Dependencies)
+* [Data and Training](#Data and Training)
+* [Building the Model](#Building the Model)
+* [Compiling the Model](#Compiling the Model)
+* [Performance and Analysis](#Performance and Analysis)
+* * *
+
+### Introduction to the Problem and the Dataset
+
+The data is a connected graph of Facebook pages which can each be categorised
+as 1 of 4 types of pages (TV Shows, Companies, Government Agencies or
+Politicians). The model is a Graph Convolutional Neural Network (GCN) which
+aims to be able to categorise a given page into one of these 4 categories. The
+data set contains 22470 nodes.
+
+Using SciKitLearn's TSNE analysis, the data generates the following TSNE plot:
+
+.png)
+
+### The Algorithm
+
+The algorithm revolves around taking advantage of the fact that any given node
+may be likely to be of the same category as its neighbours.
+
+We take the normalized Adjacency Matrix A_bar (where all nodes are self connected)
+and multiply it by the Feature Matrix and by the Weights Matrix. The result is then
+run through an activation function (I used softmax) and the loss is calculated with
+a loss function (I used Sparse Categorical Cross Entropy). The then model tries to
+minimize this loss with an optimization function (I used Adam) and adjusts the
+Weights Matrices accordingly.
+
+Overtime, hopefully, the losses will be minimized by optimal weights and the model
+will become more accurate.
+
+### Project Structure
+
+There are two `.py` files in the project as well as a `resources` folder:
+- `myGraphModel.py`: This file contains the code involved in creating the
+Model. This consists of one class (`FaceGCNLayer`, which represents my
+custom network layer) and one function (`makeMyModel`, which creates a
+model which represents mt GCN and contains all the relevant layers).
+
+- `driver.py`: This fie is responsible for parsing the data, calling `makeMyModel`
+from `myGraphModel.py`, parsing and splitting the data in training/validation sets,
+running the model, tracking and displaying the progress/accuracy of the model and
+plotting a TSNE plot of the data.
+- `resources`: This is where you should put the `facebook.npz` file. This is
+also where the images embedded in this file are stored.
+
+### Running the Model and Dependencies
+
+To run the model, run `driver.py.main()`. Ensure that the `FILE_PATH` variable is set
+to the location of the `facebook.npz` file. The `facebook.npz` file will need to be
+downloaded to an appropriate local location. by default the `FILE_PATH` variable points
+to the `resources` folder in the same directory as the `driver.py` file. The user can
+easily adjust the following
+model variables prior to running:
+- `PLOT_TSNE`: Set whether you want to plot accuracy.
+- `PLOT_ACCURACY`: Set whether you want to plot accuracy.
+- `EPOCHS`: Set the number of epochs over which the Model should train.
+- `LEARNING_RATE`: Set the Model learning rate.
+- `TRAIN_SPLIT`: The portion of the data to split into the training set.
+- `TEST_VAL_SPLIT`: The portion of the data to split into the test/validation set.
+
+The user should also ensure that the following **dependencies** are installed and up to date:
+
+- Tensorflow 2.6.0
+- Keras 2.6.0
+- Scipy 1.7.1
+- Numpy 1.19.5
+- Sklearn 1.0.1
+- Matplotlib 3.4.3
+
+### Data and Training
+
+The dataset has a stated density of 0.001, making it a very sparse graph.
+This is ideal for use of a Tensorflow Sparse Tensor to improve performance.
+
+An 80:20 Training:Testing/Validation split was used. This is because the fast nature
+of the model (Using Sparse Tensors and multiple Dense layers to reduce
+dimensionality, as well as a relatively small dataset) mean it would be
+ideal for the model to be trained as large a portion of the data as possible.
+
+It is however, as was found in testing, very easy for a GCN model to over-fit to
+data. It was therefore not feasible to split the data 90:10, or something similar,
+as it was important that the model's accuracy could be validated on a large
+testing/validation set to ensure it is not over-fitted.
+
+### Building the Model
+
+The model is built by calling the `makeMyModel` function in `myGraphModel.py`.
+This function creates a `tensorflow.keras.models.Sequential` object and adds
+the following layers to it, where N is the number of nodes (varies between
+training and testing/validation).
+* * *
+| Layer (type) | Output Shape | Param # |
+| --------------------------------- | ------------ | ------- |
+| `face_gcn_layer (FaceGCNLayer)` | (N, 128) | 128 |
+| `dropout (Dropout)` | (N, 128) | 0 |
+| `dense (Dense)` | (N, 64) | 8256 |
+| `face_gcn_layer_1 (FaceGCNLayer)` | (N, 64) | 64 |
+| `dropout_1 (Dropout)` | (N, 64) | 0 |
+| `dense_1 (Dense)` | (N, 32) | 2080 |
+| `face_gcn_layer_2 (FaceGCNLayer)` | (N, 32) | 32 |
+| `dropout_2 (Dropout)` | (N, 32) | 0 |
+| `dense_2 (Dense)` | (N, 4) | 132 |
+* * *
+The model uses 4 categories of layers:
+- **FaceGCNLayer Layers**: This is the layer responsible for the computation.
+- **Reduction Dense Layers**: These layers exist to reduce the dimensionality
+of the data to allow more epochs to be run more quickly.
+- **Dropout Layers**: These layers randomly drop a portion of the weights to 0.
+This helps to avoid over-fitting.
+- **Final Dense Layer**: This layer is required to categorise each node into
+one of 4 categories using 'softmax' activation.
+
+### Compiling the Model
+
+**Optimizer:** For optimization I used Sparse Categorical Cross Entropy.
+Categorical Cross Entropy is used to calculate loss when dealing with multiple
+categories. Sparse Categorical Cross Entropy is the same, only it allows for
+the use of Sparse Tensors.
+
+**Loss Function:** Adam, the default Keras model loss function was used.
+this is because while other Loss functions were tested (including Nadam
+and Adamax), none yielded any significant improvement in terms of accuracy.
+
+### Performance and Analysis
+
+The model reaches around 72% Validated Accuracy with 200 epochs,
+plateauing at this value at around 30 epochs.
+
+.png)
+
+The data plateau is likely due to the model over-fitting. I tried to remedy
+this by using Dropout layers, as these would randomly eliminate some
+weights responsible for the over-fitting. THis did help initially as the
+model was plateauing at around 53%, but the model still plateaus at 72%
+
+As can be seen from the following TSNE plots (one of the training data
+one of the testing data), while there are pockets that are clearly segmented,
+the data overall is not very neatly segmented. This indicates that the
+different categories share many similar features, making it difficult to
+accurately categorise the nodes.
+
+.png)
+
+.png)
+
+This difficulty makes the 72% accuracy achieved somewhat reasonable, although
+it may be further improved. The inclusion of Skip Connections could help, although
+it is not possible to do with a Sequential Model and would require the model to be
+redesigned in a non-sequential manner.
+
+Like-wise, the Sequential model does not allow
+multiple arguments to be passed to the layers. This means that the layer behaviour
+can only change based on whether the layer is training or testing but not on whether
+it is testing or validating (This is why the data is only split into Train/Testing
+and not Train/Validate/Test).
+
+In summary, redesigning the model in a non-sequential form would allow for several
+avenues of potential improvement.
+
diff --git a/recognition/44802020_facebook_gcn/driver.py b/recognition/44802020_facebook_gcn/driver.py
new file mode 100644
index 0000000000..e70b2158dc
--- /dev/null
+++ b/recognition/44802020_facebook_gcn/driver.py
@@ -0,0 +1,272 @@
+import random
+
+import myGraphModel
+import tensorflow as tf
+import keras
+import scipy
+import sklearn
+import matplotlib
+
+from tensorflow.keras import losses
+import tensorflow.keras.optimizers as op
+import scipy.sparse as spr
+import numpy as np
+
+from sklearn.manifold import TSNE
+import matplotlib.pyplot as plt
+
+# ========================= GLOBAL VARIABLES =========================
+# !!! IMPORTANT !!!
+# Ensure valid file path to facebook.npz here
+# Should be in the resources folder, which is in the same directory as this file
+FILE_PATH = r"./resources/facebook.npz"
+
+# Plotting Variables
+PLOT_TSNE = False # Set whether or not you want to plot accuracy
+PLOT_ACCURACY = False # Set whether or not you want to plot accuracy
+
+# model Variables
+EPOCHS = 200 # Set the number of epochs over which the Model should train
+LEARNING_RATE = 0.01 # Set the Model learning rate
+
+# Data Splitting Variables
+TRAIN_SPLIT = 0.80
+TEST_VAL_SPLIT = 0.20
+# ====================================================================
+
+
+def coo_matrix_to_sparse_tensor(coo):
+ """
+ Converts a scipy COO Sparse Matrix to a Tensorflow Sparse Tensor
+ Args:
+ coo: Scipy COO Sparse Matrix to be converted
+
+ Returns: The Tensorflow Sparse Tensor representation of the input matrix
+
+ """
+ indices = np.mat([coo.row, coo.col]).transpose()
+ return tf.SparseTensor(indices, coo.data, coo.shape)
+
+
+def normalize_adjacency_matrix(a_bar):
+ """
+ Normalizes the Adjacency Matrix for the model by applying matrix multiplication between the Adjacency Matrix and the
+ inverse square root od the D matrix.
+ Args:
+ a_bar: The Adjacency Matrix to normalise
+
+ Returns: A normalised version of the input matrix
+
+ """
+ row_sum = np.array(a_bar.sum(1))
+ d_inv_sqr = np.power(row_sum, -0.5).flatten()
+ d_inv_sqr[np.isinf(d_inv_sqr)] = 0
+ d_mat_inv_sqrt = spr.diags(d_inv_sqr)
+ a_bar = a_bar.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).tocoo()
+ return a_bar
+
+
+def generate_tsne_plot(labels, feats, mode):
+ """
+ Generates and plots
+ Args:
+ labels:
+ feats: The feature matrix of the nodes to be plotted
+ mode: Whether the test data or the train data is being plotted
+
+ Returns:
+
+ """
+ # TSNE
+ print("Executing TSNE, this might take a moment...")
+ tsne = TSNE(2)
+ tsne_data = tsne.fit_transform(feats)
+
+ plt.figure(figsize=(6, 5))
+ plt.scatter(tsne_data[labels == 0, 0], tsne_data[labels == 0, 1], c='b', alpha=0.5, marker='.', label='TV Show')
+ plt.scatter(tsne_data[labels == 1, 0], tsne_data[labels == 1, 1], c='r', alpha=0.5, marker='.', label='Company')
+ plt.scatter(tsne_data[labels == 2, 0], tsne_data[labels == 2, 1], c='g', alpha=0.5, marker='.', label='Government')
+ plt.scatter(tsne_data[labels == 3, 0], tsne_data[labels == 3, 1], c='m', alpha=0.5, marker='.', label='Politician')
+ plt.title(f"GCN TSNE Plot ({mode} Data)")
+ plt.legend()
+ plt.show()
+
+
+def generate_accuracy_plot(history):
+ """
+ Plots the Test Accuracy and Validation Accuracy of the model over the number of epochs.
+ Args:
+ history: history object generated by model.fit()
+
+ """
+ plt.plot(history.history['accuracy'], label='Test Accuracy')
+ plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+ plt.title("GCN Accuracy over epochs")
+ plt.ylabel("Accuracy")
+ plt.xlabel("Epochs")
+ plt.legend()
+ plt.show()
+
+
+def shuffle(page_one, page_two, feats, labels):
+ """
+ Shuffles input data, while preserving indexing.
+ Args:
+ page_one: First column of the edge list
+ page_two: First column of the edge list
+ feats: Feature matrix
+ labels: Page labels
+
+ Returns: All inputs, now shuffled
+
+ """
+ z = list(zip(page_one, page_two, feats, labels))
+ random.shuffle(z)
+ page_one, page_two, feats, labels = zip(*z)
+
+ return page_one, page_two, feats, labels
+
+
+def parse_data(data, train_val_split):
+ """
+ Takes the dataset from facebook.npz and parses it into usable Tensors. Also splits data into training/testing sets
+ and converts the dataset's Edge-List to an Adjacency Matrix in the form of a Sparse Tensor.
+ Args:
+ data: the dataset loaded from facebook.npz
+ train_val_split: The float split between training and testing/validation
+
+ Returns:Separate tensors containing the labels, features and adjacency matrices for both training and testing
+
+ """
+ # Adjacency Matrix
+ # Split EdgeList into two tensors
+ page_one = data['edges'][:, 0]
+ page_two = data['edges'][:, 1]
+ # Features
+ feats = tf.convert_to_tensor(data['features'])
+ # Labels
+ labels = tf.convert_to_tensor(data['target'])
+
+ # Split Data
+ # Data needs to be manually split here because the current implementation requires
+ page_one, page_two, feats, labels = shuffle(page_one, page_two, feats, labels)
+
+ page_one = tf.convert_to_tensor(page_one)
+ page_two = tf.convert_to_tensor(page_two)
+ feats = tf.convert_to_tensor(feats)
+ labels = tf.convert_to_tensor(labels)
+
+ # Convert split percentage into integer
+ print(labels.shape[0])
+ split_t = int(round(labels.shape[0] * (1 - train_val_split)))
+
+ train_labels, test_labels = labels[:split_t], labels[split_t:]
+ train_feats, test_feats = feats[:split_t], feats[split_t:]
+
+ # Convert EdgeList to Sparse Adjacency Matrix
+ ones = tf.ones_like(page_one) # Create Ones Matrix to set
+ a_bar = spr.coo_matrix((ones, (page_one, page_two))) # Convert to SciPy COO Matrix
+ a_bar.setdiag(1) # Make all nodes adjacent to themselves
+
+ a_dense = a_bar.todense() # Convert to Dense to easily split into test/train
+
+ # Re-create two adjacency matrices for training/testing
+ a_bar = a_dense[:split_t, :split_t]
+ a_bar_test = a_dense[split_t-1:, split_t-1:]
+
+ # Convert back to COO Matrix
+ a_bar = spr.coo_matrix(a_bar)
+ a_bar_test = spr.coo_matrix(a_bar_test)
+
+ # Normalize
+ a_bar = normalize_adjacency_matrix(a_bar=a_bar)
+ a_bar_test = normalize_adjacency_matrix(a_bar=a_bar_test)
+
+ # Convert to Sparse Tensor
+ a_bar = coo_matrix_to_sparse_tensor(a_bar)
+ a_bar_test = coo_matrix_to_sparse_tensor(a_bar_test)
+
+ return train_feats, train_labels, a_bar, test_feats, test_labels, a_bar_test
+
+
+def ensure_valid_split(train, test):
+ """
+ Checks that the combination of train and test is valid (i.e. if the sum to 1)
+ Args:
+ train: A float between 0-1, representing the portion of data to be used for training
+ test: A float between 0-1, representing the portion of data to be used for testing/validation
+
+ Returns: True if combination is valid, otherwise exits program.
+
+ """
+ if train+test == 1.0:
+ return True
+ else:
+ print("Train Split + Validation Split + Test Split must equal 1.0.")
+ print("Please ensure values for these variables sum to 1.0")
+ exit(1)
+
+
+def main():
+ print("Tensorflow version:", tf.__version__)
+ print("Numpy version:", np.__version__)
+ print("SciPy version:", scipy.__version__)
+ print("SkLearn version:", sklearn.__version__)
+ print("Matplotlib version:", matplotlib.__version__)
+ print("Keras version:", keras.__version__)
+
+ # Variables
+ ensure_valid_split(TEST_VAL_SPLIT, TRAIN_SPLIT)
+
+ # Load in Data
+ data = np.load(FILE_PATH)
+ # There are 22 470 Pages
+ # Each with 128 features
+ # Each falls into 1 of 4 categories
+ # # 0 -> TV Show
+ # # 1 -> Company
+ # # 2 -> Government
+ # # 3 -> Politician
+ # There are 342 004 Edges between the pages
+
+ # test_split = 0.2
+ train_feats, train_labels, a_bar, \
+ test_feats, test_labels, a_bar_test, = parse_data(data, TEST_VAL_SPLIT)
+
+ # ================== REAL MODEL ========================
+ print("=============== Building Model ===============")
+ # Construct Model
+ my_model = myGraphModel.makeMyModel(a_bar, a_bar_test, train_feats)
+
+ loss_fn = losses.SparseCategoricalCrossentropy(from_logits=False)
+ opt = op.Adam(learning_rate=LEARNING_RATE)
+ my_model.compile(optimizer=opt, loss=loss_fn, metrics=['accuracy'])
+
+ # ================== RUN MODEL ========================
+ # Train Model
+ history = my_model.fit(train_feats,
+ train_labels,
+ epochs=EPOCHS,
+ batch_size=22470, shuffle=False,
+ validation_data=(test_feats, test_labels))
+
+ print(my_model.summary())
+
+ # Evaluate Model
+ my_model.evaluate(test_feats,
+ test_labels,
+ batch_size=22470)
+
+ # Plot Accuracy
+ if PLOT_ACCURACY:
+ generate_accuracy_plot(history)
+
+ # Plot TSNE
+ if PLOT_TSNE:
+ generate_tsne_plot(train_labels, train_feats, "Train")
+ generate_tsne_plot(test_labels, test_feats, "Test")
+
+
+if __name__ == '__main__':
+ main()
+
diff --git a/recognition/44802020_facebook_gcn/myGraphModel.py b/recognition/44802020_facebook_gcn/myGraphModel.py
new file mode 100644
index 0000000000..bafb2f16ba
--- /dev/null
+++ b/recognition/44802020_facebook_gcn/myGraphModel.py
@@ -0,0 +1,59 @@
+import keras.initializers.initializers_v1
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Input, Dropout
+
+
+def makeMyModel(a_bar, a_bar_test, train_feats):
+ """
+ Creates a model with the desired layers.
+ Args:
+ a_bar: The Adjacency Matrix for the training data.
+ a_bar_test: The Adjacency Matrix for the training data.
+ train_feats: The Feature Matrix for the training data. This is required to know the input dimensions.
+
+ Returns: A `tensorflow.keras.models.Sequential` model, containing all of the appropriate layers added in
+ this function.
+
+ """
+ my_model = Sequential()
+
+ my_model.add(Input(shape=tf.Tensor.get_shape(train_feats)))
+
+ my_model.add(FaceGCNLayer(a_bar, a_bar_test))
+ my_model.add(Dropout(0.4))
+ my_model.add(Dense(64))
+ my_model.add(FaceGCNLayer(a_bar, a_bar_test))
+ my_model.add(Dropout(0.4))
+ my_model.add(Dense(32))
+ my_model.add(FaceGCNLayer(a_bar, a_bar_test))
+ my_model.add(Dropout(0.4))
+ my_model.add(Dense(4, activation='softmax'))
+
+ return my_model
+
+
+class FaceGCNLayer(tf.keras.layers.Layer):
+ """
+ My custom network layer.
+ """
+ def __init__(self, adj_m, test_adj_m):
+ super(FaceGCNLayer, self).__init__()
+ self.adj_m = adj_m
+ self.test_adj_m = test_adj_m
+
+ def build(self, input_shape):
+ self.weights1 = self.add_weight("weights1",
+ shape=(1, input_shape[-1]),
+ initializer=keras.initializers.initializers_v1.RandomNormal)
+
+ def call(self, feature_matrix, training=None):
+ feature_matrix = tf.squeeze(feature_matrix)
+ if training:
+ ax = tf.sparse.sparse_dense_matmul(tf.cast(self.adj_m, float), feature_matrix)
+ z = ax * self.weights1
+ else:
+ ax = tf.sparse.sparse_dense_matmul(tf.cast(self.test_adj_m, float), feature_matrix)
+ z = ax * self.weights1
+
+ return z
diff --git a/recognition/44802020_facebook_gcn/resources/Learning_(200).png b/recognition/44802020_facebook_gcn/resources/Learning_(200).png
new file mode 100644
index 0000000000..e7a923293c
Binary files /dev/null and b/recognition/44802020_facebook_gcn/resources/Learning_(200).png differ
diff --git a/recognition/44802020_facebook_gcn/resources/TSNE_Plot_(Test Data).png b/recognition/44802020_facebook_gcn/resources/TSNE_Plot_(Test Data).png
new file mode 100644
index 0000000000..c521f19b16
Binary files /dev/null and b/recognition/44802020_facebook_gcn/resources/TSNE_Plot_(Test Data).png differ
diff --git a/recognition/44802020_facebook_gcn/resources/TSNE_Plot_(Train Data).png b/recognition/44802020_facebook_gcn/resources/TSNE_Plot_(Train Data).png
new file mode 100644
index 0000000000..73faf23855
Binary files /dev/null and b/recognition/44802020_facebook_gcn/resources/TSNE_Plot_(Train Data).png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-0.png b/recognition/45005172_StyleGAN/Generated-img/img-0.png
new file mode 100644
index 0000000000..16785d26c3
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-1.0.png b/recognition/45005172_StyleGAN/Generated-img/img-1.0.png
new file mode 100644
index 0000000000..2528d0de2b
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-1.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-10.0.png b/recognition/45005172_StyleGAN/Generated-img/img-10.0.png
new file mode 100644
index 0000000000..d253338c9f
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-10.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-14.0.png b/recognition/45005172_StyleGAN/Generated-img/img-14.0.png
new file mode 100644
index 0000000000..268024f5ad
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-14.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-3.0.png b/recognition/45005172_StyleGAN/Generated-img/img-3.0.png
new file mode 100644
index 0000000000..cac6153a87
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-3.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-5.0.png b/recognition/45005172_StyleGAN/Generated-img/img-5.0.png
new file mode 100644
index 0000000000..71bf6accf0
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-5.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-65.0.png b/recognition/45005172_StyleGAN/Generated-img/img-65.0.png
new file mode 100644
index 0000000000..201bf1d06b
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-65.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-72.0.png b/recognition/45005172_StyleGAN/Generated-img/img-72.0.png
new file mode 100644
index 0000000000..248e4d64dc
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-72.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-80.0.png b/recognition/45005172_StyleGAN/Generated-img/img-80.0.png
new file mode 100644
index 0000000000..165dc73e10
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-80.0.png differ
diff --git a/recognition/45005172_StyleGAN/Generated-img/img-88.0.png b/recognition/45005172_StyleGAN/Generated-img/img-88.0.png
new file mode 100644
index 0000000000..31e9ef9293
Binary files /dev/null and b/recognition/45005172_StyleGAN/Generated-img/img-88.0.png differ
diff --git a/recognition/45005172_StyleGAN/Misc/Disc.png b/recognition/45005172_StyleGAN/Misc/Disc.png
new file mode 100644
index 0000000000..f950acdc0a
Binary files /dev/null and b/recognition/45005172_StyleGAN/Misc/Disc.png differ
diff --git a/recognition/45005172_StyleGAN/Misc/Gen1.png b/recognition/45005172_StyleGAN/Misc/Gen1.png
new file mode 100644
index 0000000000..513ad08b0c
Binary files /dev/null and b/recognition/45005172_StyleGAN/Misc/Gen1.png differ
diff --git a/recognition/45005172_StyleGAN/Misc/Gen2.png b/recognition/45005172_StyleGAN/Misc/Gen2.png
new file mode 100644
index 0000000000..0d7fb356cd
Binary files /dev/null and b/recognition/45005172_StyleGAN/Misc/Gen2.png differ
diff --git a/recognition/45005172_StyleGAN/Misc/Gen3.png b/recognition/45005172_StyleGAN/Misc/Gen3.png
new file mode 100644
index 0000000000..316e2a94f3
Binary files /dev/null and b/recognition/45005172_StyleGAN/Misc/Gen3.png differ
diff --git a/recognition/45005172_StyleGAN/Misc/StyleGANArchitecture.png b/recognition/45005172_StyleGAN/Misc/StyleGANArchitecture.png
new file mode 100644
index 0000000000..eda642e34a
Binary files /dev/null and b/recognition/45005172_StyleGAN/Misc/StyleGANArchitecture.png differ
diff --git a/recognition/45005172_StyleGAN/README.md b/recognition/45005172_StyleGAN/README.md
new file mode 100644
index 0000000000..fa78aa7c62
--- /dev/null
+++ b/recognition/45005172_StyleGAN/README.md
@@ -0,0 +1,142 @@
+StyleGAN
+========
+Generative model of the [OASIS brain](https://www.oasis-brains.org/) data set using [StyleGAN](https://arxiv.org/pdf/1812.04948v2.pdf)
+
+**Author:** *Avinash Chandra(45005172)*
+
+* [StyleGAN Architecture](#StyleGAN-Architecture)
+* [Report's StyleGAN Design](#Reports's-StyleGAN-Design)
+ + [GAN](#1.-GAN)
+ + [StyleGAN Training](#2.-StyleGAN-Training)
+ + [Data Processing](#3.-Data-Processing)
+* [Executing Code](#Executing-Code)
+* [Results](#Results)
+* [References](#References)
+
+## StyleGAN Architecture
+
+Generative Adversarial Networks (GANs) are used to generate high-quality synthetic images.
+
+Tradidional GANs have two components namely, Generator and Discriminator. Generator takes a point in latent space as input and generates specified image as output while, the Discriminator diffrentiate real images from the fake or generated ones (positive values for real and negative values for fake images). The Generator and Discriminator works in adversery with each other while training, hence the name Generative Adverserial Network.
+
+A technique called Progressive Growing GAN (PGGAN) is employed to generate large/high-quality images by progressively incresing the number of layers while training.
+
+The StyleGAN incorporates progressive growing generator of the PGGAN along with some more modifications in the generator. The modifications to a traditional generator are as follows:
+* Baseline Progressive GAN
+* \+ Tuning (including bilinear upsampling)
+* \+ Mapping and styles
+* \- Traditional Inputs
+* \+ Mixing regularization
+
+
+
+
+
+ Figure 1: Traditional vs StyleGAN Generator Architecture
+
+ In traditional generator, latent vectors directly pass into the block while in StyleGAN, latent vectors after normalisation pass through the mapping network followed by being transformed (Affline Transformation) and passed to generator and noise B is added after the instance normalisation (AdaIN)
+
+
+## Report's StyleGAN Design
+Official StyleGAN on Tensorflow was done by [NVLabs(NVIDIA Corporation)](https://github.com/NVlabs/stylegan). StyleGAN implementation for this report is inspired by the [StyleGAN implementation by Keras](https://keras.io/examples/generative/stylegan/).
+The goal for this implementation is to produce 256x256 images trained on preprocessed [OASIS brain](https://www.oasis-brains.org/) dataset provided by the University.
+
+The implementation for the report is based on Tensorflow2.X.
+Keras on top of the Tensorflow is used for modeling the StyleGAN.
+Some of the notable components of report's StyleGAN implementation are listed below. However, every other components including ones listed below are commented in the Jupyter notebook file [styleGAN.ipynb](styleGAN.ipynb)
+
+### 1. GAN
+A baseline DCGAN is used with few custom layers added in the Generator, while the Discriminirator remains fairly normal. The repeated segments of Generator and Discriminator are made by Generator and Discriminator blocks respectively.
+
+#### 1.1 Generator
+The main changes to a DCGAN are made by adding 8 layers for style mapping and addition of AdaIN (Adaptive Normalisation) in each Generator Block. The idea behind Style mapping is to reduce chances of mixing of styles of different images, for instance, in case of generating faces we don't want skin of an old person and an infant to be mixed. While, the AdaIN applies latent vector in each block of the generator. Biliner upsampling is also incorporated in the GAN blocks which is done in all but the first generator block.
+Picture below summarises the Generator model.
+
+
+
+
+
+ Figure 2: Generator Model Summary
+
+
+#### 1.2 Discriminator
+The discriminator is a fairly typical DCGAN discriminator, downsampling is done in all but the last discriminator block. Figure below summarises the Discriminator model.
+
+
+
+ Figure 3: Discriminator Model Summary
+
+
+### 2. StyleGAN Training
+In the training of StyleGAN Mixing regularization and GP Loss has been incorporated. For mixing regularzation two noise vectors have been generated for the training with one having more prevelence than other (Probalility = 0.9).
+The Gradient penalty loss is added to the discriminator loss, the rationale behind incorporating this loss to prevent discriminator dictating generator to make big changes hence resulting in [mode collapse](https://developers.google.com/machine-learning/gan/problems).
+
+
+### 3. Data Processing
+For the training, the images in training directory are converted to numpy array and are trained in batch of 12 images. For saving the generated images [Pillow](https://pillow.readthedocs.io/en/stable/) a fork of python imaging library has been used.
+
+## Executing Code
+The code can be executed by executing the "Train Model" code block in [styleGAN.ipynb](styleGAN.ipynb). Before the training, png files from source directory needs to be converted to numpy array by passing data directory path as an argument to function [convert_to_npy](), which will then save the data as .npy file in the directory [OASIS-Brain-npy](OASIS-Brain-npy). A detailed comment on useage is provided in the markdown parts of [styleGAN.ipynb](styleGAN.ipynb).
+
+## Results
+The model trained for around 50000 epoches generating 90 images of 256x256 each. Training took ~10 hours on NVIDIA GTX1080. Few of the generated images are listed below. The sample images are also in the [Generated-img](Generated-img) directory.
+#### Without Training:
+
+
+
+ Figure 4: Generated image without training
+
+
+#### Early stages of training:
+
+
+
+
+
+
+
+ Figure 5: Generated images in early stages of training
+
+
+#### Later stages of training:
+
+
+
+
+
+
+
+ Figure 6: Generated images in later stages of training
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+ 
+
+
+ 
+ 
+
+ Figure 2: Generator Model Summary
+
+
+ Figure 3: Discriminator Model Summary
+
+
+ Figure 4: Generated image without training
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+