diff --git "a/docs/notebooks/ex10 - masked image model.ipynb" "b/docs/notebooks/ex10 - masked image model.ipynb"
new file mode 100644--- /dev/null
+++ "b/docs/notebooks/ex10 - masked image model.ipynb"
@@ -0,0 +1 @@
+{"cells":[{"cell_type":"markdown","metadata":{"id":"5bhVsKIigL8j"},"source":["# Masked image modeling with Autoencoders\n","\n","**Author:** [Aritra Roy Gosthipaty](https://twitter.com/arig23498), [Sayak Paul](https://twitter.com/RisingSayak)<br>\n","**Date created:** 2021/12/20<br>\n","**Last modified:** 2021/12/21<br>\n","**Description:** Implementing Masked Autoencoders for self-supervised pretraining."]},{"cell_type":"markdown","metadata":{"id":"FE-PCjccgL8l"},"source":["## Introduction\n","\n","In deep learning, models with growing **capacity** and **capability** can easily overfit\n","on large datasets (ImageNet-1K). In the field of natural language processing, the\n","appetite for data has been **successfully addressed** by self-supervised pretraining.\n","\n","In the academic paper\n","[Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377)\n","by He et. al. the authors propose a simple yet effective method to pretrain large\n","vision models (here [ViT Huge](https://arxiv.org/abs/2010.11929)). Inspired from\n","the pretraining algorithm of BERT ([Devlin et al.](https://arxiv.org/abs/1810.04805)),\n","they mask patches of an image and, through an autoencoder predict the masked patches.\n","In the spirit of \"masked language modeling\", this pretraining task could be referred\n","to as \"masked image modeling\".\n","\n","In this example, we implement\n","[Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377)\n","with the [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset. After\n","pretraining a scaled down version of ViT, we also implement the linear evaluation\n","pipeline on CIFAR-10.\n","\n","\n","This implementation covers (MAE refers to Masked Autoencoder):\n","\n","- The masking algorithm\n","- MAE encoder\n","- MAE decoder\n","- Evaluation with linear probing\n","\n","As a reference, we reuse some of the code presented in\n","[this example](https://keras.io/examples/vision/image_classification_with_vision_transformer/)."]},{"cell_type":"markdown","metadata":{"id":"Cstm8HPwgL8-"},"source":["## Imports"]},{"cell_type":"code","execution_count":1,"metadata":{"id":"rxg7P8ENgL8_","executionInfo":{"status":"ok","timestamp":1711721982165,"user_tz":240,"elapsed":8157,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["import os\n","\n","os.environ[\"KERAS_BACKEND\"] = \"tensorflow\"\n","\n","import tensorflow as tf\n","import keras\n","from keras import layers\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import random\n","\n","# Setting seeds for reproducibility.\n","SEED = 42\n","keras.utils.set_random_seed(SEED)"]},{"cell_type":"markdown","metadata":{"id":"GhiyIqvfgL8_"},"source":["## Hyperparameters for pretraining\n","\n","Please feel free to change the hyperparameters and check your results. The best way to\n","get an intuition about the architecture is to experiment with it. Our hyperparameters are\n","heavily inspired by the design guidelines laid out by the authors in\n","[the original paper](https://arxiv.org/abs/2111.06377)."]},{"cell_type":"code","execution_count":2,"metadata":{"id":"FRy4hJIZgL9A","executionInfo":{"status":"ok","timestamp":1711721982166,"user_tz":240,"elapsed":5,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["# DATA\n","BUFFER_SIZE = 1024\n","BATCH_SIZE = 256\n","AUTO = tf.data.AUTOTUNE\n","INPUT_SHAPE = (32, 32, 3)\n","NUM_CLASSES = 10\n","\n","# OPTIMIZER\n","LEARNING_RATE = 5e-3\n","WEIGHT_DECAY = 1e-4\n","\n","# PRETRAINING\n","EPOCHS = 100\n","\n","# AUGMENTATION\n","IMAGE_SIZE = 48  # We will resize input images to this size.\n","PATCH_SIZE = 6  # Size of the patches to be extracted from the input images.\n","NUM_PATCHES = (IMAGE_SIZE // PATCH_SIZE) ** 2\n","MASK_PROPORTION = 0.75  # We have found 75% masking to give us the best results.\n","\n","# ENCODER and DECODER\n","LAYER_NORM_EPS = 1e-6\n","ENC_PROJECTION_DIM = 128\n","DEC_PROJECTION_DIM = 64\n","ENC_NUM_HEADS = 4\n","ENC_LAYERS = 6\n","DEC_NUM_HEADS = 4\n","DEC_LAYERS = (\n","    2  # The decoder is lightweight but should be reasonably deep for reconstruction.\n",")\n","ENC_TRANSFORMER_UNITS = [\n","    ENC_PROJECTION_DIM * 2,\n","    ENC_PROJECTION_DIM,\n","]  # Size of the transformer layers.\n","DEC_TRANSFORMER_UNITS = [\n","    DEC_PROJECTION_DIM * 2,\n","    DEC_PROJECTION_DIM,\n","]"]},{"cell_type":"markdown","metadata":{"id":"35pLY4KSgL9A"},"source":["## Load and prepare the CIFAR-10 dataset"]},{"cell_type":"code","execution_count":3,"metadata":{"id":"ZlE0ZnH1gL9A","executionInfo":{"status":"ok","timestamp":1711722001668,"user_tz":240,"elapsed":19505,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}},"outputId":"7b0611f5-1630-4415-be35-61b1ccad3152","colab":{"base_uri":"https://localhost:8080/"}},"outputs":[{"output_type":"stream","name":"stdout","text":["Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n","170498071/170498071 [==============================] - 6s 0us/step\n","Training samples: 40000\n","Validation samples: 10000\n","Testing samples: 10000\n"]}],"source":["(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()\n","(x_train, y_train), (x_val, y_val) = (\n","    (x_train[:40000], y_train[:40000]),\n","    (x_train[40000:], y_train[40000:]),\n",")\n","print(f\"Training samples: {len(x_train)}\")\n","print(f\"Validation samples: {len(x_val)}\")\n","print(f\"Testing samples: {len(x_test)}\")\n","\n","train_ds = tf.data.Dataset.from_tensor_slices(x_train)\n","train_ds = train_ds.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(AUTO)\n","\n","val_ds = tf.data.Dataset.from_tensor_slices(x_val)\n","val_ds = val_ds.batch(BATCH_SIZE).prefetch(AUTO)\n","\n","test_ds = tf.data.Dataset.from_tensor_slices(x_test)\n","test_ds = test_ds.batch(BATCH_SIZE).prefetch(AUTO)"]},{"cell_type":"markdown","metadata":{"id":"EL8nLg1xgL9B"},"source":["## Data augmentation\n","\n","In previous self-supervised pretraining methodologies\n","([SimCLR](https://arxiv.org/abs/2002.05709) alike), we have noticed that the data\n","augmentation pipeline plays an important role. On the other hand the authors of this\n","paper point out that Masked Autoencoders **do not** rely on augmentations. They propose a\n","simple augmentation pipeline of:\n","\n","\n","- Resizing\n","- Random cropping (fixed-sized or random sized)\n","- Random horizontal flipping"]},{"cell_type":"code","execution_count":4,"metadata":{"id":"ziFVBtIVgL9B","executionInfo":{"status":"ok","timestamp":1711722001668,"user_tz":240,"elapsed":3,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["def get_train_augmentation_model():\n","    model = keras.Sequential(\n","        [\n","            layers.Rescaling(1 / 255.0),\n","            layers.Resizing(INPUT_SHAPE[0] + 20, INPUT_SHAPE[0] + 20),\n","            layers.RandomCrop(IMAGE_SIZE, IMAGE_SIZE),\n","            layers.RandomFlip(\"horizontal\"),\n","        ],\n","        name=\"train_data_augmentation\",\n","    )\n","    return model\n","\n","\n","def get_test_augmentation_model():\n","    model = keras.Sequential(\n","        [\n","            layers.Rescaling(1 / 255.0),\n","            layers.Resizing(IMAGE_SIZE, IMAGE_SIZE),\n","        ],\n","        name=\"test_data_augmentation\",\n","    )\n","    return model"]},{"cell_type":"markdown","metadata":{"id":"3_LSURXRgL9B"},"source":["## A layer for extracting patches from images\n","\n","This layer takes images as input and divides them into patches. The layer also includes\n","two utility method:\n","\n","- `show_patched_image` -- Takes a batch of images and its corresponding patches to plot a\n","random pair of image and patches.\n","- `reconstruct_from_patch` -- Takes a single instance of patches and stitches them\n","together into the original image."]},{"cell_type":"code","execution_count":5,"metadata":{"id":"737_Gj0NgL9B","executionInfo":{"status":"ok","timestamp":1711722001668,"user_tz":240,"elapsed":2,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["class Patches(layers.Layer):\n","    def __init__(self, patch_size=PATCH_SIZE, **kwargs):\n","        super().__init__(**kwargs)\n","        self.patch_size = patch_size\n","\n","        # Assuming the image has three channels each patch would be\n","        # of size (patch_size, patch_size, 3).\n","        self.resize = layers.Reshape((-1, patch_size * patch_size * 3))\n","\n","    def call(self, images):\n","        # Create patches from the input images\n","        patches = tf.image.extract_patches(\n","            images=images,\n","            sizes=[1, self.patch_size, self.patch_size, 1],\n","            strides=[1, self.patch_size, self.patch_size, 1],\n","            rates=[1, 1, 1, 1],\n","            padding=\"VALID\",\n","        )\n","\n","        # Reshape the patches to (batch, num_patches, patch_area) and return it.\n","        patches = self.resize(patches)\n","        return patches\n","\n","    def show_patched_image(self, images, patches):\n","        # This is a utility function which accepts a batch of images and its\n","        # corresponding patches and help visualize one image and its patches\n","        # side by side.\n","        idx = np.random.choice(patches.shape[0])\n","        print(f\"Index selected: {idx}.\")\n","\n","        plt.figure(figsize=(4, 4))\n","        plt.imshow(keras.utils.array_to_img(images[idx]))\n","        plt.axis(\"off\")\n","        plt.show()\n","\n","        n = int(np.sqrt(patches.shape[1]))\n","        plt.figure(figsize=(4, 4))\n","        for i, patch in enumerate(patches[idx]):\n","            ax = plt.subplot(n, n, i + 1)\n","            patch_img = tf.reshape(patch, (self.patch_size, self.patch_size, 3))\n","            plt.imshow(keras.utils.img_to_array(patch_img))\n","            plt.axis(\"off\")\n","        plt.show()\n","\n","        # Return the index chosen to validate it outside the method.\n","        return idx\n","\n","    # taken from https://stackoverflow.com/a/58082878/10319735\n","    def reconstruct_from_patch(self, patch):\n","        # This utility function takes patches from a *single* image and\n","        # reconstructs it back into the image. This is useful for the train\n","        # monitor callback.\n","        num_patches = patch.shape[0]\n","        n = int(np.sqrt(num_patches))\n","        patch = tf.reshape(patch, (num_patches, self.patch_size, self.patch_size, 3))\n","        rows = tf.split(patch, n, axis=0)\n","        rows = [tf.concat(tf.unstack(x), axis=1) for x in rows]\n","        reconstructed = tf.concat(rows, axis=0)\n","        return reconstructed"]},{"cell_type":"markdown","metadata":{"id":"PXZ_30AhgL9B"},"source":["Let's visualize the image patches."]},{"cell_type":"code","execution_count":6,"metadata":{"id":"-YkTKCJrgL9C","executionInfo":{"status":"ok","timestamp":1711722008387,"user_tz":240,"elapsed":6721,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}},"outputId":"8583cb34-280b-4332-d65f-6e03625cbb72","colab":{"base_uri":"https://localhost:8080/","height":1000}},"outputs":[{"output_type":"stream","name":"stdout","text":["Index selected: 102.\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 400x400 with 1 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 400x400 with 64 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Get a batch of images.\n","image_batch = next(iter(train_ds))\n","\n","# Augment the images.\n","augmentation_model = get_train_augmentation_model()\n","augmented_images = augmentation_model(image_batch)\n","\n","# Define the patch layer.\n","patch_layer = Patches()\n","\n","# Get the patches from the batched images.\n","patches = patch_layer(images=augmented_images)\n","\n","# Now pass the images and the corresponding patches\n","# to the `show_patched_image` method.\n","random_index = patch_layer.show_patched_image(images=augmented_images, patches=patches)\n","\n","# Chose the same chose image and try reconstructing the patches\n","# into the original image.\n","image = patch_layer.reconstruct_from_patch(patches[random_index])\n","plt.imshow(image)\n","plt.axis(\"off\")\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"AjxREOJggL9C"},"source":["## Patch encoding with masking\n","\n","Quoting the paper\n","\n","> Following ViT, we divide an image into regular non-overlapping patches. Then we sample\n","a subset of patches and mask (i.e., remove) the remaining ones. Our sampling strategy is\n","straightforward: we sample random patches without replacement, following a uniform\n","distribution. We simply refer to this as “random sampling”.\n","\n","This layer includes masking and encoding the patches.\n","\n","The utility methods of the layer are:\n","\n","- `get_random_indices` -- Provides the mask and unmask indices.\n","- `generate_masked_image` -- Takes patches and unmask indices, results in a random masked\n","image. This is an essential utility method for our training monitor callback (defined\n","later)."]},{"cell_type":"code","execution_count":7,"metadata":{"id":"T7OwXPWdgL9C","executionInfo":{"status":"ok","timestamp":1711722008960,"user_tz":240,"elapsed":2,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["class PatchEncoder(layers.Layer):\n","    def __init__(\n","        self,\n","        patch_size=PATCH_SIZE,\n","        projection_dim=ENC_PROJECTION_DIM,\n","        mask_proportion=MASK_PROPORTION,\n","        downstream=False,\n","        **kwargs,\n","    ):\n","        super().__init__(**kwargs)\n","        self.patch_size = patch_size\n","        self.projection_dim = projection_dim\n","        self.mask_proportion = mask_proportion\n","        self.downstream = downstream\n","\n","        # This is a trainable mask token initialized randomly from a normal\n","        # distribution.\n","        self.mask_token = tf.Variable(\n","            tf.random.normal([1, patch_size * patch_size * 3]), trainable=True\n","        )\n","\n","    def build(self, input_shape):\n","        (_, self.num_patches, self.patch_area) = input_shape\n","\n","        # Create the projection layer for the patches.\n","        self.projection = layers.Dense(units=self.projection_dim)\n","\n","        # Create the positional embedding layer.\n","        self.position_embedding = layers.Embedding(\n","            input_dim=self.num_patches, output_dim=self.projection_dim\n","        )\n","\n","        # Number of patches that will be masked.\n","        self.num_mask = int(self.mask_proportion * self.num_patches)\n","\n","    def call(self, patches):\n","        # Get the positional embeddings.\n","        batch_size = tf.shape(patches)[0]\n","        positions = tf.range(start=0, limit=self.num_patches, delta=1)\n","        pos_embeddings = self.position_embedding(positions[tf.newaxis, ...])\n","        pos_embeddings = tf.tile(\n","            pos_embeddings, [batch_size, 1, 1]\n","        )  # (B, num_patches, projection_dim)\n","\n","        # Embed the patches.\n","        patch_embeddings = (\n","            self.projection(patches) + pos_embeddings\n","        )  # (B, num_patches, projection_dim)\n","\n","        if self.downstream:\n","            return patch_embeddings\n","        else:\n","            mask_indices, unmask_indices = self.get_random_indices(batch_size)\n","            # The encoder input is the unmasked patch embeddings. Here we gather\n","            # all the patches that should be unmasked.\n","            unmasked_embeddings = tf.gather(\n","                patch_embeddings, unmask_indices, axis=1, batch_dims=1\n","            )  # (B, unmask_numbers, projection_dim)\n","\n","            # Get the unmasked and masked position embeddings. We will need them\n","            # for the decoder.\n","            unmasked_positions = tf.gather(\n","                pos_embeddings, unmask_indices, axis=1, batch_dims=1\n","            )  # (B, unmask_numbers, projection_dim)\n","            masked_positions = tf.gather(\n","                pos_embeddings, mask_indices, axis=1, batch_dims=1\n","            )  # (B, mask_numbers, projection_dim)\n","\n","            # Repeat the mask token number of mask times.\n","            # Mask tokens replace the masks of the image.\n","            mask_tokens = tf.repeat(self.mask_token, repeats=self.num_mask, axis=0)\n","            mask_tokens = tf.repeat(\n","                mask_tokens[tf.newaxis, ...], repeats=batch_size, axis=0\n","            )\n","\n","            # Get the masked embeddings for the tokens.\n","            masked_embeddings = self.projection(mask_tokens) + masked_positions\n","            return (\n","                unmasked_embeddings,  # Input to the encoder.\n","                masked_embeddings,  # First part of input to the decoder.\n","                unmasked_positions,  # Added to the encoder outputs.\n","                mask_indices,  # The indices that were masked.\n","                unmask_indices,  # The indices that were unmaksed.\n","            )\n","\n","    def get_random_indices(self, batch_size):\n","        # Create random indices from a uniform distribution and then split\n","        # it into mask and unmask indices.\n","        rand_indices = tf.argsort(\n","            tf.random.uniform(shape=(batch_size, self.num_patches)), axis=-1\n","        )\n","        mask_indices = rand_indices[:, : self.num_mask]\n","        unmask_indices = rand_indices[:, self.num_mask :]\n","        return mask_indices, unmask_indices\n","\n","    def generate_masked_image(self, patches, unmask_indices):\n","        # Choose a random patch and it corresponding unmask index.\n","        idx = np.random.choice(patches.shape[0])\n","        patch = patches[idx]\n","        unmask_index = unmask_indices[idx]\n","\n","        # Build a numpy array of same shape as patch.\n","        new_patch = np.zeros_like(patch)\n","\n","        # Iterate of the new_patch and plug the unmasked patches.\n","        count = 0\n","        for i in range(unmask_index.shape[0]):\n","            new_patch[unmask_index[i]] = patch[unmask_index[i]]\n","        return new_patch, idx\n"]},{"cell_type":"markdown","metadata":{"id":"by434l8LgL9C"},"source":["Let's see the masking process in action on a sample image."]},{"cell_type":"code","execution_count":8,"metadata":{"id":"2k8dp50ygL9C","executionInfo":{"status":"ok","timestamp":1711722010326,"user_tz":240,"elapsed":1368,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}},"outputId":"44505196-14c3-4508-8384-42e418243266","colab":{"base_uri":"https://localhost:8080/","height":411}},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x1000 with 2 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Create the patch encoder layer.\n","patch_encoder = PatchEncoder()\n","\n","# Get the embeddings and positions.\n","(\n","    unmasked_embeddings,\n","    masked_embeddings,\n","    unmasked_positions,\n","    mask_indices,\n","    unmask_indices,\n",") = patch_encoder(patches=patches)\n","\n","\n","# Show a maksed patch image.\n","new_patch, random_index = patch_encoder.generate_masked_image(patches, unmask_indices)\n","\n","plt.figure(figsize=(10, 10))\n","plt.subplot(1, 2, 1)\n","img = patch_layer.reconstruct_from_patch(new_patch)\n","plt.imshow(keras.utils.array_to_img(img))\n","plt.axis(\"off\")\n","plt.title(\"Masked\")\n","plt.subplot(1, 2, 2)\n","img = augmented_images[random_index]\n","plt.imshow(keras.utils.array_to_img(img))\n","plt.axis(\"off\")\n","plt.title(\"Original\")\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"25qQAXASgL9D"},"source":["## MLP\n","\n","This serves as the fully connected feed forward network of the transformer architecture."]},{"cell_type":"code","execution_count":11,"metadata":{"id":"FfRJNIFlgL9D","executionInfo":{"status":"ok","timestamp":1711722023468,"user_tz":240,"elapsed":204,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["def mlp(x, dropout_rate, hidden_units):\n","    for units in hidden_units:\n","        x = layers.Dense(units, activation=tf.nn.gelu)(x)\n","        x = layers.Dropout(dropout_rate)(x)\n","    return x"]},{"cell_type":"markdown","metadata":{"id":"xmXFd3c3gL9D"},"source":["## MAE encoder\n","\n","The MAE encoder is ViT. The only point to note here is that the encoder outputs a layer\n","normalized output."]},{"cell_type":"code","execution_count":10,"metadata":{"id":"EtKkSHUygL9D","executionInfo":{"status":"ok","timestamp":1711722010566,"user_tz":240,"elapsed":1,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["def create_encoder(num_heads=ENC_NUM_HEADS, num_layers=ENC_LAYERS):\n","    inputs = layers.Input((None, ENC_PROJECTION_DIM))\n","    x = inputs\n","\n","    for _ in range(num_layers):\n","        # Layer normalization 1.\n","        x1 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x)\n","\n","        # Create a multi-head attention layer.\n","        attention_output = layers.MultiHeadAttention(\n","            num_heads=num_heads, key_dim=ENC_PROJECTION_DIM, dropout=0.1\n","        )(x1, x1)\n","\n","        # Skip connection 1.\n","        x2 = layers.Add()([attention_output, x])\n","\n","        # Layer normalization 2.\n","        x3 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x2)\n","\n","        # MLP.\n","        x3 = mlp(x3, hidden_units=ENC_TRANSFORMER_UNITS, dropout_rate=0.1)\n","\n","        # Skip connection 2.\n","        x = layers.Add()([x3, x2])\n","\n","    outputs = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x)\n","    return keras.Model(inputs, outputs, name=\"mae_encoder\")"]},{"cell_type":"markdown","metadata":{"id":"5n3XEmGPgL9D"},"source":["## MAE decoder\n","\n","The authors point out that they use an **asymmetric** autoencoder model. They use a\n","lightweight decoder that takes \"<10% computation per token vs. the encoder\". We are not\n","specific with the \"<10% computation\" in our implementation but have used a smaller\n","decoder (both in terms of depth and projection dimensions)."]},{"cell_type":"code","execution_count":12,"metadata":{"id":"Ybo9-PctgL9D","executionInfo":{"status":"ok","timestamp":1711722028184,"user_tz":240,"elapsed":247,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["def create_decoder(\n","    num_layers=DEC_LAYERS, num_heads=DEC_NUM_HEADS, image_size=IMAGE_SIZE\n","):\n","    inputs = layers.Input((NUM_PATCHES, ENC_PROJECTION_DIM))\n","    x = layers.Dense(DEC_PROJECTION_DIM)(inputs)\n","\n","    for _ in range(num_layers):\n","        # Layer normalization 1.\n","        x1 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x)\n","\n","        # Create a multi-head attention layer.\n","        attention_output = layers.MultiHeadAttention(\n","            num_heads=num_heads, key_dim=DEC_PROJECTION_DIM, dropout=0.1\n","        )(x1, x1)\n","\n","        # Skip connection 1.\n","        x2 = layers.Add()([attention_output, x])\n","\n","        # Layer normalization 2.\n","        x3 = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x2)\n","\n","        # MLP.\n","        x3 = mlp(x3, hidden_units=DEC_TRANSFORMER_UNITS, dropout_rate=0.1)\n","\n","        # Skip connection 2.\n","        x = layers.Add()([x3, x2])\n","\n","    x = layers.LayerNormalization(epsilon=LAYER_NORM_EPS)(x)\n","    x = layers.Flatten()(x)\n","    pre_final = layers.Dense(units=image_size * image_size * 3, activation=\"sigmoid\")(x)\n","    outputs = layers.Reshape((image_size, image_size, 3))(pre_final)\n","\n","    return keras.Model(inputs, outputs, name=\"mae_decoder\")"]},{"cell_type":"markdown","metadata":{"id":"2bfMI2jVgL9E"},"source":["## MAE trainer\n","\n","This is the trainer module. We wrap the encoder and decoder inside of a `tf.keras.Model`\n","subclass. This allows us to customize what happens in the `model.fit()` loop."]},{"cell_type":"code","execution_count":13,"metadata":{"id":"jPiaUwTsgL9E","executionInfo":{"status":"ok","timestamp":1711722049012,"user_tz":240,"elapsed":217,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["class MaskedAutoencoder(keras.Model):\n","    def __init__(\n","        self,\n","        train_augmentation_model,\n","        test_augmentation_model,\n","        patch_layer,\n","        patch_encoder,\n","        encoder,\n","        decoder,\n","        **kwargs,\n","    ):\n","        super().__init__(**kwargs)\n","        self.train_augmentation_model = train_augmentation_model\n","        self.test_augmentation_model = test_augmentation_model\n","        self.patch_layer = patch_layer\n","        self.patch_encoder = patch_encoder\n","        self.encoder = encoder\n","        self.decoder = decoder\n","\n","    def calculate_loss(self, images, test=False):\n","        # Augment the input images.\n","        if test:\n","            augmented_images = self.test_augmentation_model(images)\n","        else:\n","            augmented_images = self.train_augmentation_model(images)\n","\n","        # Patch the augmented images.\n","        patches = self.patch_layer(augmented_images)\n","\n","        # Encode the patches.\n","        (\n","            unmasked_embeddings,\n","            masked_embeddings,\n","            unmasked_positions,\n","            mask_indices,\n","            unmask_indices,\n","        ) = self.patch_encoder(patches)\n","\n","        # Pass the unmaksed patche to the encoder.\n","        encoder_outputs = self.encoder(unmasked_embeddings)\n","\n","        # Create the decoder inputs.\n","        encoder_outputs = encoder_outputs + unmasked_positions\n","        decoder_inputs = tf.concat([encoder_outputs, masked_embeddings], axis=1)\n","\n","        # Decode the inputs.\n","        decoder_outputs = self.decoder(decoder_inputs)\n","        decoder_patches = self.patch_layer(decoder_outputs)\n","\n","        loss_patch = tf.gather(patches, mask_indices, axis=1, batch_dims=1)\n","        loss_output = tf.gather(decoder_patches, mask_indices, axis=1, batch_dims=1)\n","\n","        # Compute the total loss.\n","        total_loss = self.compute_loss(y=loss_patch, y_pred=loss_output)\n","\n","        return total_loss, loss_patch, loss_output\n","\n","    def train_step(self, images):\n","        with tf.GradientTape() as tape:\n","            total_loss, loss_patch, loss_output = self.calculate_loss(images)\n","\n","        # Apply gradients.\n","        train_vars = [\n","            self.train_augmentation_model.trainable_variables,\n","            self.patch_layer.trainable_variables,\n","            self.patch_encoder.trainable_variables,\n","            self.encoder.trainable_variables,\n","            self.decoder.trainable_variables,\n","        ]\n","        grads = tape.gradient(total_loss, train_vars)\n","        tv_list = []\n","        for grad, var in zip(grads, train_vars):\n","            for g, v in zip(grad, var):\n","                tv_list.append((g, v))\n","        self.optimizer.apply_gradients(tv_list)\n","\n","        # Report progress.\n","        results = {}\n","        for metric in self.metrics:\n","            metric.update_state(loss_patch, loss_output)\n","            results[metric.name] = metric.result()\n","        return results\n","\n","    def test_step(self, images):\n","        total_loss, loss_patch, loss_output = self.calculate_loss(images, test=True)\n","\n","        # Update the trackers.\n","        results = {}\n","        for metric in self.metrics:\n","            metric.update_state(loss_patch, loss_output)\n","            results[metric.name] = metric.result()\n","        return results"]},{"cell_type":"markdown","metadata":{"id":"HB87RcISgL9E"},"source":["## Model initialization"]},{"cell_type":"code","execution_count":14,"metadata":{"id":"yBVTzjfqgL9E","executionInfo":{"status":"ok","timestamp":1711722064720,"user_tz":240,"elapsed":2739,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["train_augmentation_model = get_train_augmentation_model()\n","test_augmentation_model = get_test_augmentation_model()\n","patch_layer = Patches()\n","patch_encoder = PatchEncoder()\n","encoder = create_encoder()\n","decoder = create_decoder()\n","\n","mae_model = MaskedAutoencoder(\n","    train_augmentation_model=train_augmentation_model,\n","    test_augmentation_model=test_augmentation_model,\n","    patch_layer=patch_layer,\n","    patch_encoder=patch_encoder,\n","    encoder=encoder,\n","    decoder=decoder,\n",")"]},{"cell_type":"markdown","metadata":{"id":"cIWBQ-IrgL9E"},"source":["## Training callbacks"]},{"cell_type":"markdown","metadata":{"id":"dIUEUfZLgL9E"},"source":["### Visualization callback"]},{"cell_type":"code","execution_count":15,"metadata":{"id":"OSD5fZ4ugL9E","executionInfo":{"status":"ok","timestamp":1711722069236,"user_tz":240,"elapsed":241,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}}},"outputs":[],"source":["# Taking a batch of test inputs to measure model's progress.\n","test_images = next(iter(test_ds))\n","\n","\n","class TrainMonitor(keras.callbacks.Callback):\n","    def __init__(self, epoch_interval=None):\n","        self.epoch_interval = epoch_interval\n","\n","    def on_epoch_end(self, epoch, logs=None):\n","        if self.epoch_interval and epoch % self.epoch_interval == 0:\n","            test_augmented_images = self.model.test_augmentation_model(test_images)\n","            test_patches = self.model.patch_layer(test_augmented_images)\n","            (\n","                test_unmasked_embeddings,\n","                test_masked_embeddings,\n","                test_unmasked_positions,\n","                test_mask_indices,\n","                test_unmask_indices,\n","            ) = self.model.patch_encoder(test_patches)\n","            test_encoder_outputs = self.model.encoder(test_unmasked_embeddings)\n","            test_encoder_outputs = test_encoder_outputs + test_unmasked_positions\n","            test_decoder_inputs = tf.concat(\n","                [test_encoder_outputs, test_masked_embeddings], axis=1\n","            )\n","            test_decoder_outputs = self.model.decoder(test_decoder_inputs)\n","\n","            # Show a maksed patch image.\n","            test_masked_patch, idx = self.model.patch_encoder.generate_masked_image(\n","                test_patches, test_unmask_indices\n","            )\n","            print(f\"\\nIdx chosen: {idx}\")\n","            original_image = test_augmented_images[idx]\n","            masked_image = self.model.patch_layer.reconstruct_from_patch(\n","                test_masked_patch\n","            )\n","            reconstructed_image = test_decoder_outputs[idx]\n","\n","            fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(15, 5))\n","            ax[0].imshow(original_image)\n","            ax[0].set_title(f\"Original: {epoch:03d}\")\n","\n","            ax[1].imshow(masked_image)\n","            ax[1].set_title(f\"Masked: {epoch:03d}\")\n","\n","            ax[2].imshow(reconstructed_image)\n","            ax[2].set_title(f\"Resonstructed: {epoch:03d}\")\n","\n","            plt.show()\n","            plt.close()\n"]},{"cell_type":"markdown","metadata":{"id":"HsJ3HNh9gL9E"},"source":["### Learning rate scheduler"]},{"cell_type":"code","execution_count":16,"metadata":{"id":"qd9xuIr-gL9E","executionInfo":{"status":"ok","timestamp":1711722084961,"user_tz":240,"elapsed":13056,"user":{"displayName":"Yiqiao Yin","userId":"16271867367914268422"}},"outputId":"1a47f44a-e9dc-4f4c-d258-6ee19eb2662b","colab":{"base_uri":"https://localhost:8080/","height":454}},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Some code is taken from:\n","# https://www.kaggle.com/ashusma/training-rfcx-tensorflow-tpu-effnet-b2.\n","\n","\n","class WarmUpCosine(keras.optimizers.schedules.LearningRateSchedule):\n","    def __init__(\n","        self, learning_rate_base, total_steps, warmup_learning_rate, warmup_steps\n","    ):\n","        super().__init__()\n","\n","        self.learning_rate_base = learning_rate_base\n","        self.total_steps = total_steps\n","        self.warmup_learning_rate = warmup_learning_rate\n","        self.warmup_steps = warmup_steps\n","        self.pi = tf.constant(np.pi)\n","\n","    def __call__(self, step):\n","        if self.total_steps < self.warmup_steps:\n","            raise ValueError(\"Total_steps must be larger or equal to warmup_steps.\")\n","\n","        cos_annealed_lr = tf.cos(\n","            self.pi\n","            * (tf.cast(step, tf.float32) - self.warmup_steps)\n","            / float(self.total_steps - self.warmup_steps)\n","        )\n","        learning_rate = 0.5 * self.learning_rate_base * (1 + cos_annealed_lr)\n","\n","        if self.warmup_steps > 0:\n","            if self.learning_rate_base < self.warmup_learning_rate:\n","                raise ValueError(\n","                    \"Learning_rate_base must be larger or equal to \"\n","                    \"warmup_learning_rate.\"\n","                )\n","            slope = (\n","                self.learning_rate_base - self.warmup_learning_rate\n","            ) / self.warmup_steps\n","            warmup_rate = slope * tf.cast(step, tf.float32) + self.warmup_learning_rate\n","            learning_rate = tf.where(\n","                step < self.warmup_steps, warmup_rate, learning_rate\n","            )\n","        return tf.where(\n","            step > self.total_steps, 0.0, learning_rate, name=\"learning_rate\"\n","        )\n","\n","\n","total_steps = int((len(x_train) / BATCH_SIZE) * EPOCHS)\n","warmup_epoch_percentage = 0.15\n","warmup_steps = int(total_steps * warmup_epoch_percentage)\n","scheduled_lrs = WarmUpCosine(\n","    learning_rate_base=LEARNING_RATE,\n","    total_steps=total_steps,\n","    warmup_learning_rate=0.0,\n","    warmup_steps=warmup_steps,\n",")\n","\n","lrs = [scheduled_lrs(step) for step in range(total_steps)]\n","plt.plot(lrs)\n","plt.xlabel(\"Step\", fontsize=14)\n","plt.ylabel(\"LR\", fontsize=14)\n","plt.show()\n","\n","# Assemble the callbacks.\n","train_callbacks = [TrainMonitor(epoch_interval=5)]"]},{"cell_type":"markdown","metadata":{"id":"qhpG9B7ZgL9F"},"source":["## Model compilation and training"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vMw_iGqTgL9F","outputId":"4356c9b1-e005-4d8a-f398-ae28ba19f3b6","colab":{"base_uri":"https://localhost:8080/","height":1000}},"outputs":[{"output_type":"stream","name":"stdout","text":["Epoch 1/100\n","157/157 [==============================] - ETA: 0s - loss: 0.4935\n","Idx chosen: 92\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x500 with 3 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAABLkAAAGXCAYAAABfpYIsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACKdElEQVR4nO3deZwlVX3//3ctd+t1VoZl2MQFRASdCI4ii4wggoEIGsVERA0awa9oJIYYRUgiRhJFEUQjXzRGg4HE/etCEFF/IkGUyCIgBBUcZoZZer1rVZ3fH+O0NN2fT880s/SdeT199EPmfm5VnTp1qs7St+8nCiEEAQAAAAAAAF0s3tEFAAAAAAAAAJ4sFrkAAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa50NXe//73K4qiWW37mc98RlEU6Ve/+tXWLdTj/OpXv1IURfrMZz6zzY4BAJh7vve97ymKIl1//fXb9Dj77befXv/612/TYwAAsL08mfkdILHIhR3k7rvv1p/8yZ9or732UqVS0Z577qnXvva1uvvuu3d00eacoaEhnX322Vq8eLF6e3t17LHH6qc//em07/3qV7+q5z73uapWq9pnn3104YUXKsuyJ7VPAOg2m36JEUWRfvjDH06JhxC09957K4oinXzyyTughHNHURT60Ic+pP3331/ValXPfvaz9W//9m/TvvcXv/iFXvrSl6qvr08LFizQn/7pn+qxxx57UvsEgK3h8c/9KIqUpqn22msvvf71r9dvf/vbHV28rWrlypV6//vfrzvuuGOXLoPnRz/6kY488kj19PRo99131//5P/9HY2NjU97XarX07ne/W3vuuadqtZqOOOII3XDDDU9qn9jxWOTCdvef//mfeu5zn6sbb7xRZ511lq688kq98Y1v1E033aTnPve5+tKXvrTZ+/qbv/kbNRqNWZXjT//0T9VoNLTvvvvOavvtoSgKnXTSSfrCF76gc889Vx/60Ie0Zs0aHXPMMfrlL3856b3f/OY3deqpp2revHm6/PLLdeqpp+rv/u7v9La3vW3W+wSAblatVvWFL3xhyus333yzHnnkEVUqlR1QqrnlPe95j9797nfrJS95iS6//HLts88+OuOMM3TttddOet8jjzyio446Sg888IA+8IEP6F3vepe+8Y1v6CUveYna7fas9gkAW9vFF1+sz33uc7rqqqt04okn6l//9V919NFHq9ls7uiibTUrV67URRddtMMXuXZ0GSx33HGHjjvuONXrdX34wx/Wm970Jn3qU5/SK1/5yinvff3rX68Pf/jDeu1rX6uPfvSjSpJEL3vZy6b8gmxL9ok5IADb0QMPPBB6enrCgQceGNasWTMp9thjj4UDDzww9Pb2hgcffNDdz9jY2LYs5lbz0EMPBUnhmmuumdX2X/ziF4OkcN111028tmbNmjBv3rzwmte8ZtJ7n/nMZ4ZDDz00dDqdidfe8573hCiKwi9+8YtZ7RMAutE111wTJIVXvOIVYdGiRZOeiyGE8Gd/9mdh2bJlYd999w0nnXTSNinDTTfdNOVZuy3su+++4cwzz5zVto888kgolUrhnHPOmXitKIrwohe9KCxdujRkWTbx+p//+Z+HWq0Wfv3rX0+8dsMNNwRJ4ZOf/OSs9gkAW8um5/5tt9026fV3v/vdQVL44he/uINKtvXddtttWzS/GB8f3+Fl2BIXXnhheDLLFCeeeGLYY489wvDw8MRr//zP/xwkhW9/+9sTr916661BUrj00ksnXms0GuGAAw4Iy5cvn9U+MTfwSS5sV5deeqnq9bo+9alPafHixZNiixYt0ic/+UmNj4/rQx/60MTrm/4u+5577tEZZ5yh+fPn68gjj5wUe7xGo6H/83/+jxYtWqT+/n794R/+oX77298qiiK9//3vn3jfdN/Jtd9+++nkk0/WD3/4Qx1++OGqVqt6ylOeon/5l3+ZdIz169frXe96lw455BD19fVpYGBAJ554ov7nf/5nxjrodDq699579eijj8743uuvv15LlizRK17xionXFi9erFe96lX6yle+olarJUm65557dM899+jss89WmqYT733rW9+qEMKk74TZ3H0CQLd7zWteo3Xr1k3604N2u63rr79eZ5xxxrTb/OM//qNe8IIXaOHCharValq2bNm036t1ww036Mgjj9S8efPU19enZzzjGfrrv/5rtzytVksnn3yyBgcH9aMf/UjSxk/XXnbZZTr44INVrVa1ZMkSvfnNb9aGDRsmbRtC0N/93d9p6dKl6unp0bHHHmv+if+DDz6oBx980C2LJH3lK19Rp9PRW9/61onXoijSn//5n+uRRx7RLbfcMvH6f/zHf+jkk0/WPvvsM/HaihUr9PSnP13//u//Pqt9AsC29qIXvUiSpjwT7733Xp1++ulasGCBqtWq/uAP/kBf/epXJ72n0+nooosu0tOe9jRVq1UtXLhQRx555JQ/Z/vud7+rF73oRert7dW8efN0yimn6Be/+MWk92yaszzwwAN6/etfr3nz5mlwcFBnnXWW6vX6pPd6/cv3vvc9Pe95z5MknXXWWRN/nrnp+3+POeYYPetZz9Ltt9+uo446Sj09PRPbPnEutMl03+04NDSkd7zjHdpvv/1UqVS0dOlSve51r9PatWtnLIMk3XrrrXrpS1+qwcFB9fT06Oijj9b/9//9f1OO/cMf/lDPe97zVK1WdcABB+iTn/zklPdI0tq1a3XvvfdOqasnGhkZ0Q033KA/+ZM/0cDAwMTrr3vd69TX1zepv7r++uuVJInOPvvsideq1are+MY36pZbbtHDDz+8xfvE3MAiF7arr33ta9pvv/0mOpwnOuqoo7TffvvpG9/4xpTYK1/5StXrdX3gAx/Qn/3Zn5nHeP3rX6/LL79cL3vZy/QP//APqtVqOumkkza7jA888IBOP/10veQlL9E//dM/af78+Xr9618/aTLxv//7v/ryl7+sk08+WR/+8Id1/vnn684779TRRx+tlStXuvv/7W9/q4MOOkgXXHDBjGX52c9+puc+97mK48m36uGHH656va77779/4n2S9Ad/8AeT3rfnnntq6dKlE/Et2ScAdLv99ttPy5cvn/R9UN/85jc1PDysV7/61dNu89GPflTPec5zdPHFF+sDH/iA0jTVK1/5ykn90t13362TTz5ZrVZLF198sf7pn/5Jf/iHfzjtAH6TRqOhl7/85frRj36k//qv/9ILXvACSdKb3/xmnX/++XrhC1+oj370ozrrrLP0+c9/XieccII6nc7E9u973/v03ve+V4ceeqguvfRSPeUpT9Hxxx+v8fHxKcc67rjjdNxxx81YPz/72c/U29urgw46aNLrhx9++ERc2thvrVmzZkofs+m9T+xjNmefALA9bPpl9vz58ydeu/vuu/X85z9fv/jFL/RXf/VX+qd/+if19vbq1FNPnfS1Ke9///t10UUX6dhjj9XHP/5xvec979E+++wz6Xts/+u//ksnnHCC1qxZo/e///165zvfqR/96Ed64QtfOG1yq1e96lUaHR3VJZdcole96lX6zGc+o4suumhS2bz+5aCDDtLFF18sSTr77LP1uc99Tp/73Od01FFHTexj3bp1OvHEE3XYYYfpsssu07HHHrtFdTY2NqYXvehFuvzyy3X88cfrox/9qN7ylrfo3nvv1SOPPDJjGb773e/qqKOO0sjIiC688EJ94AMf0NDQkF784hfrv//7vyeOc+edd+r444+fqLuzzjpLF1544bRfXfPxj39cBx100KTtp3PnnXcqy7Ip/VW5XNZhhx02pb96+tOfPmnhSvp9f7XpTzG3ZJ+YG9KZ3wJsHcPDw1q5cqVOOeUU933Pfvaz9dWvflWjo6Pq7++feP3QQw+d9rtVHu+nP/2p/v3f/13nnXeePvKRj0ja+Gmms846a7M+ZSVJ9913n77//e9PLMS96lWv0t57761rrrlG//iP/yhJOuSQQ3T//fdPWij60z/9Ux144IG6+uqr9d73vnezjjWTRx99dFKntckee+whaePfwx9yyCETnwrb9PoT3/v4hbfN3ScA7AzOOOMMXXDBBWo0GqrVavr85z+vo48+Wnvuuee077///vtVq9Um/n3uuefquc99rj784Q9P/MLkhhtuULvd1je/+U0tWrRoxjKMjY3p5JNP1t13363vfve7OuywwyRt/A32pz/9aX3+85+f9MmyY489Vi996Ut13XXX6YwzztBjjz2mD33oQzrppJP0ta99beITzO95z3v0gQ98YLZVo0cffVRLliyZ8onox/cHm973+Nef+N7169er1WqpUqls9j4BYFsYHh7W2rVr1Ww2deutt+qiiy5SpVKZlGTk7W9/u/bZZx/ddtttE9/N+Na3vlVHHnmk3v3ud+uP/uiPJEnf+MY39LKXvUyf+tSnzOOdf/75WrBggW655RYtWLBAknTqqafqOc95ji688EJ99rOfnfT+5zznObr66qsn/r1u3TpdffXV+od/+AdJM/cvS5Ys0Yknnqj3ve99Wr58uf7kT/5kyntWrVqlq666Sm9+85s3t9omufTSS3XXXXfpP//zPyfqQtr4XcghBEVRZJYhhKC3vOUtOvbYY/XNb35zoi9485vfrIMPPlh/8zd/o+985zuSNv7yJoSgH/zgBxOfEj7ttNOe1Dxkpv7qBz/4waT3Wu+TNr8PfPw+MTfwSS5sN6Ojo5I0aeFqOpviIyMjk15/y1veMuMxvvWtb0nSpD+TkDTly9c9z3zmMyd90mzx4sV6xjOeof/93/+deK1SqUwscOV5rnXr1k18nHimLIX77befQgiTPtJraTQa034xcrVanYg//v+t9z7+y/k3d58AsDN41atepUajoa9//esaHR3V17/+dfNPFSVNWuDasGGDhoeH9aIXvWjSs33evHmSNv5pXlEU7vGHh4d1/PHH695779X3vve9iQUuSbruuus0ODiol7zkJVq7du3Ez7Jly9TX16ebbrpJ0sZPCrTbbb3tbW+btHh03nnnTXvMX/3qV9N+guCJtlYf88T30scA2FFWrFihxYsXa++999bpp5+u3t5effWrX9XSpUslbfzKke9+97sTn6ja9Nxdt26dTjjhBP3yl7+cyMY4b9483X333WZipkcffVR33HGHXv/6108scEkbf2H/kpe8RP/v//2/Kds8cT7zohe9SOvWrZuY92xJ/2KpVCo666yzZrWttPHP0w899NBJC1ybPPEXGE90xx136Je//KXOOOMMrVu3bqJ+x8fHddxxx+n73/++iqJQnuf69re/rVNPPXXSn8EfdNBBOuGEE6bs9/3vf79CCDrmmGPc42+LOdGW7BNzA4tc2G42LV5tWuyyWIth+++//4zH+PWvf604jqe896lPfepml/PxD9pN5s+fP+n7UYqi0Ec+8hE97WlPU6VS0aJFi7R48WL9/Oc/1/Dw8GYfaya1Wm3a78jalCFm02Rs0/9b7338pG1z9wkAO4PFixdrxYoV+sIXvqD//M//VJ7nOv300833f/3rX9fzn/98VatVLViwQIsXL9YnPvGJSc/2P/7jP9YLX/hCvelNb9KSJUv06le/Wv/+7/8+7YTkvPPO02233ab/+q//0sEHHzwp9stf/lLDw8PabbfdtHjx4kk/Y2NjWrNmjaSNfZskPe1pT5tybo//E5wttbX6mCe+lz4GwI5yxRVX6IYbbtD111+vl73sZVq7du2kxYkHHnhAIQS9973vnfLcvfDCCyVp4tl78cUXa2hoSE9/+tN1yCGH6Pzzz9fPf/7ziX1tejY/4xnPmFKOgw46aGJx5/GeOM/Y9AzfNM/Ykv7Fstdee6lcLm/2+5/owQcf1LOe9axZbbtpQfDMM8+cUr+f/vSn1Wq1NDw8rMcee0yNRmNKvyZNX5+ba1vMibZkn5gb+HNFbDeDg4PaY489JnUO0/n5z3+uvfbaa8rfR2+vB0iSJNO+HkKY+O8PfOADeu9736s3vOEN+tu//VstWLBAcRzrvPPOm/VvXaazxx57TPsF9Zte2/TnNps+Pvvoo49q7733nvLeTX9bviX7BICdxRlnnKE/+7M/06pVq3TiiSdO/Kb8iX7wgx/oD//wD3XUUUfpyiuv1B577KFSqaRrrrlm0p/L12o1ff/739dNN92kb3zjG/rWt76lL37xi3rxi1+s73znO5P6kVNOOUXXXnutPvjBD+pf/uVfJv2Ze1EU2m233fT5z39+2vI8MUHL1rbHHnvopptumvjzk028PuaJHn30US1YsGBiErm5+wSAbeHwww+f+O6kU089VUceeaTOOOMM3Xffferr65sYp7/rXe+a9hND0u9/OX7UUUfpwQcf1Fe+8hV95zvf0ac//Wl95CMf0VVXXaU3velNsyrfTPOMLelfLFs6Z8rzfIve79lUv5deeumkTy4/Xl9f3zZLdDVTf/X4PmiPPfaY+NTeE98nbX4fSL829/BJLmxXJ598sh566CH98Ic/nDb+gx/8QL/61a8m/d38lth3331VFIUeeuihSa8/8MADs9qf5frrr9exxx6rq6++Wq9+9at1/PHHa8WKFRoaGtqqxznssMP005/+dMrC2a233qqenh49/elPn3ifJP3kJz+Z9L6VK1fqkUcemdTJbO4+AWBn8Ud/9EeK41g//vGP3T9V/I//+A9Vq1V9+9vf1hve8AadeOKJWrFixbTvjeNYxx13nD784Q/rnnvu0d///d/ru9/97sSfGG5y6qmn6v/+3/+rL3zhCzrnnHMmxQ444ACtW7dOL3zhC7VixYopP4ceeqikjX2bpCl/MvPYY49NycK4JQ477DDV6/UpWcBuvfXWibi08VMBixcvntLHSNJ///d/T+ljNmefALCtJUmiSy65RCtXrtTHP/5xSdJTnvIUSVKpVJr2ubtixYpJf02yYMECnXXWWfq3f/s3Pfzww3r2s589kaFw07P5vvvum3Lse++9V4sWLVJvb+8Wl3um/mWmPxm0zJ8/f8pcpd1uT1m8OeCAA3TXXXe5+7LKcMABB0iSBgYGzPotlUpavHixarXatH8KOl19bq5nPetZStN0Sn/Vbrd1xx13TOmv7r///ilfkfPE/mpL9om5gUUubFfnn3++arWa3vzmN2vdunWTYuvXr9db3vIW9fT06Pzzz5/V/jf9RubKK6+c9Prll18+uwIbkiSZ9MkuaeN3q0z324An6nQ6uvfee6f9bcATnX766Vq9erX+8z//c+K1tWvX6rrrrtPLX/7yid+cH3zwwTrwwAP1qU99atJvYz7xiU8oiqJJf5qzufsEgJ1FX1+fPvGJT+j973+/Xv7yl5vvS5JEURRNeo7+6le/0pe//OVJ71u/fv2UbTcNcqf77fTrXvc6fexjH9NVV12ld7/73ROvv+pVr1Ke5/rbv/3bKdtkWTYxGdk0Kbj88ssn9T2XXXbZtOfx4IMP6sEHH7ROc8Ipp5yiUqk0qc8MIeiqq67SXnvtNZEBUtr4ZcBf//rXJ1KqS9KNN96o+++/X6985StntU8A2NaOOeYYHX744brsssvUbDa122676ZhjjtEnP/nJacfijz322MR/P3Gu0tfXp6c+9akTz/k99thDhx12mD772c9OWjy666679J3vfEcve9nLtri8m9O/bFo429Jfrh9wwAH6/ve/P+m1J84dpI3P+//5n/+ZNsvhpj7IKsOyZct0wAEH6B//8R81NjY2ZftN9ZskiU444QR9+ctf1m9+85uJ+C9+8Qt9+9vfnrLd2rVrde+996per7vnODg4qBUrVuhf//VfJ31Fzuc+9zmNjY1N6q9OP/105Xk+KbFAq9XSNddcoyOOOGLir2O2ZJ+YG/hzRWxXT3va0/TZz35Wr33ta3XIIYfojW98o/bff3/96le/0tVXX621a9fq3/7t3yZ+C7Clli1bptNOO02XXXaZ1q1bp+c///m6+eabdf/990ua/W8+nujkk0/WxRdfrLPOOksveMELdOedd+rzn//8xG+HPL/97W910EEH6cwzz5zxy+dPP/10Pf/5z9dZZ52le+65R4sWLdKVV16pPM8npRuWNn4s+A//8A91/PHH69WvfrXuuusuffzjH9eb3vSmSanct2SfALCzOPPMM2d8z0knnaQPf/jDeulLX6ozzjhDa9as0RVXXKGnPvWpk/7U/uKLL9b3v/99nXTSSdp33321Zs0aXXnllVq6dKmOPPLIafd97rnnamRkRO95z3s0ODiov/7rv9bRRx+tN7/5zbrkkkt0xx136Pjjj1epVNIvf/lLXXfddfroRz+q008/XYsXL9a73vUuXXLJJTr55JP1spe9TD/72c/M7FvHHXecJM345fNLly7Veeedp0svvVSdTkfPe97z9OUvf1k/+MEP9PnPf37Sn8X89V//ta677jode+yxevvb366xsTFdeumlOuSQQyZ9wfGW7BMAtofzzz9fr3zlK/WZz3xGb3nLW3TFFVfoyCOP1CGHHKI/+7M/01Oe8hStXr1at9xyix555JGJjOzPfOYzdcwxx2jZsmVasGCBfvKTn+j666/XueeeO7HvSy+9VCeeeKKWL1+uN77xjWo0Grr88ss1ODg48YmvLbE5/csBBxygefPm6aqrrlJ/f796e3t1xBFHzPj9xW9605v0lre8Raeddppe8pKX6H/+53/07W9/e0o/cv755+v666/XK1/5Sr3hDW/QsmXLtH79en31q1/VVVddpUMPPdQtw6c//WmdeOKJOvjgg3XWWWdpr7320m9/+1vddNNNGhgY0Ne+9jVJ0kUXXaRvfetbetGLXqS3vvWtyrJMl19+uQ4++OApX2/z8Y9/XBdddJFuuummGb98/u///u/1ghe8QEcffbTOPvtsPfLII/qnf/onHX/88XrpS1868b4jjjhCr3zlK3XBBRdozZo1eupTn6rPfvazE/PS2ewTc0QAdoCf//zn4TWveU3YY489QqlUCrvvvnt4zWteE+68884p773wwguDpPDYY4+ZsccbHx8P55xzTliwYEHo6+sLp556arjvvvuCpPDBD35w4n3XXHNNkBQeeuihidf23XffcNJJJ005ztFHHx2OPvroiX83m83wF3/xF2GPPfYItVotvPCFLwy33HLLlPc99NBDQVK45pprprx25plnzlxRIYT169eHN77xjWHhwoWhp6cnHH300eG2226b9r1f+tKXwmGHHRYqlUpYunRp+Ju/+ZvQbref1D4BoNtser7P9Fyb7pl/9dVXh6c97WmhUqmEAw88MFxzzTVT+pobb7wxnHLKKWHPPfcM5XI57LnnnuE1r3lNuP/++yfec9NNNwVJ4brrrpu0/7/8y78MksLHP/7xidc+9alPhWXLloVarRb6+/vDIYccEv7yL/8yrFy5cuI9eZ6Hiy66aKLfOeaYY8Jdd90V9t133yn9yb777hv23XffzaqrPM/DBz7wgbDvvvuGcrkcDj744PCv//qv0773rrvuCscff3zo6ekJ8+bNC6997WvDqlWrntQ+AWBr8J77eZ6HAw44IBxwwAEhy7IQQggPPvhgeN3rXhd23333UCqVwl577RVOPvnkcP31109s93d/93fh8MMPD/PmzQu1Wi0ceOCB4e///u+njK3/67/+K7zwhS8MtVotDAwMhJe//OXhnnvumfQeaz7zxPnI5vQvIYTwla98JTzzmc8MaZpOmmscffTR4eCDD562jvI8D+9+97vDokWLQk9PTzjhhBPCAw88MG0/sm7dunDuueeGvfbaK5TL5bB06dJw5plnhrVr185YhhBC+NnPfhZe8YpXhIULF4ZKpRL23Xff8KpXvSrceOONk45z8803h2XLloVyuRye8pSnhKuuumra+d2m12666aZpz+2JfvCDH4QXvOAFoVqthsWLF4dzzjknjIyMTHlfo9EI73rXu8Luu+8eKpVKeN7znhe+9a1vPal9YseLQnjC31wBO6E77rhDz3nOc/Sv//qveu1rX7ujiwMAAAAAALYyvpMLO51GozHltcsuu0xxHOuoo47aASUCAAAAAADbGt/JhZ3Ohz70Id1+++069thjlaapvvnNb+qb3/ymzj777IkvEAQAAAAAADsX/lwRO50bbrhBF110ke655x6NjY1pn3320Z/+6Z/qPe95j9KUdV0AAAAAAHZGLHIBAAAAAACg6/GdXAAAAAAAAOh6c+5vt4qi0MqVK9Xf368oinZ0cQCg64UQNDo6qj333FNxzO82JPoaANja6Gsmo58BgK1rs/uZsI18/OMfD/vuu2+oVCrh8MMPD7feeutmbffwww8HSfzwww8//Gzln4cffnhbPfJ3iNn2MyHQ1/DDDz/8bKufnamvoZ/hhx9++Jl7PzP1M9vkk1xf/OIX9c53vlNXXXWVjjjiCF122WU64YQTdN9992m33XZzt+3v75ckXf7VX6rW2z8lHsv+TUji/JbE+/1JpMItk6Lc29gUe+WZ7W90/BMxJTNc6TSxV0LLib3jsrOAWk7tYCm19+l9N3wSBzMWR3ZM8v82N43t8jgh5YV3TGfDyC6Nd7yZznHjfb/lscKJ5c4u82AXNs/tc2x37O1amX+OWce+X7PciRVOzK0bW3Cuo3eNg1NvG9/ghJyvUbRi9bFRveG4p048X3cGT6afkbRT1QUAzCU7y/N1a/Uz/3z999TT0zclHjudfSlNzFgnsUcmacsf8Dcr9pym7WxXcspa69jjnXFnENXjzBOikn3+IerYO5U/jg5F1YyV3aqzj9ket8taLtm12ig75+gVRVJolJxj2pUeMvv6Z8GORUXZjCXOOUaZXd9+i/PnA94neEqxU6/BPmbRtvdZr2ZmLI3ta1Fq2dtJUpHbjbVj71Zld/ppB1vBLk/SsG+AqGJvV3PWECRpuGm3x4rzLAs901/H+viYzj7lxTP2M9vki+ePOOIIPe95z9PHP/5xSRs/rrv33nvrbW97m/7qr/7K3XZkZESDg4P69I2r1NM7MCXuLRyxyGWHZlrkKs12kct+jqgyxxa5nKIqdc6RRS57j94iV5Ztm0WujrfIlW39RS7n7u+iRa4RvfqIJRoeHtbAwNTnajd6Mv2M9Pu+BgCwde0sfc3W6mc+//9+op7eLVvkKjuLXG13kcuZGUtqOpN1d5HLGXvUOnZZx51xco9zjpG3ABT5iyPe/Mtb5KrMcpGrNWaXtVJqmbG6c8AZR/t1+zpXynb7KDreIpfdNqKiYsa8Ra7YWeQK22iRq+wschWzXuSyr38a2wuApZa/IFs4HwjwF7mcFrKdF7l6ZljkGtoGi1x/suLwGfuZrf4H8+12W7fffrtWrFjx+4PEsVasWKFbbrllyvtbrZZGRkYm/QAAYNnSfkairwEAbD76GQDoXlt9kWvt2rXK81xLliyZ9PqSJUu0atWqKe+/5JJLNDg4OPGz9957b+0iAQB2Ilvaz0j0NQCAzUc/AwDda4enPrngggs0PDw88fPwww/v6CIBAHYy9DUAgG2JfgYA5oat/sXzixYtUpIkWr169aTXV69erd13333K+yuViioV++98AQB4vC3tZyT6GgDA5qOfAYDutdUXucrlspYtW6Ybb7xRp556qqSNX9R444036txzz938HYWw8Wcr8b7nPZrhy7zd74j3viTc+07q2X7vvHsiTllmOJ4X9zb1LpH3nexezP8yd+dLt2f6UnbvRJxvV/fqpnC+zNw9DacwqfNFnDN9X/lsv3je28rNLjjr67/lX57+pLlt3Ek84NXbbD8LO9N1dL94fstjM3wnZNfZav0MAADT2Jr9TJxt/HmitGKPsBrOgM/LZpgX9hedS1LUtqd+FSe5U8f+bm2psL+UOjhJqArZ23UK+/x7Cn/6WqRNMxbJXoRsd+ztOpk9Ni9V7S9zz9VjxvpH7S8lb9a8tEdSkniDQW9uYn/xejl2FmhLdnni3N4uThtmrBm8RiUludOuyvZ5dJwvUI+dxGcd58vVM+dL6Wu99rUYdzIvSlJa2G0gcb5431sOGHNuj3LJrvNWarebnhF7p5mznSTFiV0HDaddBeML6xvNzZsnbvVFLkl65zvfqTPPPFN/8Ad/oMMPP1yXXXaZxsfHddZZZ22LwwEAdjH0MwCAbYl+BgC60zZZ5PrjP/5jPfbYY3rf+96nVatW6bDDDtO3vvWtKV/eCADAbNDPAAC2JfoZAOhO22SRS5LOPfdc/mwEALDN0M8AALYl+hkA6D472Te1AAAAAAAAYFfEIhcAAAAAAAC6HotcAAAAAAAA6Hrb7Du5thUnY6Zi2SklY2dDLw2nJMXuxrPbLnIO6pdndtvNdI6RW7MOJ4tnUdjB3M02am8XgneN/ZSiTjZmBWfbyClPUThpep2Yfx3tWJjpQnoXxNvK2a13FrlzuNy5/l7VOJtJkoJ3ju6tage9Z4d783i/JphlWSS5l9HJDC3r9ki8ZxgAANhmKp2gamdqB92KnUFEyQ61S20zFqvmlqXWycxYs2wPPspte/CRxbkZK0XOVDO3t6s5A8Vm5H9GI46qdrDpjPcrdt1FnboZy3KnPD3Odv2JGWs3nQYgqTe1664R2fvNZNdNf2bXecuZuNXjphkrZ2UzltrFlCSF1B67evPIjtPkSh273joVe7v+2DlgZl///po74VWzYW+bOvvtFPZ9nNmnqMiZZFXazty0z97naOEcUFLNWW7qcbZrGY+5wn78TcInuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PVY5AIAAAAAAEDXc5Js7lixpl+Bi+3slvIy8SZOzNtupnjklMfLcOtu5xdnVhtGXsXJr1dvSzsRqeRkKVXuBL19epdqhky0KmSncQ1OBXh1kzvpdgsn/XHkNIDCqZvCaziSX3nOpsGLObv0rqOX3jd3DhiCd0S/PO7pO3UXOVu69/9s7/GZbnKn7txrZZxGyq8zAADYIZqlTHEpm/J6pJK5TZx0zFg6bm8XIns7SWo6g4g82IOPijMCzzr2Piu5PdXM++3tOpFzjm3/HNNsal1PxKLcjBUNe58NuziKMnsGEnWcuUBslyWp2seTpHbLvh7lMGrvtyibsVbHPo922R4n9xZ25TRi+1qFGWa8bdn1U3LaapHZx8xkt42Kcx5RarfjTmTXTdo2Q5KknpJd1vFgX49yyy5PObEPWnG2S7KWGVOf3d7684q9naRmsOt81L7EGgjTB1Pj9Sdi6gMAAAAAAICuxyIXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6np1HcgdLokhJPDW1aOIsy8V2pk13u8TZTpLiyE5xGjv7jZztZsia6rDTlLo7neF43jnKSY3qlabwgk4seDE7Y+yMqWhjJx4Ke8e5k4p2aP1aM5Y4ja6np8eMxYl9W8aJf45uHXjXwwk6VS6n2vyYc5HdYs4Ud9qqV3Pean9w9jnNI+r3sdjZbqazdAoU3LqbPlZKZqpVAACwLYQQK4SpHXuSt81tsoa9v6Y3MpthvO+No5PIDnYiZ7JUtmNZlpuxomnvUp1xM5SW/elrntnxTsk+x7RkD77KrZIZa6V1uzCRvV2jbddN2qzY+5SUBHtukqnqxLzBud0ee9r2OLIxYJ9HaNjbtXP/OpZiO57EzrzNmX+l3nynZe+zmdj1nToLCUmUmTFJKoLdPmqZXZ6s1y5P4s3pnXNsO02jNmbvs1XyzzF22kC5x7mORvvIi81bvuKTXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArpfu6AJY4jhSHEfTvB7MbRJnyS51ztTbbuMxndjUIk5wQjMEZ8eumSd5PGfH3jGLyIkWdoFCsLcLznk4u5Tkr+iGvDBjjfG6GfvtylVmrFYpm7GFixaasVK55sQSMyZJIZrdhXaq3I3ls4x57cZtxzO8Y7b3XOS1VSfmPRsSb7vIbm+S/HvOqyDjHEt+swEAANtIq5Mr6eRTXm9X7A497diDlqiambHQ8qd29ahtxqrOtDAOHTNWLuzzaLZLZqw/tber1+yyZA1/UBNVnXptOnXnTDLapanXb5NOvWLG8nLLjEn2edSiUWc7qXAGoM3CuY7OfEcVe7tmsOdCnRH7GgenOVZju01JUiezr2OnbB8zLexr1U6d+6rszC9a9naFnDnkDOPvNLfbo1J747xt112aeZVu1403FRp2JlGpfxlVSew3DDXt7Vr907/eiGeYQ/0On+QCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PVY5AIAAAAAAEDXY5ELAAAAAAAAXc/PM7sDxdHGnymvT/fi7yROKtrUSRmazLDUl3g5NYMdc4qqKHIO6mznHE5OSIW30xn26ybqdDYMzobePoNzJl6dxt51khQ5Beq07JTKI6PjZmxoaNiMtSplM1apVM1Y38ACMxbNcMc62Y/97bx25aSGDk67cq+xU1Dv+s90TC//rZNt2b0f49jeZ+KkBvbvfzsmyb2Z3U2NYHvOPukB7Gx++kjLjAV3zDC7vib3+iGnr3nBfnYfDWxNWRIpS6a2xVpuj5Ty2I6luX2sIvE7/Fqw43HD3nE5sgc8ecmOlUv2edSDfbyoaYaUpO7MRHGSmbEsKpmxZsd+BlWcZ0k7tecC6XjFjIXcPsn6DI+nPLXPsZPZ16MmuzwtZ+yZ5fY4uSbnOtq71IYZBsM1p33IOeaYN4/eYMfaFXvDWmZfq/KoXd9j8/xFhlrbuXdqDTM2mtjXsbdw2v+YHWtV7HsjrTrb2dNkSVLsXJB8oX0vz+9Mf8yK8fqU427WuwAAAAAAAIA5jEUuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0vTmbWD6OI8Xx1JSTSWznN02mef/vY/ax0hmW+qbJ+jshcpKjRk5q1Bmyppqc7Ntysm/PqHB2HDkx75heWYOcfTox71LF0QwV4BQodzaNYvs2qVR7nOPZ6W3Hx+tmbHR0zIzVgt9Y00rVjEWRs613rZxMzV5a98Jp5IWz3YzN2LvO3j3nnL73XInd7WYXm+m3C97jwXvmWKGy9xADgK0oK7z87U5oO/c1wPZSLhUql6Y28Lxlt88sccbJzr1ShMwtS3BmfrW6HRyrjJuxcmGPhePELmzRSuzCpPZ2rcI/x/ixsh0r29sWsX3MEWc7Ddv11krbZqwvtecJjaJkH09ScK5Vzau7eNSM5ZFdb5XMbqujznO2lNvXOHEuvyR1nLYcN+36KZftOlfF3i5u28cLZXu7sap9r/bZl3ijqtMenTlflDfMWEP29Y+q9jVWo2OGas6Ev1HyZzVj85zrOGJv24ymb+OtxgwNZ9O+N+tdAAAAAAAAwBzGIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArsciFwAAAAAAALqek0h2x4qijT9PFDvLcsksY+kMmSiT2E6NOttVwtkmtXYyeCpyU3M7QUnBy+vtlceLObssnOMVzoZOpnA5l2njtm4d2I0gLVXMWF9fvxkbHxk2Y8NDdiwp26mYB2e4ZXsTu6zevROFWaZ89zbbBtttLI69sdcE3LbjPjvsAqWzfR7N0FbjWT4hImO78kw3BwBsJR0nZfpc6muA7SXPE+X51HFmoszcpt2yG3alag8wolbLLUvqDE5a6tgb2kVVo23f9JW2M96P7Z3mbXtcHmr+jV30jNnb5vY4OWTO+SclMxQl9nlEsb3Pkcy+Fr2RfQ6S1IyrZmw4t9tAtWlfj1C3z7HtPEwr5bYZk+x9dsb9AX9ctuc8vaWGGWsG+5iF046TxJ7VFh37eL2VXjMWNZ0OUVLWdtYYnHlrb142Y0lsX4+xQfscU6cdj43adZr2OJUqqRLb93LhdOAhm36/Scc/3iZ8kgsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PTs35w6WxBt/pr5up9p0suIqSewUlWnip6It2ZkvZ71K6CZNdYKFnflTubfdDOVxspTOmnfM3DsPpzDelYoi/yScy+jXeXCucmTHNgwNmbF1ax8zY6NNOzXqXpGdMlaS0tqAGUtSu6xe3XjV6qZndzb0titmSPnut4HZxWLnEqfOMyeNvefK7PYpSbF7ljarNInb+AFg62ln9nNxLvU1wPYSxx3FcWfK63Vnm6LUsvcXKmasOUNZwqgdS6v2vZR17IFSXJp6bpuMZ/ZdX3aeFSrs2sn9WZR6RnrMWL1m12tJ9vi7Pe4csF4yQ8GpG6W5Gdogf7wf1+3zaDvT+6Jin+PwsN169mrZ13+k374eJechHKr+Azqd5p7ZZLzVtvdbsq9/VBoxY1m734zVnMWAomKff17Y9S1JUWxfq47TBIoR+/zLTjuOhu222nLu1YEB+1rM9MyJgj3pH4vtsibGnLeVbl7Hzie5AAAAAAAA0PVY5AIAAAAAAEDXY5ELAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9VjkAgAAAAAAQNez81buYHEcK4mnrsElzrJcmtgpPNPYSWmd+KkoEyfntb9K6Ow3OCmvndS4UeTs087QqdzPtuuV1C2PcxpyMoaqKJx0q05h3bqxDydJypw0rkVux/K2nTY1ipzUrx17n+Pjdmrkxc6ZONUmSWo7xyw5yduD065ir616le7cHCF+Ennd3VTydih2junFksRuyP7zyN5nOsOvF+IZW/OWKc3wjAOArSXL7GdmV/U1wFYylkt5PvX1ajrNi79TtCtmrN2075Ws8AcYpbI9pk2dMWRe1Oydtu17PiqadqxcsvdZtcfXSd2/r8eTITNWzuyx8Kjs80/q9nl0nIli2rL32Wra16rVdiafktLIqdc+5xyH7PJU++w2t6Zk13m9Yl+r3YdbZiyr+NexM2afx0Bv1d4wbtux3C5ruWbfV83cru+ibtdbT92ub0lqhrIZSwft+gnOOa6r2/usOSs/WWaXdWSNM0+ab+9Tkjod+6BZZB+z1pn+uZIbrz/RFn+S6/vf/75e/vKXa88991QURfryl788KR5C0Pve9z7tscceqtVqWrFihX75y19u6WEAALso+hkAwLZEPwMAO68tXuQaHx/XoYceqiuuuGLa+Ic+9CF97GMf01VXXaVbb71Vvb29OuGEE9Rs2iugAABsQj8DANiW6GcAYOe1xX+ueOKJJ+rEE0+cNhZC0GWXXaa/+Zu/0SmnnCJJ+pd/+RctWbJEX/7yl/XqV796yjatVkut1u8/yjgyMrKlRQIA7ES2dj8j0dcAAH6PfgYAdl5b9YvnH3roIa1atUorVqyYeG1wcFBHHHGEbrnllmm3ueSSSzQ4ODjxs/fee2/NIgEAdiKz6Wck+hoAwOahnwGA7rZVF7lWrVolSVqyZMmk15csWTIRe6ILLrhAw8PDEz8PP/zw1iwSAGAnMpt+RqKvAQBsHvoZAOhuOzy7YqVSUaViZyUAAODJoq8BAGxL9DMAMDds1UWu3XffXZK0evVq7bHHHhOvr169WocddtgW7SuOYsXR1A+aJbGd3jNxPpeWJE7qyxk+z5Y4Kaj9TWeXutrJoj3DHp1yzpBtM4qcg8pJ6+1sVjix3AlmuVNYZ58h+CeZt+00tq1m3S5Py45VZR+zcM7Ri9V6es1YWnLSLUvqZHY66shrBNPca5t41zhEXp3b7dFtxzOkfHcy0Ctygl7MewbEsR1MnDr1nhteTJqhCrxb1Tzelm8zV23NfgbA1uf24XOprwEMW7ufSTq5kvbU8VmI2uY2lUZixrLMPlanf4bCtOxxYjuxjxnJPmhU2LE8scetWWbf1/GQU86GPZ6XpGJw0IyNjwybsVrWMWOdxJ4yRy17u+Fgl7Wnbtd3rdd/enWC/SxtNOzyJOWGGRtv2deqPOTMW/rtc1xZLpux6mozJEnqr9ntIy/G7A1LNTOUpnbiiHbTvh5J0WPGonl2+x+P/HlbEo+bsU5w7p1gL6bXKna9Vct2LKvabarHybcxlvmTjN623eaKxOnbS0abK9nt+/G26tRn//331+67764bb7xx4rWRkRHdeuutWr58+dY8FABgF0Q/AwDYluhnAKC7bfEnucbGxvTAAw9M/Puhhx7SHXfcoQULFmifffbReeedp7/7u7/T0572NO2///5673vfqz333FOnnnrq1iw3AGAnRT8DANiW6GcAYOe1xYtcP/nJT3TsscdO/Pud73ynJOnMM8/UZz7zGf3lX/6lxsfHdfbZZ2toaEhHHnmkvvWtb6larW69UgMAdlr0MwCAbYl+BgB2Xlu8yHXMMccoOF+cEEWRLr74Yl188cVPqmAAgF0T/QwAYFuinwGAnddO9HXEAAAAAAAA2FWxyAUAAAAAAICut8V/rri9xNHGn6mv2ylVp3v/72P2el4cOXmr5a8Ezn6V0Cmsc47Oafgfu96cIpk7tkPFrGN2ifLcPslIdqrRIndyKksaHdpgxobWrzJjrfERM7Z4sM8+oFOeatVOb9vTY+8zTe1UvJJUOJlY3ZjXQrzbw2mQ0Sxb3UxbObeHIqews312JE4wie3zT2KvLPbxJCn2Kt2rgFkeD9habv+1n9q95aSMb3WcmJ1NXs5m6jjbveKwXjuIWTvxWdQrMEmzLcVTn411p29ulupmLJE9FkxG/GdwxxtHlyr2fp1BfblkTyejhn0ejZK9z95OYsZKM8y+xpuj9rbOzDd36rUTtc1YddwZX7bscxx1xoka9+em7X7nOq8r2eWZ32PG+lr2vGW0395nNt40Ywt77XqLa/ZcSJLqLXtbVe06Lwp7u3az34yVEvs8epy2Wqy3202a+NcxKux6bTbGzFi1ZV/HyPnawDGnOJXMrtNOxy5n1Bmydypp1Jnzpm37mCGa/mYN+eYtX/FJLgAAAAAAAHQ9FrkAAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA10t3dAEscbTxZ8rrzjaJE0s1zc4mYjOUxYnZe5WiGaKzEUKw9+jFVMywYzvuHTME+zyKwo7luR3rZHaNJyGzy9JumzFJag2tNmOjv73PjI0PrzFjg/seYMbyVsOMFbkZkoJ9/sGJzbTf3K46RZF3TPtaxU5xIqeJe7GZVt6T2G6ridPO/Zh9VO/5kDonkjj3+HTPts3nVew2OSCw2bqprwGA7SEkHYWkM+X1NLNHGEXRb8aiwh7vNkLJLUutx37Otpt1MxZC2Yylkf1cLzr28fpjpyx2SEnFH++XI3tGmNbt8V4ntQfKsVPW0Yo9+C5Kdqy6wT5eknizWqlUt9tOHtvbjrXsugup0z+37TlNT8Xpn1t2e0xktzdJKvfY23Y6dmy4MvVe26RPG+x9jtj1FnqqZixN7eOp5DRkSfVmy4wlo3Z58nl2uxpvOfdxvceMNRL7+ldqdrspOhUzJklFs2nGktQZvxnVmnecCe3j8EkuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PXs/KM7WKzpV+C8VblEdhpK70T9JK1SLDv952yTk0eRvaWXKt1Pz+6Vxk9h6sWdrO4qnOL4ad3tWs86znkEO2Vq3HZSuEoKdTttbD78sBkrhlaasWjJfHs7J/9xp2235Nw+Rbe+JSly2k7ubOtspjiyy+rdO14smrE9etvavHvVe3bETiOPnSMmzmlEs346SMHb1gtZzxXnGgJbV/f0NQCwPVSiVNVo6kyko5K5TTtrmLHCeVZWKn5Z6vVRM5aHshlLc/ugDefhXZrmvDfpOP1BWrJjzY5dzo3HbJqxomz3F63Qsnc6ZA/OE1XNWO7MaaJ+u2Mbrvh9aXVN2z5mn71tj1OeuuzzL8XevMWef42Wa/Y+i8yMSVLSsuODHef8R+3t6rLLszixzzFEdft4iX39G5l/jnFsX6tqare5saZ9zHLTWfUI9rUqO8cr1+17bnXbvt8kqVyzx2Hjzv3YYzxzcm/y9TjMfAAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PVY5AIAAAAAAEDXc3JM7ljR736eKLYzTSryYjMca6ayzCbol2emo86qNLPeLsxyvTM4+/XTujv7DE5ZnKyhXtuQpL6anf50j0XzzFinaqfU7Xf2uXbE3i7P7bTBUWSff+zEfrexGcqcNLVFYqe4zRP7YqXOPhMnxau3XcnONCtJqjoXOnHO32urnuDk6rav4sYjWqLglyVyzjHyHizmOc72uQFsqe7pawBge+goUVtTBzed2H4e9rTt2Fhkjy/yxphfmFA1Q6WGM27psUc8JaescU/djJXb9hjaG+qUi7YdlNRx5gpFZk99S5FdN21nnDwuu6MJsucCqXOp+oJdb5KUL6mYsSSzr0d1g13WYafSy5ld5yG1y9JT75gxVZwLJWmsapfnPme7fRp2Wy2cSm8stK9/c8xuN32j9jkWvf4gpJXZk55kmmfGJlHRsI9ZssvatG85JaN2vQ2ldiyvOjuVJGfO19Pa8nsnZP69MXHYzXoXAAAAAAAAMIexyAUAAAAAAICuxyIXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK5n55jc0eIwfcpJPzv57DipeGeMe+WJ7DVE74jBCQbneIWT+rVwyiJJhVMiL+ZVgFurwU5FGpxYntspbIu2naZXklptJ+VwbKdpLVV6nH3aKYUbjaYZazrpbcfHRs1YUrXLIklpbtd62mNvm8f2oyB3rnHh3Bup0wKCG/OlTkrdPLJj3j1gXw2p8FJROzer99iY6bcLbty/sYyyzFSrwNbRTX0NAGwPSRSUTDMoqFTscWKnZu8v3pDbsbzkliUN9lh5pNfetijsZ3BPj10ejVfMUCvumLG8Yu8zD34/EztjwWrF7hOiYXueUHfKOhA7dT5q7zPrOPPEmt93hYZ9zLVDDTM2f75zrVp2eYadCWh/Yu9zyJm3Djb86zg0Vjdje6X2Mdf19Zqx3g32vC1r2XWepvZ1HHbahqIZ7kdvrliumrG4Yp9HqeOMs1Ln3uiz54L1pn2t4jBmxiRJ43YdhJrdQDph+u2s16eUa7PeBQAAAAAAAMxhLHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDr2bkid7Dwu/89kZdiPDh5xL1ErDMlGI9mndbc2845D2erwjtHJ73rTOl2CyfNeuFUrFfnXjB4te6UJcvs1MdF207DKkn1pp3+NQ72rZCmPWas0bZT2LY7Tmrk3N5ufGzEjMUVJ6e0pFJu13kttVOuRonTPiInxbFTluC2m9m1f0kqnHsuj2d3DzjVptwpUeLFIrsskXMOG+O24NwfZnGKmZ5ywNbRVX0NAGwHcZYryaaO+8Yze5xY7dhjtqRij2fbaeKXJS6bsYFRe7s8s5+l63P7mD2xPd7NC3u0U27Yx2v1+M/10BwzY1lh16tq9vWInSnzhqJhxnoyu3/KEqc/bPnnmI4M2cHd7LJW1tt13jtQMWNRmpmxPLHbVNGy52Yjmb1PSVrascu6Ztxuc+0N9v0x0OfcHw27rKlz/pWkasYebfizmj0L+5ijHXv+GXvTwdi+/v3OGKxZt+/VUtU+/6Rttxtp4/PP0mjZ17janj6WNfw51MRxN+tdAAAAAAAAwBzGIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArsciFwAAAAAAALqenWNyB8t/978nKpxMnLmTRjwPdrrJaIYM4yGy9xvJ2a+7UztUOOXJvZhzjpmTpndj3InldmE7HSelrLOdnw/e26edajXL7JSxkpSU7BS3lXTQjkV2ntZWbt9CA/PsNeQ8tdOpJk57y2c4x6hjpz8OThrjkpPCNcnsc0wTe59pbJ9/Gjvb+dmvlZTt/RaRHcsS5/5wjldy7mQ/MbDH3zJ4D4HZ2Nr7w3Z3/2N2ivLIafcKzv3iPvftWNvpT+r2I2jjfudUXwMA296GKFMzmvoMKznP2cY0c6BNksJ+rsf+MFHNqv0sTZz+olWyn/tFsA/aKuzjVSt2hxA17POvjNvjckkq0l4z1ihGzVgpL5mxmuz5R9SumrFOxe67NWLXW291ob2dpGxggxmrNeyBdGuBfY3rwe7A+5y2kQX7OoZRuw9OSk7dSFo5bJ9HbU97bjLfaTvDcs6xbu+z3mNf4/GGff6Vfv8cW+kCuzxNe9tmy7mOTpsbW1cxY4v77fNoDdn3cdFnhiRJccV55lS8dZTpt4tyv04njrtZ7wIAAAAAAADmMBa5AAAAAAAA0PVY5AIAAAAAAEDXY5ELAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9excmTtYEYKKaVJ/50468MyJpU7a8ii201dKfgZyb8vI29CJuWndg31EL/165qR8lyQvA3tW2KlYG826vc/c3s47x9xJFd9u2ql/O81xe6eSyqWyHYvt/Kfl2El96txCi6MeM9YzaIbU12unqY1SO52uJEWxk1baaTuJ0z7SWd5XXlETZ3k9cdrixh3boaKwN87dmHNfzbKsuVM3csoiSZ22nao6OKmaLeN1+z5Fd/D6Pvqa2fU1ALA91LJEtWzqoKjVsp9dQW07VnUGQnHDLUt5xB5jdnrs8W5Wt8clvc5gqOP0JUXT3i6plMxYNNoyY5Kksl13g4Vddxsq9jwiGbYHtZWSvV3DGwv32gPMZme9vaGkdlyx9+uMMTvOPvvW2PXa3M2+jtGY3Tay2O6EW7F9jSWpPWi35cHC29Y+Zlq1t6s37drpHXbmgok9vxys+58nyheN2LFarxlrZHZZ+4bsNp72DpuxUdXMmAbsUFyfYeKW2+VpOyspler0N0/kXvvHlWuz3gUAAAAAAADMYSxyAQAAAAAAoOuxyAUAAAAAAICuxyIXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg6zk5aHesPIRpU6ZnwU4L6qVMzbzslk562437tdcCI3/TWXFOQ7l3jk7q9myGNOrefvPcTpvarI/Zx+zY6U2Dcx2zzD5eq2mnPs3bdop5SepxUi6niZ02NYntFM+l1E4bm1bsdtPvXKsissuZJTM0uNhJ8RvZ5QleimcnlstuN9694RTTbf8zvsGJFV4bd+6PLHdSXDtFiZ26KZz2L0nj43ba5Dz3Uo5Pf8yxUf/ewNzntdHZ2tX7GgDYHtohUjLNWMrpzlVVYsYaw/YzL67O8PmFctsMleolM5a17bFpntrblSP7eCHYz/xGvWnGegb9sXBr2D5mO+k1Y7XMGV85c8Fx2ccrFxUzFgV7n+sjf9w2kNrxqvMZlk5w9tvXZ8dG7GuV9NtzoWrZvo5q2SFJip2JRNK0Y6O5fT2yIbsd91ft+0pjdhsvlqw3Y3ltkb1PSXLmvPl6e85bWtBjxkLN2adz6+TOeKnUcp45znNMkjqpPe5L23bbabWmv46thtOmHl+uzXrX71xyySV63vOep/7+fu2222469dRTdd999016T7PZ1DnnnKOFCxeqr69Pp512mlavXr0lhwEA7KLoZwAA2xp9DQDsvLZokevmm2/WOeecox//+Me64YYb1Ol0dPzxx2t8fHziPe94xzv0ta99Tdddd51uvvlmrVy5Uq94xSu2esEBADsf+hkAwLZGXwMAO68t+nPFb33rW5P+/ZnPfEa77babbr/9dh111FEaHh7W1VdfrS984Qt68YtfLEm65pprdNBBB+nHP/6xnv/850/ZZ6vVUqv1+88rjoyMzOY8AAA7gW3Rz0j0NQCA32NOAwA7ryf1xfPDwxv/VnTBggWSpNtvv12dTkcrVqyYeM+BBx6offbZR7fccsu0+7jkkks0ODg48bP33ns/mSIBAHYiW6OfkehrAAA25jQAsPOY9SJXURQ677zz9MIXvlDPetazJEmrVq1SuVzWvHnzJr13yZIlWrVq1bT7ueCCCzQ8PDzx8/DDD8+2SACAncjW6mck+hoAwPSY0wDAzmXW2RXPOecc3XXXXfrhD3/4pApQqVRUqdiZJwAAu6at1c9I9DUAgOkxpwGAncusPsl17rnn6utf/7puuukmLV26dOL13XffXe12W0NDQ5Pev3r1au2+++5PqqAAgF0H/QwAYFujrwGAnc8WfZIrhKC3ve1t+tKXvqTvfe972n///SfFly1bplKppBtvvFGnnXaaJOm+++7Tb37zGy1fvnyLCpYXUlZMfT2K7G2SKJixrLA3jKY5zuPZe5Ui55izVTjlma5ONskL5/xzv5xZltmxdtuMteqjdqxRN2N53nHKYh9PhV3OUuyfo9d2QmSv9xbehs523hJyKHIz1hhv2mVJ/cYa91bNWOK0gSxO7J1GJft4TpXbW0klp27SGe6pUrDrruzUa5HbdZfLvsZZsGNx6sS8ZuOURZLqTfseyHP7HCOjrbba9n0z12zPfqabZM7zfbZ29b4GwK5re/Y11dBSNUydctXLdn/ecca7UexM39r++CJP7Wf0eGaPP6PEfpbmRZ8ZC84+B/IBM1ZdtMaODe1mxiRJ8VozlHXsrzXI23a9NuKF9vGyhhmqd+x+rSy7bsqJP25rdnrt4oSWGUuceUSpbsfCPHufzQ32iD9xxvuNqjPfkzTozAeikl2eUrtsxgpnTNBuO/Ovjp1Eovqo3f7X25dp47bO9KsZ2/VaG7PLk8XOp0k79gFzewqpdtm+kB1nniRJlZZ9zL5eu6xpc/prlW/m8tUWLXKdc845+sIXvqCvfOUr6u/vn/ib9MHBQdVqNQ0ODuqNb3yj3vnOd2rBggUaGBjQ2972Ni1fvtzMeAUAwCb0MwCAbY2+BgB2Xlu0yPWJT3xCknTMMcdMev2aa67R61//eknSRz7yEcVxrNNOO02tVksnnHCCrrzyyq1SWADAzo1+BgCwrdHXAMDOa4v/XHEm1WpVV1xxha644opZFwoAsGuinwEAbGv0NQCw85rVF88DAAAAAAAAcwmLXAAAAAAAAOh6LHIBAAAAAACg623Rd3JtT1kWlGVT/14+cv6G3snCqcxJQ6rIT33p7Veyt/X26n0XgJvWPbf32rEzESufKa27s3HI7TS2/T126s/5fXbq05JTqV7K9yjY5Uz9y6ieit3c3W2Dk1LXPaZd51lm73N0xE5F3Ilq3gGVlXvsmNPO88JpH85SuHf+kbfPjn3+Reynv45kt4/EiXn3R1yy20ZctmNR5DRk75Hj1Y2kKHXS/wYnjbfRVnN+n9H1Os6zn75mdn0NAGwPrXahOJn6wI2dWVhz3H6WxpEzDoj8MVQls8cDUbtuxjrVhWasp1htxrLcOcncPl62zn54j7YftfcpqVXpM2OD88bMWGOlvd2C2hozNuxMItIx53okzvjSme9IUpw3zVie2u2jMtprxkp99jHjRtmMjfTZ51Fq2tv1x20zJknZmH2OAz32OZblzBXL9nhheNy+VvMGB81Yp21f/wVVf0y0tjpuxvqjqhmLGvZ9HJz2mDvtpnDGZwOy741mNGrGJCkt7Hs5GrfbQJ5Ov10e+e1mE2Y+AAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArsciFwAAAAAAALoei1wAAAAAAADoeixyAQAAAAAAoOs5eV13rE4W1Mn8tJtPlDh51DtOLHj51yV5yXgjN3m7HQuFHSucFOxZ4cSeTFr3tp2OM3Ts2Py+mhlbOM+Ozeu308HnuX0ieWanmA/BT5vcU7XT2Co49epUbFbYKWzjyLv+9vFG++2UyvXMOQdJY4Vd5xsa9jHzrGHGoqhlx+yssAqyr1UW7HoLsd9W4469bZTax3SfATW73qLITrccnHu8iO1YPMNDJyo5aYOd300URt0U0Zx91GMzZTl9jWW2fQ0AbA9ZNVFWmzpgisbt52XSa8dqdXtclpX8/n48sbdtDNmDunJhP5/HO/YzOC/sZ3BYYB9voFmy97n3Q2ZMkspOPzQqe7/9e9h1M/KYff6dyJ5/ZLEdS2WPZ/NhezwrSc2+BWYsysfNWE/HrvPIqZtGzW5XPbFd1lLZPse6Mx6QpLxilydq2+fxWNs+5kBiD2BKjX4zFvevN2NZedCMtdpjZkyS5qX2OabOOCxK7blAXrLPv5rYsU5m38cjTXssWenvM2OSlJTtOm8649feZPrzT2YYZ27CJ7kAAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA15uzeeXzECsPU9fgEiedZu6mPLdTuDrZKyVJm5eocssEZ6eFkyo+91K3O+cfnJgktZsNM9YZHzFj86o9Zmx+n52KdY9FvWYs69jXqtG00/u2O3ZaVEnq6amascK5IJ2OnRq3ndspbEuJvYacRHas4qSTHW7669JZw2470Xjd3rC5wd4us69/kF03uZNuWoVzrVL/hmxEdp3Xp3lmTJTHic1btJsZK5Xs6xGcsoTEfrzGzvWXpKKw66CQfcwinn67Ii67x8Pc5zyGXNu7r3n5s+3n7FyzbsTuT+ZaX7PvknnuMbHlPvulb/hv8J7v26Cvmb94dzP24oPs7TD3DTbHVIumjm0fS+zxRW/TflaMBfsBnQ+Pu2XJSvYYu1azn11ZZI8hY9nHjAbssiYbnHOs2mPIeGyJGZOkZP2oGWv22uOhZNwZe+V9ZqxWe8yMpQMLzFijvsaMlQbtOZQkhbbdX9RaFTPWnm/Xa7NuX+NyYT8PmwsXmrF8fMyM1WK7/UtSuWE/S8cKu4/uGbDbcSc07eO17XY8VDjnqNVOzH6uS1Jw5m2LYnuskfXZ9067ad/jsXOP5x27TtOSPU/MNWjGJKnVsO+5ULHnSuNGH9x02uLj8UkuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PXsvI07WBESFWFqisg82Gkx88KJRXaKTjmp0jeWxY/PSnDS1BZeClu7MLkTy9p2ytiNcTttaOGkFC3HNTMW53bq07zZMGNpbDfLntRely0ndopSSUqdbb207pFTnriw91lK7FgaOecR26lRO9OkoH68DU37OndadmrcjpPGOGmvMmNp7NRbsK+/nFg+wzlGkd3miqjXjHWCfR2z1oC9z8xO01zEThpv5x6PnesvScE+pAqnzVmPwI7zTEF36DhtwrWd+5pukgb7/p1rfQ22vnz81258LvU16G7NUk1RuWfK60nTvuZZMWLG4r6qGQu9/viit9Vnxurj9hgyGXXmEaWKGcpG7PPI++2yhNGmGau2/GdlaNj1WkrtZ3AnsbeLg32O8bjdJ3TG7bF3FM2395n51zEt1pmxrOT0UXV7/lWJ7fKkuX39i/G6vc+kZMbGg/2MlaR6Yc8VqjX7HmgN2+cY9zntv7rejA046w+hWGjGOok//55Xs9vc6IjdzgecazxQs2PNyD5ePm7fG9WqXW/pOn/eli22Y+3EHoel+fT7TZy2+Hh8kgsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0vTmbr7oIkfJp0pvHkZ3yPLNDSmQHnYzeG4/pLAV62zrFcTlZSmVk05QkdZwc83Unha0kZS07VW8i+6Alp27aDTul7EjRMmMDff1mLC3ZqWiTxK/xorDTlEr2hYxjO5Y47TGO7VjqNKpKLTFj5ZadTleSQmFfq3bLrvOOc/2jzEnV6jxB4tguS+TUd97xU8NGTt2lsV2g3Ln+eds+/5ZXN5GdpjcKdjlnfDY493lwmnFhVGvHa/roCh3n1p9LfU03yZv2vT3X+hpsfaGL+hp0t7w9ojyZ+tzMgz3eq7fsNrawxx57rB+2Y5LUjIfMWNayn3tpau+3WV5vxgaq881YsKcJKsV2P9Ps2ONZSQr99raZs99qy362N1O7sNWo14zFvfZzptwaM2MK/hQ9LVXMWDMbtTfMamao7ZxjVLXPMQv2PqPasBkbGJ/hHBN7IDIc2YOiqGzHQrDbzpJO1Yw91rSvY6Xf7itK8vsZbzyVzLfrvKjY24207fLEzoQgDNh1s75jX4tK0mfGJKkaGmYsKew5f9Gc/pjFZnaVfJILAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD0/d+cO1GnnSktT01wGJ51oSO1YZGfpVRr76cCdLNIqnOTt3l4jOSk8nbzunba9Xb1up35du+ZRpzRSSXba0Pm9duWF3E7TOjZip8ZtRfY59pTttLgKdor1zKk3Scoje9uOs62339xZJ66U7HTLcdmOJal9WzqnsJFTBe3cPmZU2seMVXrsWKlkt/LEK2ywU98GL6WypLSw42kYtzds2ylsW2N2+uu1id0e+xf3mLGSnPqe4UKGwr6QhRML+fT77WQzNRzMdZ28O/qabpK1ndTec6yvwdYX9z7Hjc+lvgbdbVyF8mkGaAOFPb5utO1Yvn7EjKX2o1uSVHWmfg1nvhPX7TFNJx609yn7OVs07Wde2qqasSi15x6SVARnHJ02zViWlMxY2anXVseum8I5XlSz7/n6enteJkmq2u2jyOzzb8X2iQzU7dhwZaEZGwx2eyytGjBjo/1rzJgkdWL7HJNxJ+a046xhP9fzPme7YLfH3er2KKzT7y+1lFN7HpEFu513hux9VnrsdtWM7fIkzthusGTXd6vHf+h0WvPsY3rNPK1N/3q8eWMlPskFAAAAAACArsciFwAAAAAAALoei1wAAAAAAADoeixyAQAAAAAAoOuxyAUAAAAAAICuxyIXAAAAAAAAup6f13IHGh9tqMinpnKNynbayFLVTtutsp3etZr6a3120kyp464TZmYkLpyUsoWdmtpL696s22mrRzesNGOSVE7s/ZaDnYp0texUrFWndQ3U7FSseWFfx7KTTrbkxCQplr3f2En57u21KOzrn5acFMaJvddYdira2GniGwvkpLGN7HsgSewUtio51yq1zyPEdlmiyG5vcWLfG5IUtVbbx2zY2ybjdqriVse552K73sqD+5gxrzkmTgpnScqCk3Lb2TTk07fHbIaU4pj72s6zZi71Nd2km/oabH1xz35ufC71Nehyox0pm9qvN4L9XJ/vjMvqY3b7C2mvW5RQtscXjfqovWGP81zL7dj4sH2OvRX7eO3M3mdUtcelkhTyETOWjNv3WZQ449bYrreoGDJjvXHHjI1kdlnCgL2dJGmd3UcnfXbdlTrOuL3XnrekTft5WEQ1O1Zea+9z1H/mNdp2natiXysV9nkUVWds4zT/BSW7TY3NW2jGqvWpaxmPV0rtsradNYa+2F4PaeX2mLDmjDTGnGdO6txyadufnMZqmbFe57nSsS5V4rSLSccFAAAAAAAAuhyLXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDrpTu6AJbmeEsKzSmvhywztykpmLFKZB8rCf5aX4jseCdOzFgUWmYszoftA7ZX28ezd6ms0bF3OW7vU5KyYNer2hUzND5s182CeQNmrFat2mUp7OuYBzsmORdZUuRcxySxt41je7sit6+/Iuc8VNgxO6TCC0oKTlvO07K9XVEyY524Zh8wsh8hkXNvOCGlaa8dlCTnvgoNu52n7fVmLCqmPms2yaoLzVi7mdvHk30/RrFzI0sKsssTCrvOQzH9vRo6djnRHTqZfe/Ppb6mm3RTX4Otr3Ce7ZLmVF+D7pbnfcqznimvN/NRc5ue+fZAKVTscUB7yHnmS2przA46Y/PyBnsMWV/k9EEaN2Pj09TJJiGzn5XVtj8WLkp2/RRJ24xFqdMntO19Zs6YNhR2WYusbsaSMbu+JamI7Dofb9hl7ana5Wk37Llgu2Zfj6hjX+NOas8v2pFTcZLmVe06GI/scW2rYZe1XbKvcdtpG5XcnpvEdadfj5z5taT2Bvt6VAbsMUHsnEdszAUkqdVnl7W83j5/jdvXIu2zr7EkJcGZt2T2OYaSUdbUH4NtwogKAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD07p+M0PvGJT+gTn/iEfvWrX0mSDj74YL3vfe/TiSeeKElqNpv6i7/4C1177bVqtVo64YQTdOWVV2rJkiVbXrA0VZpOLV6Qnd4yyezUzEnbTjVazJAOvZPb6T3jmp3yOS7s1LChucqM1Tf80owVhZ3CM87s1L89TppaSWqM22mMRzfYdZfVamZsyYCdbnWwx04bPN60U9EOjdupkdu5n6a12msfM0qdVM1OOvjYSYuaya63ENttaqDkpGn28hRLyr309P32fouOvV1Tdr0WzvEU2+ltI2e7VH5q6GrVbnM9+QIzVmva7TGN7XS75WmeQ5u0R0fMmMacNN7BSeEtqVo4z6Sk395tOn0sH7fvqblme/YzkvSBzz2gas/UeguJ/cxMy3Zfs6Bi32el3O9rIqeviep2e5pLfU032Xv/PXd0EbADnbWib0cXYbP981fvMWPlyO5re7ZzX1MfH9WrTz/UPeZcsT37miLvqJjm+T/gfNYgHm+YsabTVyR99jxJklqtkh1s2GPM0dgeC9aG7bI2gj2+imN77tHqscdz7dY6MyZJlXS+GQsl+zyill2eTmHXeRHsWNZombFWsMsyw3BfPc5cKSvbdT4y7kz9C7tvT53xS5Haz6BqZo+T44o9npekkWG77uoL5tnH7LXrpje377lOZN8b5ao9Jspj+xyHUv8ce1r2XFGj9n3Vs8guz3hhPwNqY/b8K3GeR51gl6XSttdCJKmTOM+Hwm6PaWf6c+w0nDp7nC36JNfSpUv1wQ9+ULfffrt+8pOf6MUvfrFOOeUU3X333ZKkd7zjHfra176m6667TjfffLNWrlypV7ziFVtyCADALox+BgCwrdHXAMDOa4s+yfXyl7980r///u//Xp/4xCf04x//WEuXLtXVV1+tL3zhC3rxi18sSbrmmmt00EEH6cc//rGe//znb71SAwB2SvQzAIBtjb4GAHZes/5OrjzPde2112p8fFzLly/X7bffrk6noxUrVky858ADD9Q+++yjW265xdxPq9XSyMjIpB8AALZWPyPR1wAApsecBgB2Llu8yHXnnXeqr69PlUpFb3nLW/SlL31Jz3zmM7Vq1SqVy2XNmzdv0vuXLFmiVavs7wS55JJLNDg4OPGz9957b/FJAAB2Hlu7n5HoawAAkzGnAYCd0xYvcj3jGc/QHXfcoVtvvVV//ud/rjPPPFP33GN/IeZMLrjgAg0PD0/8PPzww7PeFwCg+23tfkairwEATMacBgB2Tlv0nVySVC6X9dSnPlWStGzZMt1222366Ec/qj/+4z9Wu93W0NDQpN98rF69Wrvvvru5v0qlokrFzgIBANi1bO1+RqKvAQBMxpwGAHZOW7zI9URFUajVamnZsmUqlUq68cYbddppp0mS7rvvPv3mN7/R8uXLt3i/5WpZlerUjiJvbjC3iTasNmO5nDTJbTv9uiTFTqreap/d2cW5vd+8vtKMRRv+14456V2joseMVYbWmjFJao/Z3xuQt+wUrkXNTo2azLPTTycL7dTArZZdb+NNOw1pvdk0Y5LU02vXT1yyb4Uosj/wmMhO4ZrJTnEaYjsWOwOkVmafw8Y32O2jWthl9dLmBjvbrB+zQ1Kwo051S5KyxD6PdrnXjJVSu26Khp3GOe7YKdh7qva9UcrttpqOPGrGJKl4bL0ZS3rt9OXJvKXTH6/up5Gf67ZVPyPR15ixWfY1ALa+noK+ZnvYVn1NO+koTqb2DeVee+w5XG+bsYEiMWNJ2x4jSVLJbkruAMwZeqkV7HFrPmYfMA72uD2ORs1YsLunjdu27DF2Fux67TiD2h5nDNkq7H6/nTsV3rHHwulMf2wVDThB+5ih4tTNhmEzlsd2A+h3rseYs9IQd+y5hySFsl3WnobddvJe+/7IR+y66U/mmbEi2GUZrvXZ+2z4z8RkwB5P5S37POq5XbE9Y3Z7bFbsNlfu2Pusl+w5fWvcH9vWyvZ9lQa7rH2d6dtc4k/3f7/vzXvbRhdccIFOPPFE7bPPPhodHdUXvvAFfe9739O3v/1tDQ4O6o1vfKPe+c53asGCBRoYGNDb3vY2LV++nCwkAIDNQj8DANjW6GsAYOe1RYtca9as0ete9zo9+uijGhwc1LOf/Wx9+9vf1kte8hJJ0kc+8hHFcazTTjtNrVZLJ5xwgq688sptUnAAwM6HfgYAsK3R1wDAzmuLFrmuvvpqN16tVnXFFVfoiiuueFKFAgDsmuhnAADbGn0NAOy8tji7IgAAAAAAADDXsMgFAAAAAACArsciFwAAAAAAALreFn0n1/ZULiUql6emzuwMjZvbFI/+xozlTTtNstozpDx20obGvWvt7TpOSs26nYK+PG6nfM8LO02vCjuFaXWGFKa5k/Y5bdnpdktlO/1r1OekRa3YqWizqh1rNu1U2c26n1O0KNv7LZXsWyFJnJjs88+jwoyF2I7VnXK2IzuFqyQpnmeGeisLzFgrtVMRF4mdGziTnd62sDPGSsFOYRs5KZwlKXceW+3IaY/Brtdo1L5X08JOqbxgqf1sSAt7n8XwKjMmSc0H/teMhYVOOu5o+mdA1LCfm7s6+prpzbavAbD1LSjR13SzSpKrkmZTXs8ye9xas4dJGs/scXma97plySv2mGY869gbtqeWf5OoqJmxzA6pWthj2pbsuskip3+SpMhuh1nbPsfBPrvuRuv2PiNnTpNn9ni/5Mx3ys78QpI2jNrzoaLXfib0jtjliZ3rmNfselvfsRvrYGGP2Qs57U1SOdhlHV1szz8qw3Ysyu3yNPvt7ZTbc5P+jv18LjvHk6Q4tuugXrY/ixTaTp8wYN+rncLeZ5zZz/wee5dqVfxzbDvtI3LWEYbL07fxZmG3/cfjk1wAAAAAAADoeixyAQAAAAAAoOuxyAUAAAAAAICuxyIXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg6/k5H3egEDKFME2+yiE7jXr0q1/aOxz+rRmKsxG3LElkpzDNUzuVfNSx09/GbTuFb09ulydEdnrbTHZa92ru5P6UNOjE89xOU5rX7bpJH7JjY8MbzFhRtlMDd5yyKHNikjqFk8K0ZKcwTVInNbCTUjZ32k2R2GWpJ/baczO20y1LUru2mxkb3OeZ9n4H7bTBDSc1bBrb9eZUjYLs809i/zrGkb3jKLP3mzWdFL9NO4VvX2zfG/sMVu2yjNhlGe/Y978kDY+sMWNZbb69YW6k1c3tZ9Gujr5merPtawBsffQ13a0U2iqFZMrr9ch+lkaJM9YpjPqXFDTmliVvtsxYM9h9ULndY8bStjO+lj32ypypSdRvzwWiwi6nJKXO7LavM/U6bNIas+tu1BnTLh4dNWMdpywhbpuxkcy+TpJUq9rj9jjYsY7sOU3SY88/Ume8kPTaldNoLDBjReLPTWupXT/lEXvbrGZXekl2WbN83IzFdhNXaNpzoXrqz2nCqD3WqlXrZixL7HlLe9i+jlmw76vUaRtZZO+z0nEqR1K9x75WUct+BvZUp78fo8hvN5vwSS4AAAAAAAB0PRa5AAAAAAAA0PVY5AIAAAAAAEDXY5ELAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9ZzEpjtYyKQwNT1mtWmn06wObTBj/etXm7GSkxZVkuLYTlUZR3ba2Di3t0szO/1vOdgpmIvIThmaRXaq1eCkBf7dG+yQs1mR2/stbbDPP2naaXrrJTsVa+6kDc4zP02rm/41tY9ZJHYsZHZ5isg+YOEUJovttedmYqdalaR2v53+ttS/0IzFFSdVeNlO/yu3XdlpekNwUkp3/LTJ5cxOiZ421tvbjdvPjppzHj3eU7I+ZIbi4cfMWGnEjklSuW3vt5B9Hp10+udDYbwO0dcYZtvXANgG6Gu6Wl9SqJZMHWdkLXu8N5rb9V/usccsrQ32M1+SVE3MUG3UjnWc537LGbcWfXY/kw1VzFjJOf+eujNmlZQutucY6Tx7u8fW22WtBLufbfZWzVhc2PdEJ7YHmFFs71OSosweYzfa9vXIErtu4pp9zNaYPW8pt2pmrBLZx4vsU5AkpaHHjJVS+xxrTt207MuoUmrfV83UmQy0nPleyZ9/1xp2gTpp2YyFUXu/baeoixJ7jjWW2/d/WrLL0s7s2MYd2/d5UrKfVyPG86jV3LzPaPFJLgAAAAAAAHQ9FrkAAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1nCSTO1YUMkXTpGvt7dgpbBc27DSUC8ecdLKFnZpdkkJsp38tZJcnlZ1StFTkZqw8TTr7TeytpEx2OtEo+ClMI6eskpPj1QmF3E7F22nZ16NTtptlO3Nyv3oxSamTqjdx0/jaa8Fxbtdb5FyPEDnpZhO7LEXqt9Uis1tIsX6JHetZYMdKA2YslOy0wYqdxuG0/7xptw1J0vhqM1QeediM1TYMmbFeJzVwzUm3nY3b+9T6NWYo2uCndU86dh2EyE7/20mmr1frddDXWGbb1wDY+uhrulszL0t5ecrrZWeY1OuM26OmPd6Ny864TFLctvuv3Hm0d5xeIanY20V1uzylPvuASdMee432+H1p3HHmNC07Fkfzzdh4Yd8rvZl9IYfbvWas6LPnSRXvYkhq9zhj5WyRGap17OtfH7HHBPODfZFHnLlHacCum564x4xJ0npnHFaS3a6Kwq67Vsm+d+qyz7Hcts8j6SmZsc64/0yM5zljxsguT1Ky6y6u28drDTj3cWLXTRbZbaNWdR4AkqpOFXTaTmEHjP0mmzcG5ZNcAAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArsciFwAAAAAAALoei1wAAAAAAADoeixyAQAAAAAAoOulO7oAllSF0mnSlPc46dDnt+30lrs17Vic2zFJ6qR2PEvslKKp7FjJyW5bclJt5k7q9jzYqVZjJ1W8JMlJt+qJIvscQ2zH2om9vtqK7FSswUlTmzkxSepxMpyWnFTNiZMa2Ln8CsG+yJkTa8V2LCnslMqSpOaQvd+H77NjdtNRPjZuxtLeQTtWch4vTn1nDT81dGn9w/Yx1/6vGUvGfm3vc+meZqwyYKfp7eupmrE4t69jc8RO4SxJRctOK53l9sXKNH36X+t10NdYZtvXAN3iyo98041XnL6m1+lrqmN2rN/pawaedrAZo6/pbuNJojyZOibKGvb4qhTsa54n9sN7vHAe+pLKLXvbYp59/XrHe81YGuxxW6Nst7G8sMeJUd5vxqqV1WZMksZbZTPWX11kxoba9j0fpfa8pR0vMGOl8hoz1qnb519E/nVUZh+zv7nWLo8zN4v77YlSGLPLWpmmbW/S9D5O0xlzgpJie/wde+OXsh3sbdvnPx7b7b+QPf8qt+zzr2YtMyZJGq6ZoTyz20C9Yj878ti+jnnd3i5J7Pl3T799HuO5/9xv53Y/VC3Z519pTP/sCE2/X9uET3IBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArsciFwAAAAAAALpeuqMLYFnz6COq1nqnvF5ev87cZrdWx4zFub2el4aSW5ZckRkrlJixLDg7LexQFNmXpQh2WXLZB4ydc5CkOJrleqez28gJxs55JC27cmrOPsMMzbmSO8d09ps41zF2LmTkXI/Cqe8ktdtjlJTtwkiKvOu4Ya1dHvvWUTo2ZMZKfYNmLC7Z5xGCXW95a9wujKTSyBozVh1ZbcYqnWEzVk73NmO1xQvMWP+ChWasE9fMWGPcezhIcWG35dy5P1rD09ddq9lwj7cro68xNptlXwN0i/5f/8yN09fQ12wtSTtSEk/3TG2b22SJfW0azqCtlDfdsnScsXK8we6jmrHTluzuSaWkx4xl4y0zVpSGzFhan2cfUFJbo2asVlppxuLBRWYsbzp9YvsxO5bb92elZtf3yAzzssqGuhmLcrvO19QqZqzWzMxY6oxPWvZmmjdmP0fG23ZZJKnWa7ePul2tqkT2+eexXdiS08Rz2ffceK/9zC8Fe54kSaHHHmuW86oZa0QjZqwW95ux3sLeZ7uwr3G7Y9dbxxkvSlLFaTtZx46Vk+nvgajYvDULPskFAAAAAACArsciFwAAAAAAALoei1wAAAAAAADoeixyAQAAAAAAoOuxyAUAAAAAAICuxyIXAAAAAAAAup6dR3YHW/mbh1SuTM0PWlm31txmcWant6w7qdLTyE6nKUmtyE5/WndS6gYndXviZNssO5eliOzjFSE3Y9UZMr575Ymc1J/BSyUf2dvZiVildsepUyelcim1U/FKUhI728Z2/mNvJbjI7fS2IbcbQOyUpVqbZ8bS/gGnNFI5LZuxaO0Ge79Ddkrl9pidRj2p9dqFSew6Dc7NETI//XXSttMmlzr2tklk3x9J2X4GJIPzzFjaY1+PdrCvRbvh/36hkJ0buV23z2N0zdC0rzdafp3uyuhrpjfbvgboFj2/ucON09fQ12wtjaitIpo6JipFdl/SdqqymtoP9iJU3LL09drtenjcHrdVyiNmrN2w+5JQjJuxZsk5nuxyjtaHzZgkVRb2m7HfJAvM2B6PPGbGVg/YF6SazTNjccfuoDPnGaPFdt1IUrXWY8aGnHbVkzbsnZbs51M+6oz3K/b1GJK9XaXStvcpacypnkU1e/7VLOxnVz04bbVp31flae7fTWqZfY2HcuckJIU19rO9d7F971Ry+/rno/Z1bDnzz6x/yIwFZ5/lkjerl8ac9YDe2G6rIZm+/wrewPZx+CQXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6Hp2HskdbGTDOpWnSbW8rmWn4nzUSDUpSWlcsmNO+nVJagc7lXrdSfkuJ/tr4qTTdDK/qnCOF2J7n9XCT7eZOttGkV2voXDK4xwvc4JeqtE4tVNl9/Q46W0lLZxvpw0u9dipWOVU3fjoOjPWqTspxhP7POY/9UAzNrDnXnZhJKlqp46O7r3XjBWP/sqMtUfW2rGOnTY4C07a5Nxu5LGcG0BSybkguXOfZyU7VXosu96SjtMA1tvnXx+xr/9w5qeGbkZ2e1w/aqfqXZVPn/662bFTLe/q6GumN9u+BugW9aGH3Th9DX3N1hKPJ0ryaa5Fr92OomLIjBWtqX3W7w/WdssyNl05fifpy81YiOztys5nJtrjA2asJxszY60eu25kD6ElSdWVdv9VS9ebsV/H88xYSFebsYHMPv+kbF+PRjRoxgY32GNvSRot2/VTciqoGuyxzVjDfnZlhf08qBX2cyRp23UTV/wL2VcaMWONzH6WZlm/fUzZbTxOnXlb26mbMGrGFib+M3h0ofNs32BvVynmmbEosc+jPd9e+smGnfn3oD0+bSbOHFrSgOy24y1F1TvTt9VWx3/GbcInuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PVY5AIAAAAAAEDXs/M2boYPfvCDuuCCC/T2t79dl112mSSp2WzqL/7iL3Tttdeq1WrphBNO0JVXXqklS5Zs0b4PO/hAVWu9U16vrbPTreoRO03n/95vp68cX2enk5Wk8TE7FWejaqepjZzU7SUn53s1cVJMV+2UsUnZXrO097hRGtvliZ3zyDI7B31eeCno7eOlA/PM2PzFu5mx8u67mzFJqu1mb9vb32fG4sQ+/87QGnu7cTtNbyz7Osb7PtWMFYsXmzFJUsluA/39dkrd+v/asaHfPGjGhuv2vTE0aqfUHW066W2bdkppyU/rXk3stNrVqn0XlFcO2ce7yz7/inMds0ceMWOdjpdOV1JsX8d1uX3+Q9n091zLeL0bbMt+RqKvscy2rwG6xV2j9DX0NRtt634mT+vK0jDl9VB3xtfOyL0o7OtWkn/NQ7tsxjqFfcy4bF/brDP13DZJ87a9XWq366qzz1HZcw9JqtnVqtHCPv+FkT2mbw3Z9/yo0z/3FXZhWsWIGYvjGaboLfs610r2dRyLBux9OnVerdnHi9tOrGK31U7JHp9IUtG2x2HBmZuVCvs8vLYa4tyM5WW7zYXMOcexlhmTpFLZroMkX2Bvt9AeL9Yju+2Uhp35pz0VVhrZ7V+Ff47eGsN4YT8fBurTb1dqbd4YdNYj1dtuu02f/OQn9exnP3vS6+94xzv0ta99Tdddd51uvvlmrVy5Uq94xStmexgAwC6KfgYAsC3RzwDAzmdWi1xjY2N67Wtfq3/+53/W/PnzJ14fHh7W1VdfrQ9/+MN68YtfrGXLlumaa67Rj370I/34xz/eaoUGAOzc6GcAANsS/QwA7Jxmtch1zjnn6KSTTtKKFSsmvX777ber0+lMev3AAw/UPvvso1tuuWXafbVaLY2MjEz6AQDs2rZmPyPR1wAAJqOfAYCd0xZ/J9e1116rn/70p7rtttumxFatWqVyuax58+ZNen3JkiVatWrVtPu75JJLdNFFF21pMQAAO6mt3c9I9DUAgN+jnwGAndcWfZLr4Ycf1tvf/nZ9/vOfV7XqfAHZFrjgggs0PDw88fPwww9vlf0CALrPtuhnJPoaAMBG9DMAsHPbokWu22+/XWvWrNFzn/tcpWmqNE11880362Mf+5jSNNWSJUvUbrc1NDQ0abvVq1drdyPzXaVS0cDAwKQfAMCuaVv0MxJ9DQBgI/oZANi5bdGfKx533HG68847J7121lln6cADD9S73/1u7b333iqVSrrxxht12mmnSZLuu+8+/eY3v9Hy5cu3qGAHPv2p6u3tn/L6+Fr7Ny5ry3YKy4fW2B8vXrVu2C3LhnE7bWgzc9KmJvYaYiW107su6LNjvb1TU91vUh2w6yZ10g1LUslJ4xtH9ratll3nWW6nYk3Kdgrf+XvuZcb699/f3ue++5oxSQqLFpqxvN/OmxqV7PNP6hvMWGm8YZfFSTdbn2enpx52UpNLUi67zquxkzbaucaNyN5uw3r73lkV26mY1zjpX4dG/VS0SWbfjz2Jff72nSPpkfVmKDTut8vi1He8wd5nEvw06+XYvh/bzr3aSqd/pLeDXc65Znv2MxJ9jWW2fQ3QLe7q2M9Sib5mZ+5rtnc/kyWpkmRqnYXIbmOpM4YOHfu65n6zVhrb/UVI7XFrVrenjCGzy5MssI+Xr2/a+xywT6SW+nOaemzvdzCx9xsFe/7Rm9lj2nqfM6YfHzRj5cyu07Tjf59bsXDcjI1kdqyWJE557PH+YyW7Tqu1mhlL63bbKDnPWEmKvXDbLk/WtMc2Rdkuq6LIDpWG7KKM20/9ouYvtbSbdp0n88fMWNqxx2HV8WDGYue+6mva55/02ePePHLqVJKC3eZ6nPFrmDf9eYSm32422aJFrv7+fj3rWc+a9Fpvb68WLlw48fob3/hGvfOd79SCBQs0MDCgt73tbVq+fLme//znb8mhAAC7IPoZAMC2RD8DADu3Lf7i+Zl85CMfURzHOu2009RqtXTCCSfoyiuv3NqHAQDsouhnAADbEv0MAHSvJ73I9b3vfW/Sv6vVqq644gpdccUVT3bXAADQzwAAtin6GQDYeWzRF88DAAAAAAAAcxGLXAAAAAAAAOh6LHIBAAAAAACg6231L57fWu6//wHValNTco611pnbrG/YKVNX9/eZsQ3zF7llGXFSvDYTO4VpnNipOHsqPWasumh3M1bbY6F9vAX9ZqzTNkOSpJDaKUzTadIeb5K37R1HclKYOscLg/PN2EjFTsX763E/VfYjnWEzlq630yaXq3a61WqPnRY1Luz0rp2WXdYNj9rlHOrYKVwlqdGsm7HaiJ2KtjPasfepJXZscDcz1g52rBMWm7Hx3L7GkpQ17bTKI8E+j3Jsp/hNxuzrEWf28aLUTmObRPY+00H7XpWkkpO6XTX72RFq06dN7rTte3FXd+rLDtnRRdipvPsvLnbj6Sz7mrbT18jpa7zj/e0Hz3f2iZ3d+ODT3fhc6mu+8c1PmjHMfeloS2l76ucKQmx/1iAr7GdXJZq+r5ekvJ27ZXF2q/YGe0wbBuz5TqnXeXaP2+Up9dbMWNywx7tZ7pyEpE5uj7FabXuc3J+utLeTfV9HI3ZZ0479rEjTUTO2PrfnEJK0eMyeYw7F9rVKc/talRbZ+yw17PIkY/Y1Lqp2rDPDOZYX2tdqaL1zf8g+/45z/tXYPn+NDdixil3OKMyzt5MUp3bbKRf2fKhR2GseA8681ft4U2mefY7t1FnvyPzPTLXbzpw/sudRUX36/bb8qfDvy7V5bwMAAAAAAADmLha5AAAAAAAA0PVY5AIAAAAAAEDXY5ELAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9ew8mjvY/9x5t8rlqalFm6FhblPPx8xYu2WnBc167BSdkhQtslOcprGd1jx2UpGGxE7vORzbqYE7TTv9dHnIzqnZbtvbSVIS2yluk8ROKZxldupPT5rYx6uO22WtrLWvcVLym7NXA7FzjqWKfa16++1rFed2Wvt2y663Eedajbbt9iZJrZad4rXacq5xcNLmOo+JzFknbzrnUY/ttNGhb5FTFimuOmmcnVS0wUu5LfsaF06K7yR10vSWnHNM/d8vhMRpy6mdircI09d5x3gd2NoeGrL7aGlu9TXYtXVTX4Mu1x9L1anXt2jafX2pZI/nsg32eL+n1x8Lj8sZ75btMXbR6TNjnY5d1ii3y9PKNpixdF6Pvd1j9jlIUq3kjHmS3Aw1ywvMWCe3z7HPmWO2UrssnWSJvc+wxoxJ0qOyj1ltLbY3dObRIXPmmLndl9aceVKrbpczsh+xkqR83N52vt081G7b4+TQ68yjxu1zbFftZ351xG4bzbI9F5CkUNjblp1mXqra91W77qxbVOzyJKndNhLvlor9+zHrsc+xyOxrNVCavs5L+eaNB+lRAQAAAAAA0PVY5AIAAAAAAEDXY5ELAAAAAAAAXY9FLgAAAAAAAHQ9FrkAAAAAAADQ9VjkAgAAAAAAQNfz88zuQPc9+L9K06lpJYvYzmEZUiedatlO6ZymTh5SSemgneM0ccoTeUuIwQ6Ntu0UpiMbnNSvw3aKznbHTpkrSVFk113spLUOwckp6qS3jZ3KSZz0xl6a0miG9NtZbtdBFNtlTVP7Nqk4KVxV2HWTOdej5aTwbRf+dSycY9oJfqXyNPfaJtPdh5sEr5E7bcqT9thpqiUpie37MfWK46zph8y5IYMdK1Wc9ugVJvHbqteWC6c8udHG89y7T4Gt59er7JTw0tzqa7Br66a+Bt2tNZRLlan98zQvTRidZz/XSj32PKGttluWqGPPh7Ieez5UFPb8I4qccXLFGc/U7TFUa9zeZ2/NDEmS8o7dX7ScYXtPOmbGYmfKnFYyM9bMnPlFYl+rrBgwY5K0KGuZsVZpxIyFwj6PPLePmbbtfbZTp81V7edaEflj02TAvkFGh6tmrNywtysFu96Ktn3+cWFf48IuiuKKfz9645cxu6jqtW8dzeu3j1lv2BvmFXumWJG9xhCctRBJKo3ZdZdV7G3HytNXQKuwy/J4jP4AAAAAAADQ9VjkAgAAAAAAQNdjkQsAAAAAAABdj0UuAAAAAAAAdD0WuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF0v3dEFsERpqiidWrw0isxtkjgxY+WoZMbyPHfL0so6ZixylgmT1C5PktixOLHPMYRgxgo7pCT21zNjJ54mzrZeBcguUAj2OcbO2mupXLZjqX2NJSkvCifqVJ6jyO19etejkH3+qdNuSrF/jnFs79c7xXSae20i5rTVzDn/yLlX/ZjfViOn7mLnHN17J7afAd52UeLUm9MevZgkOdWjorCfR0k0fSz27mFgK0pmfEbNnb4Gu7ae3oobn0t9Dbpbpx0UR1PHS/GiHnObftltJY/HzFgjs8fJklRN7XZfa9TNWCZnHlXuNWPx6KgZa0R2WfLIPo9Oyy6nJMXlzIxVnXlEPmSPd2vO3Ey9NTOUDNllSWN7PNcM/hQ973POsZhvH7NlH7ORtu0Dlux6G6zZc4HhzoC9z3zYjkkabNv12nTmO60+Z5xcscuTpE0zVgr2PgvZ7Tgt+dcxLez4eGrXa1ayx0RjHXuf5R77uZK27eN1nHlL1rHboiT191fNWN6y21xqPKsyp14ej5kPAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6Hp+XssdKIljJcnUVK5eSmcvVhR2auY8t9NpSlJW2PHESWueOOXxMkW323aa0ihyUlpPU18TMTf9up/WPY7t/aYlP128pcjt9J9eynevLJFzDpK/ouvVqxNSEezziIJXp5uX/nTqdv45eucx2+0Kp7EG7/xnaHOWme7H2Lmv5B3TOw/vgF7bcK5HmtrplstOKmZJKgo7HW8Idv1Y13GWzQLYYt3U12DX1k19Dbpbb5KokkydctVzu68vtStmLI/nmbGy2m5Z4mDHW/1OGxy3Q3nZDma99nYDIz324Qpn7FXy75W41+5LclXNWKVk9xexMxeMxu07u9xvT7VD3DJjedmfog827D4xqQ6ZsUay2IzFTfuYA8WwGSuGa2asOs8+xzDSMGOStD61y7ogXW/Ghnv3MGODDbuttgftOi057b8T2e2441xjSSqP2ccM/fbzIWrZ90A60DRj+Yh9Qzb67PWHct0Mqdzrz2laHfuZM+r0pT3x9PdVEW9eX8knuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PVY5AIAAAAAAEDX8/OT7kBJnCiZJp14cFIze7xU0UXhpxj3j+mkuHXSQXv77HTsFJ5e+vWSE4tmSLfplTXyjumkdffOMY/s6+FkVHbNtm1Ifv24Ke+d6x+Ct4Y8+7LOlneNi8K5VrO8d7zjedptu/1LUuKkm00TO220y2k73nl4bSNxypKkfjlD5jyT/McVsEPNdNvPpb4Gu7Zu6mvQ3cYrsbLK1PYURS1zm+GS3T4HS/ZAIJ1hjFC062asFJfNWCep2du12vZ24/ZUM6k27X1mznZOOSUp7jjjr3G7rJWSfcz2oH1/1p3jZXX7giSF3T8NRP4zpjwwaMZGg92uSql9zL5++/k03rAnZ3lp1IzVOvPs7QYWmzFJGmyMmLFKdb4Zmz/qjDPmDZixrGW3x2o+bsbqC+xrXG1UzJgkZT12ncdy5l+ZPSbK6/azo4jtc6yFHnufdkh5ZteNJMWRfV/Nr9j3Yz4y/T2QNjdvIsQnuQAAAAAAAND1WOQCAAAAAABA12ORCwAAAAAAAF2PRS4AAAAAAAB0PRa5AAAAAAAA0PXmXHbFTVmSsmz6b9t/Mhn0LF72OEnKg5PuL9jf8B9Hs0uDlhvnLkmFl0ExcupmhuyKceFk8Qh2/XSc/XrXqnAyirjZFZ2yFLm/ZuuVJ06cDIpOnXup7vy22k3ZFb1z9K6H3aa8smQdOyuMJAUn41Xw2rG701lmV3TuucRrN069SVLm3ARZZmdGyfPpnx2d9sY63RbPz25FXWwbM92/c6mvwa6tm/qabsPzdaNN9dA2srZFsrOgZYXd/lrOuMxLzixJRdseX0RONlpn6KFYTnZFd2xub9dqORkSIz8Ne+wcs2g5WVULe1rccTK6tTr28bKWM06M7EqN5VS4JDlV0JL9bCuceWtasp9BraY39rTLEnca9nZOhvrfHdQJOtfKebRHTee+co6XOrFW066AqOmfYx6cfiZ2siS27AbgtR1nuuf2QcHp8op8hnGfk11R3npAc/qDbrpOM/UzUZhjPdEjjzyivffee0cXAwB2Og8//LCWLl26o4sxJ9DXAMC2QV+zEf0MAGwbM/Uzc26RqygKrVy5Uv39/YqiSCMjI9p777318MMPa2BgYEcXb06hbmzUjY/6se2MdRNC0OjoqPbcc88ZPpm463h8XzM6OrrTXfOtZWe8H7Ym6sdG3dh21rqhr5mMfmbz7az3xNZA3dioG9vOWjeb28/MuT9XjON42lW5gYGBneoCbU3UjY268VE/tp2tbgYHB3d0EeaUx/c1mz6ivbNd862JuvFRPzbqxrYz1g19ze/Rz2w56sdG3dioG9vOWDeb08/waxYAAAAAAAB0PRa5AAAAAAAA0PXm/CJXpVLRhRdeqEqlsqOLMudQNzbqxkf92KibXQ/X3Ebd+KgfG3Vjo252PVxzH/Vjo25s1I1tV6+bOffF8wAAAAAAAMCWmvOf5AIAAAAAAABmwiIXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK43pxe5rrjiCu23336qVqs64ogj9N///d87ukg7xPe//329/OUv15577qkoivTlL395UjyEoPe9733aY489VKvVtGLFCv3yl7/cMYXdzi655BI973nPU39/v3bbbTedeuqpuu+++ya9p9ls6pxzztHChQvV19en0047TatXr95BJd5+PvGJT+jZz362BgYGNDAwoOXLl+ub3/zmRHxXrZfpfPCDH1QURTrvvPMmXqN+dh30NfQzHvoZG/3M5qOf2bXRz9DPeOhnfPQ1m4d+5vfm7CLXF7/4Rb3zne/UhRdeqJ/+9Kc69NBDdcIJJ2jNmjU7umjb3fj4uA499FBdccUV08Y/9KEP6WMf+5iuuuoq3Xrrrert7dUJJ5ygZrO5nUu6/d18880655xz9OMf/1g33HCDOp2Ojj/+eI2Pj0+85x3veIe+9rWv6brrrtPNN9+slStX6hWveMUOLPX2sXTpUn3wgx/U7bffrp/85Cd68YtfrFNOOUV33323pF23Xp7otttu0yc/+Uk9+9nPnvQ69bNroK/ZiH7GRj9jo5/ZPPQzuzb6mY3oZ2z0Mz76mpnRzzxBmKMOP/zwcM4550z8O8/zsOeee4ZLLrlkB5Zqx5MUvvSlL038uyiKsPvuu4dLL7104rWhoaFQqVTCv/3bv+2AEu5Ya9asCZLCzTffHELYWBelUilcd911E+/5xS9+ESSFW265ZUcVc4eZP39++PSnP029/M7o6Gh42tOeFm644YZw9NFHh7e//e0hBNrNroS+Zir6GR/9jI9+ZjL6GdDPTEU/46OfmRl9ze/Rz0w1Jz/J1W63dfvtt2vFihUTr8VxrBUrVuiWW27ZgSWbex566CGtWrVqUl0NDg7qiCOO2CXranh4WJK0YMECSdLtt9+uTqczqX4OPPBA7bPPPrtU/eR5rmuvvVbj4+Navnw59fI755xzjk466aRJ9SDRbnYV9DWbh35mMvqZ6dHPTI9+ZtdGP7N56Gcmo5+x0ddMRT8zVbqjCzCdtWvXKs9zLVmyZNLrS5Ys0b333ruDSjU3rVq1SpKmratNsV1FURQ677zz9MIXvlDPetazJG2sn3K5rHnz5k16765SP3feeaeWL1+uZrOpvr4+felLX9Izn/lM3XHHHbt0vUjStddeq5/+9Ke67bbbpsR29Xazq6Cv2Tz0M79HPzMV/YyNfgb0M5uHfub36GemR18zPfqZ6c3JRS5gNs455xzddddd+uEPf7ijizJnPOMZz9Add9yh4eFhXX/99TrzzDN188037+hi7XAPP/yw3v72t+uGG25QtVrd0cUB0CXoZ6ain5ke/QyA2aCfmR59zVT0M7Y5+eeKixYtUpIkU775f/Xq1dp99913UKnmpk31savX1bnnnquvf/3ruummm7R06dKJ13fffXe1220NDQ1Nev+uUj/lcllPfepTtWzZMl1yySU69NBD9dGPfnSXr5fbb79da9as0XOf+1ylaao0TXXzzTfrYx/7mNI01ZIlS3bp+tlV0NdsHvqZjehnpkc/Mz36GUj0M5uLfmYj+hkbfc1U9DO2ObnIVS6XtWzZMt14440TrxVFoRtvvFHLly/fgSWbe/bff3/tvvvuk+pqZGREt9566y5RVyEEnXvuufrSl76k7373u9p///0nxZctW6ZSqTSpfu677z795je/2SXq54mKolCr1drl6+W4447TnXfeqTvuuGPi5w/+4A/02te+duK/d+X62VXQ12we+hn6mS1BP7MR/Qwk+pnNRT9DP7Ol6GvoZ1w7+IvvTddee22oVCrhM5/5TLjnnnvC2WefHebNmxdWrVq1o4u23Y2Ojoaf/exn4Wc/+1mQFD784Q+Hn/3sZ+HXv/51CCGED37wg2HevHnhK1/5Svj5z38eTjnllLD//vuHRqOxg0u+7f35n/95GBwcDN/73vfCo48+OvFTr9cn3vOWt7wl7LPPPuG73/1u+MlPfhKWL18eli9fvgNLvX381V/9Vbj55pvDQw89FH7+85+Hv/qrvwpRFIXvfOc7IYRdt14sj89GEgL1s6ugr9mIfsZGP2Ojn9ky9DO7JvqZjehnbPQzPvqazUc/s9GcXeQKIYTLL7887LPPPqFcLofDDz88/PjHP97RRdohbrrppiBpys+ZZ54ZQtiYdve9731vWLJkSahUKuG4444L9913344t9HYyXb1ICtdcc83EexqNRnjrW98a5s+fH3p6esIf/dEfhUcffXTHFXo7ecMb3hD23XffUC6Xw+LFi8Nxxx030RmEsOvWi+WJnQL1s+ugr6Gf8dDP2Ohntgz9zK6LfoZ+xkM/46Ov2Xz0MxtFIYSwbT8rBgAAAAAAAGxbc/I7uQAAAAAAAIAtwSIXAAAAAAAAuh6LXAAAAAAAAOh6LHIBAAAAAACg67HIBQAAAAAAgK7HIhcAAAAAAAC6HotcAAAAAAAA6HoscgEAAAAAAKDrscgFAAAAAACArsciFwAAAAAAALoei1wAAAAAAADoev8/kXdwtBJmmqMAAAAASUVORK5CYII=\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r157/157 [==============================] - 829s 5s/step - loss: 0.4935 - val_loss: 0.5116\n","Epoch 2/100\n","157/157 [==============================] - 848s 5s/step - loss: 0.5139 - val_loss: 0.5246\n","Epoch 3/100\n","157/157 [==============================] - 843s 5s/step - loss: 0.5240 - val_loss: 0.5317\n","Epoch 4/100\n","157/157 [==============================] - 802s 5s/step - loss: 0.5303 - val_loss: 0.5375\n","Epoch 5/100\n","157/157 [==============================] - 803s 5s/step - loss: 0.5366 - val_loss: 0.5447\n","Epoch 6/100\n","157/157 [==============================] - ETA: 0s - loss: 0.5414\n","Idx chosen: 14\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1500x500 with 3 Axes>"],"image/png":"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\n"},"metadata":{}},{"output_type":"stream","name":"stdout","text":["\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r157/157 [==============================] - 806s 5s/step - loss: 0.5414 - val_loss: 0.5521\n","Epoch 7/100\n"," 63/157 [===========>..................] - ETA: 7:44 - loss: 0.5448"]},{"output_type":"error","ename":"KeyboardInterrupt","evalue":"","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m<ipython-input-17-3172f75f34fe>\u001b[0m in \u001b[0;36m<cell line: 9>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0moptimizer\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlosses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mMeanSquaredError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"mae\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m )\n\u001b[0;32m----> 9\u001b[0;31m history = mae_model.fit(\n\u001b[0m\u001b[1;32m     10\u001b[0m     \u001b[0mtrain_ds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEPOCHS\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/keras/src/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     63\u001b[0m         \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     66\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m             \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m   1805\u001b[0m                         ):\n\u001b[1;32m   1806\u001b[0m                             \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1807\u001b[0;31m                             \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1808\u001b[0m                             \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1809\u001b[0m                                 \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    149\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    151\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    830\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    831\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 832\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    833\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    834\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    866\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    867\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 868\u001b[0;31m       return tracing_compilation.call_function(\n\u001b[0m\u001b[1;32m    869\u001b[0m           \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_no_variable_creation_config\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    870\u001b[0m       )\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py\u001b[0m in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m    137\u001b[0m   \u001b[0mbound_args\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    138\u001b[0m   \u001b[0mflat_inputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munpack_inputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbound_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 139\u001b[0;31m   return function._call_flat(  # pylint: disable=protected-access\n\u001b[0m\u001b[1;32m    140\u001b[0m       \u001b[0mflat_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    141\u001b[0m   )\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m   1321\u001b[0m         and executing_eagerly):\n\u001b[1;32m   1322\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1323\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_inference_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_preflattened\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1324\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m   1325\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py\u001b[0m in \u001b[0;36mcall_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m    214\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0mcall_preflattened\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    215\u001b[0m     \u001b[0;34m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m     \u001b[0mflat_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_flat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    217\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpack_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflat_outputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py\u001b[0m in \u001b[0;36mcall_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m    249\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_recording\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    250\u001b[0m           \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_bound_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecuting_eagerly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 251\u001b[0;31m             outputs = self._bound_context.call_function(\n\u001b[0m\u001b[1;32m    252\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    253\u001b[0m                 \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/context.py\u001b[0m in \u001b[0;36mcall_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m   1484\u001b[0m     \u001b[0mcancellation_context\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcancellation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1485\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mcancellation_context\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1486\u001b[0;31m       outputs = execute.execute(\n\u001b[0m\u001b[1;32m   1487\u001b[0m           \u001b[0mname\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1488\u001b[0m           \u001b[0mnum_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_outputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     51\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0m\u001b[1;32m     54\u001b[0m                                         inputs, attrs, num_outputs)\n\u001b[1;32m     55\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]}],"source":["optimizer = keras.optimizers.AdamW(\n","    learning_rate=scheduled_lrs, weight_decay=WEIGHT_DECAY\n",")\n","\n","# Compile and pretrain the model.\n","mae_model.compile(\n","    optimizer=optimizer, loss=keras.losses.MeanSquaredError(), metrics=[\"mae\"]\n",")\n","history = mae_model.fit(\n","    train_ds,\n","    epochs=EPOCHS,\n","    validation_data=val_ds,\n","    callbacks=train_callbacks,\n",")\n","\n","# Measure its performance.\n","loss, mae = mae_model.evaluate(test_ds)\n","print(f\"Loss: {loss:.2f}\")\n","print(f\"MAE: {mae:.2f}\")"]},{"cell_type":"markdown","metadata":{"id":"TuHc_tnfgL9F"},"source":["## Evaluation with linear probing"]},{"cell_type":"markdown","metadata":{"id":"FZNI2_GhgL9F"},"source":["### Extract the encoder model along with other layers"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"GGFnakZ5gL9F"},"outputs":[],"source":["# Extract the augmentation layers.\n","train_augmentation_model = mae_model.train_augmentation_model\n","test_augmentation_model = mae_model.test_augmentation_model\n","\n","# Extract the patchers.\n","patch_layer = mae_model.patch_layer\n","patch_encoder = mae_model.patch_encoder\n","patch_encoder.downstream = True  # Swtich the downstream flag to True.\n","\n","# Extract the encoder.\n","encoder = mae_model.encoder\n","\n","# Pack as a model.\n","downstream_model = keras.Sequential(\n","    [\n","        layers.Input((IMAGE_SIZE, IMAGE_SIZE, 3)),\n","        patch_layer,\n","        patch_encoder,\n","        encoder,\n","        layers.BatchNormalization(),  # Refer to A.1 (Linear probing).\n","        layers.GlobalAveragePooling1D(),\n","        layers.Dense(NUM_CLASSES, activation=\"softmax\"),\n","    ],\n","    name=\"linear_probe_model\",\n",")\n","\n","# Only the final classification layer of the `downstream_model` should be trainable.\n","for layer in downstream_model.layers[:-1]:\n","    layer.trainable = False\n","\n","downstream_model.summary()"]},{"cell_type":"markdown","metadata":{"id":"ZUjDCYwogL9F"},"source":["We are using average pooling to extract learned representations from the MAE encoder.\n","Another approach would be to use a learnable dummy token inside the encoder during\n","pretraining (resembling the [CLS] token). Then we can extract representations from that\n","token during the downstream tasks."]},{"cell_type":"markdown","metadata":{"id":"MIECly1fgL9I"},"source":["### Prepare datasets for linear probing"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"reP5TulSgL9I"},"outputs":[],"source":["\n","def prepare_data(images, labels, is_train=True):\n","    if is_train:\n","        augmentation_model = train_augmentation_model\n","    else:\n","        augmentation_model = test_augmentation_model\n","\n","    dataset = tf.data.Dataset.from_tensor_slices((images, labels))\n","    if is_train:\n","        dataset = dataset.shuffle(BUFFER_SIZE)\n","\n","    dataset = dataset.batch(BATCH_SIZE).map(\n","        lambda x, y: (augmentation_model(x), y), num_parallel_calls=AUTO\n","    )\n","    return dataset.prefetch(AUTO)\n","\n","\n","train_ds = prepare_data(x_train, y_train)\n","val_ds = prepare_data(x_train, y_train, is_train=False)\n","test_ds = prepare_data(x_test, y_test, is_train=False)"]},{"cell_type":"markdown","metadata":{"id":"yD5-qA6BgL9I"},"source":["### Perform linear probing"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"zOgDHIZQgL9I"},"outputs":[],"source":["linear_probe_epochs = 50\n","linear_prob_lr = 0.1\n","warm_epoch_percentage = 0.1\n","steps = int((len(x_train) // BATCH_SIZE) * linear_probe_epochs)\n","\n","warmup_steps = int(steps * warm_epoch_percentage)\n","scheduled_lrs = WarmUpCosine(\n","    learning_rate_base=linear_prob_lr,\n","    total_steps=steps,\n","    warmup_learning_rate=0.0,\n","    warmup_steps=warmup_steps,\n",")\n","\n","optimizer = keras.optimizers.SGD(learning_rate=scheduled_lrs, momentum=0.9)\n","downstream_model.compile(\n","    optimizer=optimizer, loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"]\n",")\n","downstream_model.fit(train_ds, validation_data=val_ds, epochs=linear_probe_epochs)\n","\n","loss, accuracy = downstream_model.evaluate(test_ds)\n","accuracy = round(accuracy * 100, 2)\n","print(f\"Accuracy on the test set: {accuracy}%.\")"]},{"cell_type":"markdown","metadata":{"id":"gPW7kAy0gL9J"},"source":["We believe that with a more sophisticated hyperparameter tuning process and a longer\n","pretraining it is possible to improve this performance further. For comparison, we took\n","the encoder architecture and\n","[trained it from scratch](https://github.com/ariG23498/mae-scalable-vision-learners/blob/master/regular-classification.ipynb)\n","in a fully supervised manner. This gave us ~76% test top-1 accuracy. The authors of\n","MAE demonstrates strong performance on the ImageNet-1k dataset as well as\n","other downstream tasks like object detection and semantic segmentation."]},{"cell_type":"markdown","metadata":{"id":"JCxEOy7kgL9J"},"source":["## Final notes\n","\n","We refer the interested readers to other examples on self-supervised learning present on\n","keras.io:\n","\n","* [SimCLR](https://keras.io/examples/vision/semisupervised_simclr/)\n","* [NNCLR](https://keras.io/examples/vision/nnclr)\n","* [SimSiam](https://keras.io/examples/vision/simsiam)\n","\n","This idea of using BERT flavored pretraining in computer vision was also explored in\n","[Selfie](https://arxiv.org/abs/1906.02940), but it could not demonstrate strong results.\n","Another concurrent work that explores the idea of masked image modeling is\n","[SimMIM](https://arxiv.org/abs/2111.09886). Finally, as a fun fact, we, the authors of\n","this example also explored the idea of [\"reconstruction as a pretext task\"](https://i.ibb.co/k5CpwDX/image.png)\n","in 2020 but we could not prevent the network from representation collapse, and\n","hence we did not get strong downstream performance.\n","\n","We would like to thank [Xinlei Chen](http://xinleic.xyz/)\n","(one of the authors of MAE) for helpful discussions. We are grateful to\n","[JarvisLabs](https://jarvislabs.ai/) and\n","[Google Developers Experts](https://developers.google.com/programs/experts/)\n","program for helping with GPU credits."]}],"metadata":{"accelerator":"GPU","colab":{"provenance":[{"file_id":"https://github.com/keras-team/keras-io/blob/master/examples/vision/ipynb/masked_image_modeling.ipynb","timestamp":1711721919445}],"toc_visible":true,"gpuType":"T4"},"kernelspec":{"display_name":"Python 3","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.0"}},"nbformat":4,"nbformat_minor":0}
\ No newline at end of file