{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.11","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":3649,"databundleVersionId":46718,"sourceType":"competition"}],"dockerImageVersionId":31041,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport torchvision.transforms as transforms\nimport keras\n\nfrom sklearn.model_selection import train_test_split\nfrom keras.datasets import cifar10\nfrom tensorflow.keras.losses import SparseCategoricalCrossentropy, CategoricalCrossentropy\nfrom tensorflow.keras.models import Sequential\n","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:17.018329Z","iopub.execute_input":"2025-06-12T14:33:17.018869Z","iopub.status.idle":"2025-06-12T14:33:39.654741Z","shell.execute_reply.started":"2025-06-12T14:33:17.018843Z","shell.execute_reply":"2025-06-12T14:33:39.653945Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"As a reminder, the first 2 models are currently set to 1 epoch (because training takes quite a bit). The last model is correctly setup with 50 epochs. If you also want to see the results of the first 2 models, be sure to set the epochs to 50. (and please, use gpu if you don't want to wait 5 and a half hours)","metadata":{}},{"cell_type":"markdown","source":"# importing and preparing data","metadata":{}},{"cell_type":"code","source":"(x_train, y_train), (x_test, y_test) = cifar10.load_data()\nprint('Dataset loaded')\nprint('shape of train images', x_train.shape)\nprint('shape of train labels', y_train.shape)\nprint(x_train.shape[0], 'number of training images')\nprint(x_test.shape[0], 'number of testing images')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:39.655531Z","iopub.execute_input":"2025-06-12T14:33:39.656019Z","iopub.status.idle":"2025-06-12T14:33:45.626913Z","shell.execute_reply.started":"2025-06-12T14:33:39.655999Z","shell.execute_reply":"2025-06-12T14:33:45.626159Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"classes = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n           'dog', 'frog', 'horse', 'ship', 'truck']\n\nrandom_indices = np.random.choice(len(x_train), size=3, replace=False)\n\nplt.figure(figsize=(10, 4))\nfor i, index in enumerate(random_indices):\n    image = x_train[index]\n    label = y_train[index][0]\n    \n    plt.subplot(1, 3, i + 1)\n    plt.imshow(image)\n    plt.title(classes[label])\n    plt.axis('off')\n\nplt.tight_layout()\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:45.628715Z","iopub.execute_input":"2025-06-12T14:33:45.628954Z","iopub.status.idle":"2025-06-12T14:33:45.883055Z","shell.execute_reply.started":"2025-06-12T14:33:45.628935Z","shell.execute_reply":"2025-06-12T14:33:45.882290Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"As seen in the [digit recognizer](https://www.kaggle.com/code/erikvandenbroek/digit-recognizer-99-44), a popular way to normalise grey-scaled images is simply by dividing the individual pixel values by 255. While this is also possible to do with cifar-10, there is a more popular approach. After first dividing the values by 255, a better approach is to normalize each color channel using the dataset's mean and standart deviation. When subtracting the mean and scaling by the standart deviation, the values are centered around zero. This makes it easier for the model to learn effectively, as ir helps stabilize and speed up training the model, by making sure each feature (or color channel) contributes equally.","metadata":{}},{"cell_type":"markdown","source":"The same as in the digit recognizers, the images are shaped to be the correct format. The only changes here are that the images are 32x32, and the images are colored (so there are 3 channels).","metadata":{}},{"cell_type":"code","source":"x_train = x_train.astype('float32') / 255.0\nx_test = x_test.astype('float32') / 255.0\n\n# CIFAR-10 channel mean and std for each channel\nmean = np.array([0.4914, 0.4822, 0.4465])\nstd = np.array([0.2023, 0.1994, 0.2010])\n\nx_train = (x_train - mean) / std\nx_test = (x_test - mean) / std\n\nx_train = x_train.reshape(-1, 32, 32, 3)\nx_test = x_test.reshape(-1, 32, 32, 3)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:45.883899Z","iopub.execute_input":"2025-06-12T14:33:45.884200Z","iopub.status.idle":"2025-06-12T14:33:47.193692Z","shell.execute_reply.started":"2025-06-12T14:33:45.884174Z","shell.execute_reply":"2025-06-12T14:33:47.193044Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"this simply one hot encodes the labels, into vectors/arrays with a length of 10","metadata":{}},{"cell_type":"code","source":"y_train = keras.utils.to_categorical(y_train, 10)\ny_test = keras.utils.to_categorical(y_test, 10)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:47.194421Z","iopub.execute_input":"2025-06-12T14:33:47.195490Z","iopub.status.idle":"2025-06-12T14:33:47.200467Z","shell.execute_reply.started":"2025-06-12T14:33:47.195467Z","shell.execute_reply":"2025-06-12T14:33:47.199679Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# data augmentation\n\nAgain, data augmentation is very important. Slightly augmenting the images when training can make the model more robust and increase performance (somethimes even by quite a bit, like a difference between an accuracy of 70% and 80%). \n\nFor data augmenation, similar parameters have been used compared to the digit recognizer. The only addition is enabling horizontal flip, which gives a chance to flip the image horizontally.","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.preprocessing.image import ImageDataGenerator\n\n\ndatagen = ImageDataGenerator(\n    horizontal_flip=True,\n    rotation_range=15,\n    shear_range=0.2,\n    height_shift_range=0.1,\n    width_shift_range=0.1,\n    zoom_range=0.1 \n)\n\ntrain_generator = datagen.flow(x_train, y_train, batch_size=64)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:47.201258Z","iopub.execute_input":"2025-06-12T14:33:47.201700Z","iopub.status.idle":"2025-06-12T14:33:47.450820Z","shell.execute_reply.started":"2025-06-12T14:33:47.201679Z","shell.execute_reply":"2025-06-12T14:33:47.450164Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"To see what the ImageDataGenerator does, here some images :)","metadata":{}},{"cell_type":"code","source":"# Function to denormalize images for display purposes only\ndef denormalize(imgs):\n    return imgs * std + mean\n\n# Select random images and labels\nsample_images = x_train[np.random.choice(len(x_train), size=5, replace=False)]\nsample_labels = y_train[np.random.choice(len(x_train), size=5, replace=False)]\n\n# Create a generator for just these samples\naugmented_generator = datagen.flow(sample_images, sample_labels, batch_size=5, shuffle=False)\naugmented_images, _ = next(augmented_generator)\n\nsample_images_denorm = denormalize(sample_images)\naugmented_images_denorm = denormalize(augmented_images)\n\nplt.figure(figsize=(5 * 2, 4))\nfor i in range(5):\n    plt.subplot(2, 5, i + 1)\n    plt.imshow(np.clip(sample_images_denorm[i], 0, 1))\n    plt.title(\"Original\")\n    plt.axis('off')\n\n    plt.subplot(2, 5, 5 + i + 1)\n    plt.imshow(np.clip(augmented_images_denorm[i], 0, 1))\n    plt.title(\"Augmented\")\n    plt.axis('off')\n\nplt.tight_layout()\nplt.show()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:47.451583Z","iopub.execute_input":"2025-06-12T14:33:47.451834Z","iopub.status.idle":"2025-06-12T14:33:47.939835Z","shell.execute_reply.started":"2025-06-12T14:33:47.451811Z","shell.execute_reply":"2025-06-12T14:33:47.938993Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Network architecture\n\nThe main challenge i usualy have is finding the correct network architecture for image classification. While this wasn't too difficult for mnist (as seen in the other notebook), this can become harder when working with more complex datasets like cifar10. To start off, i was interested to see how the model would perform is the same topology was used as for the digit recogniser (the only changed being the input having 3 channels and being 32x32).","metadata":{}},{"cell_type":"markdown","source":"## types of layers used\n\nThe current network consists out of multiple types of layers:\n\n- **Input layer**: `Input(shape=(32, 32, 3))`\nThe input layer is mainly used to the define the input shape of the data the model excepts. the images are 32 by 32, and the layer has a depth of 3.\n\n\n- **Convolutional layers**: `Conv2D(32, kernel_size=(3, 3), activation='relu', padding='same'),`\n\nThese layers apply kernels (can be seen as filters) to the input image to  extract spatial features like edges, textures and patterns. The activation function used here is rely. Padding same makes sure that the output has the same size as the input, by padding the image with zero's. Why is this done? Because without padding, a 3x3 kernel reduces the width and height by 2 pixels (one on each side). For example, a 32x32 image would become 30x30 after using a 3x3 kernel. `padding='same'`, simply makes sure that the output is also a 32x32 image.\n\nAn example of a kernel looking for vertical edges could be:\n\n| -1 |  0 |  1 |\n|----|----|----|\n| -2 |  0 |  2 |\n| -1 |  0 |  1 |\n\nThe depth (num of filters) of the layers increase though the network (like from 32 -> 64 -> 128) ect. This is because each filter tries to capture different patterns within the image. When going deeper into the layers, the focus shifts from detecting simple patterns, to recognizing complex, abtract features even we can't see, which you need more kernels for to capture.\n\n\n- **Pooling layers**: `MaxPooling2D(pool_size=(2, 2)),`\nThese layers reduce the width and height of the images or feature maps, which helps prevent overfitting and decreases computation (less calculations having to be done). This works similar to a kernal from a convolutional layer, but (for maxpooling), simply takes the max value, keeping only the most important information.\n\n- **Flatten layer**: `Flatten()`\nThis layer does what it sounds like. It converts the feature maps (which for example can be 32x32), into a 1D vector (array). These values are then used as input for the fully connected layer (or 'normal' neural networks, as taught during the lectures).\n\n\n- **Dense layer**: `Dense(256, activation='relu'),`:\nTo reference back to the lectures, a dense layer can just be seen as a hidden layer in a neural network. In this case, the hidden layer has 256 nodes and uses relu as activation function. The final Dense layer represents the output layer, where the 10 nodes stand for the 1- unique classes in the network\n\n\n- **Dropout**: `Dropout(0.7),`\nDroupout is a regularization technique. During training, it randomly sets a part of the layer's output to zero. This prevents the network on becoming too dependent on a specific path in the network, which reduces overfitting. In this case, the 0.7 stands for dropping (setting to 0) 70% of the neurons in the layer.","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Dense, Dropout, Flatten, BatchNormalization, ReLU, Input, GlobalAveragePooling2D\nfrom tensorflow.keras.models import Sequential\n\n\nmodel_1 = Sequential([\n    Input(shape=(32, 32, 3)),\n    \n    Conv2D(32, kernel_size=(3, 3), activation='relu', padding='same'),\n\n    Conv2D(64, kernel_size=(3, 3), activation='relu', padding='same'),\n    MaxPooling2D(pool_size=(2, 2)),\n    \n    Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same'),\n    \n    Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same'),\n    MaxPooling2D(pool_size=(2, 2)),\n\n\n    # next, converting the image into a 1D vector (array)\n    Flatten(),\n\n    # a layer with 256 nodes\n    Dense(256, activation='relu'),\n    Dropout(0.7),\n\n    # the output is a vector of probabilities for each class (like being 0.2 certain the digit is a 0)\n    Dense(10, activation='softmax')\n])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:47.940814Z","iopub.execute_input":"2025-06-12T14:33:47.941084Z","iopub.status.idle":"2025-06-12T14:33:49.461865Z","shell.execute_reply.started":"2025-06-12T14:33:47.941064Z","shell.execute_reply":"2025-06-12T14:33:49.461348Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## other things used","metadata":{}},{"cell_type":"markdown","source":"Next, several techniques have been used which might not all have been covered during the lectures.\n\n- **Early stopping**: `EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)`\nDuring training, we keep looking at the model's performance on the validation set. If the validation loss (the lower the better) stops improving after a certain number of epochs (in this case 10), it stops training. If the model isn't getting better, continuing to train might lead to overfitting. `restore_best_weights=True` sets the weights back to when the model was performing best in the case that the early stopping has been triggered.\n\n- **Adaptive learning rate tuning**: `ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-5)`\nAs you might know after doing some modelling, it can be difficult finding the ideal learning rate. Training often converges quickly at first, then slowing down as the model gets closer to a local minumum. If we keep using the same learning rate, it might not find the local minimum or even overshoot. The learning rate tuning watches the validation loss. If it doesn't improve after a certain number of epochs (in this case 5), it reduces the learning rate. This is especially useful when the model is near a local minimum and having a too high learning rate can overshoot.\n\n- **Categorical cross entrophy**: `CategoricalCrossentropy(from_logits=False)`\nSince cifar 10 has 10 different targets (the 10 classes), we use categorical crossentropy as the loss function. `from_logits=False` simply tells that the output of the model is already gone through softmax, which turns raw output scores into probability (like 0% certain its 1, and 99% certain its 2).\n\nWhy adam as optimizer? Because it pretty much always just works better... Alternatives would be RMSProp, just SGD, AdaGrad, Mini-batch gradient descent ect ect.","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.losses import SparseCategoricalCrossentropy\nfrom tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\n\n\nearly_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\nlr_scheduler = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-5)\nloss = CategoricalCrossentropy(from_logits=False)\noptimizer = Adam(learning_rate=1e-3)\n\nmodel_1.compile(\n    optimizer=optimizer,\n    loss=loss,\n    metrics=['accuracy']\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:49.464077Z","iopub.execute_input":"2025-06-12T14:33:49.464292Z","iopub.status.idle":"2025-06-12T14:33:49.483261Z","shell.execute_reply.started":"2025-06-12T14:33:49.464276Z","shell.execute_reply":"2025-06-12T14:33:49.482552Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Please, if you want to make sure you run these models, use the gpu. Otherwise it can take 6 minutes per epoch, even for this simpler model.","metadata":{}},{"cell_type":"code","source":"history = model_1.fit(\n    train_generator,\n    steps_per_epoch=len(x_train) // 64,\n    validation_data=(x_test, y_test),\n    epochs=1, \n    callbacks=[lr_scheduler, early_stopping]\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:33:49.483861Z","iopub.execute_input":"2025-06-12T14:33:49.484066Z","iopub.status.idle":"2025-06-12T14:34:24.849405Z","shell.execute_reply.started":"2025-06-12T14:33:49.484051Z","shell.execute_reply":"2025-06-12T14:34:24.848832Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"gets 83% accuracy after 50 epochs. Just make sure to update the amount of epochs to 50 if you want to test it.","metadata":{}},{"cell_type":"markdown","source":"While just looking at the metrics is fine to understand model performance, it is often better to make some basic visualisations to better interpret the model performance.","metadata":{}},{"cell_type":"code","source":"plt.plot(history.history['accuracy'], label='Train Accuracy')\nplt.plot(history.history['val_accuracy'], label='Validation Accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.title('Accuracy Over Epochs')\nplt.legend()\nplt.grid(True)\nplt.show()\n\n# Loss\nplt.plot(history.history['loss'], label='Train Loss')\nplt.plot(history.history['val_loss'], label='Validation Loss')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.title('Loss Over Epochs')\nplt.legend()\nplt.grid(True)\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:34:24.850250Z","iopub.execute_input":"2025-06-12T14:34:24.850511Z","iopub.status.idle":"2025-06-12T14:34:25.149564Z","shell.execute_reply.started":"2025-06-12T14:34:24.850482Z","shell.execute_reply":"2025-06-12T14:34:25.148940Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"This plot shows model performance spread out across different epochs. Overall, nothing really appears out of the ordinary. As expected, the validation accuracy increases over epochs. It is also increasing slower, the more epochs, indicating that the model will start overfitting when training for much longer. Training accuracy seems to fluctuate a bit over epochs, but it is not too extreme to worry about.","metadata":{}},{"cell_type":"code","source":"from sklearn.metrics import confusion_matrix\nimport seaborn as sns\nclasses = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n           'dog', 'frog', 'horse', 'ship', 'truck']\n\ny_pred_probs = model_1.predict(x_test)\ny_pred = np.argmax(y_pred_probs, axis=1)\ny_true = np.argmax(y_test, axis=1)\n\ncm = confusion_matrix(y_true, y_pred)\n\nplt.figure(figsize=(10, 8))\nsns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes)\nplt.xlabel('Predicted')\nplt.ylabel('Actual')\nplt.title('Confusion Matrix')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:34:25.150241Z","iopub.execute_input":"2025-06-12T14:34:25.150468Z","iopub.status.idle":"2025-06-12T14:34:27.738281Z","shell.execute_reply.started":"2025-06-12T14:34:25.150449Z","shell.execute_reply":"2025-06-12T14:34:27.737550Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"While not really important for seeing the performance of the model, somethimes it's fun to see what the model is actually predicting. As seen in the plot above, the model is performing the worst on either cats and dogs, which it often confuses. The same goes for other animals, like the frog - cat, or deer-frog (maybe due to a green background? no idea). it is luckily able to differentiate quite easily between animals and vehicles.","metadata":{}},{"cell_type":"markdown","source":"# How to improve","metadata":{}},{"cell_type":"markdown","source":"While this is working.. fine.. it can for sure be improved. 83% definetly isn't bad, but the current model is most likely not complex enough, which causes it to not be able to learn all patterns correctly. Because of this, the next approach will be to try different layers and make the network a bit deeper to see what happends.\n\n- **Batch normalization**: `BatchNormalization()`\nWhy use batch normalization, the simplest answer: it speeds up convergence. A more detailed answer is that it makes training faster by adjusting the inputs to each layer. Each layer in a neural network has inputs that follow a specific distribution, which shift and change during training. These shifts affect the input to the models inner/hidden layers (and thus happends more in deeper network), which is called internal covariate shift. While there isn't really a strict definition, it changes the means and variances of the inputs during training.([source](https://en.wikipedia.org/wiki/Batch_normalization)). Other then that, it also allows the network to use higher learning rate without causing issues like vanishing or exploding gradients.","metadata":{}},{"cell_type":"code","source":"model_2 = Sequential([\n    Input(shape=(32, 32, 3)),\n    \n    Conv2D(32, 3, padding='same', use_bias=False),\n    BatchNormalization(),\n    ReLU(),\n    Conv2D(32, 3, padding='same', use_bias=False),\n    BatchNormalization(),\n    ReLU(),\n    MaxPooling2D(),\n    \n    Conv2D(64, 3, padding='same', use_bias=False),\n    BatchNormalization(),\n    ReLU(),\n    Conv2D(64, 3, padding='same', use_bias=False),\n    BatchNormalization(),\n    ReLU(),\n    MaxPooling2D(),\n\n    Conv2D(128, 3, padding='same', use_bias=False),\n    BatchNormalization(),\n    ReLU(),\n    Conv2D(128, 3, padding='same', use_bias=False),\n    BatchNormalization(),\n    ReLU(),\n    MaxPooling2D(),\n\n\n    Flatten(),\n    Dense(256, activation='relu'),\n    Dropout(0.4),\n    \n    Dense(10, activation='softmax')\n])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:34:27.739185Z","iopub.execute_input":"2025-06-12T14:34:27.739644Z","iopub.status.idle":"2025-06-12T14:34:28.219984Z","shell.execute_reply.started":"2025-06-12T14:34:27.739624Z","shell.execute_reply":"2025-06-12T14:34:28.219446Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\nlr_scheduler = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-5)\nloss = CategoricalCrossentropy(from_logits=False)\noptimizer = Adam(learning_rate=1e-3)\n\nmodel_2.compile(\n    optimizer=optimizer,\n    loss=loss,\n    metrics=['accuracy']\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:34:28.220749Z","iopub.execute_input":"2025-06-12T14:34:28.221009Z","iopub.status.idle":"2025-06-12T14:34:28.229661Z","shell.execute_reply.started":"2025-06-12T14:34:28.220985Z","shell.execute_reply":"2025-06-12T14:34:28.229141Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"history = model_2.fit(\n    train_generator,\n    steps_per_epoch=len(x_train) // 64,\n    validation_data=(x_test, y_test),\n    epochs=1, \n    callbacks=[lr_scheduler, early_stopping]\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:34:28.230419Z","iopub.execute_input":"2025-06-12T14:34:28.230700Z","iopub.status.idle":"2025-06-12T14:35:07.295204Z","shell.execute_reply.started":"2025-06-12T14:34:28.230683Z","shell.execute_reply":"2025-06-12T14:35:07.294425Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"gets accuracy of 86% after 50 epochs, just make sure to change it to the correct number of epochs if you want to check","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# Accuracy\nplt.plot(history.history['accuracy'], label='Train Accuracy')\nplt.plot(history.history['val_accuracy'], label='Validation Accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.title('Accuracy Over Epochs')\nplt.legend()\nplt.grid(True)\nplt.show()\n\n# Loss\nplt.plot(history.history['loss'], label='Train Loss')\nplt.plot(history.history['val_loss'], label='Validation Loss')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.title('Loss Over Epochs')\nplt.legend()\nplt.grid(True)\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:35:07.296236Z","iopub.execute_input":"2025-06-12T14:35:07.296494Z","iopub.status.idle":"2025-06-12T14:35:07.601376Z","shell.execute_reply.started":"2025-06-12T14:35:07.296462Z","shell.execute_reply":"2025-06-12T14:35:07.600541Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.metrics import confusion_matrix\nimport seaborn as sns\nclasses = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n           'dog', 'frog', 'horse', 'ship', 'truck']\n\ny_pred_probs = model_2.predict(x_test)\ny_pred = np.argmax(y_pred_probs, axis=1)\ny_true = np.argmax(y_test, axis=1)\n\n# Compute confusion matrix\ncm = confusion_matrix(y_true, y_pred)\n\n# Plot heatmap\nplt.figure(figsize=(10, 8))\nsns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes)\nplt.xlabel('Predicted')\nplt.ylabel('Actual')\nplt.title('Confusion Matrix')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:35:07.602442Z","iopub.execute_input":"2025-06-12T14:35:07.603079Z","iopub.status.idle":"2025-06-12T14:35:10.343814Z","shell.execute_reply.started":"2025-06-12T14:35:07.603052Z","shell.execute_reply":"2025-06-12T14:35:10.343154Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Using batch normalization and a deeper model seemed to increase the accuracy of the model slightly from 83% to 86%. While not a huge improvent, it does indicate that choosing the architecture of the model has an effect on the performance. Eventhough the model is performing better, it still has difficulties differentiating between cats and dogs, funny. So, is the sollution just adding more layers, making the model deeper and deeper until you have the perfect model? Yes, and no, which will be explained in a bit. But to first test it out, a much deeper model has been used with 8 convolutional layers.","metadata":{}},{"cell_type":"code","source":"model_3 = Sequential([\n    Conv2D(64,(4,4),input_shape=(32,32,3),activation='relu',padding='same'), \n    BatchNormalization(),\n\n    Conv2D(64,(4,4),input_shape=(32,32,3),activation='relu',padding='same'),\n    BatchNormalization(),\n    MaxPooling2D(pool_size=(2,2)),\n    Dropout(0.2),\n\n    Conv2D(128,(4,4),input_shape=(32,32,3),activation='relu',padding='same'), \n    BatchNormalization(),\n\n    Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'),\n    BatchNormalization(),\n    MaxPooling2D(pool_size=(2,2)),\n    Dropout(0.25),\n\n    Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'), \n    BatchNormalization(),\n\n    Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'),\n    BatchNormalization(),\n    MaxPooling2D(pool_size=(2,2)),\n    Dropout(0.35),\n\n    Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'), \n    BatchNormalization(),\n\n    Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'),\n    BatchNormalization(),\n    MaxPooling2D(pool_size=(2,2)),\n    Dropout(0.45),\n\n    Flatten(),\n    Dense(256, activation='relu'),\n    BatchNormalization(),\n    Dropout(0.5),\n    Dense(10, activation='softmax')\n])\n\n# model_3 = Sequential()\n# model_3.add(Conv2D(64,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n\n# model_3.add(Conv2D(64,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n# model_3.add(MaxPooling2D(pool_size=(2,2)))\n# model_3.add(Dropout(0.2))\n\n# model_3.add(Conv2D(128,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n\n# model_3.add(Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n# model_3.add(MaxPooling2D(pool_size=(2,2)))\n# model_3.add(Dropout(0.25))\n\n# model_3.add(Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n\n# model_3.add(Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n# model_3.add(MaxPooling2D(pool_size=(2,2)))\n# model_3.add(Dropout(0.35))\n\n# model_3.add(Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n\n# model_3.add(Conv2D(256,(4,4),input_shape=(32,32,3),activation='relu',padding='same'))\n# model_3.add(BatchNormalization())\n# model_3.add(MaxPooling2D(pool_size=(2,2)))\n# model_3.add(Dropout(0.45))\n\n# model_3.add(Flatten())\n# model_3.add(Dense(256, activation='relu'))\n# model_3.add(BatchNormalization())\n# model_3.add(Dropout(0.5))\n# model_3.add(Dense(10, activation='softmax'))\nmodel_3.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:35:10.345490Z","iopub.execute_input":"2025-06-12T14:35:10.345705Z","iopub.status.idle":"2025-06-12T14:35:10.509728Z","shell.execute_reply.started":"2025-06-12T14:35:10.345688Z","shell.execute_reply":"2025-06-12T14:35:10.508827Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)\nlr_scheduler = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-5)\nloss = CategoricalCrossentropy(from_logits=False)\noptimizer = Adam(learning_rate=1e-3)\n\nmodel_3.compile(\n    optimizer=optimizer,\n    loss=loss,\n    metrics=['accuracy']\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:35:10.510651Z","iopub.execute_input":"2025-06-12T14:35:10.511410Z","iopub.status.idle":"2025-06-12T14:35:10.519845Z","shell.execute_reply.started":"2025-06-12T14:35:10.511384Z","shell.execute_reply":"2025-06-12T14:35:10.519149Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"history = model_3.fit(\n    train_generator,\n    steps_per_epoch=len(x_train) // 64,\n    validation_data=(x_test, y_test),\n    epochs=50, \n    callbacks=[lr_scheduler, early_stopping]\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:35:10.520679Z","iopub.execute_input":"2025-06-12T14:35:10.521066Z","iopub.status.idle":"2025-06-12T14:48:28.448607Z","shell.execute_reply.started":"2025-06-12T14:35:10.521042Z","shell.execute_reply":"2025-06-12T14:48:28.448016Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"plt.plot(history.history['accuracy'], label='Train Accuracy')\nplt.plot(history.history['val_accuracy'], label='Validation Accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.title('Accuracy Over Epochs')\nplt.legend()\nplt.grid(True)\nplt.show()\n\n# Loss\nplt.plot(history.history['loss'], label='Train Loss')\nplt.plot(history.history['val_loss'], label='Validation Loss')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.title('Loss Over Epochs')\nplt.legend()\nplt.grid(True)\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:49:13.629867Z","iopub.execute_input":"2025-06-12T14:49:13.630179Z","iopub.status.idle":"2025-06-12T14:49:13.942153Z","shell.execute_reply.started":"2025-06-12T14:49:13.630143Z","shell.execute_reply":"2025-06-12T14:49:13.941401Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"y_pred_probs = model_3.predict(x_test)\ny_pred = np.argmax(y_pred_probs, axis=1)\ny_true = np.argmax(y_test, axis=1)\n\ncm = confusion_matrix(y_true, y_pred)\n\nplt.figure(figsize=(10, 8))\nsns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes)\nplt.xlabel('Predicted')\nplt.ylabel('Actual')\nplt.title('Confusion Matrix')\nplt.show()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:49:18.766097Z","iopub.execute_input":"2025-06-12T14:49:18.766812Z","iopub.status.idle":"2025-06-12T14:49:21.674377Z","shell.execute_reply.started":"2025-06-12T14:49:18.766789Z","shell.execute_reply":"2025-06-12T14:49:21.673635Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"So making the model even deeper did seem to help. This improved the results from 86% to 91% (and yes, still struggeling with seeing the differences between dogs and cats). While just making the model infinely deeper sounds like a way to make good models, this comes with it's own issues that have to be dealt with:\n1. diminishing returns:\nAdding more layers will, after a certain point, give less and less improvement, especially if the current model is already doing well. In this case, its more important to find the right balance between training speed and model performance.\n2. Vanishing and exploding gradients:\nIn very deep networks, the gradients can become either very small (vanish) or very large (explode). When the layers vanish, the early layers stop learning as the weights become 0. It can be solved by using BatchNormalization or ReLU as activation function, but it's still something to remember.\n3. If the model is too deep and has too many parameters, it might also predict noise and overfit. To solve this, dropout and data augmentation can help.","metadata":{}},{"cell_type":"markdown","source":"# weird predictions\n\nIt's always fun to see where the model went wrong. Especially since in some cases, i also cannot tell for certain what it should be. ","metadata":{}},{"cell_type":"code","source":"class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n               'dog', 'frog', 'horse', 'ship', 'truck']\n\ny_pred_probs = model_3.predict(x_test)\ny_pred_classes = np.argmax(y_pred_probs, axis=1)\ny_true = np.argmax(y_test, axis=1)\n\nwrong_indices = np.where(y_pred_classes != y_true)[0]\nnp.random.shuffle(wrong_indices)\nwrong_images = wrong_indices[:6]\n\n# Function to invert normalization, for visualisation purposes\ndef invert_normalization(img):\n    img = img * std + mean\n    img = np.clip(img, 0, 1)\n    return img\n\nplt.figure(figsize=(10, 6))\nfor i, idx in enumerate(wrong_images):\n    img = invert_normalization(x_test[idx])\n    plt.subplot(2, 3, i+1)\n    plt.imshow(img)\n    # plt.title(f\"Predicted: {class_names[y_pred_classes[idx]]}\\nTrue: {class_names[y_true[idx]]}\")\n    plt.title(f\"True: {class_names[y_true[idx]]}\\nPredicted: {class_names[y_pred_classes[idx]]}\")\n    plt.axis('off')\nplt.tight_layout()\nplt.show()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:49:28.024055Z","iopub.execute_input":"2025-06-12T14:49:28.024799Z","iopub.status.idle":"2025-06-12T14:49:31.425239Z","shell.execute_reply.started":"2025-06-12T14:49:28.024774Z","shell.execute_reply":"2025-06-12T14:49:31.424567Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# honerable mentions of weird pictures:\n\n![image.png](attachment:3ae77c84-8abb-4cb5-8a84-8f04b12c43a8.png)\n![image.png](attachment:e3930c77-cc0c-48fc-a84f-414a839252e5.png)\n![image.png](attachment:0752fa5b-9953-4aa0-8c7b-d3312699dcfd.png)\n![image.png](attachment:04feef91-8788-49be-97b3-a41e394aac7f.png)\n","metadata":{},"attachments":{"0752fa5b-9953-4aa0-8c7b-d3312699dcfd.png":{"image/png":"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"},"04feef91-8788-49be-97b3-a41e394aac7f.png":{"image/png":"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"},"3ae77c84-8abb-4cb5-8a84-8f04b12c43a8.png":{"image/png":"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"},"f7c6d74b-b4f8-4832-87de-bd3da19a3911.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAmYAAAFICAYAAAD6YjJRAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAADxESURBVHhe7d0HnFxnfe//MzM7u7O9N7XVSpa0kotsSW4yxg2wjePYGHCh2NxAQrkQmh3ahTiQXFogBuf+/4QEU/K/kD/FkJhqMNhxwZa71bu0Xdv7zuzszNx9zv5EJPY8z2/CJfis/Xn7JfjOzmjKmTPP/GY0+51Ibo4HAACA511U/h8AAADPMwYzAACAkGAwwx/E/fff70UiEW9kZER+AgAwWB9xIgazRco8iF1/br/9djklALy4BK2JJ/5hfUSYMZgtUj09Pb/5c8cdd3gVFRUn/ezWW2+VU3qe+f2O2dlZOQQAL2wnroWsj1hsGMwWqaampt/8qays9F8FHj+8Z88er7y83PvJT37ibd682SsqKvIeeugh701vepN37bXXyjnMe8973uNdfPHFcsjzstms98lPftJrbW31iouLvY0bN3rf/e535dj8/fjHP/bWrl3rn8cll1ziHTlyRI75D9/73ve8U0891b9+K1eu9D73uc/JMfPMAnrVVVf552Guzze/+U3/dGahBQAb1kcsZgxmL2Af/OAHvU996lPe7t27vTPOOEN+6mYWnW984xvel770JW/nzp3ee9/7Xu8Nb3iD98ADD8gpPP/B7/qngI6ODu+6667zrr76au+ZZ57x3vKWt/jX5URPPvmkd/3113s33nijt337dv/8PvrRj3pf+9rX5BSed/PNN3vd3d3+5y/MIvXlL3/Z6+vrk2MB4HfH+ojQMj1mWNy++tWv5uZeFcqhXO5Xv/qV6abL/eAHP5CfzLvlllty11xzjRya9+53vzt30UUX+TmZTOZKSkpyjzzyiH/4uDe/+c25m266SQ7lcpdeemnuzjvvlEMLfehDH8pt2LBBDs37wAc+4F+n4eFh//DrXve63Mtf/nI/H3fbbbf95u/NLZb+6R9//HH/sLF//37/Z3/3d38nPwEAN9ZHLDa8Y/YCtmXLFkn5OXDggDc1NeXNLQheWVnZb/6YV4gHDx6UU3nefffd573zne+UQwuZV6DnnnuuHJp3/vnnS5pnTnPBBRfIoXnm8Nzi4mUyGW/v3r1eQUGBt2nTJjnW80455RSvurpaDgHA7471EWHFYPYCVlpaKmleNBr1P+h6onQ6LcnzJiYm/P//0Y9+5L/FfvzPrl27fqfPUQBAWLE+IqwYzF5E6uvr/Q+MnsgsLMdt2LDB/6Bpe3u7/+rrxD/Lly+XU+nWr1/vbdu2TQ7Ne/TRRyXNM6d5+OGH5dA8c9h8IDYWi3nr1q3zf1Pq6aeflmPnX7EODw/LIQD4/WF9RFgwmL2IXHrppd4TTzzhv/Vu3hL/y7/8S2/Hjh1yrOf/ppL5NXLzgdavf/3r/tvzTz31lHfnnXf6h4+77LLLvL//+7+XQwu97W1v88//tttu899yN78tdOKHVo33v//9/lv+n/jEJ7x9+/b552/O8/ivsbe1tXkve9nLvD/7sz/zFzGzAJlsfgPJ/IYVAPw+sT4iNPxPmmFRs3249fgHSU/0sY99LNfY2Oiffm6Byb3zne/8zYdbjWw2m7vjjjtyc6/IcvF4PDf3KjJ3+eWX5x544AE5RS7X0tKSm1u05FCwe+65Jzf3SjI39wozd+GFF+buuuuuBdfpu9/9rv9hVnM5K1asyH32s5+VY+Z1d3fnrrzySv88zGXOLWC5hoaG3Je+9CU5BQC4sT5isYmY/5nbIYDQ6+zs9P/J4Be/+IX/qhQAMI/18YWDwQyh9ctf/tL/wO3pp5/uf/bjL/7iL7yuri7/rf25V5FyKgB48WF9fOHiM2YILfMbUR/+8If99utXvepV/odzTZkiiw6AFzvWxxcu3jEDAAAICd4xAwAACAkGMwAAgJBgMHuBe9Ob3uRde+21csjzLr74Yu8973mPHPrDMZ99MP06IyMj8pP8/OAHP/ALHE2p4vNxvQG8MLE2IqwYzJ4HZkEwD0Tzp7Cw0H9wffzjH/ebnP+r3X333X5pYT5+1wXj9+mtb32r95rXvMbr6OjI+3oDWJxYG/PH2vjCxWD2PLniiiv8X3E2DdCm5fn222/3PvvZz8qxJ5uZmZH0f6+mpsZvsF4MzK+C9/X1eZdffrm3ZMmSwOttvtA3m83KIQCLHWujjrXxhY3B7HlivnOtqanJa2lp8d7+9rf7X6/xb//2b/5xx99i/5u/+Rv/QWe+F80wr4yuv/56r6qqyl9ErrnmGu/IkSP+cYZ5IL7vfe/zj6+trfV7bX77l25/++36VCrlfeADH/CLCc11Mq9Qv/KVr/jne8kll/inqa6u9l8dmutlmAf7Jz/5Sa+1tdX/CpCNGzcu+BLfH//4x/73upnjzfmceD3zYV6RHl9szFelmMs3PzNfXWJun9lWJ353nfmOuJtvvtm/riUlJd6VV17pL+wn+sd//Ef/dprjza+Xf/7zn/fPC0B4sDa6sTa+8DGYhYR5kJ746s98T5r5HrWf//zn3g9/+EO/s8a8OjIPyAcffND/QtuysjL/1eXxv/e5z33Of3Dedddd3kMPPeQNDQ153//+9/3jbMwD9lvf+pb3xS9+0du9e7f3D//wD/75mgfp9773Pf805nqYV7Bf+MIX/MNm4THfJ/elL33J27lzp//dcW94wxu8Bx54wD/eLJLXXXedd/XVV/tfAvyWt7zF++AHP+gfdyKzoPz2d8Qdt3XrVv9yDXM9zOWbnxlTU1Pepz/9ae+f/umf/MtvaGjwF0bzPXdmUfr1r3/tL7qvfOUr/e1mmO1lvqPu3e9+t3+dXv7yl/uLO4BwY208GWvji8DcnYQ/sFtuuSU394rOz+a71+YWGP/7zm699Vb/Z+Z4831tc6/Y/MPGP//zP/vfz2ZOf5w5fm7Ryv3sZz/zDzc3N+c+85nP+NmYe+Dlli1b9pvLMsz3vs09AP089+A2Lxn9yw8S9J1yyWQyN/eqKvfII4/IT+a9+c1vzt10001+/tCHPuR/x9uJ5l55Ljgvc3vuvvtuObSQOa35O+Z6HGe+9878bG4BkZ/kcvv27fN/NrfAyE9yuYGBAX/bfPvb3/YP33DDDbmrrrrKz8e9/vWvP+k79AA8v1gb57E2vrjxjtnzxLzSM6++EomE/9by3IPD/yzFceZrNsyHX4979tlnvQMHDvivCs3fM3/MW/Zzi4F38OBBb3R01H/ldO6558rf8LyCggJvy5Ytcmgh8+rI/EbP3IIkP9GZ62BelZlXVcevh/ljXiWa62GYV5cnXg/j/PPPl/Qf9uzZ479t/p9ltssZZ5whh+Yvz9zWEy/T/HOF+WcOc5xhXmGec845fj7utw8DeP6xNrI2vtgxmD1PzGcLzIPf/Fv/9PS09/Wvf90rLS2VY72TsmE+7Ll582b/75z4x3wv2ute9zo51X+O+SeC/yxzPYwf/ehHJ12PXbt2LfgsxX8Vc73NW/0AXnhYG393rI0vDAxmzxOzuJgPk65YscJ/RaPZtGmTv1CZzwyYv3fin8rKSv9Pc3Oz99hjj8nf8PxfMX/yySfl0ELmlaf5sOrxzz/8tuOvSs0HZ4878UOlv309zGcvjPXr13vbtm3z83GPPvqopN8/c3nmtp542wcHB/1Xgub6GuYV4uOPP+7n4377MIDnH2vj7w9r4+LEYLZIvP71r/fq6ur83zYyH3A9fPiw/5s4f/7nf+51dnb6pzEf3vzUpz7lFw+at8Lf8Y53OHt2Vq5c6d1yyy3en/zJn/h/5/h5fvvb3/aPN78VZV59mX9a6O/v918Rmn8uuPXWW/0PtZpXsuYt+qeeesq78847/cOG+SCpWShvu+02fwH45je/GfhB1ra2NvUDuPlYs2aNv13+9E//1P9gr/mnDfOB26VLl/o/N971rnf5vw1lftvIXDfzQd6f/OQnvLoEFjnWRjvWxkVKPmuGP6ATP+AaxHZ8T09P7uabb87NLUL+B2JXrVqVm3vA5UZHR/3jzQdazYdXKyoqclVVVbn3ve99/ulPPK8TP+BqTE9P5+YWEv/DsXOvAnNzr+5yd911lxyby3384x/PNTU15eYepP71MsyHbO+44w7/A6rxeDxXX1+fu/zyy3Nzry7944177rnHPy9zPS+88EL/PM3uduIHXM1h84FVG9sHXIM+lDo0NJR74xvf6B9nPthqro/54OuJvvzlL+fmFiT/+GuvvTb313/91/5tAxAOrI3zWBtf3CLmf+buYOBFx7yKNK+ezatsAMA81sbnF/+UiReNv/3bv/3Nb3Ad/+eFuVe6ciwAvDixNoYL75jhRcM0g5vPiYyPj3urVq3yP1thPvMBAC9mrI3hwmAGAAAQEvxTJgAAQEgwmAEAAIQEgxkAAEBILPiM2R/98cWS7MpKqyUFq6uvlWS3Z+8OSXZjo/YCQOPSC/XrWl+pf7VGrMB9OXsPHpBkV17dKsluaCopyS424z7NBRvWS7Ib722XZDc5NiApWKSkSpJdYdMpkuwmvRJJwTr7ByXZzUzPf9WJS0NJTFKw1GiHJLt4jQSHvqNDkoJ1PXNEkl1hYkqS3fS4BIfzr3J/3Ux06RJJdr3txyTZrVm+QlKwpcv0ff+mG6+XtLi96cqVkuwKlJe7leX6mlRTefLXDgVJJIokBSstLZNkFy/Um/UTif/4XsogiSK9iLSiPCHJLpqZkWSXKHNvu7Ja/blnJjstyS455T7NYJd7/TRmZ/XbU1Hrfi6dmsxKshuf0i9nYtp9H/V0jUqye3a/fpufOuh+Lp1O6R9pj0Z/P+8XReb+c8lk9W2bz0fwtX0lk/2Pb4ewSU6OSZrHO2YAAAAhwWAGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgsKZi+5bLMku+3b90kKtq5NLx5tbCiXZFdX4y5Z7DjaJcmuKO4uODXOPvdUScEmpvVi2P4BveRvcnpYkt0S5TZvaNJbUGPjeZQfjvVLCnb4WJ8ku+GoXoIZrWqRFKykVi8nXblirSS7upIKScEmR3sl2U3N6sW8o0fdxcjxPncBrTFwTL8ue9vz2FfOcxcsd+rdiN7kuF6yWFPuLhuub1wmye7/+dwXJS1ur71Iv61VZXFJwWoq9DWpvEIvh61VirxLStwFtL48CjTjcXcJbTSrr31l+RTMZmcl2SXH3UWokTzKScsbmyTZZbLu7ZKd0UuiM3kUzBYUue+jSETfbtMTk5LsRlPux/nQoF66Oz2ql9A+fdi9XZ44qF/XyWRakl0eS5un3IVeTjvBnNkZ/T6cSbrng4jy+DGmx05e73nHDAAAICQYzAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBjMAAAAQoLBDAAAICQW9Ji9/qYrJdn1j7q7Sgr02g5v5VJ375RRVuruGdmx64Aku7379D6ullNWSgq2ZKnee9NxVL+c2iq9v+ii8zdKCpbq17vb4pODkuxaa93b/4lHHpVklyvSu5Yu/KPXSgpW1ax3lEUyepdP3HNv27KaBkl2fUOHJNkN739QUrDEcLcku+ee2SPJ7sk89qfGredKCla54TRJdkcOH5NkV6V0xBXn0bn1yY98TtLi9uqXLpVk11Dl3l9rK/X+v8amekl21dWVkoJl0noHUzqtd0Zpr99j0Ygku0xG74Kcmda7tCbGlB6s2ZQEu3ql/80orXT3bMbi+nsa8TxOU1BUKClYYUJ/bMUyehfh6Ii7g+xQ75gkuzzqxbzZXExSsPue0Z+bDnTpXWfpWb3zbjaTkRQsO+M+3khO6X11uZx7+8eUrjpjauTk7lHeMQMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQWFAw+4H3/zdJdsMpd/Frf59egpoeb5dk17qiRlKwgVG98W7nfnexnlGhFA6WlrtL84yZKf26lBa4ywSN0oS7nbe2NC7Jrr5QL3ysibln8u3//rAku/r6Okl2V9xwnaRgBaXuIkcjm9SLAKtKqiQFq2holWQXjekFwP17H5EUbPiIXsz76JM7JNntHdZLIze/9jWSgvVG9P1gsHdYkt3SGvf9PDgxJMnui5/6hqTF7bUXLZNk11Dlfpw31ldLsmtdqV9OQdy9VgwPjkiyi8b0faSi1n19C+N6geZgt/6c0Nt9cslmkN7+CUkW+s3xmqv1NXTNaneRcHGpvlYUFOlN6wWF7n0llse2jUXcz8dGatS9Lxzs1Itf+7P6bV7R6F6Hf3y/XuL94PZ+SXaz+k32ZtPuEtrfVwFzLOaeD6LKfWxMDp98m3nHDAAAICQYzAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBjMAAAAQoLBDAAAICQYzAAAAEJiQcHsq6++WJLds/v2Swr20pecJcluZYNe8pfzkpKCPbe/T5LdscE8ClmXusscO3sPSLJrVEpqjeyU3or3yCOPSQq2Ymm9JLu1S5sk2Y22d0gKFh3Ri0dbmvXbvPVlZ0sKVlmXkGQXy6Qk2ZXG3edT26gXzCYKmiXZ9R/eLSlYT8c2SXbbj+jlymNF7oJLo3TNqZKC7enukWTXUKmXna5vcV+XR5/Sb/O3/rdeWLwYvPal+v1SV+EulFza6C7ONpoa9fLmiaT7cZEoK5Vk15DH5VRUVUgKFvf0MuSJIX096e3Wi4p3HeiWFGxwZFySXXOl/pywcf0KScFKSvMofi3WL6co4S5tzeXRpJqL6q2602Pu7dLRoRfMduqb1quuc68n9z96WJLdY3v165LJ6rc5k9EKZvXnlWxW3/6xuPt+jhboBfUTwyeXK/OOGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACEBIMZAABASDCYAQAAhASDGQAAQEgs6DH7yK3vlGTX1evuYTp38zpJdrXF7o4R40hfl6Rg37n3UUl27QfHJNk1N7s7rqZmpyXZVdWVSbLLTKcl2e3bt09SsJpavQMppvS3GPHUjKRgpelJSXbLq/QOsnPOdu8LLSvcnU/G9FivJLto1N0HtHLdFkl2dWXLJdn1drr3/aFkvyS7o6N6f07HtP6aaVS5m5sblkiya66tkmSXS49ICjYyoRccfeKT35O0uP3xufn0mLk7rlYt1x/DVdX6elJY6t7ni8rcxxuxiL6fxSLux/lUWu/0mpqYkuSQ0U/ToXSd9fQck2S3slFft9a0NkgKlsvo3W2lZfraVlRcIClYetrd5WkUKl1oRtZzd2kdbNe7wx7efnLXVpBBZVEaHtfXiu5BfX2ccj99+WYz7ufbzKz+fByL6h1ksUL3/ZzLZSTZTY2dvMbyjhkAAEBIMJgBAACEBIMZAABASDCYAQAAhASDGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACExIKC2e9/958l2aVm3IWrO57+tSS7szeukWQ3rRSlbtu+W5LdQ/c/JMkunT5pEyxwuMNdamgUFeuFkDVlEUl2VVXFkoIlSssl2aWm9YK+xup6ScG6D7uLVI3U6LAku9NWNUoKtqFVL/BLj3RIsisvdRdCFtSslmRXWeneJkZlrbvMMVajF7aO5dzbxHj4OXfRsJFMu8snm+v0y1nWVCfJbmSoW1KwnL5bex/+yP+StLi9fKO+j1SVuAsnmxv0x3Bxub6eTKbdG76rR398JqqaJdlNJJUizhm97bM4oZfQ5nJ64WdauajsrF7I2lQtwWH10gpJwcpL9JLa5uY8Lijjvr5jo+5yZ6OoyP2cYeQ8974yMKY/Zzy2S38eHBt3l6mOj+mF7wNj+n04kdQLfsen3ddlKuV+3vfF9OenSNS9bWNxfYEcGzp52/KOGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACEBIMZAABASDCYAQAAhASDGQAAQEgwmAEAAITEgoLZv/3c7ZLsykrc5YcH9unFr40N7gI/I5Vyl94dOnRQkl16ZkCS3ZhSenfwyIQku/GJAkl2S+v0ormmplJJwdKzerFevFAvHCwpcZcfTif1mX37s3sk2WVH+iQFu+isSkl2DYXuQmMjm3Rv/6eO6AWKJTW1kuyufM1LJQU7NKwXQtauuEiSXWl5kyS7wrh7X3jumaclOWTdJc7GJRddKClYT0+XJLt3vv02SYvbVZv1+6Ws2F0wW12ll5NW1er7Yle/u4jzYMekJLs1Z54jyS45fFiSxcyoBLuOcb14uSirF5hG0u7HcaxAL7KtLnffP0adcnXPaFsqya6pXi8Jzqbda9vIsL5tYwX6c08u4y5bTc/q5b7DUxIcth12NwD3trufD4yZpH5BMyn37TFSyk1KpvXzGNM3i5dSnpJLyvTn477uXknzeMcMAAAgJBjMAAAAQoLBDAAAICQYzAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBb0mN14wxWS7CrL3N1TS5Y0SrLrPKZ048xJFLk7afp7Tu7+CFJarPc0DQ0NSwqWTOt9NIePurvQjPJid8eL0VDrvs2FsZPurkDRWFySXSrtPs2RDr1TqLdL74grybm7lrae7u5tM9Y06j0wxTF3L94T+/TbU1K3RJLdxgvPkBTs8QP7JNnVLNkkya66coUkuzWt7tP88lc/l2QXL4hJsjt1g/s2j0/q+/5ffeSvJC1uf3y23mPWWONeL1pb6iTZ1TXo/X7Ts+7X1QcO6516A9P6Y2tQWR8LPb0vLRUpkWSndXoZkbS7C7Iornd61VXpPWYFnrvA6vT1+n6wfIne1Tk7635OSM/oz19eXH8MR+Pu9X5i2H0fG6k8OjQ7R9zXt+OofjntnXp3W0orKZtz8mSz0Oys3mM2kdRPM51175ORhL7vd3Z0S5rHO2YAAAAhwWAGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgsKZu/8/Mck2U2PTUgKVlGtF6p1DR2VZDcy5i6aqy6vlWR3aN8BSXZTk+6SvyOdg5Ls9h/Wy24TxXr5YbFSINtco5cjRpXCOyM54y4ljGT0Itt4Vi/fKytyn2ZVi35da8v11w8bN2yWFKysSi+PTUf04s8Hn3lOUrD+lL6vNK5YKcmut1cvllzduk5SsOHRPkl2ratWSbLrP6YUPsb0++eTH/+0pMXtxpfqxb81Ze4yz9oqd4m0UddQLcmuoqpcUrCiIr3gdHBav+92HXTv0909epFt1tPXk8kxvai2IuHetivr9cLceFQvstXKVFcu1QuAG/MoCS4oSkgKFs2jPDZRqj/fRovczxujI/p9ODbqft73KVf34CF9fXzsqS5JdhPj+n0YV7ZdNo/nuOS0/hyXVM4mGdMf7x2dJ88PvGMGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgxmAAAAIbGgYPaLn36bJLuNG9okBctF3aV5xr/8692S7KbSKUnBhgb0wrv9Bzok2dXWNkgKNjWuFGzOSU6PS7JLZd3liEY07S7FS+T0y2lp1gsHq8vdZaptq1ol2eUy7vvH2PbUTknBJqf0+7C0UC9b3XrOGknBrrjiKkl2vaP6dvu7f/qWpGB943rRcNtpyyTZ1dSdIslu05kvlRSsurxUkkNOLz0eGExKCta4XC/vfdU110pa3N7yytWS7KqK3Y/z4jxKQ6NRvfyyssZdMFvXoBcmV9fqp0ll3CXQhw4dk2TX2zcsySGnl02XJ9zvJZR4aUl2U0l3obhRWO5+DlvSUCXJrqhQX+8LE+7LiSuFuoa+p8xdlwp32W1BkV6C2n1EL4XvOzYgKdjUlHstMdp79eeE7l79eXB03H0/p5J6eWxqRj/NjLuL2Jv29Puwo6df0jzeMQMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQWFAw+4mP/ZEku/Wr3eWjVeWrJNmlMnqZ56H2A5KCfe8Heknt+KxeWnhsYERSsIbyQkl261fqRY3TKb0K8FjHlKRgsZlBSXbnba6RZLeirl5SsPLiakl2h7v1MtUf/mK3pGCdPXrZY1O5/vrhJedUSAp29taNkuxmilok2X37p09LCrbzoF7C2NysF782NC6XZHfN1a+RFGzzhg2S7GZSennvxLT7NEd6uyTZvfWtfy5pcXv3DadLsqsrdZd1Jor0/Xkm6V4HjESRe10qLSuWZFdcoq/DFTXuAu5cWmnYnBOJ6Lc5m9XLPGOZaUnB+rr7JNkd7tYLw5etbJIUrKJELw2NxfTnjZm0+7GVyerrY7xQL4lOK+/BlFS610+jMKY/l06Mugtk+weGJNmNT+jlsROT+rrV0TspKVh3n15kO5VHCW1SaZidyOr3TzsFswAAAOHEYAYAABASDGYAAAAhwWAGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACGxoMfswx95pSS78sKEpGAFM7WS7LZsukiSXTI9ICnYoc49kuye2HVEkt3OAx2SgsUyepdMcc7d32LEUvr5JKIxScHWtup9MxXFY5LsCiPufpbCiN6BNDCs3+Ynd7jvw7FRvQ9oeaPetbRmpbtjZ8OpqyXZxWrWS7L70aPunrKuYXfPkjE8qnctZWf0bXta21pJwU5ZtUyS3amn6l1nraeskxTsyZ07Jdm9/a0fk7S4/ffrT5Nk19Lk7gCsrtL350RBHq+Z02kJwTIzKUl2yWl9P4vG3I/RqqpKSXaFhXn0fhW6+9+MmNKl1Xm0W5LdwJD+GF221H0fpvPYbpNpvfcrG3GfpkivwDLP4hLsJqfc+0JqVu8FKy7W75+KCvfzU2GZvq9MT+rbdnBA7/McHnX3oQ2O6o+PjmN619nwmPt5fXBS7/k73H3y7eEdMwAAgJBgMAMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAiJBQWzb3vXxZLsBnv6JQVbt3yTJLvzzjpfkt3KFndZ3chkryS7nz78rCS7+x95WlKwzIxeDBtLusvsjIaoXmh31qnuUtD6Or1xcGLMff8Y0xPu61ugFNAa8SK9NLKzZ0qSRaZOgt0ZG9xFqkY0Nyop2MoVZ0myq129RZLd091DkoLt7nIX0Bp7Drj3N2Nls17EONDdKSlYb/+wJLsbb/oTSXabznSvCb96aJsku/e9739IWtxufuUpkuyWN7jvu8baUkl2leV6wXOh8rI6l8e6lZrWy1Zn0u7y0eKyMkl2xaV5lOqW6Lc5EnGvfyNDI5LsIln9/Yh41L3+DQ251xtjOqevj4Ul7u0Sd/eN+zKzeoGpViSsn8Pcdovp262gsFBSsFn9acWLRfXtVpDHdUkl3bd5bELf9zuPudd741Cne1842qcX5h7sOXmt5h0zAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACIkFBbP/89N64WREGee6DukFp4nISRcb6JzN6yQFixe5y+yMB5/aK8nu3vselRRsOI+SuVNb6iXZndOqlyxWV05ICpaezaM0clIvahwccF9OzhuTZLeytUaSXWVlg6RgZYkWSXarVq6RZBdVCiHLK/Vi0OmEfnt+9vRTkoId6muXZFffpBeMnnWKvl1Ghtz75fd/ep8ku+raFZLsLnrJH0kK1nfMvS8ZH/7ghyUtbtdfpt8v1Uo5bH2Vvm5VlemnqShzX040p9eGJvJYQzOz7oLZbCYiya64XC+hjUf189FuUjSu3554ob4+ziTd5aPDw3rB7GxEL0rNeu7bnMvjedKL6C20Bcr5FOTxFk0mjxbalFJGrD3vGEOD+mnicX1fqa11F9QXJvR1eHhEL47v7neXGh/o1J9LH9x+clk475gBAACEBIMZAABASDCYAQAAhASDGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACExIIesw//xXWS7GqXNUoK9uQTz0iyGxnQ+55amt2X09LSJsluYFwvX/nlr9w9ZkMdPZLstp6q90FtWKZfl3j8mKRgw6NpSXYDPXpn0OCgu28mUeLu8THO3Kh3Ol1w3oWSgi1pOlWSXcTT+9/SWff1PdTfJcnu3sefk2Q3U1wtySKekGBXWV4uye7Ki18mye7xJ7ZJCvbkHnfnmpH23P1vxkzKvc+dtvZMSXaf+OgXJC1u17xEf5wXJ9y9UuWletdWZWmBJLvyQvflVFcWSbIrKdZP42Xd61Y2j6qtgph+ewrz6CArKnWvBRlP7/SKRPXTZDPuGzXQPyzJbiatd04WJdzbv7RMX8vVYtE5Q0Purq3hAf32xKL6fVhS7O5um5h0P+8Yx4amJNmNTKQk2eWU7VJUoq/VBXnsk8Vl7vtwJq0/73/lO7+WNI93zAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBjMAAAAQoLBDAAAICQYzAAAAEKCwQwAACAkFhTM3v5+vdhy294jkoK1rF4jyS4e0cv3akpKJQXLZfXi0Yef2ifJrrPdXa4XHe+XZHfOumJJdrWJpCS7bMRd+Dmd0Qshe7v1ctjUtLvor6lZL2E8+8x1kuzOP+ulkoIlqqsk2Q0Oj0qymxp370/3PPykJLu779dP86rXvkpSsNdc88eS7AbyKFAcn9VLCX/6859ICpZMTUqyu+Sl50iy6+s5JClYIqIXT37sr/5F0uJ26VnNkhwiEQnBonkUnFbqS5vXXOVec0rzKKktKtRfm5coRbbRiN4wW1LqXsuNiqpKSXaFhe71bzbr3va+iL79R0bchawjg3oha2WlfptrG9wl6rmcfv9MT0xIsuvqcj+HjY3p55FPke10yr0vzCjFvcbolF56PZJHUW0y7b6+M7P65UQK9NtcWOZ+sBaX6A/mn/38MUnz9EsFAADAHwSDGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACEBIMZAABASDCYAQAAhASDGQAAQEgsKJj9q/dfKMluMuYuAly+Si+YbT+0X5Jda1OdpGAd7T2S7O659zlJdu1H3EWcLVVpSXZXnF8mya4op5fqHulwF/1lChKS7GbSejlpcsp9XVpX6YW552w8RZJd65I2ScE6RoYk2fUNDkqya2lqlRTs/mc7JNn9/KkDkuxe8pLzJAVbt2KZJLv2rjFJdv0zeknw0Jh7u8T03cDbfMYGSXbLmt0lwNmZlCS7t73rDkmL26a1DZLscsp2rygtlGRXWqqXoJYoZauFeRT/FhTrr82batznUx7XizoLC/Ti1+JCfbt4Mfd1GZ/Si0fTeZSczqbd62OBp59HPB6XZFeklKgXJfT1PlGoX45WQjs1pZdep6b158HeMff2P9yvl6xPTuj7Ux5PcV62wL0/ZfIoI87m8ti3S90Fsrk8Co23bXtG0jzeMQMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAiJBT1mH3rXVkl2Y7PufpDCEnevh7Fn105JdtdcfoGkYNkZvbPmjv91ryS79nZ3h8s5a/VOryte4u4UMnIpvZuqo9Pd8zI8qRe4ZHJ6r83QsPt8zjyzRpLd1s16Z9dM0r2vPLqrXZJdaka/zVdddomkYM+1631p7ZP665TOjj5JwQ5t3yfJrrff3ZtnlNbr2z+qdEMtX6rfP1s2nSnJbunSWknBysrLJdn997d/VNLitjmPHrN4gXs/KojpvUbjSX1tSyrLyYbl+nVdvkRf2+JF7i6nwiK9L62yRD9NeR6dahGlPqyza0SSXSqt93EVJ9zPYbFoHtc1qq9bsQL3dqmu0Psxq6rcXWhGdtZ9m7s7+yXZdffo23Yo4749h47p2352Vt+20bj+GCooct+HZRXufkajcXmLJLvZtPvx0XX0kCS7+x98WNI8fQsAAADgD4LBDAAAICQYzAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBjMAAAAQoLBDAAAICQWFMx+4W9eL8mud2hUUrBcVC84nZmZkWRXkXAX9E2MDEuyu/eBw5Ls9u91l4+eu04v+Tt7fUqS3bJGvYgzUeguvTvY7t72RlefXk65Y5/7fDadqV/XV7xULzAdGnWXoP7Lj/dLsluxYrkku/9248skBdu2t1uS3a/39Eqye+JxdzFyPI8y3IYlrZLsVqxeIclu06bTJQWrrtYLRr2IXtRYVVMhKVguj8LUN7z2ZkmL20Ubl0iyy2Td+0Am435MGFMp/TEcibq3e3Wxu9zZOHuFvp9Fi9zn89wx/XFTX6U/J7Q068XkTTXu00yN6+vw8Ji7xNsXcb9nkT35aTNQRCmPNUqKlRLUEv0+LCvWLyeacW+XiWH9uXRoxF3EbnSPS7DY26dvt0xMf+7JpvSS7qKEuzy5Zc0GSXbRqL5tuzs6JAUb7HMfbzy+fbekebxjBgAAEBIMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACGxoGD27m/8tSS7dMZdoJgo0YsCD7d3SrLLJN1FgL29XZLs7vnFNkl2hw70SwrW1piQZHf6cr0wd+uWpZLsNqx1l949u12/zfdv08tUn9rjLhTcurlakt11V+nllO0D7n3ljrt2SLI764w2SXZvuHaLpGA/f3SPJLv7njkiye70M9ylri+/4FxJdums/vhYsqRekl1zo/s+GhrT98l9h/THYdNyd5FwUYn++Ljx6uskLW7XX6SXA6ez7hLN2axeMDuZ1IuKh4YmJAUbndRLahvKayTZXbD2FEnBxlNjkuy6JgYl2SVK9e1SU14kKVhdtbtU1CiI6WW3uXRaUrBkWr9/vAL3dTXKy93Xt7JMf2x5mTzKiGfc+0osq59HNqffP0OT7jXn2aN6ue9oWi90z6b16zs97t4vy6vdZe5GRW2dJLv+HnfB8sBAnyS7PUdPfs7mHTMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQWNBj9u8//poku2jE3WcyPKz32hxpPyrJrrba3SFSU6t3Pd338EOS7P7lW/8qKVh0Ur89bUsLJdmtXynBYevZ7p6s9qPTkuy+9f3tkux6J9wz+TmbayXZvfHV7s41YyZSISnYp//hEUl2+fRxrVri7gPqHNTvw6L6Zkl2r7zqcknBLth8piS7iTxuz7q1el9WUdzdkzQ4lpFk1903IMmuqs7dl1ZTrXfenXf2VkmL25te4e70MhLF7p6slNIDaYyO6T1NfcPu/ejYsLu7yphK6vtIQ2m5pGBrm/V1OFGgd2D1Kr1TxmjOvV1iMQkOVSUFkuzqqtzrSXFCP4+qCr2Pq7LC3WlYnNB7zMZH9e0WnXX3slWU6s9fEf0me1q92P6jo5Ls9nbrXWcllfpanfDc+1xTq77GRovdz1/Gjsd/LSlYd0+7JLvdh0/uk+QdMwAAgJBgMAMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAiJBQWz///XPyPJrqHBXfza16MX3g0OHpNk17KsUVKwopi7BNAX1WfP3bv3Swr23e/8QJJdx5GDkuzWt+rth5dtXS0pWF/HpCS7++7vkmQ3mnVfl7Jqfbvd8uotkuzO3uguXP3K3Y9KsvvXB3dIsstF3WWCK5bXSLLLFei3eV2b+/654rLLJNk1VenXpa5eL23NRislBdu+p1eSXVVNqSS7Na3LJAUriroLVY22M8+VtLhdd9laSXZ1le6yzrJivcxzfEwvku4fdpeGHu7W1+GB8ZQku5OfIRaqTLhLUo3TlrjXcmNpub4vzja5HxfHpvTb8/RDj0myKyt2r4/1jVWS7JYs0R/DddXu57DSEr1gNqd3BHulhe522GzGvS8ZsTzWx0jGvQ4PDk1Jsusc0Eto+0b165srcK+PJSV6AfD4iF7AHfHcj9XxSf02P7775Ods3jEDAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQYDADAAAICQYzAACAkFhQMPve97xSkl3rKe6Sxba28yTZ7dq7S5LduhXNkoKtbW6R5BDVyxxTSlfdszv3SrL76lf/tyS7oc7tkuw2n1orKdhQz4gku55ed8mfMZSUYDGeGpdkd9XF6yTZXf2KzZKC/WLbbkl2P/31AUl2kUiRpGCnrKqXZJee+0/TuNS9TzY1NUmyW1qvl22m41lJdtm4u+i5onKlJLv0rF5+ONjnLqpd2rBckt2b3/hmSYvbxVv0NWfWc5d51lXpxdgNle792Sjw3PvI6LheUns0jxLagz3uUutZfVf1ygr1cu2WGr2Q9YyVyj4d1S9nulwvbU1UuQtkO5/dKckuEdGbX7NKO2w6j7dOpmaUxXxONDIrKVhJif48WVejF7LGC9z7fnImj3Utq59mMjUjyS6Zdj8PplLubWLk0vpzwohS0tw7pt8/R7r6JM3jHTMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQWNBj9pUv6n1DGc/dsVNYskySXUmV3lmTnBiQFKy1cYkku4KiUkl2xwbcXT5DY3of0NiY3geVHh+WZPf4wz+TFGxyZEKSXTRSKcnuUFe3pGBjE+7uImNJtd59s2FNhaRghwf0bdLZr3fJlBSUSApWU+/u1zFWrHJ3lBnTM+7eocFRvReqdfVqSXaRhN7HVFKyVFKwC19ylSS7rq6jkuyyGfdtjkT0Xq73vv2dkha3Gy49RZJd/7h7fz3YpT+2Cgr0+39lc7mkYMUl+j4/nUfXWbvSYzY44e5xMgryeAugIKqfaGmpez1fVq6v91vPO0eSXe3aNknB2p/Se8xOrXD3DBqlhe5usOlZvWurI4/nlaTnPp90Vu/aihXq/ZgJ5Y6uKNbvn8N9J3d6BXn6sN6Dmpx136bJcf02Tyf1vrSJnHse6ps6acQKNDHSL2ke75gBAACEBIMZAABASDCYAQAAhASDGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACEBIMZAABASCwomP337/ylJLuiEnc5bC6iF+uNTurlbnsObpcUbOXqFkl2E5N6gWIy6S6EbGx0F3kaw3kUvzY1Lpdk99ij90kKlojrpZFLm/Tt8r3vf0dSsGee0wsUoyl38agRybjv57Gs/togF41Lslva4C7bbDtdL48dHRuXZDc44D7NmVvOlmS3cctZkuySKb1Ycv2qLZKCNVTr++1kUi+nbGxyb7sdew9LsnvVta+RtLjdcEmrJDutkLdnUC9kHR7VH1tFCXep8mge5aRFxQlJdlMT7vLsvjxKoqN5lMcWxPTTJJTi3YYS9zYxTquvl2SXiLvLVIuL3OuN8eotl0iyW6s8t+Ri+tpXUF0jyS5a4r6fZ7P6vjKbR9mqVowcmdCfjwcG9ILZrz1yjyS7hw49KynY1ExWkl00ohc9T+bc99HItH45g/29kubxjhkAAEBIMJgBAACEBIMZAABASDCYAQAAhASDGQAAQEgwmAEAAIQEgxkAAEBIMJgBAACExIKC2bu++A5Jdsmku/ywbc15kuyqqvRSvI5+d3HlaEovddXrWD2vuMB9qtUr9GLYifFJSXa9I+4iW2PvoR2SgsVjevFkQ61eoLhr568lBZuY6JFkNzWqF7KODEqwONinl+8ls3oh59pVVZKCVdRUSrI7sr9Lkt3ZZ7hLXS+44EJJdjM5d3mlEcmjwHL5kjZJwUqihZLsxqf0+zla5C5Q7OwfkWT3ule/SdLiduMlenmz9no3k9Yfw9NTeplnv7LkDGb1ctKiYvfjxhjq75cUbDalr32zmZOeZgKl0nrJaUmRe5+OFOiPrUQe70esqXKvF1VxvXj0wtWnS7K7sHWDpGB1JfrzZLy2VpJdtMxdvBtJ6GtFJq3vk16iWEKwaFa/f7yBAQl22/Y+Icnu/332XknB9vXoxcjxiL5dtI70bETf3w4e7pQ0j3fMAAAAQoLBDAAAICQYzAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBjMAAAAQoLBDAAAICQWFMx+5COvlWRXNPefy5WXXC3JbnlDoyS7rr52ScF2HNorya6jt0OSXaTAXXLaVK+X/HmzelHq6adtlWSXyblLFnfufk6S3fj4qCS74RF3meryZQlJdp2H90uyO3J4WlKwIz166W51fbUku7Y2d/FnKqPfntjcf5otm86SFCw1rZeHjuVRHnqkr0+SXcuKUyQFqywqlWQ3Mak0AM9ZvnqZpGB7Dx2RZHfbn/4PSYvbG1+xWpLDyUvqArmsvlakZvT9aNdRd8FzplRftwrL9cfW2DF3CXF5Tt+fhyeTkuxGkvpaEFHeS4hG9ALTgkK9dryx1P3YOaVcf2y11dRJslvT4H5sLVm9VpLdmatPk2RXpFSt55SSdSOSx7ZNpd33YSaPouHMiF5Y3ZvH8/pntv1UUrBn+vRy7aKYvl20R7N+iz1v/4GjkubxjhkAAEBIMJgBAACEBIMZAABASDCYAQAAhASDGQAAQEgwmAEAAIQEgxkAAEBILOgxu+nN6yXZrV2+TlKwdctXSbJradZ7zGK5QknBSiuaJNnt7jgoyW730X2SgsXj+vxaGNH7Ti465xWS7Orr3LdpcETvnRoc1U+zY/cOScGmJ/SemLHhTkl2S5askRSstKxekl1Ly0pJdkuWt0oKtmf/MUl2gyNDkuxKK0okBesbGJZkV1hUKcmuZ1DvMZtNuzvvVi/TH4drVuu9XCNK19mxwW5Jdm+94b2SFrfXvUzfphGl2SiXR+dhJKK3H3X0uzsCh2b07r7Z4ipJdgWF7t7KogL9uk4P64+/0f4xSXbDSgdgVumQM+JRva8wkXDf5jW1ev/bpga9R665vFxSsMTpp0uy29ykd52t89xrTkzpbTNm8yjkyqTd9890HmtsJql33o2N6uvsZ5+6T1KwZ4d6JdkVxfTn/tmse8Nk8+hu27f/sKR5vGMGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgxmAAAAIbGgYPbDt18tyW5D20ZJwQYH9BK52XRKkt26VndxXnFML8U7ePTk4rYgR9uPSArW3KCXoEZz+oy7rEUvC2xb7z5NOuMu8DP6BvUyx+4edyno6LB7mxgFEb0IcMOpZ0kKFonGJdl19rRLsjvW3y8p2HTKXVZs1NUvkWQXibrPJ5rHPnn6GedIsssUZCTZPfnkNknBKovc5ZVGfY1eMProtgclBZvM6GWPn/rIP0pa3G66TC+YjUUkWOT0ftm5HU0/0fCEu2B4b3ceRZ2z+rqV89yFrIXlxZLsEkV6qWt8XC+YTU5OSQo2ntIfN9Mp93YzogXu61tcqBeKt1RVSLLb1NggKVhjTZ0kuxJPX9tuPONCScGKymsl2Y3L/7sUxt3reXJcXyuSeewH/aP6jPGFnY9ICnZwalSSXSKPMuJ01r3P5VMwu2f3fknzeMcMAAAgJBjMAAAAQoLBDAAAICQYzAAAAEKCwQwAACAkGMwAAABCgsEMAAAgJBjMAAAAQmJBwexj935Nkl1nz6CkYMWVerHeRHJCkt2/P3SvpGAzSb2s7tS2Nkl2K5qWSgpWliiRZFdZWSPJ7uhAHhV9MXdZ4L79eyTZJZOTkuzOPnuLpGArljZLsptJ6mW3FRXVkoLt3LNLkt2//ehuSXZjSnHhBRdcJsnutNPOlmSXSrmLJdvaNkuyq6zSC4t//vAPJdk9tu1+ScHO2+i+j40z1q+RZDcxNSAp2IGOg5Lsbn7txyQtbtdfeooku0w6LSlYOq2XoGY8paV2znjSfT47D+vrzUQeZavZrLvsNhrRCzQLE3rxckOlXjbdUuN+/KVm9WLe5Ix+mtFJ99o2NOa+j42CPJ436svcp6lO6O+dtFXoJbTv2PwyScGWN62QZJdPL/LAmLsctn3EPTsY9RVlkuweOrxXkt3/d+hZScGm8ihrj+q7trpdfmvECrR7FwWzAAAAocRgBgAAEBIMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgxmAAAAIbGgx+yJez8vye6ZHe4OkaM9PZLs6pprJdmNTU1LClZaWiXJrqZU71RbvXyVpGBNSs+ZkZzVe20O9nRJsjt45JCkYHt375RkV1ackGTX1rZWUrCljS2S7IqL9O1fUenu2Ok5dkyS3Y497j4aY/2pqyUFKy8ulmSXy+rbLZl0dy01Nq2UZBeN631NP3ngB5LsJqfcnUAXnKn3mC2td/fMGdPTfZIsCtzde8bWrbdIWtyuPHuZJLuU0g02Oa13h81m9R4z7XIGJvU1aTqPTq/iEncH2bLqckl29TG9W7E7rb9PUF4kwaKqOCbJrrTM3YVmZDz3+fQOuZ+bjIGRpCQX9+UU5rGWJzL6drt+jbuj8YazLpBkV1SoP86Hxt3dedMxfb/Oo/bL+8r2ByXZPdjt7leM5NEVOKN0EhoR5WzyuT27d9NjBgAAEEoMZgAAACHBYAYAABASDGYAAAAhwWAGAAAQEgxmAAAAIcFgBgAAEBIMZgAAACGxoGAWAAAAzw/eMQMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAkGMwAAgJBgMAMAAAgJBjMAAICQYDADAAAICQYzAACAkGAwAwAACAXP+z+nqs5jA+9fkQAAAABJRU5ErkJggg=="},"e3930c77-cc0c-48fc-a84f-414a839252e5.png":{"image/png":"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"}}},{"cell_type":"code","source":"class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n               'dog', 'frog', 'horse', 'ship', 'truck']\n\n\ny_pred_probs = model_3.predict(x_test)\ny_pred_indices = np.argmax(y_pred_probs, axis=1)\ny_pred_labels = [class_names[i] for i in y_pred_indices]\n\nsubmission_df = pd.DataFrame({\n    'id': np.arange(len(y_pred_labels)),\n    'label': y_pred_labels\n})\n\nsubmission_df.to_csv('submission.csv', index=False)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-06-12T14:49:47.938795Z","iopub.execute_input":"2025-06-12T14:49:47.939304Z","iopub.status.idle":"2025-06-12T14:49:50.528950Z","shell.execute_reply.started":"2025-06-12T14:49:47.939279Z","shell.execute_reply":"2025-06-12T14:49:50.528430Z"}},"outputs":[],"execution_count":null}]}