{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "dVvUPPTPOJUu" }, "source": [ "# Google Colab 上で TPU を使う\n", "# MNIST\n", "\n", "https://colab.research.google.com/github/GoogleCloudPlatform/training-data-analyst/blob/master/courses/fast-and-lean-data-science/01_MNIST_TPU_Keras.ipynb" ] }, { "cell_type": "markdown", "metadata": { "id": "cCBEVlS2OZXm" }, "source": [ "## MNIST on TPU (Tensor Processing Unit)
or GPU using tf.Keras and tf.data.Dataset\n", "
\"Keras+Tensorflow+Cloud
\n", "\n", "\n", "This sample trains an \"MNIST\" handwritten digit \n", "recognition model on a GPU or TPU backend using a Keras\n", "model. Data are handled using the tf.data.Datset API. This is\n", "a very simple sample provided for educational purposes. Do\n", "not expect outstanding TPU performance on a dataset as\n", "small as MNIST.\n", "\n", "

  Train on GPU or TPU  

\n", "\n", " 1. Select a GPU or TPU backend (Runtime > Change runtime type) \n", " 1. Run all cells up to and including \"Train and validate the model\" and \"Visualize predictions\".\n", "\n", "

  Deploy to AI Platform

\n", "\n", " 1. Configure a Google cloud project and bucket as well as the desired model name in \"Deploy the trained model\".\n", " 1. Run the remaining cells to the end to deploy your model to Cloud AI Platform Prediction and test the deployment.\n", "\n", "TPUs are located in Google Cloud, for optimal performance, they read data directly from Google Cloud Storage (GCS)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 5377, "status": "ok", "timestamp": 1639691468977, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "hApfeQ7EOC4B", "outputId": "a18b5db9-658e-4a0d-9896-7c8ee663115c" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tensorflow version 2.7.0\n" ] } ], "source": [ "import os, re, time, json\n", "import PIL.Image, PIL.ImageFont, PIL.ImageDraw\n", "import numpy as np\n", "import tensorflow as tf\n", "from matplotlib import pyplot as plt\n", "AUTOTUNE = tf.data.AUTOTUNE\n", "print(\"Tensorflow version \" + tf.__version__)" ] }, { "cell_type": "markdown", "metadata": { "id": "xACGSeLxOjcO" }, "source": [ "# Visualization utilities" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "executionInfo": { "elapsed": 235, "status": "ok", "timestamp": 1639691527607, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "sgxHJuV-OhTf" }, "outputs": [], "source": [ "#@title visualization utilities [RUN ME]\n", "\"\"\"\n", "This cell contains helper functions used for visualization\n", "and downloads only. You can skip reading it. There is very\n", "little useful Keras/Tensorflow code here.\n", "\"\"\"\n", "\n", "# Matplotlib config\n", "plt.rc('image', cmap='gray_r')\n", "plt.rc('grid', linewidth=0)\n", "plt.rc('xtick', top=False, bottom=False, labelsize='large')\n", "plt.rc('ytick', left=False, right=False, labelsize='large')\n", "plt.rc('axes', facecolor='F8F8F8', titlesize=\"large\", edgecolor='white')\n", "plt.rc('text', color='a8151a')\n", "plt.rc('figure', facecolor='F0F0F0')# Matplotlib fonts\n", "MATPLOTLIB_FONT_DIR = os.path.join(os.path.dirname(plt.__file__), \"mpl-data/fonts/ttf\")\n", "\n", "# pull a batch from the datasets. This code is not very nice, it gets much better in eager mode (TODO)\n", "def dataset_to_numpy_util(training_dataset, validation_dataset, N):\n", " \n", " # get one batch from each: 10000 validation digits, N training digits\n", " batch_train_ds = training_dataset.unbatch().batch(N)\n", " \n", " # eager execution: loop through datasets normally\n", " for validation_digits, validation_labels in validation_dataset:\n", " validation_digits = validation_digits.numpy()\n", " validation_labels = validation_labels.numpy()\n", " break\n", " for training_digits, training_labels in batch_train_ds:\n", " training_digits = training_digits.numpy()\n", " training_labels = training_labels.numpy()\n", " break\n", " \n", " # these were one-hot encoded in the dataset\n", " validation_labels = np.argmax(validation_labels, axis=1)\n", " training_labels = np.argmax(training_labels, axis=1)\n", " \n", " return (training_digits, training_labels,\n", " validation_digits, validation_labels)\n", "\n", "# create digits from local fonts for testing\n", "def create_digits_from_local_fonts(n):\n", " font_labels = []\n", " img = PIL.Image.new('LA', (28*n, 28), color = (0,255)) # format 'LA': black in channel 0, alpha in channel 1\n", " font1 = PIL.ImageFont.truetype(os.path.join(MATPLOTLIB_FONT_DIR, 'DejaVuSansMono-Oblique.ttf'), 25)\n", " font2 = PIL.ImageFont.truetype(os.path.join(MATPLOTLIB_FONT_DIR, 'STIXGeneral.ttf'), 25)\n", " d = PIL.ImageDraw.Draw(img)\n", " for i in range(n):\n", " font_labels.append(i%10)\n", " d.text((7+i*28,0 if i<10 else -4), str(i%10), fill=(255,255), font=font1 if i<10 else font2)\n", " font_digits = np.array(img.getdata(), np.float32)[:,0] / 255.0 # black in channel 0, alpha in channel 1 (discarded)\n", " font_digits = np.reshape(np.stack(np.split(np.reshape(font_digits, [28, 28*n]), n, axis=1), axis=0), [n, 28*28])\n", " return font_digits, font_labels\n", "\n", "# utility to display a row of digits with their predictions\n", "def display_digits(digits, predictions, labels, title, n):\n", " plt.figure(figsize=(13,3))\n", " digits = np.reshape(digits, [n, 28, 28])\n", " digits = np.swapaxes(digits, 0, 1)\n", " digits = np.reshape(digits, [28, 28*n])\n", " plt.yticks([])\n", " plt.xticks([28*x+14 for x in range(n)], predictions)\n", " for i,t in enumerate(plt.gca().xaxis.get_ticklabels()):\n", " if predictions[i] != labels[i]: t.set_color('red') # bad predictions in red\n", " plt.imshow(digits)\n", " plt.grid(None)\n", " plt.title(title)\n", " \n", "# utility to display multiple rows of digits, sorted by unrecognized/recognized status\n", "def display_top_unrecognized(digits, predictions, labels, n, lines):\n", " idx = np.argsort(predictions==labels) # sort order: unrecognized first\n", " for i in range(lines):\n", " display_digits(digits[idx][i*n:(i+1)*n], predictions[idx][i*n:(i+1)*n], labels[idx][i*n:(i+1)*n],\n", " \"{} sample validation digits out of {} with bad predictions in red and sorted first\".format(n*lines, len(digits)) if i==0 else \"\", n)\n", " \n", "# utility to display training and validation curves\n", "def display_training_curves(training, validation, title, subplot):\n", " if subplot%10==1: # set up the subplots on the first call\n", " plt.subplots(figsize=(10,10), facecolor='#F0F0F0')\n", " plt.tight_layout()\n", " ax = plt.subplot(subplot)\n", " ax.grid(linewidth=1, color='white')\n", " ax.plot(training)\n", " ax.plot(validation)\n", " ax.set_title('model '+ title)\n", " ax.set_ylabel(title)\n", " ax.set_xlabel('epoch')\n", " ax.legend(['train', 'valid.'])" ] }, { "cell_type": "markdown", "metadata": { "id": "DRhN06uFOz1G" }, "source": [ "# TPU or GPU detection" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 53868, "status": "ok", "timestamp": 1639691604331, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "Pp019Xo0Orhj", "outputId": "9667d86a-394b-42cf-de77-45168d3559fa" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Deallocate tpu buffers before initializing tpu system.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Deallocate tpu buffers before initializing tpu system.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Initializing the TPU system: grpc://10.127.241.2:8470\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Initializing the TPU system: grpc://10.127.241.2:8470\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Finished initializing TPU system.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Finished initializing TPU system.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Found TPU system:\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Found TPU system:\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Num TPU Cores: 8\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Num TPU Cores: 8\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Num TPU Workers: 1\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Num TPU Workers: 1\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Num TPU Cores Per Worker: 8\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Num TPU Cores Per Worker: 8\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Number of accelerators: 8\n" ] } ], "source": [ "try: # detect TPUs\n", " tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect() # TPU detection\n", " strategy = tf.distribute.TPUStrategy(tpu)\n", "except ValueError: # detect GPUs\n", " strategy = tf.distribute.MirroredStrategy() # for GPU or multi-GPU machines\n", " #strategy = tf.distribute.get_strategy() # default strategy that works on CPU and single GPU\n", " #strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy() # for clusters of multi-GPU machines\n", "print(\"Number of accelerators: \", strategy.num_replicas_in_sync)" ] }, { "cell_type": "markdown", "metadata": { "id": "4h2WuSsKO6S_" }, "source": [ "# Parameters" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "executionInfo": { "elapsed": 5, "status": "ok", "timestamp": 1639691604332, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "7BDktHTDO3xE" }, "outputs": [], "source": [ "BATCH_SIZE = 64 * strategy.num_replicas_in_sync # Gobal batch size.\n", "# The global batch size will be automatically sharded across all\n", "# replicas by the tf.data.Dataset API. A single TPU has 8 cores.\n", "# The best practice is to scale the batch size by the number of\n", "# replicas (cores). The learning rate should be increased as well.\n", "\n", "LEARNING_RATE = 0.01\n", "LEARNING_RATE_EXP_DECAY = 0.6 if strategy.num_replicas_in_sync == 1 else 0.7\n", "# Learning rate computed later as LEARNING_RATE * LEARNING_RATE_EXP_DECAY**epoch\n", "# 0.7 decay instead of 0.6 means a slower decay, i.e. a faster learnign rate.\n", "\n", "training_images_file = 'gs://mnist-public/train-images-idx3-ubyte'\n", "training_labels_file = 'gs://mnist-public/train-labels-idx1-ubyte'\n", "validation_images_file = 'gs://mnist-public/t10k-images-idx3-ubyte'\n", "validation_labels_file = 'gs://mnist-public/t10k-labels-idx1-ubyte'" ] }, { "cell_type": "markdown", "metadata": { "id": "DNeqaXR8O-zn" }, "source": [ "# tf.data.Dataset: parse files and prepare training and validation datasets\n", "\n", "Please read the [best practices for building](https://www.tensorflow.org/guide/performance/datasets) input pipelines with tf.data.Dataset" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "executionInfo": { "elapsed": 861, "status": "ok", "timestamp": 1639691636855, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "6vAivOGJO9pX" }, "outputs": [], "source": [ "def read_label(tf_bytestring):\n", " label = tf.io.decode_raw(tf_bytestring, tf.uint8)\n", " label = tf.reshape(label, [])\n", " label = tf.one_hot(label, 10)\n", " return label\n", " \n", "def read_image(tf_bytestring):\n", " image = tf.io.decode_raw(tf_bytestring, tf.uint8)\n", " image = tf.cast(image, tf.float32)/256.0\n", " image = tf.reshape(image, [28*28])\n", " return image\n", " \n", "def load_dataset(image_file, label_file):\n", " imagedataset = tf.data.FixedLengthRecordDataset(image_file, 28*28, header_bytes=16)\n", " imagedataset = imagedataset.map(read_image, num_parallel_calls=16)\n", " labelsdataset = tf.data.FixedLengthRecordDataset(label_file, 1, header_bytes=8)\n", " labelsdataset = labelsdataset.map(read_label, num_parallel_calls=16)\n", " dataset = tf.data.Dataset.zip((imagedataset, labelsdataset))\n", " return dataset \n", " \n", "def get_training_dataset(image_file, label_file, batch_size):\n", " dataset = load_dataset(image_file, label_file)\n", " dataset = dataset.cache() # this small dataset can be entirely cached in RAM\n", " dataset = dataset.shuffle(5000, reshuffle_each_iteration=True)\n", " dataset = dataset.repeat()\n", " dataset = dataset.batch(batch_size)\n", " dataset = dataset.prefetch(AUTOTUNE) # fetch next batches while training on the current one (-1: autotune prefetch buffer size)\n", " return dataset\n", " \n", "def get_validation_dataset(image_file, label_file):\n", " dataset = load_dataset(image_file, label_file)\n", " dataset = dataset.cache() # this small dataset can be entirely cached in RAM\n", " dataset = dataset.batch(10000)\n", " return dataset\n", "\n", "# instantiate the datasets\n", "training_dataset = get_training_dataset(training_images_file, training_labels_file, BATCH_SIZE)\n", "validation_dataset = get_validation_dataset(validation_images_file, validation_labels_file)" ] }, { "cell_type": "markdown", "metadata": { "id": "R0VhSsRKPN_7" }, "source": [ "# Let's have a look at the data" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 177 }, "executionInfo": { "elapsed": 4725, "status": "ok", "timestamp": 1639691662705, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "GPLgvO7DPMjl", "outputId": "2cd9f136-dc19-422d-e4bc-83574f6fd26a" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuMAAABQCAYAAACzvHtWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeVhT19b/vwkJCXMAmWRWEBEBFRQRRaxapWqtWmutHazVqh3s6K3trdrb9rW3rdbWtlatt7Zaa52rVgTFARVQEZBB5plACEMIEMic9fvDy3mlAjIEvff9nc/z5BFz9tlr73Ny9ll77bXX4sjlcgILCwsLCwsLCwsLywOH+7AbwMLCwsLCwsLCwvL/K6wyzsLCwsLCwsLCwvKQYJVxFhYWFhYWFhYWlocEq4yzsLCwsLCwsLCwPCRYZZyFhYWFhYWFhYXlIcEq4ywsLCwsLCwsLCwPCVYZZ2FheWg0XL+BixOnMP+/Gj0HDddv9Khsb7m9/iMUffdDn8/vKb3p01/pTdkHRZu4CrG+I2DQ6Qak/N0oq6txLjgEpNf3+JxLUdNQn5jUo7KxviPQWl7e63b191wWFhaW7uA97AawsLCwtDPxzCmj1CM+ehziw0cx/vdfme8CPvnIKHX3lt706e6yhdu+Q1t5BYK3fDEQzTIal6KmYeT/fIxBERP6XZfZ4MGYnpFqhFaxsLCw/PfAWsZZWFhYWP7jISKQwfCwm8HCwsJidFhlnIWFpV+U7NyN9Nfe7PBd7iebkPPx/wAAxEeO4cqM2Tg3KhQJUx5FxYGDXdZ1t8uBXqVC5t8+QHzIeFyZORvNmVl/kfsjEh6ZgXOjQnFl5mxIz8YDABRFxcjZ8A/I02/hXHAI4seEAQAy//YBCr76hjm/8uBhXJ46A+dDxyN15atQSWuZY7G+I1Dx2++4PG0m4seEIeejT0DUebLi+7Xz3j69f6fsjNko2fWvDi4t7WXrLl9ByY5dqImJxbngECTOmXfnWh49joQpj/77Wk5H9YnOre7yjEwkL1yM+DFhuDghEjn/+BQGjaZH/SO9Hnn//ALnx01AwpRHUXcpoavbhcx334OqWoK0la/iXHAISnb9izkmOfknLkU+gvPjJqB4+w7mezIYmHt3fmw4bq15Cxq5HMC9Li7Xl7yAgq++xrVFS3AucAzaKiu7bEtP+g0AdZcuI2HKozg/bgLy/vllBwVffPgorsyYjfiQ8Uh5cQWUVVWdyqm7lIArM+/8pi9OjELp7p+6bRcLCwtLd7BuKiwsLP3CZXY0ir7bDp2iFTxLC5Bej5ozsRj9/bcAAFN7e4Ts2g4zD3c03riJm8tXwiYoEDYBI7qtt+jb7VBWViDyfCz0SiVSX1rZ4bi5hzvCDuyDwGEQas7EIfPd9zApPhaWPkMx4uON97ip3E1D8jUUbNmK0D27YeXjg7zPv0DGm+8g7MA+pkzdxQSEHzsEnUKBpCcWwuGRKDhETup1O+8pK67C5Atx0LcpcXPFqk7LOUROwpBVL3dwU9G1tSH3k00IP3YIlkO8oaqtg7ZJ3un5HBMT+H+wDtaBAVDVSJH60kpU7P8dXi8+f9/+VR48jLqLCZhw4ihMzMxw6y8TrbsJ2vw5ZDdTO7iptInvKLCNqWmYdDYGraVlSF6wCE6PToelz1CU790P6bnzCNv/C0zt7JDzyf8g56NPMerrzZ3KqP7jJEL+tRMW3t5AFxOi3vS79tx5hB8/BH1bG1JeeAkWQ7zh/tSTkMafR8mOXRizczvMvTxRunM3Mt5ai/GHfrtHTvYH6xH8zVewGxsKbVMT02cWFhaWvsBaxllYWPqFmasrrANGQHrujmW6Ifk6uEIziEYHAwAcp0yGuacHOBwO7MLGYtDECWhMub9fcE1MLIasXglTkQhmLi7wfP7ZDsedo2dC6OQIDpcLl1nRMPf0QFNmZo/aXH3yT7gtmA+bgBHgCkwx7J23IL+V0UGpGrJyOfjW1jAbPBj248ehJTevT+28t+zL4NvYQOji3G3ZzuBwuVAUFEKvUkHo6AArX99Oy9mMDIBodDC4PB7M3Vzh/vRTkKWkdCjTVf9qzsTB84XnYObiAlORCENWruhVG9vxee0VmAiFsPYfDmv/4WjJywcAVB44iGFvvwGhizO4AlP4rHkN0rizXW74dJ0/D1a+vuDyeODy+d3K7Em/vV9+6c69GjwYXkufh+TP00y7hqx6GZY+Q8Hl8TBk9ctozs3r1DrO4fGgKCqGrkUBvo3NfSeWLCwsLN3BWsZZWFj6zeA5syD58zRc582F5NSfGDxnFnOsLuEyir7djrayMpCBoFcpYTVs2H3rVNfWQujizPxf6Dq4w/Gq4ydQ9tPPUFZVAwD0bW3QNnZuKe6sbuu7FCiehQX4IhuopVKYu7kCAEwdBjHHuUIz6Frb+tTOv5Y1c76r7F3n3Q+euTmCv9mCst17kP3BetiOGQ2/9/8Gy6FD7inbWlqGvE2foyk7G3qlCqTXw2ZkR4Wxq/7d6Y9Lj/rTHR3rF0LXdqd+ZXU10l5ZAw73f21BHC4XmvqGTuvpzTXqSb873KvBg6GW1t1pV1U1cj/dhLzP7towSwSVtBZmrq4d6hj93Tco3r4DBZu3wspvGIatfRu2o0f1uJ0sLCwsd8Mq4ywsLP3GeeYM5H32BVSSGkjPnWeW9g1qDdJfexNBX3wGx2mPgMvnI231a136X9+NwNEBKkkNY/1VVUuYY8qqKmT/fQPG7f0JotGjwDExQeKceUy9HA7nPnU7QvVvJR644wKilTdB4OTU6753185Oy9ZIYenrc6espKbLsp31wWHSRDhMmgi9SoXCrd/g9ocbEHbgXlec2xv/AesR/gjeuhk8SwuU7dmLmrizPeuPgwNUkv/tQ3f96aqd3SF0cUbgZ5/CNmTMPcc6dffoRf096fdf75XAyeHf7XLB0NUrMXjunPvKsQkKxJgd38Og1aLi19+QseZtRF250ON2srCwsNwN66bCwsLSb0zt7WAXNhZZ6/4OMzdXWPoMBQAYtFoYNBqY2tmBw+OhLuEy6q/2LCa0c/RMlOz4EdqmJqgkNSjft585pm9TgsPhgG9nB+DOJlFFYdH/tmeQPVQ1Nfds3mvHZfZjEB89juacXBjUGhRu+Ro2wUGMVbw3dNfOTsvu/HfZGikquilram8PZVU1s8FQXV8Pafx56NrawDU1hYm5OcDpfAjXt7aBZ2EJEwtzKIpLUHHg9171p3zvr1BJaqBtakLJrh+7LW9qbw9lpbjH9XssXoSCr75h3D80DTJI48/3+Pzu6Em/S3f/BG1TE5QSCcr37oPLY9FMu0p2/oiWwkIAgLalBTVnYu8536DRoPrEKWhbWsDl88GztAS4vZuQsLCwsNwNq4yzsLAYBZc5s9GQlNzBRYVnaQH/9R/g1htv43zIeEhOnYbj1J4l7vF5/RWYuQ5GwpRHkfLicrjeZbG09PWB10tLcf2pxbgQPgktBYUQjRnNHLcfHwYrHx9cnBCJ8+PujX89KGICfN98HemvvYmLEZFoq6jEqK2dbyDsTzv/ytDXVkPo7HSn7AsvwXnmDHBNTTst6xw9EwBwfuwEJM1dADIQyn76BZcionA+NByyGzcR8I8NnZ7r995aSP48jfhRobj94QZG4ewJbouexKBJE5H4+DwkPfEknB6d3m35IatWoHj7DsSPCetRVBHPF56D49QpSHlxBc6NCkXywsVoyuiZr//96Em/Hac+gqQnFiLp8flwiIqE28IFAACnR6fB++XlyHjzXZwbNRaJj81FXcKVTuVUnziFhKjpODdqLCoOHPyPjwXPwsLynw1HLpfff72YhYWFhcXoVOz/HZLTMQj7be/DbgoLCwsLy0OCtYyzsLCwPCBUtXVoTE0DGQxQlJSi7Kc9cJo+7WE3i4WFhYXlIcJu4GRhYWF5QJBWg9vrP4JSXAWetRVcZkXDY8nTD7tZLCwsLCwPEdZNhYWFhYWFhYWFheUhwbqpsLCwsLCwsLCwsDwkWGWchYWFhYWFhYWF5SHRrc+4jY3Ng2oHCwsLCwsLCwsLy/9ZDAYDWlpa7vmetYyzsLCwsLCwsLCwDDCGfydx+yv/9dFUDh8+DJVKhfLycqSkpKC5uRlBQUEYO3YsgoKCEBQU9LCbyMLCwtIBg8GA9PR0fPvtt6itrcWECRPw4YcfPuxmsbCwsPSIsrIyHDt2DImJiVAoFJg+fTqeffZZODs7G11WTEwM9u3bh1mzZiE6Ohr29vZGl/Gw+a9VxokIu3btws8//wydTge5XA6xWAyVSoW8vDzcunULs2bNgpeXF6ytrR9Yu/R6PcRiMTZt2oRFixbhkUceGRA5RAS5XI6TJ08iMTERHh4eWLVqFQYNGjQg8lhY1Go1mpuboVarAQA8Hg88Hg/Xrl2Di4sLnJyc4Obm9pBb2XtqamogEAjA5/MhFouRk5ODyspK+Pn5gcPhYMiQIfD19TWaPIPBgLy8PBw8eBAnTpwAANZo8IAoKSnBuXPnkJ2djaCgIKxYsWLAZWo0GpSXlyMzMxO3bt2CVCoFEYHD4cDV1RXOzs4IDw+Hj48PzM3NB7w9/xdQq9VobGzElStXoNPpEBwcDG9vb5iZmT3spv1/w9GjR7F//34UFBQAALhcLnx9fTF37lyjyzpy5AhiY2MREBAAjUZj9Pr/E/ivVMb1ej1Onz6NH374AZmZd9Ioi0QiDBs2DFqtFhKJBCkpKbCyssLkyZMRFhb2wNqm1WqRk5ODPXv2IDw8fMDk6PV6VFVV4YcffkBKSgpcXV0RHh6OqKgomJiYGF2ewWCARCJBTExMty+wpqYmtLW1wcbGZsBfLHK5HJmZmSgoKMCECRPg7+8PDodjlLpVKhUuX74MABg6dChcXV0hFAq7PUej0aCmpgb29vawsLAwSjv+E6ioqEBZWRmKi4tRXl6O5uZmAIBQKISNjQ0SEhLg4OAAe3t7fPXVVw+5tT1Hq9Xi6tWrSExMBBGBz+ejoqICeXl5qK6uho+PD4A799/X1xdTp07FsGHD+v18VVZW4vTp04iPj4e7uzsiIiIwc+ZMY3TpvwKNRoOGhgZUVVUhJycHtbW1sLKygru7O+zt7REUFDRgSlVxcTEOHjyIpKQkjB07Fo899hhcXV2NKqOiogLV1dWoq6uDXC5HW1sbMjIykJeXh9u3b6Ourg5BQUHw9fWFr68vLCwswOfzweWyXqM9QaPRICkpCbGxsbhx4wZ0Oh1GjBiB8PBwREREwNvbGzzef45qEx8fj0GDBsHHxweWlpYPuzlGQSwW4+zZsygsLISbmxtGjx4NX1/fAdE9FAoFUlNT4evri+HDh/9HXcPy8nIUFRWhsLAQra2tIOoYKdzZ2bnHlvz/nF9sDyEi1NXV4csvv0RmZiasra0REhKCIUOGICgoCGq1GjExMUhOTkZ5eTlu3779wJXxgoIC8Hg8DB8+fEBkGAwGNDQ04NKlS0hNTQUAxqIXGRk5IA+ERqNBSkoKNm3a1K0yXllZiZycHHh5eWHcuHFGb0c7er0e2dnZ2L59OxISErB8+XJs3LjRKIOwTqfDuXPnsH37dohEIjzzzDNwcnK67zkXL17ErVu3EB0dDX9/f/D5/D63gYigUChQUlICpVKJsLAwo000ekJbWxtKSkpQWVmJ1NRUpKWlITc3F2KxGK2trQAAgUAAkUgEmUwGrVYLANiyZcsDbWd/uH37Nn744QckJCSgpaWFsY4DgImJCVJTU0FEiI+Ph0AgQGVlJd544w04Ozv3S3EqKirC5cuX0dDQgEWLFmH16tXw9vY2Vrf+YyEilJSUIDc3F/n5+bh9+zYSEhJQUlICBwcHjBw5El5eXli2bBkmTpw4IG2QSqUoKiqCWq1GQUEBUlNTja6Mx8fH48KFC6isrERDQwP4fD7a2tpgbm4Ob29vREREYPr06Rg3bhyCgoL6NU50BRGhoaEBEokEEokEKpUKVlZWcHJygqen53+tscBgMCA7Oxu7du3CoUOHGOUnKSkJSUlJKC4uxqxZszBixIgHuiLeHbt378aYMWNgb28/4IqkSqWCWCyGTCaDo6MjXFxcIBAIjCpDq9XiyJEjyMvLg6WlJebOnYv58+fDycnJ6LIAID8/H3V1dViyZAlGjx4NKysro8voKXq9HhKJBFKpFLW1tbh58yaSk5ORnZ0NHo8HGxsbWFlZQaFQQCwWY/DgwXB1dcWUKVPuW3efNBe1Wo2mpiYolUqYmJjAxMQENjY24PF4MDU17UuVPabd8nzt2jUIBAJERkZi69atcHZ2hpmZGeRyOWQyGXJycgDggSoGRITm5mbcunULzs7OGD9+vNFlqFQq1NXV4fr169i+fXuHY21tbWhoaIClpSXMzc2NamlRqVRITExklK6uqKurw4ULFzBo0CCMHTt2wK5/c3MzLl++jNjYWLS2tuLPP//Ehx9+2G9lXK/XIy8vD++99x7q6+sRFRUFGxub+w6i5eXlWLduHVpbW+Hr64uhQ4f2+SWr0WhQV1eH9PR07NmzBw0NDYiLixuQga4rKioqsHnzZhw7dqzTGX/7c69SqYy+AqLVaqHX69HW1obW1lZoNBrweDyIRCKYmZkZZYxRq9XYs2cPLl68CLlcDjs7O3h4eMDd3R0ikQiWlpYgIuj1ehw7dgxSqRTff/89QkJCMGPGjH5FmmptbUVrayvs7OwQFhb20BRxlUoFqVSKlpYW5v5aWFjAzs4OlpaWMBgM0Ol0MDMzM8pzXFtbix9//BEHDx6ERCKBVquFqakphEIhGhoakJCQgNTUVOh0ugFTxuvr61FZWQngjmJXX19vdBlXr17F0aNHAQBeXl4ICwvDyJEj4eHhAVtb2wFzXWxHrVajvLwcV69eRXx8PDPx8/LyQnh4OFatWoVRo0b1+TnSarVobGxEbW1th3GBw+HA2toaHA4HPB4Ptra20Ov1IKIOE93+oNfrcfLkSRw8eBAAYG9vD4FAAA6Hg7KyMmzbtg1ZWVlYvnw5JkyYAFtb24dqHGhra0NmZiYGDRrEuPcNBO2rTQUFBThx4gTS09MRGRmJhQsXYsiQITAYDDA1NTXK2CmVSrFlyxbU1NRg9uzZeOqppzBmzJgBu85nz56FUqmEk5PTQ3PjUqvVqKurg0Qiwfnz53H58mXcvHkTWq0WdnZ2GDFiBCZMmIDAwEAMHToUeXl5+Pnnn1FVVQWxWNwjGX3SXG7fvo0jR44gPT0dtra2EIlEmD17NpycnJil3a5of1AFAkGfLLhEhJaWFtja2sLPzw87duyAi4sL80M4e/YsLl68iIaGBowYMQLBwcF96WKfUCqVyMjIwB9//IFly5YNiIzbt29j3759SEhIQGFhYYdjycnJ0Gq1CAwMRGRkJEQikVEeECJCU1MTLl++fN+HedCgQbCyskJ5eTlUKtWALjdnZ2ejqakJTk5OmDFjhlGU1fr6eqxduxalpaV48skn8be//Q2BgYHdnqPX6/H999+jvLwca9euxfjx4/tseSIi5OfnY8+ePfjtt99QW1sLa2trSKVSuLu7D9iAp9frGaWXz+ejtrYWv/32G/R6PQDA1NQUPB6vw+R7yJAh8PT07FBPf9qn1+uhVqtRUlLCTEauXr2KsrIyODs7Y/78+Rg9ejQz0emPda+kpAQXLlyAXC6Hg4MDVqxYgYULF8LJyQlWVlaMS5JOp4OXlxc+/fRTtLS04Mcff4SPjw9GjhzZpxcbEaG1tRUqlQouLi4PdHy6G41Gg+vXr+Ozzz7DhQsXmEn2+PHjsXz5ckRFRaGlpQVSqRQTJkzotzVKr9dj37592LZtG6OUCAQC+Pv7Mz70Go0GCoUCsbGx/e5fT7CyshqQcXrs2LFITU1FbW0toqOjH+hqkUqlQnp6Ol599VVkZ2fDwsICHh4ecHNzQ2NjIw4fPgyRSAQbGxv4+PjAYDDAxMSkV4YbiUSCPXv24NNPP4VOp2O+FwqFmDlzJjgcDpydnfHUU0+hpaUFGo0GPj4+GDJkCPh8PjOG9MVYxOFwmH1RAoEAzz33HAICAsDhcHDkyBEkJycjJiYGRUVFWL58OZ577rkB2+xHRNBoNNDr9V1OWAsKCiCTyZi2DwR6vR6ZmZn46aefcPz4cdTW1jIbxKVSKebOnQulUokhQ4Zg1KhR/ZaXmpqKpqYm8Hg8zJ8/H0OHDh2wvhkMBpw7dw4qlQp+fn6wtbUdEDn3o6CgAJs2bcIff/wB4M5v3c/PD4GBgVi+fPk9rnUcDgfh4eFQq9VYsmRJz4TI5XLq6tMVX375JTk6OhKXyyUej0dcLpe4XC5ZW1vT+PHju/1MmTKF3nrrLcrMzOyy/vthMBiovLycZDLZPd+vWbOGBg0aRBwOh6ZMmUJpaWl9ltNb6uvr6dtvvyVra2u6fPmy0es3GAz0zTffEIfDYa55+4fD4RCPxyMej0eenp508OBBamxsNIpcuVxOe/fuJTMzM1q/fn23Za9fv05LliyhiRMn3nN/jIVGo6HPPvuM3NzcCAAFBAQY7XrHxcWRlZUV8Xg8io2NJbVafd9zMjIySCgU0qxZsygnJ4d0Ol2f5Tc2NtLnn39OVlZWBIA4HA4JBAJavHgxSaVS0uv1fa67K1QqFWVmZtJHH31E586dIyKi5ORkcnJyIk9PT3J0dKTZs2fTunXraP/+/ZSZmUmNjY2kVCqN1ga9Xk8ZGRn01ltvka+vLwkEAuJwOMzn7msRGBhIK1eu7Jf8lJQUcnV1JS6XSytWrKCMjIxuy69fv57MzMwIAG3bto1qa2v7JLehoYFWr15NLi4u9P7779+3vMFgYD7Goq2tjWJiYsjFxYW4XC6ZmpoSn89n/g0PD6d58+aRv78/+fv708mTJ/slz2AwUGZmJjk7OzPvC1NTU1q2bBndvHmTLl26RPPnzyc+n09cLpcGDRrUr2eoO77++msCQADIy8trQJ6n5uZmWr9+Pbm5udHChQtJIpEYXUZnqNVqunLlCgUEBBCPx6Nhw4bR2bNnmXd5dXU1LVq0iKKjoykmJoaysrIoJiaGysrKeiUnJyeHXn/99XveQe3vofYPn89n/nZ1daWFCxfS999/T3FxcZSbm9una69SqWjmzJnE4XDo6aefptbWVuZYbm4uLV++nKytrYnD4ZCDgwO98cYbpFKpei2nJ9TW1tLu3bvp/fffp+rq6k7LpKWlkZOTE23ZsoVqamqM3gatVku3bt0iV1dXZpy8+yMQCEgoFJKNjQ0tWrTIKOPI2rVrSSgUUnR0NBUWFhqhF11TXl5O1tbW5OLiQqmpqV2Wu3uc1Ov1Rh0viYhiYmLI1taWLCws6Pnnn6ebN2+SRqPpsnxjYyNJJJJOy2i12k717T4p40VFRXTw4EHatWsXHT9+nD777DN6+umnydXVlQCQu7t7hx8Gl8slkUhE1tbWzPHPP//cKBfpbvbt20ejRo0iHo9Hrq6utG7dugF7EDsjMzOTRo8eTYGBgR0GCWOxe/du8vf3ZxSTuz8ODg7k5eXVYUA8ffp0v2U2NzfTkSNHyMHBgUaNGkUKhaLb8vv376fhw4cPqDJeWFhIixYtYq7D5MmTjVKvVCql1atXk1AopC+++KJHCldWVhY5OzsTAPr222/7PQE6ceIERUVFMc/O3fdYJBLRl19+ed970Bu0Wi3FxcWRn58fOTo6dvjNlJWVkcFgoKqqqgF9jjIyMmjVqlXMJBoA2dnZ0eTJk2nVqlU0b948srGxoeDgYOJwOOTi4kIeHh60ffv2PittV65cIRcXF5o1axalpKT06Jx2JeeJJ56grKysPsn917/+RaNGjeqRMp6amkp//PEHHTp0iJKSkqi+vr5PMu9GrVbThQsXGOXJ1dWVfv/9d4qLi6OzZ8/Svn376JdffqGlS5eSjY0NhYaGUnJycp/l6fV6ysrKojlz5jBjk4eHBx07doyampqYMrW1tfTzzz/ToEGDyNTUlEaPHt3vvnZGcnIyLVy4kACQSCSizz77bEDknD9/nubMmUNTpkyhvLy8AZHxV3Jycuj5558nPp9Pfn5+nRoSKisrqby8nJKTk2np0qXE4XAoMjKyV8+3Xq+n0tJS+v777+nvf/87bd++nbZv305btmyhqKgomjx5Mk2ePJk8PDxIIBDcoyC2j2X/+Mc/et3H1tZWpo5bt27do9CXlpbSF198Qf7+/sThcMjKyopWrFgxIJO7mzdv0nPPPUfjxo2jCxcudFrmyJEjZGdnR/v27etWp+oter2eqqqq6O9//3uHa2ttbU18Pv+ea87n82ncuHH9vg5SqZSCgoKIz+fTvn37mGd4oFi7di0JBAJatmxZl5NGlUpFV65coYMHD9LBgwfprbfeoitXrnSrLPeW69evU1RUFDk4ONCBAwf6VZdRlfH22Uf7R6fTkUajoZqaGoqNjaW6ujo6e/YsnTlzhs6cOUPx8fF0+/Zt+vjjj8nS0pJ8fX1p//79/erQX7l48SIFBwcTn88na2trWrZsWZ9fmH2htbWVjh8/TgKBgMaOHWv0+nNzc+m1114jBweHDpZxoVBIq1evpmPHjlF8fDxt2LCBRCIRcblcev311yknJ6dfclNTUyk6Opo8PDzo+vXr3ZZtbW2ljRs3EgCKiIgYMGV8//79NHbsWAJAzs7O9Pbbb/e7ToPBQEuXLiUej0dBQUGUl5d334FLr9fTzp07icPh0OLFi6mhoaFfbaivr6c333yTzMzMyMbGhkaPHk0REREdFHJXV1cqKSkxikVPp9PRqVOnKCIiglxcXGjTpk1GVfTvh0qlYqzEPB6PAFB4eDgtX76crl27RkqlkrRaLcXHx9OLL75I58+fp9DQUDIzMyMvLy8yNTWlioqKPllB5syZQ0KhkNauXUvFxcU9Ouf1118nCwsLGjJkCF25cqXXMtvrsLGxoWnTpjGrEH9lzZo15OfnR3Z2diQUCkkgEJBIJKLZs2f3y0qtVCrp0qVLjEV82rRplJSURBqNhhnL6+rqaMOGDeTp6UkBAQH0ww8/9MvKpNVqae/evcz95fP5tG7dOqqqqrqnbElJCS1fvpwZ21avXt1nuV3RvrI40Mp4fHw8zZ49mz2WLcEAACAASURBVEJDQ+nYsWOUlpbGfNra2owur6ioiNatW0dCoZACAwO7HXsrKipoxYoVZGlpSe7u7vT+++/36R7rdLp7PhqNhvnk5OTQTz/9RJ9//jm9+OKL5OXl1UEhd3Jy6rUyp1QqacqUKcThcKiwsLDTcbCqqoq++OILxkJuY2NDR48e7XX/7sfBgwdp/PjxNHny5C51jccff5wcHR0pNTXVqNZamUxGy5Yt6/Bcffnll3T8+HF64oknSCQSdbCOT548ucdGh64wGAz01VdfMTrW6dOnB8ToeDeLFy8mPp9P33zzTafGiJaWFjp58iR5eXkxngFcLpf4fD6dOnXKKO2Ty+W0c+dOEolEFBER0e8JSFfKeJ98xjkczj0+QiYmJnB0dMSUKVPA5/MxefLkDsdzc3NRUlICHo+HkJAQTJs2rS+iuyQ7OxuNjY3Q6XQIDAzEjBkzBiyaSWfIZDJkZWWBw+EY3a+prq4O27Ztw9GjR9HY2Ajgjg+vl5cXoqOj8d577zH+4W5ubjh69CiUSiX2798PtVqNl156CaGhob320SsvL0dMTAzS09Ph7++P0aNHd1v+woULSExMhKOjI4KCggZs53heXh4kEgm4XC4CAwPx/PPPG6VevV4Pg8HAbBTp6nrRvzfq/vDDD9ixYwcAYPPmzf2+75WVlRCLxbCxscHTTz+N999/H01NTTh69Ch27tyJsrIyVFdXY+XKldixYwc8PT37HDlHo9EgISEBe/bsQUZGBsaMGYNly5Y9kCgLRITGxkb8+OOP2LdvH9ra2pioNStXroSrqyssLS2ZDV96vR4KhQJ2dnZ47bXXsHTpUojF4g7+qr2hoqIClZWVEAqF8PHx6XHUhYiICOzbt++ezaw9RaPRQK1Ww9zcHKGhoYiMjOxwrH3jWVFRERMedNy4caitrYVYLEZSUhI8PT0RHh7ep3wCUqkUO3bsgEwmw/Tp0/Hpp58iODi4w8Y6iUSC7OxsVFdXY9KkSQgJCen3PoDz588zew/CwsKwYsWKThODeHh44K233sKVK1dQWFjIRLMxpj+qwWDo8/3rKQqFAsnJybh58yYaGxvx8ssvg8vlMv2YNWsWFixYgBkzZhgt8pVMJkNZWRn4fD58fHwgEom6LGtnZwehUAidTgcejwdLS8s+XePO2n73d8OGDYOXlxcMBgNUKhXzjvz5559x6tQpyGQy7NixA3/72996LJPL5cLPzw+XLl1ivjt58iROnz6NkSNHwtPTEwaDAWZmZpg8eTL+/PNPaDQaFBcX97p/3aFWq5Gfnw+9Xo9p06bBz8+vy3IcDgd8Pt9ov+OysjJ88MEHOHXqFAwGA0aOHIkvvvgCt2/fxjfffINbt26hqamJKW9ra4tRo0YZxV88Ly8Per0e7u7uGDly5IDHdW9/Vru6dlKpFHv37kV5eTkAYMOGDQgJCcGaNWuwdetWBAQE9HuDfG5uLuLj42FqaoqIiIgBi+Zi1NCGHA6H2dR09+YmhUKBkydPIj4+Hj4+PnjyySeNuqli/fr1zMaF0NBQvPjii5gyZcoDjTXa3NyM0tJSWFlZ4ZlnnjFq3RqNBhKJBI2NjTAYDBCJRJgyZQreffddeHp6wsHBgVEcvb298eyzz2Lbtm2oq6vD8ePH4ezsDB8fH9jZ2fVKbllZGZKSksDn8zFnzpxud8M3NjYiMTER2dnZ8PPzw7x58wYkZFdRURFu3ryJ2tpa8Pl8ODs7G33SlZKSgvfffx+Ojo6IiIjokMimtbUVmZmZSE1Nxfnz51FfX4+pU6fCzs6u34OtWq2GVquFv78/Zs6cCUdHR9jZ2eGZZ55BXFwcysrKQERoa2vrdELcG3JycnDgwAEkJydj0qRJWL9+PRwcHPrV/p7S1taGpKQk7Ny5EwqFAg4ODtiyZQsmT54MFxcX5ndD/97sKBQK4ejoiLfffpuJfqHT6RAdHQ0bG5teX4fTp0+jrKwMgYGBCA0N7fEkqj1qQ1+5fPky8vLy4OrqiuHDh8PU1BQ6nQ7V1dU4ceIEdu7ciaKiItjY2OCJJ57AggULmA3x+/fvx6FDh1BVVYXGxsZeK+OFhYX49ttvERcXBysrK7zzzjsIDAzs8Izq9XrExsYiOzsb9vb2GDt2LEaOHNnn/rZPutLS0jooooMGDep0omtiYgInJyfMnDkThYWF/5XJPRQKBb777jvs378fBoMBgYGB8PLygq+vL3Q6HU6dOoXk5GRcvnwZtra2+PrrrzFy5EhYWlr2K/pVc3MzpFIp7O3tsWjRom5/pwUFBRCLxTAYDBg8eDBCQ0P7LLc7TExMGGXNwsICIpEIdnZ20Gg0OHXqFMzNzREVFdWrOtsNMMCddwGXy8WWLVuQk5ODM2fOMJv4dTodkw9Bp9Ph6NGjCAkJwbhx44xiJJJKpSgrK4OpqSmGDRvW6btOoVCgtLQUQUFBRosCUlVVhYMHDyImJgZtbW3w8PDASy+9hL///e+or6+HTCZDW1sbo8RaW1sjKioKL774Yr/1ISLC5cuXQUSYN29en8ZeY9Lc3IyUlBScO3cOAoEAH330EZYuXQpLS0uMHj0aly5dYsLw9ge1Wg2FQgGBQAAvL68B6/MD0VZv3ryJpKQk1NfXY/To0fDz8zOaRUAulyM2NhbFxcXg8XiIjo5GVFTUA02XKpfLkZaWhrS0NPj4+Bg9dBX9O8QaEcHa2hqTJk3C6tWrERISck9EB1NTU0yfPh3nz5/HtWvX0NDQAJlM1msrolarRWVlJfLz82Fra4t58+Z1W/7mzZtIS0uDRqOBv7//gA3whYWFkEql0Gg0GD58OEJCQowSRYXD4SA6OhqxsbEdQgleuXKlw0xYq9Wirq4ODQ0NaGhogJOTE1avXm2UiUdeXh4qKyvB5/OZFRAejwc7OztUV1eDw+GAiODr6wsrK6t+x7ouKCgAl8tFUFAQxowZ88CSjuj1esjlckaxbo9EcPXqVdTU1ECv14PH46G5uRkVFRVMXNfc3Fwm6oeNjQ1WrFjRp5fc6dOnYTAYMHv2bLi7uw9IXP7OyMvLQ21tLTw9PZm49TKZDL/99hv27t2L/Px8jBw5EitWrEBERASTJITD4SAgIACDBg2CVqvt04pAfX09rl27hpaWFri5uSEsLKzDc2MwGHD27FmcOXMGVVVVmDhxIqZOndovy5dOp0NhYSHKysoAAH5+fpg2bVq3dZqYmMDOzo6ZdMrl8ocWQaEv1NTU4MaNG9Dr9Vi8eDHmzp0La2triEQiGAwGTJs2DfX19Th79ixSU1OxceNG+Pj4YMmSJRgzZkyffs96vZ7J72Bra4thw4Z1W/bMmTPIysoCADg4ONw3ApqxMDExARFBKpUCuKPkFBcX9yofhYmJCaKiovDqq69i6NChMBgMkEqlkMvlaGho6PQcnU6HnJwcbNy4Ee7u7li5ciVCQ0Nhbm7eZ8WqrKwMEokE9vb2XWbnvXr1KqRSKWbPnm2UFUciQmlpKY4cOcJYvhsbG3Ho0CFkZWVBKBQiKioKVVVVKCoqgkKhwJAhQzBlypQuLfe9RS6Xg4ggFotx9OhRNDc3Iz8/H3K5HMCdKCNeXl6YOXMmxo0bN6DKulgsRlxcHIgIa9as6ZAPxMLCAkqlEunp6XB3d+9XKNra2lqUlpYyBoqBYsCVcalUipMnTyIrKwv+/v547LHHjJoy+5dffkFJSQk0Gg2CgoIYS+aDzGZWU1ODtLQ0SCQSzJw5E4MHDx4QOXq9HqGhoVi1ahXCw8O7DK3m5OQEOzs78Hg8EBHKysqQm5sLR0fHHsvS6XTMLDssLAxeXl7dli8sLER1dTWsra3h6ek5YC/Q4uJitLS0gM/nIzAwEBEREUarOyoqCu+88w4KCgpQWlqK1NRUNDQ0MKsPwJ2H3NvbG7/++is4HA78/f2NlvXU3NwcAoEAEokEt2/fZpTQrKwsVFdXQygUQqlUory8HA0NDRCJRH22drQr/kqlEhUVFUhPT8fQoUMfiHW83cXK29sbeXl5aG5uxq+//gqFQoGGhgYQEbhcLtra2iCTyaBSqZiY5jweD4GBgViwYAEiIyP71P+Kigo4Ojpi8uTJ/Rqke4tUKkVbWxsEAgEEAgE0Gg1KSkpw7NgxFBUVYdy4cVi1ahWio6Ph4ODQ4UUmFAphb28PFxeXPhkatFotmpubmSXzu11zmpqakJaWhj179iArKwsGgwHDhg3rl1W8Xebt27cZ69RTTz0FX1/fHt+z2tpalJeXGy1E618RCoVGj2duZWWF+fPnY8aMGQgLC7vHNcDX1xdKpRJDhw5FQUEBTp8+jdTUVKhUKrS2tvYpjKTBYEBzczPq6uowaNCgLjMFGwwGVFZW4vr16xCLxXBxcUFQUNB9E5oZC61Wi+LiYiY8HI/H69U7CbhjNBk6dChefvlleHp6oq2tDY8//jiSkpIgk8lQU1PDKIZ3o1AokJiYCD6fD6VSiQkTJmDu3Lnw8vLqdYhSg8GAtLQ0iMViBAQEoKGhAcePH2dyIlRUVAC4EwKwtbUVIpHIaBN+tVrdITZ+W1sb0tPTMWHCBERFRcHX1xc7d+6EXq+HSCTC+PHjMXHixPtmj+4tV69eRV5eHlpaWpj+AndW8V1cXJhV3P7mWmm3visUCsbVrV1OYWEhkpOT4efnh2XLlsHd3f2e82tqaqBUKvs8zuv1eshkMsjlcowaNQoikQi1tbXM8XY9yxgMuDKelZWFxMREtLa2IioqCnPmzOnWn603VFVVYefOnWhuboa9vT3mzJmD4cOHP9DkKMAdn+6ioiLw+XyMHDnS6JY2sViMlpYWAMCIESMQHR3dbXmJRIK6ujqo1WrGwtR+fm/gcrmwtLSEg4MDtFptl9ZfjUaDoqIi1NfXw83NzaiTrbuRyWRIS0tDQ0MDhEIhhg4dalQXFRcXF7z++uuoqKhATk4OLl68CLVajWHDhjF9Mjc3h5mZGX799VfY29tj7ty5vXb/6Yr2hAG5ublITEyEmZkZKisrcevWLYhEIkyaNAkxMTG4efMmrl69Cmdn5z4PMqWlpZBKpUxKeB6Ph9GjRyMyMhL29vZQKBSwtrZmBsOWlhZYWFjA0tKy34OPQCBAQEAAnn/+eaSnp+PWrVtIS0uDQCBgrFVyuRyNjY1QqVQAwCSIGT58OF544QUsW7asT+NI+74Ae3t7uLu7D3iSsrtpbm7u4Hohk8lw7do1FBQUYOjQoVi5ciWeffbZTseP9ljGrq6uffIX5/F4MDc3Z8aDM2fOMMeqqqpw9uxZnDt3Ds3NzXB3d4e3t3e/Vxf1ej3EYjGzZL5w4UJYWVn1SLGmf+c2aE8sMxDKuJmZmdGVcScnJzz77LP3lRsWFoawsDAMHToUFy5cwKlTp3DgwAHo9XqMHz++V2NK+wTL1NQUWq0WtbW18Pf371BGpVKhtLQUp06dQm5uLjOuRUREPLBsnE1NTUhPT0dycjJ4PB4CAgIQHh7e63oEAgHjqmJqaoqlS5ciKCgI9fX1KCkpgVQqhU6ng06nA4fDgUAgABEhKysLxcXFOHHiBFJSUgCgTwq5VqtFVlYWKisrYWFhgYMHD6KoqAjAnXvR/rdEIoFOp8OtW7dQWFgIS0vLfq00cTgcDB48GHPmzMHNmzfB4/Hg4OAAe3t7TJ8+HVOnTsWlS5eY/kdERGDmzJldWu77046KigooFAq4u7sjNDSU8dXPz89HeXk5jh8/Dh6PB1dX106V5J4yduxY7N27F9evX8fChQuZyZtYLEZycjLq6urw6KOP3mP5b2trg1AohKura7+uefskV6VSobGxEceOHetwfPjw4QgKCoKrq2u/V8cHVBknIib5wfDhwzF+/Hi4uLgYpW6tVotTp06htLQUer0egYGBmDt37oApgl3RvkwmFovh6OjYYVOWsUhISIBYLIaJiUm3LyWdTgelUolz584hLy8PKpWKsSCHhYX1SqapqSmcnJwgEomQm5uLjIwMDBkypEMZpVLJzNRTUlIglUoRHBxstHv8VwoKCnDt2jXIZDK4urrC0dHR6JtEzc3NMXz4cAwfPhzz58+/53hLSwtiYmLA5/MxceJEvPDCC0aT7enpieDgYFy9ehUJCQm4ePEieDweBg8ejPnz52Pt2rUoKytDSkoKTp48iUmTJvXZXcXMzAx8Ph8ajQZisRi//vor/vjjDzz22GMYMWIEampq4ObmBm9vb3A4HFRVVcHNzQ0+Pj7w8vLql6LWvsn5nXfeQUtLC/bt24fMzExYWVnB0dGRsTwlJiaiqqoKwJ0VCV9fXyxduhQvvfRSn+97dXU1Wltb+6SAtC/R9lUxbE8Q0q6c1tTU4PLly4wCtnTp0k7P0+l0qKurY6zqfbnf9vb2GDduHEpLS1FXV4c333yzQ79EIhGEQiGTXKPdp70/GAwGJuEJcOfF9SBXLP8bmDBhAoKCgqBSqfDnn3+iubkZKpUKUVFRPVbIuVwu3NzcEBQUhIqKCsTFxcHZ2Rm2trZQKpXQ6/UoLy9HXFwc9u7di5qaGvB4PCZ51YNAr9ejrKwMly9fhlqthqWlJRYuXGgUX2o/Pz94eXmBz+dDr9dDp9MxCaTaE5QZDAbs3r0bv//+O/Ly8lBdXY19+/aBz+dj/vz58PDw6FVflEol2trakJubi4aGBjg7O8PLywsODg5MoIPdu3ejubkZMTEx8PT0hLOz8z3v0N4ybNgwfPDBB8jIyGDuYXviNbFYjP3796Ompga2traYM2cOoqKijLp3y8HBAVKpFIMHD8ajjz6KadOmwcXFBUOGDAER4fr16/jjjz9w+PBhHDp0CI888ggWL17cZ3lz5szB+vXrceLECSxfvhxubm4QCoXIy8tDQkICrK2t73EdkclkqKyshI+PD8aOHduv1c/GxkZm70FJSQm2bdsG4M4KRWtrKzw8PPDMM89g1qxZGDFiRL8U/wFVxmUyGW7cuAGlUonp06cjIiLCKINxu8/Szp07oVarIRQKERwcDDs7uwc+2Dc2NqKgoAD19fWYPHlyr5XenpCRkYG6urr7lquoqEBGRgZ++eUXyGQy8Hg8ODk5wdHRsdcPpImJCRwcHODg4IDr16/j3XffveehKi4uRkVFBaqqqnD79m3GQmPsJbF26urqoNVqweFwMGzYsAfm69hO+wvll19+gZmZGV5//XWjrfIAdxTkBQsWMJkem5ubIRKJsGLFCqxduxYCgQBz585FTk4OUlJSkJWVBWdn5x5HA7mbadOmoaSkBMnJyUy6e4VCgUOHDnV5jrW1Nfz8/LBixQo8++yzRrnPVlZWeOWVVzp819bWhq+//hppaWkA7ijiISEhWLt2LR577LF+PePnzp2DWCzutXVZq9Xi/PnzUKlUsLa27pOi2q7E363MtyvmEomEWX34a//EYjGuXLmCmpqaPrsR+fr64u2334ZcLsfFixeZpdb2dPRr165FYmIi4uPjERISgqCgoD7JuRutVov8/Pw+TV44HE6fszT+t2FpaYnnnnsOwJ39DF9//TUUCkWPo0RxuVxMnToVKpUKb7zxBr777jskJyfj0UcfRWFhIVQqFbKystDS0sK4etnZ2cHNzc2o41dXEBFqa2tx8eLFDhbT++1D6glqtRoVFRUoLS3FsGHD4O7uzoxLf53MvP3225g8eTLWr1+PK1euIDs7G7/88gu8vb0xePDgHq/4tUesGTFiBPz8/LBkyRJERkZ2UPoMBgMOHz4MtVoNJycnZGRkQCaT9VsZNzExgbOz8z3RiIgIMTExuHjxIlpbWzFt2rR+K6J/hcPhYPbs2cjNzUV4eDg2bdp0j1Fm7ty5cHFxQUpKCsRiMWpqavol09HREePHj8eZM2dw7NgxODg4YOTIkVCpVNBoNBAIBB2uhVKpxLFjx5CVlYWNGzf2e9Xa1tYWo0ePxty5cyESiTB48GAYDAZIJBJkZWUhJycH//znP5GUlIRNmzb1OTMzgL5l4OwJer2eNm/eTC4uLjRu3DiKiYnpV313o1ar6d1332ViL8+bN4/KysoGJJva/YiPj6dZs2aRl5cXffLJJwMiY/HixWRjY0M8Ho/eeOONTsuo1Wpas2YNCYVCJt6mi4sLffLJJ1ReXt4nuY2NjXTy5EmaPXs22djYkFAo7PBxd3cnT09PsrS0ZOJ7rl271qjB9u9mzZo1ZGdnR5aWlvThhx+SWCweEDldUVlZSZ988glxuVxyd3enW7duDZicvXv30urVq2nTpk0dYqUqlUpasmQJmZmZUXR0NKWnp/dJhsFgoMrKSvriiy8oICCAvL29mZjWf82k99dPZGQkHTt2zFjd7YBer6effvqJAgMDmXjQ4eHhFB8fb5T6//WvfxGPx6PQ0NBOY113hsFgoOvXrzMZJLdv3051dXW9lr1q1SpycHCgxx9/nC5cuEAajYYSEhLIzc2NRCIRffzxxx2yNer1etJoNLRmzRry8PCgVatW9TgmeleoVCq6ePEibd26lbZu3UpnzpwhnU5H69atI0dHR3J3d6cff/zRKPF56+rq6JFHHmHihmu12vueI5PJaMOGDcThcMjOzo7S0tKMGp/5rxk4e9KmB4VCoaCtW7eSu7s7TZs2rdfnS6VS2r17N40bN44Zo62srCgoKIhWrFhBp06dopEjRxKXy6WJEycOSOztzmhubqaff/6ZxowZQwDI0dGRdu3aZZS6z5w5Q6GhoWRlZUXvvvsu5efn3/f30tLSQpGRkSQUCsnCwoLefvttys/P75VcpVJJcrm8y+ekoqKCrK2tadSoUZSQkEAFBQUDGpO7pqaGxo4dS6ampuTq6kqxsbFG14cMBgN9+eWXTC6OrsbP/Px8evLJJ8nS0pK++uqrfss9ceIEk1AyLCyMtm7dSq+++ioBoFGjRpFYLCadTkcqlYr27dtH7u7u5O3tTbdu3RowXYTozm8gLS2N5s+fz+R76UlGUqPGGe8J586dw+bNm6FQKLB48WKMGTPGaHVrtVpmuQAA/vnPfz7wTZvtNDY2QiaT3bMp6kGi1+vxxBNPMDFA22n35+rNEtzdiEQizJkzB9OmTUN2djYTy7OdJ554AjweDx999BH27NkDsVgMHo83ICEN28O/yWQyeHp6YsSIEXB1dTW6nO6QSqW4du0azM3NMXPmTAQHBw+IHDc3Nzz33HOMtexuhEIhnnjiCcTFxSEtLQ3l5eXw9/fv9T6J9pj0a9euxdq1a9HS0oIbN25AoVBg06ZNjE9lZ9TU1DARMozN4cOHsWXLFuTn54OIMGjQIIwfP35A3L96AhEhLS0N27ZtQ319PcaMGYNHHnmk1246tbW1kEgkjA88cMfCFh4ejj///BNLly7Fxx9/jPj4eJw8eRI2Nja4cOECvvvuOyQmJmLixIlYtGhRvy1rAoEAUVFR94SUO3DgAOrq6hAVFQVvb2+jhWLr7ZisUChw+PBh8Hg8rF+//r65DXqLq6srAgICcPv2bcjlcmzevBnr1q0zqoy+YmFhwaz4GQyGXp/v6OiIZcuW4emnn2aipZiamjLv3tLSUiYiU3BwMAICAoza/q44f/489uzZg7S0NAiFQgQEBGD58uVGqVuhUEAqlaK1tRVbtmyBVqvFm2++2W3AAUtLS2zbtg1PP/008vPzmRjl3UWh+StCobDLlUEiwtmzZ9HS0oLp06dj1KhRA64bPPnkk0hPT4dOp8OyZcvg7+8/IPqQubk59Ho9NBoNNBrNPW57crkcN27cwIULF4wWz//xxx9HXV0ddu3ahYyMDFy/fp051traisTERGg0Ghw/fpzx6b5w4QJGjBgxILpIO0KhEE5OThCLxcyG2f649g2IMi6TyfDee++hoaEBU6ZMwaRJkwZ0x3ZjYyMaGho6bHwSCAQwMzMDl8tl/MeICHK5HN988w3zQzExMcFLL72EgICAPm28zMnJQW5uLoKCgjBhwgSj9emv0L/DG5aVlSE2NhZlZWX49NNPmeXmdveNu1m/fj1mzJjRb9lmZmYYO3bsPeEK2+UNHjyYeXnX1dVBLBYb3Xe/3d0JuLOpo7+B/PuCRCJBSkoKnJ2d73GteJDMmzcPFy5cwO+//46jR4/C3d2935NdKysrPPLII0zymZSUFPB4PCxZsgTPP/88Tp48iSNHjjA+3ANBWloaNm7ciOLiYuh0OggEAsyaNQsvv/yy0QZVLy+vXiU50Wq12LJlCw4ePAgnJycmPFpvXS8cHR0xZMgQXL9+HYWFhcjNzUVERARMTU0RHByMa9euIS4uDv7+/mhpacH69euxd+9eaDQaLFy4EK+//vqAhQutrKyEXq+HhYUF5s2bZxQXFeBOJISNGzciMzMT9fX1ePnll/H9999361ep1+vR2NgIR0dHrFy50ijt+G+hpqYGV69eRXFxMaZOndqnOjgcDiwsLDqNYiGRSJjQoF5eXv3aWNdTrl69il27duHy5cvg8XgYNWoUvv/+e6NtyF2wYAFkMhk+++wzlJeXg4h6pATm5uYy7xNXV1ej6yftoWknTZo04AElSktLkZ2dDZ1OhylTpuCZZ54ZkHvL4XCwevVq3Lx5EwcOHMCHH36I9evXw9fXF1wuFy0tLYwRVi6Xw9LSsk+bzTtj2bJleOyxx3D8+HHs3r0b6enpAO5EcXv66aeZcuPHj8dvv/0GT0/PATXOEhGuXLmCN998ExkZGQgJCcHChQv7FUnP6Mq4wWDAwoULkZubCxcXF6xevbpXM86+MHPmzHse7mHDhmHMmDGwtLSEWCxGbGwsgDsX8W7rFHDnhfvKK6/0ejNLQUEBCgoKGAf/gYqp+dhjjyE3NxeZmZmIi4vDpUuXQETM5px27pY/d+5ceHp6GrVN96uLiGBvbz8goR3bs6va2Njg8ccfZ3bTPyhycnIQFxcHuVwOT0/PBy7/bkxMTLB8+XIkJibiyJEjCAgIgJeXV7/9twxVpgAAFuVJREFU49p9/qdOnYoNGzZAp9Ph999/R1VVFePzCPxvAg9jEx8fz0QCEAgEWL58OVatWmXU8SMyMhKurq5QKBSQyWRwdHS8x1dUqVQiIyMDv//+OzIzM5GUlASDwYDvvvsOkydP7rPV+K233kJraytOnDiBLVu2IDs7m4nGo9PpkJaWhu+++w6pqaloa2vD4MGDsXr1aixYsKDPq1s94euvv0ZzczPGjx+PsLAwo71A+Xw+QkND8Y9//AOvvPIKjh8/jhUrViA0NLTTyVVpaSk+/vhjyOVyPP7440bP7ldaWorExETk5uYatd6/cu7cOUgkEgQGBvbYsl9fX4/Dhw8zPvsDYa2Pj49nwv71N2lYT8jMzMTmzZuZRDEhISHYsGGD0WJeA3f68eSTTzKb2g8fPozCwkLMnDkTCxYsuGf1dNeuXfjtt9+Ql5fHjGd3Z0c1Nv1NFNYdRITq6mrMnTsXTU1NcHFxwUcffTSgiWk4HA4+/fRTJCYm4sSJE0y+Bnt7e8THx+PgwYOQyWTw9fXFokWLsGjRIqPJdXZ2xksvvYRnn30WP//8Mz766CM0NjbCysoKL7zwAsaMGYP58+f3O4FWZ7QbQ01MTNDU1IStW7di586daGhoQHBwMDMp6U+kMaMr4xUVFbhx4wY0Gg1eeeUVhIWFGT3ihYmJCSIjI3H+/HkA6JD6tZ2MjAzk5+eDy+VCp9OhpaUFPB6PuUmRkZEYMWIETExMMG7cuD5Fh8jIyEBxcTFEIhECAwPvCSdlLP5fe/ceFOV1PnD8u7vgKjdhQW7LRe5iFoaLCKiItyAipFhjFBPbkI4mjXRiGtQhzYzTaWPasU5majvOZMbJ1E4qauhY0wQSotJwUxoDwbsGo6AEiRXEXS7usvv7g9/uaNS0xj37puV8ZjKJToZn35f3nPfZc3tmzZrFe++95yiTPTIy4hjFV6vVWK1WVCoV/v7+REVFUV5eTlJSkmOXtWh3Nny1Wi3kG2lzczO3b98mODiYwMBAYZtEH+TMmTPU1dXh4+NDZmYmGo0Gk8nEwMCAsNNjvs1jjz1GaWkpO3bsoLq6mvj4eIqKih752EF7uen8/HxqamoYGRmhqamJkZERrFYrCQkJjt3jzjQ4OMiuXbswGo3A2OzH4sWLSUhIcOrzZO8DLl68yMaNGwkLC7snMTQajbS3t3P58mWGh4eZNGkSBQUFZGdnP9LyjdDQUF555RW0Wi379++nsrKS6upq1Gq148hBk8nE4OAgRUVFvPTSSxgMBvz8/IQVJuro6OD9999naGiIjIwMgoKCnPoit5eQXrp0KTU1NbS0tNxT+RPGZlPr6+s5cuQIwcHBrF+/3mmfwa6+vp66urrvtATkP/Xpp5+yc+dOhoeH8fb2fmAy3tfXR11dHRaLhZaWFtrb27lx4wYGg4FVq1Y5febv2rVrfPDBB/T39xMXF0dYWJjQYz1NJhO/+tWvHFUQp02bxooVK5gzZ47T3w++vr68+uqrmEwmamtraWpqorW1lZ07d97znrh27Rp9fX2OJRaRkZEsW7ZMaDEXUaxWKydPnnQs6SsuLv5OSxYfVnBwMNu3b2fTpk3U1tbS0NCARqPBaDTi5ubG0qVLee655+5blPBR2I+p1Gq1TJ8+ndTUVA4fPozVauX69es0NTWRmprq1OWjZrOZS5cuOWp99Pb20tDQwIkTJzAajaxdu5a1a9cSFxf3yEeEOi0Zt/3/junNmzdjMplYs2YNxcXF9xSvcIYJEyawdetWdu7ceVc1up6eHtra2rh+/TojIyP4+vo6yl27ubmRlZXlmL4JDAxk8uTJqNVqvL29H3rXsdlspr29nStXrhAREUFqaqrT1ll+k16v55lnniEoKIhPPvmE9vb2+/5/JSUlrFixgqSkJDw9PZ12GP2/YzabsdlsuLu7C0kaRkdH+eKLLzCbzY61eq6qmmg3NDTkOCrLzc2N2tpaDh48SEhICBUVFS4vC6zValmyZAl1dXUcO3aMY8eOMXv27IcuonE/kydPpry8nBs3bnDhwgX6+/vR6XSkpaWxcuVKHn/8caeNnsLYGcgvvPACly9fxmKxEBISwtNPP01WVpaQNX/2kZVjx45x/Pjxe5IDs9mM0WjEYrHg4+PDihUrWL9+/SP3ZRqNhujoaNatW8e0adNobW3l4sWLtLe3k5OT4/j/8vLyyMzMJCEhwVGdVJTTp087qp76+Pg4/X6r1WpiYmIoKyvj+PHj7N69G41Gw6pVqwgICODmzZt0dXXR0NDAn/70J27dusXy5cuduscIxgaJmpubOXfuHDC2n6a8vFzIl8re3l5OnTpFX18fR44cIT4+ntHRUXp6evD29ubo0aOMjIzQ29uL1WpFo9Gg1+spKSkhNzeX2NhYp/8eurq66O7uZmRkhOTkZCIiIoT1ofYp/JMnTzIwMMCUKVMoKCjgySefdPrAHIw9Y5GRkVRUVDBr1iwaGhr4/PPP6enpccxa3/nZYOx0IYPBwJIlS1i4cKHTakXYY5w+fdoxcn3n7LWz2KuK/uY3v+H27du4ubmxYMGC//gc/0ehVquZO3cur732Gn/5y19obm5m0qRJpKWlkZOTw9KlS4mLixPyu7ZLS0vjhRdeAMaWqlitVkJCQpyWg9lsNlpaWjhw4ACnT59meHiYrq4uTCYTfX196PV6tmzZQl5eHlFRUU5pr07L1kZHRzl06BA1NTXYbDaWLFlCRESEkIRQrVaTkZGBSqW6a5Sjv7/fcRg9jB3FFhUV5TguLCYmxqmVIQcHB9HpdOTm5jq1EuQ3abVaZs+eTUREBElJSdTW1tLW1kZXVxeJiYlkZmZitVopLi4mOzvb5YnqiRMnMJlMpKSkCJsd8Pf3R61Wo9PpXD4qfiej0UhdXR3nzp1z/F5cnYjbTZ06lTVr1nDt2jU+++wzWltbnbJHQKPRkJWVRUVFBTU1NZw9e9ZxbGdaWprT11eePXuWgwcPMjIyAsCSJUuYM2eOUxP+Oy1fvhw/Pz/efPNNOjo67irEA2Pr5zMzMwkLCyM3N5e0tDSnjba4ubmRmJjIlClTyMzM5Pr163R2dt41dW8wGJyaHHyb7u5ubt++TWBgIAaDQUhFUg8PD7Kzs9m8eTN79uxh7969XLt2jczMTC5dukRLSwtnz56lo6ODpKQkiouLnf4it1d3tVdeXbhwIXl5efccEfeoYmJiWL58Of7+/vT39zv2XwwNDeHu7o6/vz8DAwN4eXkxb948VCoV0dHRREdHYzAYHuqIvYdhLwJnr48g8ljYzs5Odu3aRXd3t2Oz6Pz584mIiBDWV6rVapKSkggMDCQlJYVLly5x9epVRwXjqKgourq6mDJlCmFhYSQkJBAdHU1CQoLTj0S22WyOI/1EzMLY977t27ePo0ePAmObUsPCwlz27vfx8SE/P5+goCCeeOIJJkyYgF6vJzo6mqioKOGHaeh0OubPn4+Pjw/d3d0EBQURHBzstFnqxsZGdu/eTU1NDdevX0er1WI2mwkLC6OoqIicnBwWLFjg1IrVTmn1VquVK1euUFlZ6fgmGhoaKvzBELWh6T+h0WjIyckhIiKCtLQ04Wde63Q6dDod4eHhJCQk8Omnn9LZ2YnBYGDWrFlYrVaX3PP76evrIykpiYKCAiHnrKvVavLz8+ns7CQ+Pt5lFePupNfrSUlJoa2tjYkTJxISEsK8efOckvx+V1qtlsWLF9PQ0MCHH35IQ0MDs2fPdkoi4+HhwQ9+8AP0ej1ffvkl2dnZhISEOP35stlsVFVVOfqNxMREli1bJnTdY0xMDFOmTGFwcPC+ybiPjw/p6emEh4cL2ZSt0WgICgpyWRnyb/P5559js9lITU1l+vTpwtqWj48PpaWluLu7889//pPGxkZOnTrF8PAwN27ccJyhP2/ePCF9iJ+fH4sWLSI9Pd3xbxH0ej1PPfUUSUlJ9Pb2cvPmTS5cuOD4wuPl5UVwcDBeXl4kJyej0Wjw9/cXPgNy5swZbt++jU6nY/r06U5NIu5kNpv585//zMcff+yokzB79mxSUlJcMmhhb1dZWVkYjUYGBgb47LPPiImJ4fLlywQHBxMeHo6fn5+wZTr29c1Tp0595HXE9zM0NMTx48epqqpyLKMrLi4W0j9/G51Ox8KFC7/zZuNHFRAQIOz9e/XqVbq6uoCxQa/4+HgiIyOJiYkhLy/PqZW/7ZzylIyMjNDS0kJtbS0wdvrGv6sW+d9OrVZTXFzs8rg6nY65c+cqdtTb/eTm5hIZGcnMmTOFjGaqVCqWLVuGxWLBz89P2Ijpt0lOTuYnP/kJLS0tJCcns2jRIqeUhn9UXl5ezJ49m/b2ds6dO0d3d7dTNzzOmDFD6Jdem83Gu+++i81mY8KECZSUlDBz5kyhU5wwlhy+9NJLQmP8Nzh58iRWq5W0tDThX3J9fHx49tlnycvL4+9//zvNzc3ExcURGxvrqFwYHh4uZFQtJCSEdevWOf3n3o9er3f5sav/zscff8zw8DDTpk3D29tbWJzu7m7++Mc/cvPmTby8vMjJySE3N9fl98PNzQ1fX198fX0dm59dtelepVJRUFBAeHg4KSkpTl9yZDQaaW5u5uLFi0RHR5OUlMSrr74qdOZhvHnsscf44Q9/SEpKCiEhIcyfP5/ExESh73un/GSz2exYV6PVasnMzESn08kHY5z46U9/KjyGTqdT9Kgzf39/CgsLKSwsVOwzPEhRUREDAwO0tbVhMpmU/jgPzd7BRUZGUlxc7LIlGtLYTER7ezsTJ050SX/t4eFBbGwsGzZsYMOGDcLjSWO++uorIiIiyMjIENq+Tp06xeDgIFqtlqysLH72s5+RlZU1rnIB+wkvTz75pJCfr9FoCAgIIDU1lWeeeYaVK1cKm+kYrwwGw0OfrveonJKM23e5Tp48GYPBwLvvvvudTieRJOnhabVannvuOaU/xneiUql4/vnnee211ygrKyMqKkrx2YbxZMGCBVy+fJmUlBRhG9Al5dnPZRYtPj6e6OhoAgIC2LJlCzNmzFB0j8//In9/f8rKyigrK1P6o0hOpOrv73/gCfkiNvNIkiRJkiRJ0nhjsVjuO4P9rUNQVqtV6JmskiRJkiRJkjQePGhPzLcm47du3RLyYSRJkiRJkiRJArGHQUqSJEmSJEmS9EAyGZckSZIkSZIkhchkXJIkSZIkSZIUIpNxSZIkSZIkSVKITMYlSZIkSZIkSSEyGZckSZIkSZIkhTg9Gdfr9Xf9o9Pp2Lhxo7PD3GNkZISysjIMBgNhYWHMmTOH2tpa4XEB3nrrLebNm0dgYKBLSsPfqa+vj6effprQ0FAMBgP79+93afyOjg6CgoJYt26d8FhK3mc7V14vwLlz5ygqKiIiIoLU1FTee+89l8QFWLp0KUFBQY62PGPGDJfEVeqalWxLVVVVzJw5k9DQUFJSUmhqahIeU8lnS6l7rVQfMt7aklJ5AMC6detISEggPDyc9PR0du/e7ZK4duPpHQHK9F1KxRXZjp1ed/rq1auO/zYajSQkJFBcXOzsMPewWCzo9Xref/99wsPD+eijjygtLaWxsZHIyEihsYODgykvL+fw4cMMDQ0JjfVN5eXlTJgwgfPnz3PixAlWrlyJwWAgMTHRZfHT0tJcEkvJ+2znyuu1WCysXr2a0tJSDhw4QENDAyUlJSQmJhIbG+uSz7Bt2zZ+9KMfuSQWKHvNSrWlI0eOsGXLFt5++23S09Pp6ekRGg+Uf7aUutdK9iHjqS0plQcAvPzyy+zYsQOtVsv58+cpLCwkOTmZlJQUl8QfT+8IJfouJeOCuHYsdJnKwYMHCQgIYNasWSLDAODp6UlFRQWRkZGo1Wry8/OJiIigra1NeOwnnniCwsJCdDqd8Fh3MplMHDx4kF/84hd4eXmRnZ1Nfn4+e/fudUn8qqoqJk+ezNy5c10ST6n7bOfq6z1//jw9PT2sX78ejUZDbm4umZmZVFZWuiS+EpS6ZiXb0htvvMGmTZvIyMhArVYTGhpKaGio0JhKPltK3mul+xBX+r70H67MAwASExPRarUAqFQqVCoVX375pUtij7d3hBJ9l5JxRRKajO/Zs4dVq1ahUqlEhrmv3t5eOjo6XDZCrIQvvvgCNze3u74BJyUlcebMGeGxBwYG2Lp1K6+//rrwWN8H35frtdlsLvn92v3yl78kOjqaxYsXU19f77K4d3LFNSvVlkZHR2ltbeVf//oXqampTJ8+nY0bNyoy8+OqZ0vJfktJ46UtfZMSecArr7xCSEgIGRkZBAUF8fjjjwuPOd7eEUr1XUr3maLasbBkvLOzk8bGRkpKSkSFeCCz2czatWspKSkhPj7e5fFdxWQy4e3tfdff+fj4YDQahcd+/fXXWbNmDXq9Xnis7wMlrjcuLo6AgAB+//vfYzabOXz4MI2NjS7tdNra2jhz5gw//vGPKSkpET7CpNQ1K9WWent7MZvN/O1vf6O6upr6+nra29v53e9+JzSuks+Wkv2WUsZTW7qTUnnA9u3buXLlCtXV1RQVFTlGykUab+8IpfoupeKC2HYsLBnfu3cvWVlZTJ06VVSI+7JarTz//PNMmDCBbdu2uTS2q3l6enLr1q27/m5gYAAvLy+hcdvb2/nHP/7Biy++KDTO94VS1+vu7s4777zDhx9+SHx8PH/4wx9YtmyZy6bjZsyYgbe3N1qtltWrV5OZmclHH30kNKZS16xUW5o0aRIwtuksODgYf39/Xnzxxf/Z+wzK3Wsljae2dCel8gAAjUZDdnY23d3d7Nq1S2is8fiOUKrvUiouiG3HTt/AaVdZWcmGDRtE/fj7stlslJWV0dvby/79+3F3d3dpfFeLjY3FYrHQ0dFBTEwMACdPnhS+NKehoYHOzk4MBgMwNtI1OjrK2bNn+eSTT4TGVoKS12swGPjggw8cf87Ly1NktgnG1l/abDbhcZS4ZqXakq+vL3q9/q4pfFdN5yv1bCl1r79P/pfb0p2UyAO+yWKxCJ+FGI/vCKX6LiX7zG9yZjsWMjJ+7NgxvvrqK5ftnrb7+c9/zvnz56msrHR8e3IFi8XC8PAwo6OjjI6OMjw8jMViER7X09OToqIitm7dislk4ujRo1RXV7Ny5UqhcZ999llaW1upr6+nvr6e0tJS8vLy+Otf/yo0rlL3WanrhbEkZXh4mMHBQXbs2EFPTw+rV68WHre/v59Dhw457vG+fftoampi0aJFwmMrcc1KtSWA1atX89Zbb/H111/T39/Pzp07Wbx4sfC4Sj1bSt5rJfqQ8daW7JTIA77++muqqqowGo2Mjo5y6NAhqqqqyM3NFRp3PL4jQLm+S4m4otuxkJHxPXv2UFhYeM+6QJE6Ozt5++230Wq1JCQkOP7+zTff5KmnnhIae9u2bfz2t791/Hnfvn1s3ryZiooKoXFhbG3c+vXriYuLQ6fTsX37duEjTB4eHnh4eDj+7OnpycSJEwkICBAaV6n7rNT1wtg07+7du7FYLGRnZ3PgwAGXrH+0WCz8+te/5sKFC6jVauLj43nnnXdcclyWUtesRFsC2LRpEzdu3CA9PZ2JEydSXFxMeXm58LhK3WdQ7l4r0YeMx7YEyuQBKpWKXbt28fLLL2Oz2QgPD+eNN96goKBAaNzx+I4A5fouJeKKbseq/v5+8XNlkiRJkiRJkiTdQ+jRhpIkSZIkSZIkPZhMxiVJkiRJkiRJITIZlyRJkiRJkiSFyGRckiRJkiRJkhQik3FJkiRJkiRJUohMxiVJkiRJkiRJITIZlyRJkiRJkiSFyGRckiRJkiRJkhQik3FJkiRJkiRJUsj/ATUD5Klz7u3gAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "N = 24\n", "(training_digits, training_labels,\n", " validation_digits, validation_labels) = dataset_to_numpy_util(training_dataset, validation_dataset, N)\n", "display_digits(training_digits, training_labels, training_labels, \"training digits and their labels\", N)\n", "display_digits(validation_digits[:N], validation_labels[:N], validation_labels[:N], \"validation digits and their labels\", N)\n", "font_digits, font_labels = create_digits_from_local_fonts(N)" ] }, { "cell_type": "markdown", "metadata": { "id": "O4HyOPGwPS-z" }, "source": [ "# Keras model: 3 convolutioal layers, 2 dense layers\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 2289, "status": "ok", "timestamp": 1639691708196, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "lPvXoSnuPSDO", "outputId": "7abf798d-7ab7-4bb9-a5f5-d6cde29ab78f" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " image (Reshape) (None, 28, 28, 1) 0 \n", " \n", " conv2d (Conv2D) (None, 28, 28, 12) 108 \n", " \n", " batch_normalization (BatchN (None, 28, 28, 12) 36 \n", " ormalization) \n", " \n", " activation (Activation) (None, 28, 28, 12) 0 \n", " \n", " conv2d_1 (Conv2D) (None, 14, 14, 24) 10368 \n", " \n", " batch_normalization_1 (Batc (None, 14, 14, 24) 72 \n", " hNormalization) \n", " \n", " activation_1 (Activation) (None, 14, 14, 24) 0 \n", " \n", " conv2d_2 (Conv2D) (None, 7, 7, 32) 27648 \n", " \n", " batch_normalization_2 (Batc (None, 7, 7, 32) 96 \n", " hNormalization) \n", " \n", " activation_2 (Activation) (None, 7, 7, 32) 0 \n", " \n", " flatten (Flatten) (None, 1568) 0 \n", " \n", " dense (Dense) (None, 200) 313600 \n", " \n", " batch_normalization_3 (Batc (None, 200) 600 \n", " hNormalization) \n", " \n", " activation_3 (Activation) (None, 200) 0 \n", " \n", " dropout (Dropout) (None, 200) 0 \n", " \n", " dense_1 (Dense) (None, 10) 2010 \n", " \n", "=================================================================\n", "Total params: 354,538\n", "Trainable params: 354,002\n", "Non-trainable params: 536\n", "_________________________________________________________________\n" ] } ], "source": [ "# This model trains to 99.4% accuracy in 10 epochs (with a batch size of 64) \n", "\n", "def make_model():\n", " model = tf.keras.Sequential(\n", " [\n", " tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1), name=\"image\"),\n", "\n", " tf.keras.layers.Conv2D(filters=12, kernel_size=3, padding='same', use_bias=False), # no bias necessary before batch norm\n", " tf.keras.layers.BatchNormalization(scale=False, center=True), # no batch norm scaling necessary before \"relu\"\n", " tf.keras.layers.Activation('relu'), # activation after batch norm\n", "\n", " tf.keras.layers.Conv2D(filters=24, kernel_size=6, padding='same', use_bias=False, strides=2),\n", " tf.keras.layers.BatchNormalization(scale=False, center=True),\n", " tf.keras.layers.Activation('relu'),\n", "\n", " tf.keras.layers.Conv2D(filters=32, kernel_size=6, padding='same', use_bias=False, strides=2),\n", " tf.keras.layers.BatchNormalization(scale=False, center=True),\n", " tf.keras.layers.Activation('relu'),\n", "\n", " tf.keras.layers.Flatten(),\n", " tf.keras.layers.Dense(200, use_bias=False),\n", " tf.keras.layers.BatchNormalization(scale=False, center=True),\n", " tf.keras.layers.Activation('relu'),\n", " tf.keras.layers.Dropout(0.4), # Dropout on dense layer only\n", "\n", " tf.keras.layers.Dense(10, activation='softmax')\n", " ])\n", "\n", " model.compile(optimizer='adam', # learning rate will be set by LearningRateScheduler\n", " loss='categorical_crossentropy',\n", " metrics=['accuracy'])\n", " # Going back and forth between TPU and host is expensive. Better to run 128 batches on the TPU before reporting back.\n", " return model\n", " \n", "with strategy.scope():\n", " model = make_model()\n", "\n", "# print model layers\n", "model.summary()\n", "\n", "# set up learning rate decay\n", "lr_decay = tf.keras.callbacks.LearningRateScheduler(\n", " lambda epoch: LEARNING_RATE * LEARNING_RATE_EXP_DECAY**epoch,\n", " verbose=True)" ] }, { "cell_type": "markdown", "metadata": { "id": "3_29XvTdPf6R" }, "source": [ "# Train and validate the model" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 39316, "status": "ok", "timestamp": 1639691769977, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "-pJDpTa7Pdv0", "outputId": "38f771ce-57e7-4272-afbb-87f594202360" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Steps per epoch: 117\n", "\n", "Epoch 00001: LearningRateScheduler setting learning rate to 0.01.\n", "Epoch 1/10\n", "WARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/engine/training.py:2970: StrategyBase.unwrap (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "use `experimental_local_results` instead.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "WARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/keras/engine/training.py:2970: StrategyBase.unwrap (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "use `experimental_local_results` instead.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "117/117 [==============================] - 11s 43ms/step - loss: 0.1743 - accuracy: 0.9478 - val_loss: 1.0314 - val_accuracy: 0.5840 - lr: 0.0100\n", "\n", "Epoch 00002: LearningRateScheduler setting learning rate to 0.006999999999999999.\n", "Epoch 2/10\n", "117/117 [==============================] - 3s 23ms/step - loss: 0.0488 - accuracy: 0.9856 - val_loss: 0.2297 - val_accuracy: 0.9407 - lr: 0.0070\n", "\n", "Epoch 00003: LearningRateScheduler setting learning rate to 0.0049.\n", "Epoch 3/10\n", "117/117 [==============================] - 3s 22ms/step - loss: 0.0323 - accuracy: 0.9902 - val_loss: 0.0743 - val_accuracy: 0.9792 - lr: 0.0049\n", "\n", "Epoch 00004: LearningRateScheduler setting learning rate to 0.003429999999999999.\n", "Epoch 4/10\n", "117/117 [==============================] - 3s 23ms/step - loss: 0.0252 - accuracy: 0.9925 - val_loss: 0.0509 - val_accuracy: 0.9831 - lr: 0.0034\n", "\n", "Epoch 00005: LearningRateScheduler setting learning rate to 0.0024009999999999995.\n", "Epoch 5/10\n", "117/117 [==============================] - 4s 31ms/step - loss: 0.0182 - accuracy: 0.9942 - val_loss: 0.0239 - val_accuracy: 0.9915 - lr: 0.0024\n", "\n", "Epoch 00006: LearningRateScheduler setting learning rate to 0.0016806999999999994.\n", "Epoch 6/10\n", "117/117 [==============================] - 3s 22ms/step - loss: 0.0128 - accuracy: 0.9962 - val_loss: 0.0188 - val_accuracy: 0.9933 - lr: 0.0017\n", "\n", "Epoch 00007: LearningRateScheduler setting learning rate to 0.0011764899999999997.\n", "Epoch 7/10\n", "117/117 [==============================] - 3s 23ms/step - loss: 0.0100 - accuracy: 0.9972 - val_loss: 0.0173 - val_accuracy: 0.9944 - lr: 0.0012\n", "\n", "Epoch 00008: LearningRateScheduler setting learning rate to 0.0008235429999999996.\n", "Epoch 8/10\n", "117/117 [==============================] - 3s 22ms/step - loss: 0.0089 - accuracy: 0.9975 - val_loss: 0.0157 - val_accuracy: 0.9945 - lr: 8.2354e-04\n", "\n", "Epoch 00009: LearningRateScheduler setting learning rate to 0.0005764800999999997.\n", "Epoch 9/10\n", "117/117 [==============================] - 3s 23ms/step - loss: 0.0066 - accuracy: 0.9985 - val_loss: 0.0171 - val_accuracy: 0.9944 - lr: 5.7648e-04\n", "\n", "Epoch 00010: LearningRateScheduler setting learning rate to 0.0004035360699999998.\n", "Epoch 10/10\n", "117/117 [==============================] - 4s 32ms/step - loss: 0.0066 - accuracy: 0.9984 - val_loss: 0.0172 - val_accuracy: 0.9944 - lr: 4.0354e-04\n" ] } ], "source": [ "EPOCHS = 10\n", "steps_per_epoch = 60000//BATCH_SIZE # 60,000 items in this dataset\n", "print(\"Steps per epoch: \", steps_per_epoch)\n", " \n", "history = model.fit(training_dataset,\n", " steps_per_epoch=steps_per_epoch, epochs=EPOCHS,\n", " validation_data=validation_dataset, validation_steps=1,\n", " callbacks=[lr_decay])" ] }, { "cell_type": "markdown", "metadata": { "id": "XcCAaXzyPlTI" }, "source": [ "# Visualize predictions" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 561 }, "executionInfo": { "elapsed": 7698, "status": "ok", "timestamp": 1639691777671, "user": { "displayName": "Yoshihisa Nitta", "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgJLeg9AmjfexROvC3P0wzJdd5AOGY_VOu-nxnh=s64", "userId": "15888006800030996813" }, "user_tz": -540 }, "id": "CBYFpaa2PjzL", "outputId": "bf981779-af35-4b98-c051-25e199adc370" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# recognize digits from local fonts\n", "probabilities = model.predict(font_digits, steps=1)\n", "predicted_labels = np.argmax(probabilities, axis=1)\n", "display_digits(font_digits, predicted_labels, font_labels, \"predictions from local fonts (bad predictions in red)\", N)\n", "\n", "# recognize validation digits\n", "probabilities = model.predict(validation_digits, steps=1)\n", "predicted_labels = np.argmax(probabilities, axis=1)\n", "display_top_unrecognized(validation_digits, predicted_labels, validation_labels, N, 7)" ] }, { "cell_type": "markdown", "metadata": { "id": "iH6a_i33Ux1F" }, "source": [ "## Deploy the trained model to AI Platform prediction\n", "\n", "Push your trained model to production on AI Platform for a serverless, autoscaled, REST API experience.\n", "\n", "You will need a GCS (Google Cloud Storage) bucket and a GCP project for this.\n", "Models deployed on AI Platform autoscale to zero if not used. There will be no AI Platform charges after you are done testing.\n", "Google Cloud Storage incurs charges. Empty the bucket after deployment if you want to avoid these. Once the model is deployed, the bucket is not useful anymore.\n", "\n", "\n", "Google Cloud Platform に deploy しないので、以下は省略。" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "UoPZHczBP2EG" }, "outputs": [], "source": [] } ], "metadata": { "accelerator": "TPU", "colab": { "authorship_tag": "ABX9TyPqQ6XR/PZEM3dRdYll4QRR", "name": "TPU_MNIST.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.9" } }, "nbformat": 4, "nbformat_minor": 1 }