{"cells":[{"metadata":{},"cell_type":"markdown","source":"# **Image segmentation using Unet architecture and TFrecords**\n### Authors: Muhammad Valiallah and Martin Page"},{"metadata":{},"cell_type":"markdown","source":"## Abstract\n\nWe are presented with images of kidney tissue. These images are supplemented with a CSV file where for each image the pixel location of glomeruli cells (spherical capsules) are indicated. The task is to take the image files as well as the pixel location of the glomeruli (referred to as masks) and train a machine learning model to find the pixel locations of glomeruli on an unlabelled data set of kidney images. \n\nThis problem is an image segmentation type problem and can be solved using an encoder-decoder architecture, where a CNN is first downsampled to extract features and then subsequently symmetrically upsampled to reproduce the image and identify the pixels containing glomeruli.\n\n### In this document we show:\n1. How to sub-sample a large image into smaller images, a process referred to as tiling.\n2. How to associate pixel lables (masks) to the image\n3. How to convert images into TensorFlow record files (TFrecord) to save on storage space as well as faster processing\n4. How to read a TFrecord\n5. How to construct a class of encoder-decoder models (UNet type model)\n6. How to use a TPU for faster machine learning\n7. How to train a UNet type model"},{"metadata":{},"cell_type":"markdown","source":"## Introduction\n\n**Image segmentation** is the process of separating a digital image into specific partitions by creating a pixel-wise mask for an object(s) of interest. Pixels are labelled if they share a certain shared characteristic. Segmentation creates a representation of an image that is easier and more meaningful to analyse.     \n\n**Problem example**: An example of a image segmentation task is a recent [Kaggle challenge](https://www.kaggle.com/c/hubmap-kidney-segmentation) where a structure in the kidney called the glomeruli, cells and capillaries that facilitate the filtration of waste products (100-350 μm in diameter; spherical shape), needed to be identified in unlablled images (on a pixel level). The functional tissue unit (FTU) that needs to be identified is a block of cells around a capillary (a 3D sphere).    \n\n**Objective of Notebook**: This notebook will walk you through a pipeline using **TF records** and the convolutional neural network **U-Net** architecture for biomedical image segmentation (also see this [academic article](https://arxiv.org/pdf/1505.04597.pdf)) using Python with tensorflow and keras.   \n"},{"metadata":{},"cell_type":"markdown","source":"## Data\nThe [data set](https://www.kaggle.com/c/hubmap-kidney-segmentation/data) contains 8 training and 5 test images as TIFF files. The images are stained (with Periodic acid Schiff stain) histology tissue sections of the kidney. The training images come with an associated mask that identifies the areas of interest that can be accessed as in both an unencoded JSON form and as a run-length encoded (RLE) form from a CSV file, which stores a sequence of data in a single value. Additional information is also available for each image such as demographic information.    \n\n### Encoding\nRun Length Encoding (RLE) is a lossless compression format. Here pixels are numbered in 1D first from top to bottom (row-wise) then from left to right.  Here the pixel locations (label) of an object are represented by two numbers. The first number refers to the starting pixel (in 1D) and the second number is the number of successive pixels that object is present on. So for example if an image has an object with pixels labelled at (789, 790, 791,900, 901, 904, 906). THe run length encoding would be 789 3 900 2 904 1 906 1.\n\nAs can be seen from the above example the RLE will only be smaller than the original image if the object of interest is dense (i.e. connected consecutively).\n\nFor this problem there is only 1 object for detection so glomeruli pixels so binary classification is used where 1 represents the presence of a glomeruli and 0 not a glomeruli.\n\n### Images\n\nThe image files are large (1-2GB) and difficult to train (computationally intensive). As a general rule of thumb many smaller images are faster to train and process than one large image of the same disk size. So the strategy is to first sub-sample the large images into smaller images before passing them on to a CNN. \n\n"},{"metadata":{},"cell_type":"markdown","source":"## Evaluation Metric: Dice Coefficient\nThe dice coefficient is used to compare the pixel-wise agreement between a predicted segmentation and the true value (ground truth) and is defined as 2 times the area of overlap between the predicted and actual value divided by the total number of pixels in both images ([see more](https://towardsdatascience.com/metrics-to-evaluate-your-semantic-segmentation-model-6bcb99639aa2)).    \nHere is the formula: $\\Large \\frac{2*|X ∩ Y|}{|X|+|Y|}$    \nAnd here is its visualisation: ![Dice](https://miro.medium.com/max/858/1*yUd5ckecHjWZf6hGrdlwzA.png)    "},{"metadata":{},"cell_type":"markdown","source":"## Libraries to import"},{"metadata":{"trusted":true},"cell_type":"code","source":"import os\nimport sys\nimport random\nimport warnings\n\nimport numpy as np\nimport pandas as pd\n\nimport math, re, os\nimport numpy as np\nimport tensorflow as tf\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport json\nimport cv2\nimport os\nimport pandas as pd\nimport gc \nimport tifffile\n\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\n\nfrom tqdm import tqdm\nfrom itertools import chain\nfrom skimage.io import imread, imshow, imread_collection, concatenate_images\nfrom skimage.transform import resize\nfrom skimage.morphology import label\n\nfrom tensorflow.keras.models import Model, load_model\nfrom tensorflow.keras.layers import Input\nfrom keras.layers.core import Dropout, Lambda\nfrom tensorflow.keras.layers import Conv2D, Conv2DTranspose, LayerNormalization\nfrom tensorflow.keras.layers import MaxPooling2D, UpSampling2D\nfrom tensorflow.keras.layers import concatenate\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\nfrom tensorflow.keras import backend as K\nfrom tensorflow.keras import layers\nfrom keras.engine.topology import Layer\nfrom tensorflow.keras.optimizers import Adam\nfrom keras.utils.generic_utils import get_custom_objects\n\nclass LayerNormalization(Layer):\n\n    def call(self, x, mask=None, training=None):\n        axis = list(range(1, len(x.shape)))\n        x /= K.std(x, axis=axis, keepdims=True) + K.epsilon()\n        x -= K.mean(x, axis=axis, keepdims=True)\n        return x\n\n    def compute_output_shape(self, input_shape):\n        return input_shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def dice_coeff(y_true, y_pred):\n    # this formula adds epsilon to the numerator and denomincator to avoid a divide by 0 error \n    # in case a slice has no pixels set; the relative values are important, so this addition\n    # does not effect the coefficient\n    _epsilon = 10 ** -7\n    intersections = tf.reduce_sum(y_true * y_pred)\n    unions = tf.reduce_sum(y_true + y_pred)\n    dice_scores = (2.0 * intersections + _epsilon) / (unions + _epsilon)\n    return dice_scores\n\n\ndef dice_loss(y_true, y_pred):\n    #defined as 1 minues the dice coefficient\n    loss = 1 - dice_coeff(y_true, y_pred)\n    return loss\n\nget_custom_objects().update({\"dice\": dice_loss})","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# We tackle this problem into two general steps\n \n1. Preparing the images for processinng (Normalising --> Tiling --> Serialising)\n2. Building a CNN and reading the serialized images (Model Definition --> Model Compilation --> Model Fitting-Model Tuning)"},{"metadata":{},"cell_type":"markdown","source":"## Data Processing: TF Records\nThe Tensorflow record is a format to store a sequence of binary record from large datasets. A major advantage of this format is the datasets that are too large to be stored fully in memory can be loaded in batches from the disk and processed ([see more](https://towardsdatascience.com/metrics-to-evaluate-your-semantic-segmentation-model-6bcb99639aa2)).  "},{"metadata":{},"cell_type":"markdown","source":"The first step is to have a look at the image arrays to get an idea of:\n1. The image shapes\n2. The image formats\n\nSteps:\n1. Look for all the tiff files in the training set.\n2. Read the images into arrays using the tifffile library.\n3. Print out the image shapes to see if there is consistency.\n4. Normalise/Standardise the images so that they are in the same format.\n5. Convert the image masks into image arrays (0s and 1s) of the same size as their associated images.\n6. Pick an image size to subsample the image (The image tile chosen must have equal dimensions and be a multiple of the number of filters in the convolutional kernals).\n7. Convert the images into a TFrecord (steps outlined later)\n"},{"metadata":{},"cell_type":"markdown","source":"This code is used to read all the tiff image file paths in the training set and put it in a list"},{"metadata":{"trusted":true},"cell_type":"code","source":"file_list = tf.io.gfile.glob('../hubmap-kidney-segmentation/train/*.tiff')        ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Normalisation function:** "},{"metadata":{},"cell_type":"markdown","source":"We noticed that the colour channel sometimes occurred in the first column and sometimes in the third. Some images allso had leading dimensions of size 1 which we remove using the squeeze function. We run the garbage collector to free up memory space after calling the function"},{"metadata":{"trusted":true},"cell_type":"code","source":"def normalize(input_image):\n    image = tifffile.imread(input_image)\n    image = tf.squeeze(image)\n    print(image.shape)\n    if image.shape[0]==3:\n        image = tf.transpose(image, [2, 1, 0])\n       #image = tf.cast(image, tf.float32) / 255.0\n    return image, image.shape[0], image.shape[1]\n    gc.collect()\n#plt.figure(figsize=(20,10))\n#plt.imshow(image)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**RLE decoder function**: "},{"metadata":{"trusted":true},"cell_type":"code","source":"def convert_rle_to_image(rle_file, image_shape):\n    image_shape = (image_shape[1], image_shape[0])\n    file_string = rle_file.split()\n    # Convert strings to integers and subtract 1 because of python's 0-indexing\n    start_pixel = np.array(file_string[0::2], dtype=int) - 1\n    length = np.array(file_string[1::2], dtype=int)\n    end_pixel = start_pixel + length\n    mask = np.zeros(image_shape[0] * image_shape[1], dtype=np.uint8)\n\n    for start, end in zip(start_pixel, end_pixel):\n        mask[start:end] = 1\n\n    return mask.reshape(image_shape).T","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"This function is used to encode an image into its run length"},{"metadata":{"trusted":true},"cell_type":"code","source":"def RLE_ENCODER(mask):\n    # add 0 to start and end so that first change will be 1s \n    #mask = np.concatenate([[0],mask,[0]])\n    mask = np.append(np.insert(mask,[0],0),0)\n    #print(mask)\n    start_of_ones = (np.where(mask[1:] != mask[:-1])[0] +1)[::2] #This gives us all changes in sequence we add 1 to get index of 1s, we want every second change i.e. 0s to 1s\n    print(start_of_ones)\n    end_of_ones = (np.where(mask[1:] != mask[:-1])[0])[1::2]\n    print(end_of_ones)\n    length_of_encoding = end_of_ones - start_of_ones +1\n    return ' '.join([(str(item1)+\" \"+str(item2)) for item1,item2 in zip(start_of_ones,length_of_encoding)])\n    ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Generating a TFRecord\n \nA Tensorflow record file consists of serialised messages which is a dictionary of a feature label and its associated value.\nTo convert images into TFrecord files we utilize the protocol tensorflow.train.Example\n\nSteps 1:\n1. Break down the image into smaller images (tiling)\n2. Create helper functions to cast datatypes into 1 of the type lists (integer,float and bytes)\n3. Create a feature dictionary which will be the contents of message. This is how we associate the image to the mask\n4. Convert the features into to bytes, a process called serialization\n5. Add the features to a message\n6. Create a tfrecord file and write the messages (image and its associated features) to it\n"},{"metadata":{},"cell_type":"markdown","source":"**Serialisation function and its helpers:**"},{"metadata":{"trusted":true},"cell_type":"code","source":"def _float_feature(value):\n  \"\"\"Returns a float_list from a float / double.\"\"\"\n  return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\n# For the mask\ndef _int64_feature(value):\n  \"\"\"Returns an int64_list from a bool / enum / int / uint.\"\"\"\n  return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))\n\ndef _bytes_feature(value):\n  \"\"\"Returns a bytes_list from a string / byte.\"\"\"\n  if isinstance(value, type(tf.constant(0))):\n    value = value.numpy() # BytesList won't unpack a string from an EagerTensor.\n  return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\n\ndef serialiaze_images(image_id, image, mask, tile_no, start_row, start_col, image_dist0, image_dist1):\n    \"\"\"\n    Creates a tf.train.Example message ready to be written to a file.\n    \"\"\"\n    image = image.numpy()\n    image_bytes = image.tobytes()\n    mask_bytes = mask.tobytes()\n    feature_dict = {\n        'image': _bytes_feature(image_bytes),\n        'mask': _bytes_feature(mask_bytes),\n        'tile_No': _int64_feature(tile_no),\n        'image_id': _bytes_feature(image_id),\n        'start_row_pixel': _int64_feature(start_row),\n        'start_col_pixel': _int64_feature(start_col),\n        'image_distribution0': _bytes_feature(image_dist0),\n        'image_distribution1': _bytes_feature(image_dist1)\n\n    }\n\n    # Create a Features message using tf.train.Example.\n    message_feature = tf.train.Example(features=tf.train.Features(feature=feature_dict))\n    return message_feature.SerializeToString()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Creating the TF record**:"},{"metadata":{"trusted":true},"cell_type":"code","source":"def create_tf_record(image_id,image,mask, tile_size,tf_record_filename):\n    tile_no = 0\n    \n    # Num_tile_cols \n    num_tile_rows =  image.shape[0] // tile_size\n    num_tile_cols =  image.shape[1] // tile_size\n    \n    compress = tf.io.TFRecordOptions(compression_type=\"GZIP\")\n    with tf.io.TFRecordWriter(tf_record_filename, compress) as writer:\n    \n        for row in range(num_tile_rows):\n            for col in range(num_tile_cols):\n                #print(tile_no)\n                start_row = row*tile_size\n                start_col = col*tile_size\n                image_tile = image[start_row:start_row+tile_size, start_col:start_col+tile_size]\n                image_dist = np.histogram(image_tile)\n                image_dist0 = image_dist[0].tobytes()\n                image_dist1 = image_dist[1].tobytes()\n                mask_tile = mask[start_row:start_row+tile_size, start_col:start_col+tile_size]\n            \n                message = serialiaze_images(image_id, image_tile, mask_tile, tile_no, start_row, start_col, image_dist0, image_dist1)\n                writer.write(message)\n                tile_no = tile_no + 1\n    writer.close()\n    tile_count = tile_no\n    return tile_count","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The code below is used to package all  steps into a single function which will generate a separate TFrecord file for."},{"metadata":{"trusted":true},"cell_type":"code","source":"def generate_tf_records(tile_size, file_list):\n    image_list = []\n    for file_name in file_list:\n        image, shape0, shape1 = normalize(file_name)\n        image_name = Path(file_name).stem\n        image_id = bytes(image_name, 'utf8')\n        tf_record_filename = 'train+'+image_name+'_'+str(tile_size)+'.tfrecords'\n        mask = convert_rle_to_image(df_train[df_train[\"id\"] == image_name][\"encoding\"].values[0], (shape0,shape1))\n        tile_count = create_tf_record(image_id, image, mask, tile_size, tf_record_filename)\n        image_list.append((image_id,tile_count))\n        gc.collect()\n    return image_list","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We now call the above function which will generate tfrecord files.\nWe define a pandas DataFrame to store the image names along with the number of tiles, this is helpful in getting an idea of how many images can be trained on. "},{"metadata":{"trusted":true},"cell_type":"code","source":"file_list = tf.io.gfile.glob('../hubmap-kidney-segmentation/train/*.tiff')        \n\ndf_image_details = pd.DataFrame(generate_tf_records(512,file_list),columns=[\"Image_id\", \"Tile_count\"])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Using TPU from Kaggle"},{"metadata":{},"cell_type":"markdown","source":"A TPU is a Tensor Processing Unit it, it has a built in distribution strategy with 8 cores. In order to use a TPU, the datasets need to be stored on Google Cloud Storage; Google Colab also has TPUs but TFrecords are not supported. In order to use the TPU functionality on Kaggle, the Tfrecords need to be uploaded to Google Cloud Storage.\n\nSteps\n1. Create a bucket on Google Cloud Storage (GCS)\n2. Link GCS drive to Kaggle Notebook (Add-ons --> Google Cloud SDK)\n3. Set the Accelarator to TPU on the Notebook\n4. Use the Secret Keys\n5. Reference the GCS bucket"},{"metadata":{},"cell_type":"markdown","source":"1. Link Notebook to GCS\n![image.png](attachment:image.png)\n2. Login to your GCS account\n![image.png](attachment:image.png)\n3. You will then be provided with the code snippet below\n","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"from kaggle_secrets import UserSecretsClient\nuser_secrets = UserSecretsClient()\nuser_credential = user_secrets.get_gcloud_credential()\nuser_secrets.set_tensorflow_credential(user_credential)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"You can now add a TPU by setting the accelerator to TPU v#-#\n![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAdEAAAFXCAYAAAD9KnReAAAgAElEQVR4Ae2di3ccR53v909Jzsk92XN1L3dvdrm72d1AWAxh8aIFgxfwEsCsdzHJgjewAbIJXifBGLLGgbxAIUC8E/yMY0WKLT8iP6KXLVmyZUuW5dFblvWypUi2Yske+3vPr2dqprvV3ZrpqZmenvnqnDoz0931q+pv/bo//auqLv0R+GdR4MqVq/CT+voHLHb4gwpQASpABcKjwL79B+CWvJjwR+E5xfzU1Essr32EaH7ah6VQASpABXKhgBtAZbvXvZ8QtbWGl1he+whRm5D8SQWoABUIkQKEqKbG8gKl1z5CVFMD0AwVoAJUIAAFCFFNonuB0msfIaqpAWiGClABKhCAAoSoJtG9QOm1jxDV1AA0QwWoABUIQAFCVJPoXqD02keIamoAmqECVIAKBKAAIapJdC9Qeu0jRDU1AM1QASpABQJQgBDVJLoXKL32EaKaGoBmqAAVoAIBKECIahLdC5Re+whRTQ1AM1SAClCBABQgRDWJ7gVKr32EqKYGoBkqQAWoQAAKEKKaRPcCpdc+QlRTA9AMFaACVCAABQhRTaJ7gdJrHyGqqQFohgpQASoQgAKEqCbRvUDptY8Q1dQANEMFqAAVCEABQlST6F6g9NpHiGpqAJqhAlSACgSgACGqSXQvUHrtI0Q1NQDNUAEqQAUCUIAQ1SS6Fyi99hGimhqAZqgAFaACAShAiGoS3QuUXvsIUU0NQDNUgApQgQAUIEQ1ie4FSq99WUH0xjRGRkYwMr2g6SxohgpQASpABTJRgBDNRC2PY71A6bUvK4iOt6GiogIVrWMeNeMuKkAFqAAVyJUChKgmZb1A6bWPENXUADRDBagAFQhAAUJUk+heoPTaR4hqagCaoQJUgAoEoAAhqkl0L1B67QscojcXsLAQT7HbmYgRS+ZbuJl+vliirIWFWPqZsjnytr96wqxLhuXn/Rwzqt8Edqy+B3fd7ZDK7seKp3ahYyYjg8mD52dmMDMlaT65zfjSsilR3hrsGLXu4i8qEHYFCFFNLegFSq99QUF0bqQdtbsj8TFVGVc1UgTVjVE4zVMaa40f0zYOLIy249B2lUc+I9hZ24FJj/lNsekomvZvs5QX2X0cXdMxwHFsdw7Rw2L7EKLXnRtpLnrIsHcoOrf4gLkRtNfuRCR5bvH6RqqbEL3qUdEbY4vzba9B2/ACcD2KQ2LvcBQOJRq6LNJ0ew2aotPwKHFx3XO6xQOiCqzLNqHV6QQ962W2uwmt5mMJUbMa/F5kChCimhrUC5Re+/IP0Rgmz1Qn4LINNXXNaD/TjvYzzahXkNvbjkmbLgqiTafbUGlAsymer+U4qiMJoDrkEzOxccmTgO2BejQb5TXFIR6pRfRicxyulglS/iEam2hP1mnbflVeO5rrarDNqEcl2q/YTlB+zkZRmziXbXuPo8miSyXaoh2uEJ2N1i7WtKUeNYmHjcqGQUfwOtQix5tMsFsVQYcROc5gZrQTOx5/KBmhPvBCZ4b1MNm9mxDNUDweHmIFCFFNjecFSq99eYfodAeqBSSR2ngUaDn/OfTVxaPT+gFr7KQgWlFRibZR6z4sjKD5zThIm4Zt3bSxETQbYKpEs0Rzlr8FjLVWpqJTLRCdRkd1HNi1XdOw1QZz/fVx2NUN2qLDWXTtd883e1FB0iESvdIef0jYW4++WcsJAjen0XVENI3ArqntyDz9NMFu9S5MmEuNtWFjWaKb94GX0TFchXXl5VheXo5Vr/eYj8R84xZju+zbWLkXPygvx4dV3rvvwzLJ98TBuH1LJDqP6O4NWLXsPtwlx63dhCMDFtPGj5nOKmxcm7BZdj+Wr92EHS2W2mJi3xOJOryG1tgEGl54BMvuuwd3JbqlnTooFpeUxpbYfKKbWnVXu3xmHL2nUTYPKXgFCFFNTeQFSq99eYeonG9sDpNOfbayb9QpKgQURPecsceocQFV12rktHX/Qv9xA5KRkyOLgBbPOYn2BICtr+r4j0SBGOauuHWhjqHZiEbbYHkx6Eo79sj2/V2wczBezwX0HYs/KFi7c2MYOSmQ3IO2cTuy4zkx04UaT9uJ4/Ly4QFRmPYZ0WQPtpYnoFoeQdRUv9ZNZYmo9THUXNyF1aor2PypIG2C6IuvPIZ7zcfI97LHUDOVMj60e83iY4w8ZVjxSifUiOvE7jWJOmzA5i2pKDo53rsigqhLk6RKS+/b0FuP4EP2ept+37t8i48u8PTK5lGFrQAhqql9vEDptS8QiHqcc2yo3qFrNQXRRZGmsuU4rrmAwbp4dCdjqW5/s13VDmVmA1G3kgDcHES9A0Qnz+4x6uA4vpowFxtuitfTPCYaG0GT2NvnBl/JPIvoQdGhHoP2YNyjqrnZZQKlgpwqaNgEwwQ0h95Y6TApqBMvPpCA63cOYsaI1DqxdZWarLQBR6SbeCaBuyREBZgrsbmqEQ11Vdi8UoH4HqzenYgyeyJYkYDTvWsi6BiNdzVvXaOOfQgvJnqaUxC9B3ctewJb321Ew7sR/GCZqkcZNrepk8v+0w2kBGj22obZAiGqqfW8QOm1L0iIxmYnMTIURceZdjQdq0Z1tWkijqVrNQVRVxg6QlTBoxZ9Hl1dSThZytQA0ZuzmBwZRPRcO9pPHEf1vmrsVOO3FdZIdKwlAXtrj6HVO2a64l3hZoiqyUZv1ibGemV82Z6aUWtE2+6TpKwF5fKXCaLlm1BZJ0BrROUbG7BKukITAEtCbSAFtXX7EtN2eyJYnjhu/dFkXGia9es2JnoP1laZpv6OmqC9KU67jlceTNShHFvNPcimetybODYF0Qfx4lmTZo1qNrAJzqbd2Xy1g5QAzUbN4shLiGpqRy9Qeu0LAqKLZ9fGAbKz+hDqj9U4RIV+ITqGNiPqa7Z2ndo1dwRwFhCVGbaHrTOBZfZxZHc1DtUdj3etWiBqKsu5LzdeYwVMM0RV3Y3zFB29UgRtXpC265KT3yaImrojFTzlc9njBzGU7AYdxtYVCbg+ddToSo2+Xh4HXdkGNCiGLuoKNlXeFIlubDFtRxs2qjoYYJxA5RoFchuI0YbNasw1EUGnIGp7dcYE5+TDgLnYLL8rkBKgWQpZJNkJUU0N6QVKr335hmhsQs2U3YZDZ/owNj0Hy3ueCgqWqNAvRE1wcnlNReRfGHDqQl46rxqHtXTBxibRtjcOsm2H29E3Po05yzupCuy2SNT0Co+rS6hxUzNEZxOvvRzswnTyHdjUu7fqHVz1mdm7uK41yWKHCaIyYScxcWh5+cNY92wElWcXUz4Jq7JNxgQe9Z7pvRsak+OT0ARRZfsu+wxfmLqQA4aoiD/0bhU6PHpXsmggZg2ZAoSopgbzAqXXvnxDNN5tWYHj/S6Dc1ohCqjyXMdSIYCWiTn2NYBNEHWJDtVkJwtE1cSoY3222beqoZ0hOnsx/s5pdZdLYQAUtC0Ti9SY6JuLXwtSJRbWpwmi9jFRt4omI7sH8eLRg1hnRI9lWF+XDEOhB6JA6xY19mmLLqeqsFZFrYmIOAn3u23HJuurvzvXTSJuL10FCFFNbe8FSq99+YWomuhTiY5p5xOf7nSa5OM3EgViI83xV0rcZr2a3s20zs6NYeREPKJ0BP7NseRrNWaIqqi2stPtBBOv+Fi6c4HkDNpIE0acVmC6OZaMcC0QhdLUY3YupjHWP4bpG8k+Umfx87LVB0Qxg8pH492sDzyQGLM0olJzhc1dsU+gRoY+1emm3Z0LzNdtSM7MXbapETNiIzaDhk1q9m0K3oSoWX9+D0oBQlST8l6g9NqXX4gCahZqjQNkFibaUaMm3mjpzhVx59BnvCdZAeleHZlVd9YYFq5EUb83gpoDzuOwychPFmQwB4gL8u7lNmzbHo9gzRCF6nLd34Fp+zKGC5NoP5CIeu0QRQyTp+PvrBqrGl1ZSDIgNjuCtgMRVB6oib8GY+7OlXu86iJ3ek8UMUx3Jd4xteXT5HoZmvEDUWCm6pHkpCMZN1WTe8yFp2byJsY1n22M784AosAMah6Xd0jV2Kj18941u5LjtYSoWX1+D0oBQlST8l6g9NqnBaLbK42ZpzL71DE1mlbLud6XWJVHlupLrDoks3ONJfIiqK+Lv9dpjQr9R6KGvDfN8LJOvNl2rA9zLl3IMI1vGksLVsv5VRqrDkWORDGW6IK1QNQE7cju2sSqQzI7t9aYmRupq8dxY/KPdUw07gazGGwwLf5gmiQUqW7H5Iz7sn+OKxadacLxvYkJTvYHAU1+l7kZfxDFjOrGFajZZsOqSsSGUflEeTKSvGtFBEOyLyOIGk8laHhhjWnxhvgCCqtfaMSEegaTDuTke6LszlVNwM/8K0CIatLcC5Re+7RA1HSzd5wdaouAjHVsq1VEloBapBpN/bMu69hmCVFD4wXMDnWhue5QHPTHmtDRn1gQwQ2ikm9hEh2WNXC3oeZEFNM3U2OUVojKu6DTiDaqpQ0VtGVd4D7M3nYeEzW7wdx4FB2JV2KqD9ej+cII5iSqve4OUaOqo87rEe+sbcfYDXMJYfxumtgjqxmZYLbobIz3Rs3jpYuOSHvDvNOC9mnn5oFUIPcKEKKaNPYCpde+rCCaZd3lv43MXhnD9NwCgpw16vyeqO3kYj7+04zkmZ1cPAPZZjrtn07viTpkTv0Xl2B1daha5pvmO1H5xi7seHZlMsJc8cZw5naYgwoUqQKEqKaG9QKl174gIarp1Jc2szCNafOYpi3H5JmlVwuyZcnNz9seyyFKUJxYwtDe1Z2byhSI1ZZNSXgaY6Fc3q5AGobVKBQFCFFNLeEFSq99RQ9RmX0r/8nEZUwwNZmpBl2mxWw0NUv6ZmT2rdHF7bDAvliZ7UO98f5pBM0jXn2Z6RcZhiNnWiLYvGWLkV7d3WYZkwxD/VlHKpBrBQhRTQp7gdJrX9FDFDGMnVbjkxHsNP0rtOSkm4oIai3TbzU1SoZmZnuPJ/5VWgUs/wrtQGo5xMrWseSs3QzN83AqQAWKUAFCVFOjeoHSa1/xQzQu8NxIR+r/lSYnQglUm9A14bLwg6a2ycTMwtU+tFkmMsUnJglU24dmCdBMxOSxVKAEFCBENTWyFyi99pUKRJMy344huQRecmMhfjHV0/6+aSFWl3WiAlQgEAUIUU2ye4HSa1/JQVST3jRDBagAFSgEBQhRTa3gBUqvfYSopgagGSpABahAAAoQoppE9wKl1z5CVFMD0AwVoAJUIAAFCFFNonuB0msfIaqpAWiGClABKhCAAoSoJtG9QOm1jxDV1AA0QwWoABUIQAFCVJPoXqD02keIamoAmqECVIAKBKAAIapJdC9Qeu0jRDU1AM1QASpABQJQgBDVJLoXKL32EaKaGoBmqAAVoAIBKECIahLdC5Re+whRTQ1AM1SAClCBABQgRDWJ7gVKr32EqKYGoBkqQAWoQAAKEKKaRPcCpdc+QlRTA9AMFaACVCAABQhRTaJ7gdJrHyGqqQFohgpQASoQgAKEqCbRvUDptY8Q1dQANEMFqAAVCEABQlST6F6g9NpHiGpqAJqhAlSACgSgACGqSXQvUHrtI0Q1NQDNUAEqQAUCUIAQ1SS6Fyi99hGimhqAZqgAFaACASjgG6I3btxAWNP8/DxisZhWub1A6bWPENXaDDRGBagAFcirAiUJUQX/W7duaRPbC5Re+whRbU1AQ1SAClCBvCtQ0hAVmOqKSL1A6bWPEM27z7NAKkAFqIA2BUoeotK1q+PPC5Re+whRHerTBhWgAlQgGAVKHqISjer48wKl1z5CVIf6tEEFqAAVCEYBQpQQDcbzWCoVoAJUoAgUIEQJ0SJwY54CFaACVCAYBQhRQjQYz2OpVIAKUIEiUIAQJUSLwI15ClSAClCBYBQgRAnRYDyPpVIBKkAFikABQpQQLQI35ilQASpABYJRgBAlRIPxPJZKBagAFSgCBQhRQrQI3JinQAWoABUIRgFClBANxvNYKhWgAlSgCBQgRAnRInBjngIVoAJUIBgFCFFCNBjPY6lUgApQgSJQgBAlRIvAjXkKVIAKUIFgFCBECdFgPI+lUgEqQAWKQAFClBAtAjfmKVABKkAFglGAECVEg/E8lkoFqAAVKAIFCNEwQ/TGNEZGRtJIk5iLBeSts304vr0C2/a3YzKoOgR06iyWClCB4leAEA0zRMfbUFFRkUY6hOj1YJx5LnooUb8I2iaCqUOplRpbWMDCwgL4zFJqLc/zDUIBQrQYIHq8Y4loNMBI9OYkuuqOo/7CJG/qebnC5xA9LA9WwT045eU0WQgVKBAFCNFigGjrWIG4E6sRvAKEqKUNYhNo3f0aNn73MazfsgWvHmV3iEUf/shaAUKUEI070c14F2Bg3YAxVb57J6TqplxYcD/G+YqIGd2bcm4LN52PcNx6O5XPqUQ/9fGTJ163VF28z6EwITqxew3uuvseh1SGD6/cgB2dM45NkNXGWCdeXV5mKXPdvhyUk1UlmTnsChCipQjR61EckrHUw1HM3ZxGtLEaEfPY6vYaNPXPWnx7of+4MbYZOTni3i073ha3I3ZVbnNZahuAsdb4WG7beAzTF45jZyQxtmvOaxwfw3S0CTXbbWO/UsfotGNdUraBhdF2HLLkjWBnbQcmF0yVSXw155sdaEK1qpNos70GbcOJTLN9aKqOWMaitx1ux9iNxTbVFqlH7W5rHrEp5+BQFZM+6Z6DgqdNJ6Nd2xB0X4U7RBVYH8LGlnkll5bP+aMbkgBdtvY1VFbtwpFRLaZphAokFSBESxqibWg7EjEAUd/SjvYz7Wg6vC05Eah+wHR7XxhEvdyQI80YcQrLEMPIyTgkjveb8i0B0foTTQZ4t+09jiYpv3UwBWDEMNZaGa9PZCdqT8Tr2H6iNgndytaxRSBVMGw63YbKCoFmk3Fu7S3HU2Dc247J5GUQ/2LNtw2HEuWlNKlB13AUtRGZbVyP5jPtaG+pTwHewaZYno3WJh5StqGmrjlRl1S+ygbzOTvVJZ1zWMDYBdGnGbVvCkj3oPZkQq8zg7A+EtlOPA8/UxB9GFs7ZzAzJWkCHbufwDIVoT7wMjocfctfBVNl3oONLf5sMBcVWEoBQrSUIVpRgciRKGZvW91k9kJiRu2+LtPNNwXJpmGHO11sBM1G5FaPQRNDsQREKyoq0TZqzpCqy8JAfRw+e9swZj9kYQxtewUWEVhgb4pyHW0vjKDZgEwF7OehIFoRqUXUQp0YJs/WJCPPReC+marLohnIV9pRKQ8fe+vRZ7EJ4OY0uuQhRuM5ACoiLayJRSmgrcEOWzTYukl1uT6IFzul/dvwank5lpeX4wf7JjC0bwNW3F+Gu9ZUQY1oTrTtwsa15fhw2T24676HsHztJlQmu4QnUPNEOZZLngSgP7RM7D2BGmUA8xh69zWse/ghfOjue3Dv/eVY9d3X0GCpW7b1kHNJ1EXOp6INmGjEi2tVmSuxfncPFsXfM52o3PRIov5l+PDyR7Bxdxsm7Jfd3DCOVDyGVcvuw113y3EPY11F4+LjlD3jOLdzTV13/JaZAoRoMUB0f308upHIyCkN2O7eCmwVx9Hn2AU5hjYDiLXoS/bLArGR5jjUTizu0lX7FnX3qrJs3bQKWHvO2ONB5cCTaDdgV4Mut2EsBaj9ZtinuordbKvXbiKnrWV71kmdR4XtISFR3dmuagOyh6ImwZLR+R5It7Xj30wXagSyms4hjBBNAVZFjG3YmIDfqqc2YIWKVFfvMiA6tHsN7lXbLJ8P4QcHhJIT2LFadRObPxXA59G66aEkYBVojc+ylXi1U2Et23pIi5vq8tQWbF5mrk/8+4rXe1KuMbwLq+XBwHJe8d/3rtmFIeVGc23Y6GBL8t278jV0qFOYOogf3Ods766yNdgxnCqa3/wpQIgWA0SNcS+nsbDENvvsXQUES6RpdiC3aEaBzQ6SGEZOxKPCZntfryrLBaJt4+ZyTd9nulAt52XLZzpCOkrRtU/KrbaAVsHQHmkm86r3a226qHzNlmgkkUudR4Xz+KICswWisRE0yTm46iy2ZxE9KOdg1VTVJdNzCB1EY8Mm4JVjq8GTFLwECh96+GVU1jWiobEHMz2RJFSXbTiKoZl5zM8M48iGBBTLNqBhHpifmUHH6w8nYbT+3XgX8nwMkLHSOITLsPr1TkzMzWN+tBNb1yQi1xURDBnNnn09LBC9+x4sezyCI3WNOPKGqRu7bAtajfKGsXVFAnhlK7G5bjje5f166qFhbZU8Uc7jyFOJupatwdazE5ifm8fE2UgSwCveiNMx9YDyIDbWJZ5GRw9i/QMJMG9pSzg4P/wqQIgWA0RPDqZmnyZetDdmoqrv9hmpCgiugHKDKDB5Zo8RcVm6UBUs3lw8zrhUd64rRF1AZ3d0BRuzHadtlnwutj3zKc0ygajK82ZtfPzUqZcgOYZp7X71rIucjMs5FD5Ey7GxqhENAsWqCNY/LF2RCXAkIk3pzlWR6F0rIoiq6AtAxysPxo8v24RW03bMH8X6hJ31R+NhWAogKsIV4WZQ8x17eQnv6IlguWHDAea+62GKRG1jvg3PJupxdyJC7nwZDyTOYflvTdEphrFjbbx72+gSnjmIdYnjVu9O9k8bJxF9vTyuT3kEUYmDk7OiH8T6A8OQhwjjbz4Rqqrfic38yFwBQrQYIGqLqJZ0A3Vz9wFRqAjxWF9yVqmMXcrKSY7dpy5lLQUJx8jO4cSUHXMEqLaZwWrJ6gIgz3zqPDKBqCpnqZ4CY791RSfPusjJKNuL2t79AciiQZ5/pG7mChy2z2VPoCbZtWiC6CZzpDSByjW2fAmYJEF89z1QYDGXmZpY1IbNLt2lZhvx43XUwwTR5ENCXPxU/eIQnXgr9RpQqr4ODdW2xaU726zNpnh02xPBKsv5JsZOn43gSI/bOIlDmdzkqgAhSog6OIfXjXgWXful+1GNpy5gsG5xl2rSqIKPDdj+IZG0bHxxsuO0zZLLBUCe+dR5ZALR2cSrRAe7MK16BTw+Y6YJXp51kZNxOYfCj0TlJp6IqsplMs8mbK3qtE2GcYdXcqyz7H5j4pFMPrInmYwkfylImSNRk22ZkOSQX7a9arDbdKwN5unXIwOIJqNGc30tnhv/0bIpGb3HJ0wt1mB5+WuJLmJgfuAoXv3uyvgkLMtDRxlW704+uTgUxE3pKECIEqIOfuIFUUBFicarLDf6cFwiKdvEmKRRBZ9MIaoiXlu+pF3jixpPdB4TDTwS9ermtp7Iol/FC1E1uWfRKZs2uMELSHaBSteoKYfTV2eIDmPHqkTE9p2D8I7FdNQjfYjCFGGqaDp+XjNofX0LNm/Zgs0HhoHhXViVgGGmi0fMz0wg+u4WrFDRaRo6OmnLbSkFCFFCNOUNyW/eEIUC57E+TCcWYTB3pybNyBe/EIWaxOQxO1fNbLWNxfoFkGc+dR6ZRKJQUbrH7FxMY6x/DNM3rINTnnURXZeMRK0PFpY2CeBHCmjZQXS+zjQpaHsqippp3IRlxmse5dh4NI7GVJnWyG7ojZWJSO4hbGxMYXRou0zguQ/LytcsnuBkiUSB9OuRAUTnG7E+CbcNqElMcIufWxz88QlDpglIyzahQZ2CTNKSyVESYa+WMdEZHHk28RrQA5vQoCaOx3rwanniQYIQzfpqIEQJUQcnWgKiSThUotJ4V1N17TqYUvCxRZRLQgJAtu+JBh6JAohNyIIPLu+JIobprsRCDJnq4wpRYKxFutcrcOii7dUmh+bJ16YU0LKDqMx2rVSzaBPvdy5PvP9ojGkuSy3YkCrTClHMt1leNTG6RE3vlN6bjFDdI9H065EBRKULuuoR471V8/hs8vuyTWhNgHC+bUtqkQoD/AlYGhFqGVSEajlOdYEnz7UMq9+yTkzKlz8UUzmEaDFAdHslqvdVe6YO87XiAraUYy8FUSA23GTcqI1/xVY3mJxklLKR+OZSVjoQRZYrFhUCREUFxxWLzjTh+N7E6lCLFndIveua6TlIeUlwy2pN1dWoPtyF6UUNk98NKaBlC1HjBNHwwhrbGN99WPHULphf002VaYOonPpcD3Y8tdIKrLL7sfoF82IFXhBNtx6ZQVSqNtH4MlYnQScRYxk+vOZlNJivYXnRpXsX1q8wzW42HirW4MVG64GL7cmCC2uw8d1UJJ9fbyiu0gjRYoBoGrM/LTdjF7ClXHtpiCK5QlEEi94NTRnKojtXGclu7VxlxfLpEsV5gl1pllF3bqpUx7VzjSUJndfc9ayLmHU5B1WirP2bWm/Y+vqMOqYYPueN5QNnUq9uZHpSsfnEEoRqdYJMDcSPz7oeTsXOpd5tddqd3DafWEZRddcmd9i+JOzNLHWcLRt/eitAiIYZot5tW3R7/f8HlMKRInUOCzDPxs1VDY3y7O8J56ow2qUCJagAIUqIlqDb85SpABWgAnoUIEQJUT2eRCtUgApQgRJUgBAlREvQ7XnKVIAKUAE9ChCihKgeT6IVKkAFqEAJKkCIEqIl6PY8ZSpABaiAHgUIUUJUjyfRChWgAlSgBBUgRAnREnR7njIVoAJUQI8ChCghqseTaIUKUAEqUIIKEKKEaAm6PU+ZClABKqBHAUKUENXjSbRCBagAFShBBQhRQrQE3Z6nTAWoABXQowAhSojq8SRaoQJUgAqUoAKEKCFagm7PU6YCVIAK6FGAECVE9XgSrVABKkAFSlABQpQQLUG35ylTASpABfQoQIgSono8iVaoABWgAiWoACFKiJag2/OUqQAVoAJ6FCBECVE9nkQrVIAKUIESVIAQJURL0O15ylSAClABPQoQooSoHk+iFSpABahACSpAiBKiJej2PGUqQAWogB4FigaiH3zwAfymO3fuINs0OXkFflJvX3/WZWdbd+bPvv2pITXMpw/ouf3Tig4FQg1Rv9C059Ph/H4AKnkIUd58dfgfbZSuH+kAAW34VyCUELVDUH7Pzc1Z0vXr15FuisViyGH2qBYAACAASURBVDaNj0/AT4r29GZddrZ1Z/7s258aUsNc+sDt27dhTk4PTf4xwJzZKBA6iJoBqsBphuW1a9eQabp16xayTWNj4/CToj09WZedbd2ZP/v2p4bUMB8+YAa1gqoZqNnAgHn9KRAaiHrBU6A5OztrpJmZGdjT+++/D680Pz+PbNPly6Pwky50X8y67GzrzvzZtz81pIa6fWBhYQH2dPPmTUgSYCugEqb+4KcrVyggageoijwVPAWaAsnp6WkjTU1NwZ6uXr0Kt6Qi2mw+h4cvwU/qPN9l6YbOpg7Ma+3Spx7UI6w+YL7nqe83btyAJIG1wNUJpoxKdaExfTuhgqhcEAJQJ3heuSKzYyeNNDExAUnj4+NpJXvk6ud3f/8A/KSz5zoWRc5+ymeexT0Q1ISaFIMPqF42NUwl90A3mEpUqkCaPgZ4ZDYKFDxE1VOYHaAq8hR4CjBHR0dx6dIlDA0NYWBgIJn6+/uxVLp8+TKyTZ2d5+EnnTjZnHXZ2dad+bNvf2pIDXPhA3JfU0mCAgkUpJdNwGqGqTkqJUizQWLmeQsaol4AFUcShxobGzPAKY4mTiVPYfyjAlSAChSbAnJvk3uiBA4CVBm+kuhUtkkXL0EaTIuHCqLy9CURqAKogFOiTHnfkn9UgApQgVJRYGpq2ujBknuhHaQy4YjRaP48oWAh6hSFyviGPH3Jk5hEoIODgxgeHs6fWiyJClABKlAgCkgQIfdBuSeqrl2ZcKRm7hKk+Wmo0EBURaEyw1a6MmT888KFbmNSTn6kYilUgApQgcJRQCJQmcwow1oSYMi8EdWty2g0f+1U8BCVJyxxFnsUKpOH2tvPGt0W+ZOLJVEBKkAFCkMBiTQlkJCI1C0a5Uzd3LdVQULU3pVrjkLVTNze3j6cOtWWe4VYAhWgAlSgQBU4d64Tly6NJGfsMhrNf0OFBqJqLFS6ckdGRtDT04uTJ1vyrxhLpAJUgAoUiAKnT7cbi7zIPBHprVNjozJTl126+WmkgoeoU1euPHl1d1/EiRPN+VGJpVABKkAFClCBtrYzGBgYNN5QkDcXFETVBCNOLsp9o4UGouq1FpmNJsvrCUSbmk7mXiGWQAWoABUoUAVaW08bEJ2YmLS8N0qI5q/BChqi5klFdojKgDohmj9HYUlUgAoUngICUZmh6wZR6dLl5KLctluoICqTilQkKhBtbDyBmWvXmagBfYA+UJI+IJMrzRCVSZgyMVNFooRobgEq1kMHUZnOPTQ0jK6uC4Qob5wleePkgyMfnJUPCET7+voxPj6RnKFLiOYenOYSCFGCiCCiD9AHQuoDhKgZZ8F8DwVEZdaZrFSk3hFlJMoncfUkzk/6Qin7gBNE1buiavk/jonmFq6EaEifQEv5xsFzJzjpA3EfIERzC8h0rBOihCi78ugD9IGQ+gAhmg7mcnsMIRrSi4dP4ozG6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhGhILx5GIYxC6AP0AUI0t4BMxzohSogyCqEP0AdC6gOEaDqYy+0xhKjDxbPrzbfwF3/5AHbu3oP3r11zvME8/8sX8PVvrMHwyGXH/YwSGCXQB+gDufYBQjS3gEzHOiHqAdHln/l7nDp9xhGShChvkLm+QdI+fWwpHyBE08Fcbo8hRF0g+tcfeRCf/NRyPPrtdRi+PLoIpIQob3BL3eC4nz6Sax8gRHMLyHSsE6IuEC3/3Ofx9jv78IWVX8Irv67A1MysBaROEJWuX4lcv//Ek/jEJ/8Wn/67cjz38+cxMHzJkvc3v3sdz23egq6LUTy1/mnjWCnn9//9BiauTlmOtdv87IqVeOHlXy2ymeuLlfYJBPpA4fkAIZoO5nJ7DCHqAdFznV3Ys7cSn/r0Z3Csrt4CNyeIyjFy7PoNz+Bw7RHsrXrHGDcVQJ7t7Ezml7z/9M/fxDcf+Vf8+jevofbYcQO2Ev3age1m81/WPoL+weGkTd7gCu8GxzZhm+TaBwjR3AIyHeuE6BIQnZyaxjMbN8EOLTtE+waH8NWvfwO/eOElS9Q6PDKKR//1O4YNsSUXleT9m2WfNOCpLjKJdCWv2Bi8FI9clc0XX/m1xaZsFwj/+tXXXCc+Kbv85I2cPlC8PkCIpoO53B5DiC4BUbkBRfv68ZWHv24BpB2iEnlKF7BEr/ab1js1NfiHL61Cd09PEqIC1pGxccuxEnWabYjNf3z4a+gdGLQcJ/Zfj7xhwNluw142fxfvDZRty7YlRHMLyHSsE6JpQFRuVtLlKuOcAjb5bYeovBbj9sqLdOXKWGbDiZPJvP/x5I8wceWqBY51jU0WiIrNjzz4cQPgX1u9BuYk9tzK482VN1f6QGn4ACGaDuZyewwhmiZEpbtVulW/+OWvGBOCMoGoRKcSYQokFYDThai8ZrP5+V8aZUv55iQTkUYnJi0g5s2zNG6ebGe2s/gAIZpbQKZjnRBNE6LisDKRR8ZGZeLQj3/yM0skaO+yNd/kpJv2M3+/Ijm5SACcDkTFplt3rtk+v/OGSh8oTR8gRNPBXG6PIUQzgKjcqCSalBm4H/3YMgtE5XUVmYVrX+VIItifPfdzfO/7P8TYZDxqTBeiYlPGUqv311iiTXntZf/Bw6hraLRMOOKNtDRvpGz30m13QjS3gEzHOiGaIUQFYK++9jtjWUDzmKTaLuOmAlKZYRvt7cd/bfnFoldk0oWo2eYfduwwImGJhuW7KkeO4U20dG+ibPvSbntCNB3M5fYYQjRDiMpN6/L4BL7779+3RKKyXaLO3W/tNRZZkLV3JX35Hx9GfWOT5VWUdCHqZlMWcZBypDzeREv7Jsr2L+32J0RzC8h0rPuGaDrG/R5z584dSIrFYrh16xbm5+cxNzeH2dlZTE1NYXx8An19/cageiHeRARuslSgvH6iK1Kcnr1m2BS7hGdp3zgL0edZp2B8khD1Sxl9+QhRh0iUN4RgbgjUnbrTBzLzAUJUHwz9WiJECVF2CdMH6AMh9QFC1C/69OUjREN68fCJPbMndupFvYrRBwhRfTD0a4kQJUQZhdAH6AMh9QFC1C/69OUjREN68RTjUzXPidEifSAzHyBE9cHQryVClBBlFEIfoA+E1AcIUb/o05ePEA3pxcMn9sye2KkX9SpGHyBE9cHQryVClBBlFEIfoA+E1AcIUb/o05ePEA3pxVOMT9U8J0aL9IHMfIAQ1QdDv5YIUUKUUQh9gD4QUh8gRP2iT18+QjSkFw+f2DN7Yqde1KsYfYAQ1QdDv5YIUUKUUQh9gD4QUh8gRP2iT18+QjSkF08xPlXznBgt0gcy8wFCVB8M/VoiRAlRRiH0AfpASH2AEPWLPn35CNGQXjx8Ys/siZ16Ua9i9AFCVB8M/VoiRAlRRiH0AfpASH2AEPWLPn35CNGQXjzF+FTNc2K0SB/IzAcIUX0w9GuJECVEGYXQB+gDIfUBQtQv+vTlI0RDevHwiT2zJ3bqRb2K0QcIUX0w9GuJECVEGYXQB+gDIfUBQtQv+vTlI0RDevEU41M1z4nRIn0gMx8gRPXB0K8lQpQQZRRCH6APhNQHCFG/6NOXL/QQ1ScFLVEBKkAFwqUAIRp8exGiwbcBa0AFqAAV8KUAIepLNq2ZCFGtctIYFaACVCB/ChCi+dParSRC1E0ZbqcCVIAKFLgChGjwDUSIBt8GrAEVoAJUwJcChKgv2bRmIkS1ykljVIAKUIH8KUCI5k9rt5IIUTdluJ0KUAEqUOAKEKLBNxAhGnwbsAZUgApQAV8KEKK+ZNOaiRDVKieNUQEqQAXypwAhmj+t3UoiRN2U4XYqQAWoQIErQIgG30CEaPBtwBpQASpABXwpQIj6kk1rJkJUq5w0RgWoABXInwKEaP60diuJEHVThtupABWgAgWuACEafAMRosG3AWtABagAFfClACHqSzatmQhRrXLSGBWgAlQgfwoQovnT2q0kQtRNGW6nAlSAChS4AoRo8A1EiAbfBqwBFaACVMCXAoSoL9m0ZiJEtcpJY1SAClCB/ClAiOZPa7eSCFE3ZbidClABKlDgChCiwTcQIRp8G7AGVIAKUAFfChCivmTTmokQ1SonjVEBKkAF8qcAIZo/rd1KIkTdlOF2KkAFqECBK0CIBt9AhGjwbcAaUAEqQAV8KUCI+pJNayZCNA05r1+/jqmpKSPdvHkzjRw8hApQASqQewUI0dxrvFQJhKiHQj09vfjGN9bgrrvvSab/8yd/ipdefgVzcx9YckajPfirv/5o8jiV594/LsN/PPkUxsbGk8cLkD/7uc/jpz97LrnN/uXEiZOGLfnkHxWgAlTASQFC1EmV/G4jRF30rm9owIf/3/0G7Pbvr8H4+AQGBgcNgMr2h7/6dWObyq4guvEnP0V9fUMyVb5dhU8v/wy++KVVyeMJUaUaP6kAFchGAUI0G/X05CVEHXScmJjAP3zxy/i3x76Ha9euLTpCACsR6Su/+jXu3Llj7FcQ3blr96Lju7u7jSj1vyNvGPsI0UUScQMVoAI+FCBEfYimOQsh6iBoVVU1/vwv/hLnznU47IUBzhdfetmIMEdHx4xjvCD6wQcfYN26x/DDJ56EjKkSoo6yciMVoAIZKkCIZihYDg4nRG2i3orF8J8bnjGgJ/BL948QTVcpHkcFqIAuBQhRXUr6t0OI2rRTUaPXpB9bFuOnF0RlLPVjf/MJ/O53rxvHMhJ1UpDbqAAVyFQBQjRTxfQfT4jaNJ2eft+YBOQE0QMHDmLL87+wpN7ePsOCgujrr29Nvg4jsDzV2mrM8P3kJ//WmJgkBxOiNtH5kwpQAV8KEKK+ZNOaiRC1yekVif7616/i7z+7wkgfX/ZJ3PM//hgtLS2GBQVR9WqL+XPVqofRffFisiRCNCkFv1ABKpCFAoRoFuJpykqI2oRUY6L//C9rIYssuP3J+5vyXqjAU/4URO2RqJMNiXa/8IUv8j1RN3G5nQpQgbQUIETTkimnBxGiDvLKe6HyCktb22mHvZnPzrUbmZ+fx3e/97jn5CV5VcYMabsN/qYCVIAKEKLB+wAh6tAGEinKYgqyQMLly5cXHSFwFcBt/vnzkMhV/lQk6vSe6CIDAOSdUQG1vHNq/5OFHaTstWsfwdzcnH03f1MBKkAFDAUI0eAdgRB1aQMZw5QZtR998OP4wx+248yZdmP8c9NPfwZZys9txaJ0ISpwlGhULSMo5Y2MjKC6+h1jlSSBdEdHp0vtuJkKUAEqABCiwXsBIerRBpOTk3j6mWcNaKqJQgp6bmvnpgtRKVZsyDq8YlPZl8lK3/rWoxgcHPKoGXdRASpABQjRQvABQjSNVpAuW+ninZmZSS7zl0a2tA9R9mXWbiYLPKRdAA+kAlSgKBVgJBp8sxKiwbcBa0AFqAAV8KUAIepLNq2ZCFGtctIYFaACVCB/ChCi+dParSRC1E0ZbqcCVIAKFLgChGjwDUSIBt8GrAEVoAJUwJcChKgv2bRmCg1Er12/jtnZWWPdWXmPsq+v35jerVUNGqMCVIAKhEgBQjT4xvIN0b7+Abgl+R+bbvvS2d7b1w9J0Z5eRHt6cKH7Is53XTCSvE8pi75LEgfiHxWgAlSgVBUgRINved8Q9aq6gDKbvzt37hivksRiMdy6dQuyTJ4sTjA9PY1Lly6ho7MLDY1NeO+9+myKYV4qQAWoQKgVIESDb75QQdTcnXvhQjdqag4FryBrQAWoABUISAFCNCDhTcWGFqIcEzW1Ir9SASpQkgoQosE3OyEafBuwBlSAClABXwoQor5k05qJENUqJ41RASpABfKnACGaP63dSiJE3ZThdipABahAgStAiAbfQAUF0ffffx/t7eeMWbgyQ9c+O9c8sYhjosE7D2tABahAsAoQosHqL6UXDEQvjVzGkz96GuseexxP/mgDhi+NEKLB+wdrQAWoQAErQIgG3zgFA9Hz57vw3X//oQFR+ezsPE+IBu8frAEVoAIFrAAhGnzjFAxEpet2b2U1/vPpjXhrb5WxyAK7c4N3ENaAClCBwlWAEA2+bQoGomYp3FYs4pioWSV+pwJUoNQVIESD94CCgqgsLH+qtQ1jY+OOy/4RosE7DGtABahA4ShQVbUPx9+rR8upNpw+045zHZ3oPN9lrDcu647L+uNqLfJ01i3nMe5rwrtpUzAQ5cSiwrkwWRMqQAXCoQAj0eDbqWAgyolFwTsDa0AFqEC4FCBEg2+vgoGoTCI6dLgWP/7Jz3Dw0LucWBS8b7AGVIAKFLgChGjwDVQwEDVLwYlFZjX4nQpQASrgrAAh6qxLPrcWDEQFnN0Xo9i5601jUPz27dtpvSc6c+06mKgBfYA+UIo+QIjmE5fOZRUMRHt7+/D4D540FluQz56eXkKUDwh8QKIP0Ac8fIAQdQZbPrcWJEQzWbGoFJ8+ec6MuugD9AHxAUI0n7h0LqtgICrdt+/VNeCnz/3ceO9JJhqls2IRbya8mdAH6AOl6gOEqDPY8rm1YCBqPulMJhaV6sXD8yY46AP0AULUTI5gvhOiHuMNvEnxJkUfoA8Usg8QosGA01wqIUqIcuIGfYA+EFIfIETNOAvmOyEa0ounkJ+OWTdGb/SB/PgAIRoMOM2lEqKEKKMQ+gB9IKQ+QIiacRbMd0I0pBcPn/Tz86RPnalzIfsAIRoMOM2lhhaiFy50o6bmEJ+g+RBAH6APlKwPEKJmnAXzPVQQnZ6exqVLI+jo7EJDYxPee6++ZC+eQn46Zt0YvdEH8uMDhGgw4DSX6huibv+gVLaPjo7Ca/9S+9Q/kZV/KCv/WPZC90XjH82e77qA7u6L6O3thywTKA7EizU/Fyt1ps70gcLzAULUjLNgvvuGaC6ry8UWCu9i5Q2UbUIfKDwfIERzSaL0bBOiHE9iNE8foA+E1AcI0fRAl8ujCNGQXjyMCgovKmCbsE3y7QOEaC7xmJ5tQpQQZRRCH6APhNQHCNH0QJfLowjRkF48+X7iZXmMsugDhecDpQvRDzDQdQm3cknHNG0TooQooxD6AH0gpD5QmhC9hYHDL+Hxxx/HS4cHAgcpIRrSi4dRQeFFBWwTtkm+faD0IJoCqEC0EEBKiBKijELoA/SBkPpAaUF0MUALAaSEaEgvnnw/8bI8Rln0gcLzgdKBqA2gz2xDW08btj0Tj0aDjEgJUUKUUQh9gD4QUh8oDYg6AHQqMetnKniQEqIhvXj8RAXjV65i8NIIhkYuY2pmNqsb5/TsNcOO2Ls8PpGVLT/nwjyFFxWxTfLfJsUPUQ+AqtmzAYOUELVB9My5Tjz48U/gj//n//ZMP/npcwY4BCKfX/mlRcf+rw/9Cb75rUfR3tFpAYzkk+Mln9NNR9lT9p2OyXTb4KXLeGr9Bkid1Hl94qFP4eC7tXj/2jXHeniVcaLlFL606uGkLbH77XXfRf/QcMa2vMrhvvzflKl5uDQvboimAdACACkhaoPo5bEJHD3+Hg4fOWakvVXV+ORDn8azP/lpcpvsa2s/awBDQU8govLI59vV+/C11f9k5D199lwSLvmGqESf//79H+Jvl5fj0LtHDHh3R3ux4Zkf468/8jGcPNWarFs6N9DOC92GrUe/vQ7nzncZ9t5raMKKL3zRKEfKS8cOjwnXzZrtVZjtVbwQzQCgAYOUELVB1H6zUJB8Y9sORzio/U6RY0//AP7hy/+Ip3/8k2T3ab4h2nDiJP7qgQchoDOfm3TpfuWrX8dzm7dYtpuPcfq+Y+duLP/MZ9Hd02vJd/S9Onz4z/8SUp5TPm4rzJsw2yXc7VK8EAU+uHgAL8lrLDKJSI2BKmC6fSa7dl/C3s6rbkdp3U6I5hCicoMSaH7t69/ApdExAy46ICrR8uM/fAI/f/6XSTirm6FAXaLE32+NGOVdmX7fcQxUIsZ1j33PqJ/Km85nxWu/deyOlmj7ox9bBoFpOnZ4TLhv3my/wmi/YoaokO6D/jZE0wWoQuNUFCcv5gegUiQhGkKIyg1MYPa5z6+ERLvmG9qBw++mFRFKd7SM/e5+a68lv9mW03eJaB/46N+gvulEMp+Mq0b+sB1/V/45XLgYTW53ys9thXHzZTsURzsUO0QVFwv5kxDNIURVl+mPNjyTjBh1RKJyAzx1+owR+Qk01Q1RZtxK1/HaR7+N0YnJ5Ha1v+viRWPc9levvgaZWLT+6Wcdj1PHO31KGVt+8UsDpL948SXsP3DIsCNR6Ds1B3xNVHIqh9uK4ybPdsxtOxKiweOVENUEUQGSdKWqJJD7wRNPGlGhOWrTBVHVHWsGtESlEp3+9vX/XgRQuZnJuK6anStdzDIBSl5VUTc6+6QqNVFK4KuOkeNrDh02IKxsyec3/vmbaGk9nTxOHc/P3N5EqW9p60uIEqKOCty5cweSYrEYbt26hfn5eczNzWF2dhZTU1MYH59AX18/xIFyfRNRE4eWmlhkBor6LhNwjr1XZ4nOdEFUzlu6Yj/z2RWI9vUbOkhUKDOJZQatly4TV6ew8823DMBLVKneGXV7vcd87tt37sL9f/URA8iTU9NGOSNj48bsZSnbPBPZqw7cV9o3f7a/nvYnRB0RkteNjERzFInKRCKndzBlNqyu90QlQvzUp/8Ob71dZYBQolKZcKTg5nWjkrr95re/N/KbI02vPHJOEsGaZxur42XfP/3LWmx6brPjeavj+Knn5kkdqaP4ACGaV146FkaIaoKoRJjp3NjkFRGZ0CNRn9PxKho0R39Ox8k2NQYq3cayqIMAVaJR8/GympCMzZq7bdV+mUnrVRd1nPr0isrF/tPPbjRm/PJdUd7glc/wM7e+QIg6ci2vGwnRPENUxkplkYP/2vKLZDequtEIFGW77Jfj1HavT5lYJPCU112cZuvK+KiAUi0OoWxJWRI1OuVRx9g/VST6n0//eFHd1TuxjERze9O0twl/l7behGheeelYGCGaZ4hKN+ob23caS/D92/ceN96r7O0fND5lZaH/83//DK/9fmvaXaJqBrCMwzoBTGyv+spXjYlAMoYqvwXQTzy13ihL6uLU7ex2c95TWWXkk/xiR5b6O1R71HF1Jjcb3F7aN362v772J0QduZbXjYRoniEqNxA1w1UmHqlJSPIpv2Xmq1PXq9uNRwD4ixdewn1/9ueLViVSebov9uD7P/wPfOhP/jRZnp+yxJ6UJ2vumusua+d+69Hv4Hx3ahavKpuf+m6Y1JJa2n2AEM0rLx0LI0SXgKjdaXX+FiBJF6mMNcpnJhGhn3pIF65Errr+64rYkbrLqkh+6sM8hAJ9IDsfIEQduZbXjYRogBDlDSS7Gwj1o36l7gOEaF556VgYIUqIMoqkD9AHQuoDhKgj1/K6kRAN6cVT6k/gPH9GofQBvieaV1q6FEaIEqKMQugD9IGQ+gAjURey5XEzIRrSi4dP4YzE6AP0AUI0j7R0KYoQJUQZhdAH6AMh9QFC1IVsedxMiIb04mEUwiiEPkAfIETzSEuXoghRQpRRCH2APhBSHyBEXciWx82EaEgvHkYhjELoA/QBQjSPtHQpihAlRBmF0AfoAyH1AULUhWx53EyIhvTiYRTCKIQ+QB8gRPNIS5eiCFFClFEIfYA+EFIfIERdyJbHzYRoSC8eRiGMQugD9AFCNI+0dCnKN0T7+geQq9Tb1w9J0Z5eRHt6cKH7IjrPd+FcRydOn2lHy6k2HH+vHlVV+/gEzYcA+gB9oGR9gBB1IVseN/uG6I0bN5Cr9MEHH0DS9evXce3aNbz//vu4evUqJiYmMDo6iqGhYXR1XUBj44mSvXgYhTAKoQ/QBwjRPNLSpShClE/xfBChD9AHQuoDhKgL2fK4mRAN6cXDKIRRCH2APkCI5pGWLkURooQooxD6AH0gpD5AiLqQLY+bCdGQXjyMQhiF0AfoA4RoHmnpUhQhSogyCqEP0AdC6gOEqAvZ8riZEA3pxcMohFEIfYA+QIjmkZYuRRGihCijEPoAfSCkPkCIupAtj5tDD9E8asWiqAAVoAIFpQAhGnxzEKLBtwFrQAWoABXwpQAh6ks2rZlCAdGZmRlMTU05rlikVQ0aowJUgAqESAEniMpqbwsLC7h16xZisRju3LljpBCdVqiqSoiGqrlYWSpABahASgFCNKVFUN9CB9GxsTEMD1/ChQvdxtq5QQnHcqkAFaACQSvwVuU+HD3WgBPNp3Gq7SxOt3fibMcFdHZF0dXdg67uXnRH+410sWcApZqivYMYvjSK2dnr2pssVBCdnJyEgmh390U0NZ3E7du3tYtCg1SAClCBQldA7n2tracxMDCIiYlJTE9PG/+wg925i1tOurSvXZ/D0PBlDA2PLj4giy0FDdG5uTnDKdSYqBmiFy9GcfJki/HfXbI4f2alAlSACoRSAZkncvp0OwYHh1whKqDlmGiqeWO3bxsg1RmRhgai8pR15coVIxK9dGkEPT29OHWqFe3tZ1MK8RsVoAJUoEQU6Ow8j3PnOozhrcnJK8a/jJR/Hyn/olJNLCJEFzuDRKTStavrr+AhKk4xOztrdFUIRMfHxzEyMoL+/gGcPXsOx4/X4WI0qksP2qECVIAKFLwCvX19xnCWDGtdvjxqBBjSY6cgvE70WQAABPlJREFUevPmTWNmLiG6uCklMpcxUl1/oYGo+R9zy7io/GNu6dKVaPTd2iNobm4xACtOwz8qQAWoQLEpIPe2iYkJtLWdxnt19UYUKl254+MTRpAhwYYMgc3Pz4MQ9W59mWCl668gISrdETI4LkmerK5duwZ5yjJ36Uo0KgPqMku3peUUjh17DzUHDqLy7Srs2bsXb771VjLt3rMHTunt6mroSus3PAM/6dXf/lZbHeRcfvUbvfZ06UM7+nyNWpaGllXvvAOVqvftw/6aA6g9ctR4K0F64aQ3bnR0zIhCJchQUajqyuU7ou6YLCmIypOV6tK1R6MyNiqOJF0a4lQCU5mx29DQhLq6hiWTTEzSlZ5//kX4SXsrq7XVQc7lzT167enSh3b0+Rq1LD0tW1pajZm4cp+T+50EENKNK2OhElwwCnUHptOekoSoPRqVsVHp1hWQSpdGb2+f0b3b1XUB5893QQbdOzo6PVM02gNd6Tev/R5+0tFjx7XVQc7lcK1ee7r0oR19vkYtS0tLmUQp97e+vn7jXif3vLGx8SRAzWOh5iiU46FO+IxvKwmImrt07dGoTO1Wk4wEpJcvXzZmqMk4qTyhSZIIVZI4nlsaGbkMXSkS2QY/qelEs7Y6yLnUN+q1p0sf2tHna9SydLSUaFOSdNtKkvFPeSf06tWrRgSqACpDXxwLdYemfU/JQlSiUem2kG5dBVIZaBeQKpjKDUae1FSS1Y3ckjijrrRt+y74SadaT2urg5yLrFyi65xoR59/UEtq6ccHpLtWpStXribhKfdAuRfKUJcZoGq9XEahdmxaf5cMRJ2iUTNIZSxAnsgkKhWYqi5eBVX5HB2VpzjnJCDWlXbuehN+0ukz7drqIOfS0qrXni59aEefr1HL0tFS7nEqCTgl8lTwlB46uUeqCJQAtYLS61dJQdQLpOJQ4lhmmApQZWUjSQJWryTOqCu9uWcv/KRzHZ3a6iDnImtn6jon2tHnH9SSWvr1AQkcJEnUKckMTxkDlddZCFAvZC7eV7IQlW4LNT4qzqSiUjNMBahOT+oSsdqT2NKV3tr7NvykzvNd2uog59J+Tq89XfrQjj5fo5bFr6Xc6+xJAgoVedrhKa+zmLtwZUEB/rkrUHIQNUejCqRyI1FPZgqm8qQnQLUniVadknSD6EqVb1fDT7rQfVFbHeRcOs7rtadLH9rR52vUsjS0FFDak0Sd5shTwZMAdQem056ShKh6CjM/nakncgVTFZ2q7o+lPqULRFeqqt4HPyna06OtDnIu8u+PdJ0T7ejzD2pJLXX4gEBTJQEn4emEyKW3lTRE7VGpgqoCqvo0g9Xtu3JGHZ/V7+yHnxTt6U1eFDrqIf8/UIcd2kjdrKgFtQjaBxQw1af6zyzmz6XRwSOUAiUPUaeoVME0k0+zA2b7/Z19NfCTevv6k/+qKNs6SH75B7w67NDGHep4hxqE4TpQYOBn+goQookBdgVTt+h0KaDqvED8AFTyEKK8Uev0Q9oqDX9KHxc80kkBQtQBomagpvvdSVy/27xW8vfa19ev778JSN11OodfLZiPClABKlDICui8T3rd32WBDLf0R+mCqpCP09nIXkJ67SNEdbYCbVEBKkAFllaAEGUk6uolOp3DtRDuoAJUgAqEWAGd90mvIMktCpXtjERtDuQlpNc+RqI2IfmTClABKpBjBQoBov8fld527yg9ZwAAAAAASUVORK5CYII="}}},{"metadata":{},"cell_type":"markdown","source":"Run the code below to see ther tensorflow version as well as if the TPU is infact running"},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"Tensorflow version \" + tf.__version__)\ntry:\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver() \n    print('Running on TPU ', tpu.master())\nexcept ValueError:\n    tpu = None\n\nif tpu:\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nelse:\n    strategy = tf.distribute.get_strategy() \n\nprint(\"REPLICAS: \", strategy.num_replicas_in_sync)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We created tfrecords for all of the training image files. These records can be accessed by referring to the global storage path"},{"metadata":{"trusted":true},"cell_type":"code","source":"filenames = tf.io.gfile.glob(\"gs://dsi_module_4_mm/*.tfrecords\")\nfilenames","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We now split the training data into a training set and validation set. We did not use all the images as we the number of files was quite large and we wanted to first generate a training model and see what the performance is like before loading all the images.\n\n![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"train_data = np.array(filenames[0:6])\nvalidation_data = np.array(filenames[6:9])\ntrain_data","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"validation_data","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We now need to read in the TF records.\n\nSteps:\n\n1. Create a dictionary mapping the features of the messages in the TFrecord to a label and specifying the data type\n2. Creat a function to decode the messages into images and masks\n3. Uncompress the TFrecord and pass it to the decode function "},{"metadata":{"trusted":true},"cell_type":"code","source":"image_feature_description = {\n      'image': tf.io.FixedLenFeature([], tf.string),\n      'mask': tf.io.FixedLenFeature([], tf.string),\n      'tile_No': tf.io.FixedLenFeature([], tf.int64),\n      'image_id': tf.io.FixedLenFeature([], tf.string),\n      'start_row_pixel': tf.io.FixedLenFeature([], tf.int64),\n      'start_col_pixel': tf.io.FixedLenFeature([], tf.int64),\n      'image_distribution0': tf.io.FixedLenFeature([], tf.string),\n      'image_distribution1': tf.io.FixedLenFeature([], tf.string)\n      \n  }\n\ndef _parse_image_function2(example_proto):\n  # Parse the input tf.Example proto using the dictionary above.\n    single_example = tf.io.parse_single_example(example_proto, image_feature_description)\n    \n    image_id = single_example['image_id']\n    start_row_pixel = single_example['start_row_pixel']\n    start_col_pixel = single_example['start_col_pixel']\n    \n    num_channels = 3\n    tile_size = 512\n        \n    \n    image =  tf.io.decode_raw(single_example['image'],out_type='uint8')\n   \n    #img_array = tf.reshape( image, ( 1, tile_size, tile_size, num_channels))\n    img_array = tf.reshape( image, (  tile_size, tile_size, num_channels))\n    \n    img_array = tf.cast(img_array, tf.float32) / 255.0\n   \n    mask =  tf.io.decode_raw(single_example['mask'],out_type='bool')\n    \n    mask = tf.reshape(mask, (tile_size,tile_size))\n    \n    mask = tf.cast(mask,tf.float32)\n    \n    image_distribution0 = tf.io.decode_raw(single_example['image_distribution0'], out_type = 'int64')\n    image_distribution1 = tf.io.decode_raw(single_example['image_distribution1'], out_type = 'int64')\n    \n    image_distribution = (image_distribution0, image_distribution1)\n    \n    mtd = dict()\n    mtd['img_index'] = single_example['image_id']\n    mtd['tile_id'] = single_example['tile_No']\n    mtd['start_col_pixel'] = single_example['start_col_pixel']\n    mtd['start_row_pixel'] = single_example['start_row_pixel']\n    struct = {\n        'img_array': img_array,\n        'mask': mask,\n        'mtd': mtd,\n        'image_distribution': image_distribution,\n    } \n    return img_array, mask","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"### A second version of the function that manipulates the image dimensions\ndef _parse_image_function2(example_proto):\n    # Parse the input tf.Example protocol. The image_feature_description dictionary must be loaded!\n    single_example = tf.io.parse_single_example(example_proto, image_feature_description)\n    \n    #the keys ultimtaley refer to the image_feature_description dictionary\n    image_id = single_example['image_id']\n    start_row_pixel = single_example['start_row_pixel']\n    start_col_pixel = single_example['start_col_pixel']\n\n    num_channels = 3\n    tile_size = 512\n\n    image = tf.io.decode_raw(single_example['image'], out_type='uint8')\n\n    img_array = tf.reshape(image, (tile_size, tile_size, num_channels))\n    img_array = img_array[None,:,:,:] #needs to be 4-dimensional for the model\n    img_array = tf.cast(img_array, tf.float32) / 255.0\n\n    mask = tf.io.decode_raw(single_example['mask'], out_type='bool')\n    mask = tf.reshape(mask, (tile_size, tile_size))\n    mask = tf.cast(mask, tf.float32) #the model cannot take in bool, so must cast to float\n\n    image_distribution0 = tf.io.decode_raw(single_example['image_distribution0'], out_type='int64')\n    image_distribution1 = tf.io.decode_raw(single_example['image_distribution1'], out_type='int64')\n\n    image_distribution = (image_distribution0, image_distribution1)\n\n    mtd = dict()\n    mtd['img_index'] = single_example['image_id']\n    mtd['tile_id'] = single_example['tile_No']\n    mtd['start_col_pixel'] = single_example['start_col_pixel']\n    mtd['start_row_pixel'] = single_example['start_row_pixel']\n    struct = {\n        'img_array': img_array,\n        'mask': mask,\n        'mtd': mtd,s\n        'image_distribution': image_distribution,\n    }\n    return img_array, mask #, image_distribution0","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Reading the TF record:"},{"metadata":{"trusted":true},"cell_type":"code","source":"def read_tf_dataset2(storage_file_path):\n    encoded_image_dataset = tf.data.TFRecordDataset(storage_file_path, compression_type=\"GZIP\")\n    parsed_image_dataset = encoded_image_dataset.map(_parse_image_function2)\n    return parsed_image_dataset","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"We now have a function that reads a TFrecord and can be used to generate images and masks that can be passed to a CNN"},{"metadata":{},"cell_type":"markdown","source":"## U-Net Model\n\nThe UNet architecture was proposed in 2015. It was based off a similar architecture called FCN, but it has no dense layer.\n\nThe U-Net architecture uses a contracting path and an expansive path (encoder-decoder), which thus give the U-shape. The contracting path is a typical convolutional network with repeated application of convolutions with ReLU and max pooling activations (downsampling operations). The contracting pathways reduce the spatial information while increasing feature information, thus the resolution of the output is increased (at each step the number of features is doubled). The expansive pathway combines the feature and spatial information through a sequence of up-convolutions (down sampling that halves the number of feature channels) and concatenations with the high-resolution features from the contracting pathway ([see more](https://www.kaggle.com/prvnkmr/unet-architecture-breakdown)).   \nThe basic architecture is:  ![UNet](https://www.researchgate.net/profile/Alan_Jackson9/publication/323597886/figure/fig2/AS:601386504957959@1520393124691/Convolutional-neural-network-CNN-architecture-based-on-UNET-Ronneberger-et-al.png)\n\nTo summarize the architecture:\n1. 23 Convolution operations\n2. Downsampling operations (Conv(3x3)-->Relu-->Conv(3x3)-->Relu-->MaxPooling\n3. Upsampling operations (Upsampling-->Conv(2x2)-->Concatenation-->Conv(3x3)-->Relu-->Conv(3x3)--Relu)\n4. Last Level (Conv(1x1)-->2D softmax function which is the sigmoid function)\n5. The authors of the paper recommended initailising the kernal weights to have a Gaussian Normal Distribution due to the repeated Convultions and Pooling layers\n6. No padding in the layers\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"import tensorflow.keras as keras\nimport tensorflow.keras.layers as layers\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We now define the model within a with strategy.scope(): block to ensure the TPU is used. The model designed is very similar to the one in the [paper](https://arxiv.org/pdf/1505.04597.pdf). The differences being that a few normalisation layers were added to the downsampling block and we used strides of 1 for the convolution layers and different size input images."},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    def unet_model(OUTPUT_CHANNELS=1, tile_size=512, strides=1):\n        initializer = 'he_normal'\n        #keras.initializers.HeNormal()\n\n        inputs = layers.Input(shape=[tile_size, tile_size, 3])\n\n        ###LEVEL1\n        d_conv1 = layers.Conv2D(filters=64, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(inputs)\n        norm1 = layers.BatchNormalization()(d_conv1)                         \n        d_conv2 = layers.Conv2D(filters=64, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(norm1)                             \n        d_pool1 = layers.MaxPool2D(pool_size=2, strides=2, padding ='same')(d_conv2)\n        ###LEVEL2\n        d_conv3 = layers.Conv2D(filters=128, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_pool1)\n        norm2 = layers.BatchNormalization()(d_conv3)                             \n        d_conv4 = layers.Conv2D(filters=128, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(norm2)\n        d_pool2 = layers.MaxPool2D(pool_size=2, strides=2, padding='same')(d_conv4)\n        ##LEVEL3\n        d_conv5 = layers.Conv2D(filters=256, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_pool2)\n        d_conv6 = layers.Conv2D(filters=256, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_conv5)\n        d_pool3 = layers.MaxPool2D(pool_size=2, strides=2, padding='same')(d_conv6)\n        ###LEVEL4\n        d_conv7 = layers.Conv2D(filters=512, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_pool3)\n        d_conv8 = layers.Conv2D(filters=512, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_conv7)\n        d_pool4 = layers.MaxPool2D(pool_size=2, strides=2, padding='same')(d_conv8)\n        ###LEVEL5\n        d_conv9 = layers.Conv2D(filters=1024, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_pool4)\n        d_conv10 = layers.Conv2D(filters=1024, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(d_conv9)    \n\n        ###Upsampling\n        ###LEVEL1\n        u_sample1 = layers.UpSampling2D(size=2)(d_conv10)\n        u_conv11 = layers.Conv2D(filters=512, kernel_size=2, strides=strides, padding='same',\n                                 kernel_initializer=initializer)(u_sample1)\n        u_copy1 = layers.Concatenate(axis = 3)([d_conv8, u_conv11])\n\n        u_conv12 = layers.Conv2D(filters=512, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_copy1)\n        u_conv13 = layers.Conv2D(filters=512, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_conv12)\n        ###Level2\n\n        u_sample2 = layers.UpSampling2D(size=2)(u_conv13)\n        u_conv14 = layers.Conv2D(filters=256, kernel_size=2, strides=strides, padding='same',\n                                 kernel_initializer=initializer)(u_sample2)\n        u_copy2 = layers.Concatenate(axis = 3)([d_conv6, u_conv14])\n        u_conv15 = layers.Conv2D(filters=256, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_copy2)\n        u_conv16 = layers.Conv2D(filters=256, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_conv15)\n\n\n        ###Level3\n\n        u_sample3 = layers.UpSampling2D(size=2)(u_conv16)\n        u_conv17 = layers.Conv2D(filters=128, kernel_size=2, strides=strides, padding='same',\n                                 kernel_initializer=initializer)(u_sample3)\n        u_copy3 = layers.Concatenate(axis = 3)([d_conv4, u_conv17])\n        u_conv18 = layers.Conv2D(filters=128, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_copy3)\n\n        u_conv19 = layers.Conv2D(filters=128, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_conv18)\n\n        ###Level4\n\n        u_sample4 = layers.UpSampling2D(size=2)(u_conv19)\n        u_conv20 = layers.Conv2D(filters=64, kernel_size=2, strides=strides, padding='same',\n                                 kernel_initializer=initializer)(u_sample4)\n        u_copy4 = layers.Concatenate(axis = 3)([d_conv2, u_conv20])\n        u_conv21 = layers.Conv2D(filters=64, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_copy4)\n        u_conv22 = layers.Conv2D(filters=64, kernel_size=3, strides=strides, padding='same',\n                                 kernel_initializer=initializer, activation ='relu')(u_conv21)\n        ###Last Level\n        u_conv23 = layers.Conv2D(filters =1, kernel_size = OUTPUT_CHANNELS, activation='sigmoid')(u_conv22)\n\n        return keras.Model(inputs=inputs, outputs=u_conv23)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We now compile the model"},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():   \n    model = unet_model()\n    model.summary()\n    model.compile(optimizer= tf.keras.optimizers.Adam(learning_rate=0.001),\n              loss=dice_loss,\n              metrics=[dice_coeff])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We then fit the model to the data set using a batch size of 128 and 30 epochs. "},{"metadata":{"trusted":true},"cell_type":"code","source":"with strategy.scope():\n    ACCELERATOR_TYPE = 'TPU'\n    if ACCELERATOR_TYPE == 'TPU':\n        batch_size = 128\n        train_dataset = read_tf_dataset2(train_data) \n        train_dataset = train_dataset.batch(batch_size, drop_remainder=True).cache().prefetch(2)\n        validation_dataset = read_tf_dataset2(validation_data)\n        validation_dataset = validation_dataset.batch(batch_size, drop_remainder=True).prefetch(2)\n        steps_per_epoch = 100\n        checkpointer = ModelCheckpoint('/kaggle/working/unet-tpu.h5', verbose=1)\n        history = model.fit(train_dataset,batch_size=batch_size,validation_data=validation_dataset, epochs=5,callbacks=[checkpointer])\n        model.save_weights(\"/kaggle/working/hubmap-tpu-unetf.h5\")\n        model.save(\"/kaggle/working/hubmap-tpu-unet_model.h5\")\n    ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We first ran the training model without a validation dataset, to get an idea of the training times. The below information summarises this:"},{"metadata":{},"cell_type":"markdown","source":"Epoch 1/30\n    119/Unknown - 167s 1s/step - dice_coeff: 0.2725 - loss: 0.7275\nEpoch 00001: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 169s 1s/step - dice_coeff: 0.2725 - loss: 0.7275\nEpoch 2/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00002: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 886ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 3/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00003: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 4/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00004: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 5/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00005: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 6/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00006: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 7/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00007: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 8/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00008: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 9/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00009: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 106s 888ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 10/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00010: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 106s 887ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 11/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00011: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 12/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00012: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 13/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00013: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 14/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00014: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 15/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00015: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 16/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00016: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 17/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00017: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 18/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00018: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 19/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00019: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 20/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00020: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 21/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00021: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 22/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00022: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 23/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00023: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 24/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00024: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 25/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00025: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 26/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00026: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 27/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00027: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 105s 885ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 28/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00028: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 106s 888ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 29/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00029: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 106s 887ms/step - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 30/30\n119/119 [==============================] - ETA: 0s - dice_coeff: 0.2920 - loss: 0.7080\nEpoch 00030: saving model to /kaggle/working/unet-tpu.h5\n119/119 [==============================] - 106s 888ms/step - dice_coeff: 0.2920 - loss: 0.7080\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"history","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"This plots  a graph comparing training to validation"},{"metadata":{"trusted":true},"cell_type":"code","source":"history_frame = pd.DataFrame(history.history)\nhistory_frame.loc[:, ['loss', 'val_loss']].plot()\nhistory_frame.loc[:, ['dice_coeff', 'val_dice_coeff']].plot();","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"history_frame","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"history_frame.to_csv('model_performance')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Acknowlegements\nThis workflow is based on the below sources, mainly by reading other Kaggle Kernals, in particular the Notebooks of the Hacking the Kidney coach Marcos Novaes' notebook series.\n- https://www.kaggle.com/marcosnovaes/hubmap-3-unet-models-with-keras-cpu-gpu/   \n- https://www.kaggle.com/marcosnovaes/hubmap-unet-keras-model-fit-with-tpu"}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}