From 8cd12162a24bcd0113a73bdde0eddd1f1607bd93 Mon Sep 17 00:00:00 2001 From: tdelteil Date: Tue, 23 Oct 2018 22:12:37 +0000 Subject: [PATCH 01/10] Fixing the autoencoder example --- example/autoencoder/README.md | 19 +- example/autoencoder/autoencoder.py | 206 ------ .../convolutional_autoencoder.ipynb | 598 ++++++++++++++++++ example/autoencoder/data.py | 34 - example/autoencoder/mnist_sae.py | 100 --- example/autoencoder/model.py | 78 --- example/autoencoder/solver.py | 151 ----- 7 files changed, 606 insertions(+), 580 deletions(-) delete mode 100644 example/autoencoder/autoencoder.py create mode 100644 example/autoencoder/convolutional_autoencoder.ipynb delete mode 100644 example/autoencoder/data.py delete mode 100644 example/autoencoder/mnist_sae.py delete mode 100644 example/autoencoder/model.py delete mode 100644 example/autoencoder/solver.py diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 7efa30a19b78..3111bac438f3 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -1,16 +1,13 @@ -# Example of Autencoder +# Example of a Convolutionnal Autencoder -Autoencoder architecture is often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using stack of fully-connected layers for both encoder and decoder. The number of hidden layers and size of each hidden layer can be customized using command line arguments. +Autoencoder architecture is often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using stack of convolutionnal layers for both encoder and decoder. -## Training Stages -This example uses a two-stage training. In the first stage, each layer of encoder and its corresponding decoder are trained separately in a layer-wise training loop. In the second stage the entire autoencoder network is fine-tuned end to end. +![](https://cdn-images-1.medium.com/max/800/1*LSYNW5m3TN7xRX61BZhoZA.png) -## Dataset -The dataset used in this example is [MNIST](http://yann.lecun.com/exdb/mnist/) dataset. This example uses scikit-learn module to download this dataset. +([Diagram source](https://towardsdatascience.com/autoencoders-introduction-and-implementation-3f40483b0a85)) + +The idea of an autoencoder is to learn to use bottleneck architecture to encode the input and then try to decode it to reproduce the original. By doing so, the network learns to effectively compress the information of the input, the resulting embedding representation can then be used in several domains. For example as featurized representation for visual search, or in anomaly detection. -## Simple autoencoder example -mnist_sae.py: this example uses a simple auto-encoder architecture to encode and decode MNIST images with size of 28x28 pixels. It contains several command line arguments. Pass -h (or --help) to view all available options. To start the training on CPU (use --gpu option for training on GPU) using default options: +## Dataset -``` -python mnist_sae.py -``` +The dataset used in this example is [FashionMNIST](https://github.com/zalandoresearch/fashion-mnist) dataset. diff --git a/example/autoencoder/autoencoder.py b/example/autoencoder/autoencoder.py deleted file mode 100644 index 47931e5731df..000000000000 --- a/example/autoencoder/autoencoder.py +++ /dev/null @@ -1,206 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# pylint: disable=missing-docstring, arguments-differ -from __future__ import print_function - -import logging - -import mxnet as mx -import numpy as np -import model -from solver import Solver, Monitor - - -class AutoEncoderModel(model.MXModel): - def setup(self, dims, sparseness_penalty=None, pt_dropout=None, - ft_dropout=None, input_act=None, internal_act='relu', output_act=None): - self.N = len(dims) - 1 - self.dims = dims - self.stacks = [] - self.pt_dropout = pt_dropout - self.ft_dropout = ft_dropout - self.input_act = input_act - self.internal_act = internal_act - self.output_act = output_act - - self.data = mx.symbol.Variable('data') - for i in range(self.N): - if i == 0: - decoder_act = input_act - idropout = None - else: - decoder_act = internal_act - idropout = pt_dropout - if i == self.N-1: - encoder_act = output_act - odropout = None - else: - encoder_act = internal_act - odropout = pt_dropout - istack, iargs, iargs_grad, iargs_mult, iauxs = self.make_stack( - i, self.data, dims[i], dims[i+1], sparseness_penalty, - idropout, odropout, encoder_act, decoder_act - ) - self.stacks.append(istack) - self.args.update(iargs) - self.args_grad.update(iargs_grad) - self.args_mult.update(iargs_mult) - self.auxs.update(iauxs) - self.encoder, self.internals = self.make_encoder( - self.data, dims, sparseness_penalty, ft_dropout, internal_act, output_act) - self.decoder = self.make_decoder( - self.encoder, dims, sparseness_penalty, ft_dropout, internal_act, input_act) - if input_act == 'softmax': - self.loss = self.decoder - else: - self.loss = mx.symbol.LinearRegressionOutput(data=self.decoder, label=self.data) - - def make_stack(self, istack, data, num_input, num_hidden, sparseness_penalty=None, - idropout=None, odropout=None, encoder_act='relu', decoder_act='relu'): - x = data - if idropout: - x = mx.symbol.Dropout(data=x, p=idropout) - x = mx.symbol.FullyConnected(name='encoder_%d'%istack, data=x, num_hidden=num_hidden) - if encoder_act: - x = mx.symbol.Activation(data=x, act_type=encoder_act) - if encoder_act == 'sigmoid' and sparseness_penalty: - x = mx.symbol.IdentityAttachKLSparseReg( - data=x, name='sparse_encoder_%d' % istack, penalty=sparseness_penalty) - if odropout: - x = mx.symbol.Dropout(data=x, p=odropout) - x = mx.symbol.FullyConnected(name='decoder_%d'%istack, data=x, num_hidden=num_input) - if decoder_act == 'softmax': - x = mx.symbol.Softmax(data=x, label=data, prob_label=True, act_type=decoder_act) - elif decoder_act: - x = mx.symbol.Activation(data=x, act_type=decoder_act) - if decoder_act == 'sigmoid' and sparseness_penalty: - x = mx.symbol.IdentityAttachKLSparseReg( - data=x, name='sparse_decoder_%d' % istack, penalty=sparseness_penalty) - x = mx.symbol.LinearRegressionOutput(data=x, label=data) - else: - x = mx.symbol.LinearRegressionOutput(data=x, label=data) - - args = {'encoder_%d_weight'%istack: mx.nd.empty((num_hidden, num_input), self.xpu), - 'encoder_%d_bias'%istack: mx.nd.empty((num_hidden,), self.xpu), - 'decoder_%d_weight'%istack: mx.nd.empty((num_input, num_hidden), self.xpu), - 'decoder_%d_bias'%istack: mx.nd.empty((num_input,), self.xpu),} - args_grad = {'encoder_%d_weight'%istack: mx.nd.empty((num_hidden, num_input), self.xpu), - 'encoder_%d_bias'%istack: mx.nd.empty((num_hidden,), self.xpu), - 'decoder_%d_weight'%istack: mx.nd.empty((num_input, num_hidden), self.xpu), - 'decoder_%d_bias'%istack: mx.nd.empty((num_input,), self.xpu),} - args_mult = {'encoder_%d_weight'%istack: 1.0, - 'encoder_%d_bias'%istack: 2.0, - 'decoder_%d_weight'%istack: 1.0, - 'decoder_%d_bias'%istack: 2.0,} - auxs = {} - if encoder_act == 'sigmoid' and sparseness_penalty: - auxs['sparse_encoder_%d_moving_avg' % istack] = mx.nd.ones(num_hidden, self.xpu) * 0.5 - if decoder_act == 'sigmoid' and sparseness_penalty: - auxs['sparse_decoder_%d_moving_avg' % istack] = mx.nd.ones(num_input, self.xpu) * 0.5 - init = mx.initializer.Uniform(0.07) - for k, v in args.items(): - init(mx.initializer.InitDesc(k), v) - - return x, args, args_grad, args_mult, auxs - - def make_encoder(self, data, dims, sparseness_penalty=None, dropout=None, internal_act='relu', - output_act=None): - x = data - internals = [] - N = len(dims) - 1 - for i in range(N): - x = mx.symbol.FullyConnected(name='encoder_%d'%i, data=x, num_hidden=dims[i+1]) - if internal_act and i < N-1: - x = mx.symbol.Activation(data=x, act_type=internal_act) - if internal_act == 'sigmoid' and sparseness_penalty: - x = mx.symbol.IdentityAttachKLSparseReg( - data=x, name='sparse_encoder_%d' % i, penalty=sparseness_penalty) - elif output_act and i == N-1: - x = mx.symbol.Activation(data=x, act_type=output_act) - if output_act == 'sigmoid' and sparseness_penalty: - x = mx.symbol.IdentityAttachKLSparseReg( - data=x, name='sparse_encoder_%d' % i, penalty=sparseness_penalty) - if dropout: - x = mx.symbol.Dropout(data=x, p=dropout) - internals.append(x) - return x, internals - - def make_decoder(self, feature, dims, sparseness_penalty=None, dropout=None, - internal_act='relu', input_act=None): - x = feature - N = len(dims) - 1 - for i in reversed(range(N)): - x = mx.symbol.FullyConnected(name='decoder_%d'%i, data=x, num_hidden=dims[i]) - if internal_act and i > 0: - x = mx.symbol.Activation(data=x, act_type=internal_act) - if internal_act == 'sigmoid' and sparseness_penalty: - x = mx.symbol.IdentityAttachKLSparseReg( - data=x, name='sparse_decoder_%d' % i, penalty=sparseness_penalty) - elif input_act and i == 0: - x = mx.symbol.Activation(data=x, act_type=input_act) - if input_act == 'sigmoid' and sparseness_penalty: - x = mx.symbol.IdentityAttachKLSparseReg( - data=x, name='sparse_decoder_%d' % i, penalty=sparseness_penalty) - if dropout and i > 0: - x = mx.symbol.Dropout(data=x, p=dropout) - return x - - def layerwise_pretrain(self, X, batch_size, n_iter, optimizer, l_rate, decay, - lr_scheduler=None, print_every=1000): - def l2_norm(label, pred): - return np.mean(np.square(label-pred))/2.0 - solver = Solver(optimizer, momentum=0.9, wd=decay, learning_rate=l_rate, - lr_scheduler=lr_scheduler) - solver.set_metric(mx.metric.CustomMetric(l2_norm)) - solver.set_monitor(Monitor(print_every)) - data_iter = mx.io.NDArrayIter({'data': X}, batch_size=batch_size, shuffle=True, - last_batch_handle='roll_over') - for i in range(self.N): - if i == 0: - data_iter_i = data_iter - else: - X_i = list(model.extract_feature( - self.internals[i-1], self.args, self.auxs, data_iter, X.shape[0], - self.xpu).values())[0] - data_iter_i = mx.io.NDArrayIter({'data': X_i}, batch_size=batch_size, - last_batch_handle='roll_over') - logging.info('Pre-training layer %d...', i) - solver.solve(self.xpu, self.stacks[i], self.args, self.args_grad, self.auxs, - data_iter_i, 0, n_iter, {}, False) - - def finetune(self, X, batch_size, n_iter, optimizer, l_rate, decay, lr_scheduler=None, - print_every=1000): - def l2_norm(label, pred): - return np.mean(np.square(label-pred))/2.0 - solver = Solver(optimizer, momentum=0.9, wd=decay, learning_rate=l_rate, - lr_scheduler=lr_scheduler) - solver.set_metric(mx.metric.CustomMetric(l2_norm)) - solver.set_monitor(Monitor(print_every)) - data_iter = mx.io.NDArrayIter({'data': X}, batch_size=batch_size, shuffle=True, - last_batch_handle='roll_over') - logging.info('Fine tuning...') - solver.solve(self.xpu, self.loss, self.args, self.args_grad, self.auxs, data_iter, - 0, n_iter, {}, False) - - def eval(self, X): - batch_size = 100 - data_iter = mx.io.NDArrayIter({'data': X}, batch_size=batch_size, shuffle=False, - last_batch_handle='pad') - Y = list(model.extract_feature( - self.loss, self.args, self.auxs, data_iter, X.shape[0], self.xpu).values())[0] - return np.mean(np.square(Y-X))/2.0 diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb new file mode 100644 index 000000000000..17548ca9714a --- /dev/null +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -0,0 +1,598 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Convolutionnal Auto-encoder" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](https://cdn-images-1.medium.com/max/800/1*LSYNW5m3TN7xRX61BZhoZA.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example we will demonstrate how you can create a convolutionnal auto-encoder in Gluon" + ] + }, + { + "cell_type": "code", + "execution_count": 243, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import mxnet as mx\n", + "from mxnet import autograd, nd, gluon" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data\n", + "\n", + "We will use the FashionMNIST dataset which is of a similar format than MNIST but is richer and has more variance" + ] + }, + { + "cell_type": "code", + "execution_count": 315, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 512\n", + "ctx = mx.gpu() if len(mx.test_utils.list_gpus()) > 0 else mx.cpu()" + ] + }, + { + "cell_type": "code", + "execution_count": 316, + "metadata": {}, + "outputs": [], + "source": [ + "transform = lambda x,y: (x.transpose((2,0,1)).astype('float32')/255., y)\n", + "\n", + "train_dataset = gluon.data.vision.FashionMNIST(train=True)\n", + "test_dataset = gluon.data.vision.FashionMNIST(train=False)\n", + "\n", + "train_dataset_t = train_dataset.transform(transform)\n", + "test_dataset_t = test_dataset.transform(transform)\n", + "\n", + "train_data = gluon.data.DataLoader(train_dataset_t, batch_size=batch_size, last_batch='rollover', shuffle=True, num_workers=5)\n", + "test_data = gluon.data.DataLoader(test_dataset_t, batch_size=batch_size, last_batch='rollover', shuffle=True, num_workers=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 317, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,10))\n", + "for i in range(10):\n", + " ax = plt.subplot(1, 10, i+1)\n", + " ax.imshow(train_dataset[i][0].squeeze().asnumpy(), cmap='gray')\n", + " ax.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Network" + ] + }, + { + "cell_type": "code", + "execution_count": 640, + "metadata": {}, + "outputs": [], + "source": [ + "net = gluon.nn.HybridSequential()\n", + "with net.name_scope():\n", + " # Encoder 1x28x28 -> 32x1x1\n", + " net.add(\n", + " gluon.nn.Conv2D(channels=4, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=8, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=16, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=32, kernel_size=3, padding=0, strides=(2,2),activation='relu'),\n", + " gluon.nn.BatchNorm()\n", + " )\n", + " # Decoder 32x1x1 -> 1x28x28\n", + " net.add(\n", + " gluon.nn.Conv2D(channels=32, kernel_size=3, padding=2, activation='relu'),\n", + " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=16, kernel_size=3, padding=1, activation='relu'),\n", + " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=8, kernel_size=3, padding=2, activation='relu'),\n", + " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=4, kernel_size=3, padding=1, activation='relu'),\n", + " gluon.nn.Conv2D(channels=1, kernel_size=3, padding=1, activation='sigmoid')\n", + " )\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 641, + "metadata": {}, + "outputs": [], + "source": [ + "net.initialize(ctx=ctx)" + ] + }, + { + "cell_type": "code", + "execution_count": 642, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + " Layer (type) Output Shape Param #\n", + "================================================================================\n", + " Input (1, 1, 28, 28) 0\n", + " Activation-1 0\n", + " Activation-2 (1, 4, 14, 14) 0\n", + " Conv2D-3 (1, 4, 14, 14) 40\n", + " BatchNorm-4 (1, 4, 14, 14) 16\n", + " Activation-5 0\n", + " Activation-6 (1, 8, 7, 7) 0\n", + " Conv2D-7 (1, 8, 7, 7) 296\n", + " BatchNorm-8 (1, 8, 7, 7) 32\n", + " Activation-9 0\n", + " Activation-10 (1, 16, 4, 4) 0\n", + " Conv2D-11 (1, 16, 4, 4) 1168\n", + " BatchNorm-12 (1, 16, 4, 4) 64\n", + " Activation-13 0\n", + " Activation-14 (1, 32, 1, 1) 0\n", + " Conv2D-15 (1, 32, 1, 1) 4640\n", + " BatchNorm-16 (1, 32, 1, 1) 128\n", + " Activation-17 0\n", + " Activation-18 (1, 32, 3, 3) 0\n", + " Conv2D-19 (1, 32, 3, 3) 9248\n", + " HybridLambda-20 (1, 32, 6, 6) 0\n", + " BatchNorm-21 (1, 32, 6, 6) 128\n", + " Activation-22 0\n", + " Activation-23 (1, 16, 6, 6) 0\n", + " Conv2D-24 (1, 16, 6, 6) 4624\n", + " HybridLambda-25 (1, 16, 12, 12) 0\n", + " BatchNorm-26 (1, 16, 12, 12) 64\n", + " Activation-27 0\n", + " Activation-28 (1, 8, 14, 14) 0\n", + " Conv2D-29 (1, 8, 14, 14) 1160\n", + " HybridLambda-30 (1, 8, 28, 28) 0\n", + " BatchNorm-31 (1, 8, 28, 28) 32\n", + " Activation-32 0\n", + " Activation-33 (1, 4, 28, 28) 0\n", + " Conv2D-34 (1, 4, 28, 28) 292\n", + " Activation-35 0\n", + " Activation-36 (1, 1, 28, 28) 0\n", + " Conv2D-37 (1, 1, 28, 28) 37\n", + "================================================================================\n", + "Parameters in forward computation graph, duplicate included\n", + " Total params: 21969\n", + " Trainable params: 21737\n", + " Non-trainable params: 232\n", + "Shared params in forward computation graph: 0\n", + "Unique parameters in model: 21969\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "net.summary(dataset_transformed[0][0].expand_dims(axis=0).as_in_context(ctx))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the original image goes from 28x28 = 784 pixels to a vector of length 32. That is a ~25x information compression rate.\n", + "Then the decoder brings back this compressed information to the original shape" + ] + }, + { + "cell_type": "code", + "execution_count": 643, + "metadata": {}, + "outputs": [], + "source": [ + "trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': 0.001, 'wd':0.001})\n", + "net.hybridize(static_shape=True, static_alloc=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 644, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [0], Loss 150.58451856303418\n", + "Epoch [1], Loss 65.12515858707265\n", + "Epoch [2], Loss 59.445904230667374\n", + "Epoch [3], Loss 56.62768763354701\n", + "Epoch [4], Loss 54.96188484909188\n", + "Epoch [5], Loss 53.87394831730769\n", + "Epoch [6], Loss 52.72701322115385\n", + "Epoch [7], Loss 51.91863496424788\n", + "Epoch [8], Loss 51.15499382345085\n", + "Epoch [9], Loss 50.44610543536325\n", + "Epoch [10], Loss 49.78377904647436\n", + "Epoch [11], Loss 49.42993790064103\n", + "Epoch [12], Loss 48.85279147907839\n", + "Epoch [13], Loss 48.56229133279915\n", + "Epoch [14], Loss 48.0335202991453\n", + "Epoch [15], Loss 47.71448484241453\n", + "Epoch [16], Loss 47.63018746661325\n", + "Epoch [17], Loss 46.98289346287393\n", + "Epoch [18], Loss 46.91378939353814\n", + "Epoch [19], Loss 46.51542467948718\n", + "Epoch [20], Loss 46.18931540464744\n", + "Epoch [21], Loss 45.93053886217949\n", + "Epoch [22], Loss 45.839977297008545\n", + "Epoch [23], Loss 45.72159278998941\n", + "Epoch [24], Loss 45.57212373130342\n", + "Epoch [25], Loss 45.30989165998932\n", + "Epoch [26], Loss 45.123990050747864\n", + "Epoch [27], Loss 45.19418569711539\n", + "Epoch [28], Loss 44.83272643008475\n", + "Epoch [29], Loss 44.79928719284188\n", + "Epoch [30], Loss 44.52551999866453\n", + "Epoch [31], Loss 44.39976045005342\n", + "Epoch [32], Loss 44.31792534722222\n", + "Epoch [33], Loss 44.13317140758547\n", + "Epoch [34], Loss 44.093042405985166\n", + "Epoch [35], Loss 44.001953125\n", + "Epoch [36], Loss 43.874645265758545\n", + "Epoch [37], Loss 43.696017795138886\n", + "Epoch [38], Loss 43.65276108440171\n", + "Epoch [39], Loss 43.773793365995765\n", + "Epoch [40], Loss 43.58095870058761\n", + "Epoch [41], Loss 43.38808760683761\n", + "Epoch [42], Loss 43.41396651308761\n", + "Epoch [43], Loss 43.167876936431625\n", + "Epoch [44], Loss 43.35061490333686\n", + "Epoch [45], Loss 43.18432825854701\n", + "Epoch [46], Loss 43.1171875\n", + "Epoch [47], Loss 43.11041833600427\n", + "Epoch [48], Loss 42.99752938034188\n", + "Epoch [49], Loss 43.00297559428419\n" + ] + } + ], + "source": [ + "epochs = 50\n", + "for e in range(epochs):\n", + " curr_loss = 0.\n", + " for i, (data, _) in enumerate(train_data):\n", + " data = data.as_in_context(ctx)\n", + " with autograd.record():\n", + " output = net(data)\n", + " # Compute the L1 loss between the original and the generated image\n", + " l = (output.flatten() - data.flatten()).abs().sum(axis=1)\n", + " l.backward()\n", + " trainer.step(data.shape[0])\n", + " \n", + " curr_loss += l.mean()\n", + "\n", + " print(\"Epoch [{}], Loss {}\".format(e, curr_loss.asscalar()/(i+1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing reconstruction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot 10 images and their reconstruction by the auto-encoder. The results are pretty good for a ~25x compression rate!" + ] + }, + { + "cell_type": "code", + "execution_count": 645, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAAD4CAYAAAB7VPbbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XncXeO9//+PjioImSQikyBDIxLUXPMQHJTW1Koa2jrqlFMe6CnfPsppa+hwqgOtKi1KWxxKSWuoIcbGLIhMIhJJRCISdK7fPz/XeV9v97rs3LnvO3vf6/X867Oz1r322mut61pr71yfz7XaW2+9FQAAAAAAAOje3rOqdwAAAAAAAACdjx+BAAAAAAAAaoAfgQAAAAAAAGqAH4EAAAAAAABqgB+BAAAAAAAAaoAfgQAAAAAAAGqAH4EAAAAAAABqgB+BAAAAAAAAaoAfgQAAAAAAAGqAH4EAAAAAAABq4H1d+WarrbbaW135flUGDx6c4jlz5nT49o844ogUX3nllR2+/fZ46623VuuI7TTLOayjjjqHEc15Hq+55prs9VprrZXiZcuWpbhHjx7ZemuvvXaKJ0+enC07+eSTO3IXOwRtsfV197ZYF13dFldbrfrt3nqrfZfBhhtumOKDDjooxdtuu2223mc+85kUv/766w1t+/3vf3/2+tBDD03xxz72sRT/6Ec/yta78847G9p+R6Atdg+tcl98z3v+7//O//Wvf7VrGyeccEKb//7aa69lr/v27Vu5jf/5n/9p8991/1x797dRzdAW3/ve97b57yvSv+q673vf/31N/vvf/96eXWqXqs8RUf4seo/x9Ro9/63SFpV+746I2HPPPVOs53D11VfP1tPvE3rs/vKXv2TrLVq0KMUzZszIls2cOTPFy5cvb/N9IyJuuummyv0vnbf2aPQcMhIIAAAAAACgBlbriF+cGn6zLvxVcIcddshe//CHP0zxZpttluInnngiW+9Xv/pVip9++ukU+6/ro0ePTrH+71tExLhx41KsvwR++ctfztY777zzqj9AB2vFX3aRa4b/ZeloL730UooHDBjQ4dt/6qmnUjx27NgO33570BZbX3dsi3XUFW2xI0b/6GifCy64IFu28847p3jJkiUp9lEFL7zwQornzp1b+V4f+MAHUvy3v/0tWzZ8+PAU67ONj87UEUTf/e53s2UdPTqattg9NOt90Z/92zOa5pxzzslen3rqqSl+4IEHUuwj73TkiX+n+eY3v5niM844Y4X3KaJjRjWpZmiLOoJG+1fvh0ufXf+udFx+8YtfpFj76Mcffzxbb+TIkSnu06dPtmz8+PFtbtuvBd2nRu8brTISqNTG9Dj4SCz9Ln/DDTdky/T+p8fBj3/VPVMzDCLy+6KP0FuwYEGKP/jBD7YZR0Tsu+++KZ4yZUq2TO+n//jHP2JlMRIIAAAAAAAACT8CAQAAAAAA1AA/AgEAAAAAANRAy9UE0ry8Bx98MFu2wQYbpLhUVV+rfnul8I7Q6Pa1irjWH4p458weK6tZ863RuGbIt24Pz4v1qvtv0+r7ERF//etfU1w1W4Nv3/OodYax0j557YvORFtsfa3aFpFrptoH6sgjj8xen3TSSSn2/lOfI0r/3r9//xTr84XWq4jI+1efbVFfa//8xhtvZOtpP6x1GyIiHn744RR/4hOfaHPfVwRtsXtoxfvi5ptvnr3eaqutUjxhwoQUf+hDH8rWe/nll1Pcs2fPFK+xxhrZetrGtO5IRMSwYcNSrLMV3Xbbbdl6N954Y5vb6wzN0Ba1j9U6QF4TSPveRmvlHHDAAdnrz3/+8ynWmpOlfn7SpEnZsieffDLF5557bkP74Rqtg/TPf/6zoe2t6lkzqz6D/16xxx57pPjrX/96tmzhwoVtvpf+ThAR8eKLL6ZYvwf4e2nb0dp4vg1tw+uvv3623pe+9KUU33PPPdkyZgcDAAAAAABAp+FHIAAAAAAAgBpouXSwhx56KMU69DIiH67lw8uq0j3839tzPHQontMp7Tw1TPdxzTXXzJb95Cc/SfG///u/r/A+uVYcaotcMwy1bdSxxx6b4ksuuSRbpu30z3/+c4o11TMiH1a5bNmyFHsb1fU8VUKHv+p6/l5f+MIXUnzRRRdFZ6Ittr5Waouo1kzD3gcMGJBin+5W+0l/ZtHnD13mabOaoqBD4r/yla9UrudTT8+bN6/N9y09b3mfPGjQoBRrGrzeM3w/SukatMXuoVnvi//2b/+WvT7zzDNTPH369GyZtmGdbvqFF17I1tPvAtpOS+Uj3nzzzey1frfQtDR9VvLX3idoesqcOXNS3GjaqmuGtqh9kX5en15ceXrPIYcckuItttgixV5G4O67707xdtttl+IDDzwwW09TwK6//vps2S677JJiTaP97W9/m6135ZVXpvj1119v41O8cxv+rNzo1OOrui3qvUWf4TfccMNsvXPOOSfFnualbVPP23rrrVf5Xnqf9Wu+R48eKfbvD9OmTWvzvfy3Af0shx12WFRp9N5XQjoYAAAAAAAAEn4EAgAAAAAAqAF+BAIAAAAAAKiBlqsJpPvreZGah37rrbdmyzRPT7fh+XaaQ6rreW6f5uz51Naac6g59J5HeNBBB6XYc4E1d9Cnl2yPVZ3jiZXXDPnWVbmqe++9d7beLbfckuLFixdnyzRnWfNsPedd24C2HZ+OWLfhbUXrD2n/4FOl9u3bN8Vf/OIXs2U//OEPU9yVubrvhra46jRDW8TKa6a2+Jvf/CbFAwcOzJYtWbIkxeuss062TPu1V199NcXrrrtutp72u1r7wGspqGeffTZ7rX2t98NV63m9IH1u69evX4q9333iiScqt6HPZrTF7qGZ2qLe57UWS0ReV8W/g2j9K21v/qygzzbaFr0Wj37v8GVa41CX+XOUTkHvU1ZrnZz9998/VlYztEV9VqyqBRuRT8eudX8iIl555ZU2Y69vpt8XtY/2vnfp0qUpXmuttSq3od9TtXZaRF439te//nW27Mc//nG0ZVXXdmr0HDa6n14nSY+ztqmIiP79+6dYp2Pv1atXtp62CW07y5cvz9YbOnRoirXeV0TEjBkzUqznV9teRP459ZqIiDj00EOjLaV7Xwk1gQAAAAAAAJDwIxAAAAAAAEANvO/dV1n1dtpppxSXpvnToZN/+tOfsmV9+vRJ8fjx41N8xRVXZOvptG2PP/54iu+7775svT322CPFDz/8cLbslFNOSfH555+f4mOOOSZbT4dM+9AzHfp3wAEHpNiHwwHN4Kijjspez58/P8U+raambOlwXR/2qK91qKembkXkw3VffPHFbJmmG+jQTE8H0+kkDz/88GyZpoO1NwUMANxGG22U4n333TfF/vyiKQ6a8hWRP9toP9m7d+9sPV2mzxeasu586mTdxtprr51i7xd1umldLyJPI9PtffWrX83W+/jHP57irixbAOizuraViHy6d/8+UjUFt0/brqliyp9LtF15qrumrugzlm9b1/Op6vVZSmMvcdFKqp7RTjjhhOz1tttum+LbbrstW6b9rZfqUNp/aXqe91d6Dfn+6XOuppt5Kq5eG/6M+uijj6bY7x2tQFPiIvLvBePGjUuxP/t7SpXSlK1tttkmxXfddVe2npZv0XOtaZoR+fn1c6P7P3jw4BR7KQy99+n2fD8WLlyYYi9FU9XHtBcjgQAAAAAAAGqAH4EAAAAAAABqoCXSwb797W+nWIc6+tBJHXZ86qmnZst+/vOfp3jmzJkpnjVrVraeVnjX1BKvuH///feneMiQIdkyHbaplciPPPLIbL2q4dkR+RAwTbUhHQyrUtVQWx3KGJEPcX3ppZeyZXqta2qDD3fW9XQ4taeN3XnnnSnW1IiIiM022yzFmvbgMwnoME3fBoDGtGf2PE3BjoiYMmVKm/GK8D5CNVNq0UUXXZRiHdLvs9rocfXZZR577LEUX3PNNSn2Ye/HH398imfPnp3iESNGZOvpbGHXXntttkz7ZJ0ZSWc6jYjYcsstU6ypwRH5bCwvv/xyirWvjojYZZddUqx9PNDZttpqqxR7yol+7/BUd00n8e8MjahKE2uLpqLpPvlMS5oG7+lr+n577bVXin1GtFai6TL6PUpLeETksw/6M1/VjG3+3Fh1L/FnWX1+9fOj50SvJ0/70fuppttGRBx99NEp1nSwVilfUCrzsv3226e41D78uM6dOzfFmqI1cuTIyvU23XTTFHsaoH5X8Zkxhw0blmJNAfPZAzXN0M+Npm9rOljpWaYjMBIIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAGWqIm0Gc/+9kUX3zxxSkeNWpUtp7mznkOub7W3HOdGjoiz//VnEDPI5w6dWqKfVpq3a8NN9wwxffcc0+23o477phizY2PiDj44IMr/w5oNqNHj85el3J8NX990KBBKb7vvvuy9bRNaN0Kz/3V/FzN5Y/I609oW/cpW3W9AQMGVO47UHd6n/V89VINgi996UspPvTQQ1Os0+JGRGyyySYp1na5Ipqp7o8aM2ZM9nqdddZJsdYP8JoS+nm8zoDWkdB+cvLkydl6Wu9Az5PWS4jI62iMHz8+W6Y1jLbYYosU+7T1el143RTte7X20bRp07L1Tj755BRTEwhdqV+/fin2Z3O9nkv9nU4BXXoe0tovXnPGp4dW+t5aD9Wfj7Rt+v5qja+xY8dWvlermjBhQoq9nox+v/OpvPWcaOx9mfbLOk146Tz6+dFzon/n91b9O5++XOu4VU013sxK92u9b/lx1WPix1Xbn9YB9vqluk2t46XHNCLi1ltvTbHW2YrIrx89N1oDyPmynXbaKcXPPPNMikt9R0dgJBAAAAAAAEAN8CMQAAAAAABADbREOphO5bf11luneN11183W02GPp512Wrbspz/9aYqvv/76FJ911lnZejo8Uodn/b//9/+y9TSlTIccRuTD+HR6e03x8u0Draxv377Za02R1JSHiHx47fPPP59iHdIckQ+h1aG7OswzIp/604frahrBNttsk2Kf9lW371MwA2hbKR3iyCOPzF4feOCBKR4yZEiKX3vttWw9vX/6sPdXXnklxTpN7qxZs7L1dHi2D4k/55xzKve5s33ta1/LXvvne5v3hfoZfNi7Tm+sqVZDhw7N1tOp5DX2/lmP6w477NDm/kXkw+i9T9YUP5/uXtfVfffzpGm5+twXEfHQQw9V7hfQHj169Eixfre49957s/V22223FHuKkT5v6DY0Bd5pH+ptu2q9iLz9VU0XH5H3JR/+8IezZS+88EKKveRFd6DlATzlS8+PT/mtaUGq0em6S+extE09p36+NQXJ0wT1/Guffd111zW8H81KP7ffL/V4eUqZLuvVq1eKly9fnq2nqZ96HXgaqKb7+XcEv7be5mndValnERFHH310ijXturMxEggAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAZaoiaQ5kxq3p9PS6q8NsjTTz+dYs3X9Nogmher9YLmz5+frffRj340xT5lq9J8YmqNoDspTX+oNTq8noPWrXjyySdTvOWWW2br6WutAeFTSm+77bYpnjJlSrZs3rx5KdbcX88ffumll1LsUyb3798/xQsWLAisPK3BFJHXWFu0aFG2THOzS30tuobWwfB6L5p7f8YZZ2TL9H6tfYD3I9q+vV6Q5tiPHj26zdi36VOPd3VNIO0/Pv7xj2fLHnjggRRrrQKvKaH1ffzzaF0P/TutcRKR15HQPlPPRUT+DKT9s9NnKv9cWrvBp7jVZRp7jUe9tryeIjWB0NEGDRqUYp+KWvXu3TvF3nb0tdYX9fou/v2kEd4nVE1Vr88yERGbbLJJir3WmO6vPh91F/pcoXUqI/LPq/UiI/J+2e9x7VGqJVRVE8jr/uhztPb5EXktG+3bu0NNIJ2q3evo6LHzNqa17rROlp8LrVGn9fD8e4ZeL94/6POs1jz19bSukN8X9focM2ZMiv07TUdjJBAAAAAAAEAN8CMQAAAAAABADbREOlgVH0auw/aWLFmSLdM0Ah32qcP+IiKmTp2aYh165lO9aXrYiBEjsmU6XFSnjvPUM+VTTfpQMVSnBTo9lvo3PtxcpzX34ZU+jeDK7lN35CkYSodEeuqPvtbhuj78VVMF9G98SmNti95udtlllxTr0Of11lsvW0/TC8aPH58t02lVSQdbMTpk/eyzz06x98/aZidNmpQtO/3001N8wgknpFivsXfTaDs9/vjjU+xThHaHodWN8iHTesxKw+P32WefFPt0ruuvv36KdTpw75e1H/Cpe/U60eHfPkxcU6/1nr4qaJ+h091GREycODHFmkrnzwrad/kQc51KXdPG9P4WkR9/TZP1Zw89H97f6bPNkCFDUjx9+vRsvXHjxqXY0+D1vGl6ik4XHxHxn//5nym+5557oquVpnn2PkRf6/VbSivae++9s9df+MIXUqypB56mo+3vd7/7XYr/+7//O1uv9LxZ1R+W2n13V5XmpWldEXlqyfe///1s2YQJE1Ks9w9P/9JrS9uDp7ToeqXvCPp33u4vvvjiFF944YXZsqpp5luZ9rH6vc2vZU338WOmx8KfS5W2F42979Dz499bq/oL319NWyr1qZr+p38T8c77ZLPS53Y9Xp6ipcfIv2eo0rOiHnO9f2rfGhGxxx57tPk3vn095n4d6O8B3p71uj311FNT/JnPfKZy3zsCI4EAAAAAAABqgB+BAAAAAAAAaqAl0sGqhqSWhnhpFe6IPL1HU0E01SMiH8b861//OsU+E5nOvHHEEUdky3TWDB3W9rWvfa1yf0tDj7uzFRl+XLXMU3v03OswXJ8ZQYew+zY01elPf/pT5T7Uabi006r9TlO2HnvssWyZpmMqHwo9d+7cFOsQV58hSofH61DtiHyIqKag+LWgM/g4nW3hjjvuqFyvu2lPquPmm2+evf6P//iPFN99990p/uMf/1i53m9+85ts2eOPP55iHc5+/vnnZ+vNmDGjcr+q9t+HeuuwcE2fieie6WB6jnXYtbejKscee2z2+qijjkqxpz5peorPXKW0//ah83qf1KHhfr/XFA4fEr8q+WxC22+/fYp12Pe5556bracpr95P6rnSY67pWhER999/f4q1Tz7kkEOy9TTVYPLkydmysWPHplj7eP33iLyP9ranKcD33Xdfivfdd99svVWdnuLHuVGlFLC77rorxf7seeSRR6ZYnzk0hSAiYrfddkvx7bffnmJPG/jJT36SYp+pr6o/7IznmVKaTDM9P+l+apsq9R9+z9HnSJ3Z0FM/lF7nfnz070qzgyl/ltHUT09tU3rd+vOwPjs1u+HDh6dYnw09hUrP8XPPPZct02Ot59/bdtUzkpcPKfUleh71e6Y/m+g901OyNW1a75n6/TMi4uabb67cj2aiqbH6efx5QJ/RfPY3PeYDBw5MsT8r6Ixgesx33333yu35fVzblW7f241eF/58pOdU760f+9jHsvVuuOGG6Ej1/OUBAAAAAACgZvgRCAAAAAAAoAb4EQgAAAAAAKAGWqImUBXPD9QaAV4vSPPjq/I9IyJeeeWVNt/Lczr17w4//PBsmU6Nq8tK0/OV8si7sxXJCdecXq3d4ee6Ksdzv/32y9bTXFzP2dZ8fc3t9mmjfarrqu2XcoJ1/5spR/7djBgxIsX++bTmjk8BrXnPmlPt7UPz0h955JEUe167tm3vE7SukLZZb+eag+vndIcddojuRNuEnrcVqXel5/7ggw9OsdYfiIi44oorUqw1gbbbbrtsPa0v9fzzz2fLtL/W86Tbi4h44oknUjxlypRs2Y033phiPb9+zWkNlJ133jmaiddP09el/kWPn9cZ0HoUpTpAO+20U4p/9atfpdjvn5dffnmK9VxF5G1T991z9JXXPtBrsiqOyI+H1/NrVr/4xS9S7Hn/ely9P9UahGeffXaK/bjq+dXj5dMja+2mhx9+uKF91/45IuI73/lOiv3+/JWvfCXFv/3tbxvaflfRZwytUxYR8dJLL6V46tSp2bKHHnooxZ/73OdSrLUtIiKeeuqpFHsdksMOOyzFu+66a4q9n5s4cWKKtR15/abTTjstxVtttVW2TKc77mx6rTXzc66ee93PAQMGZOtpjaZp06Zly/r165fiF154ofK9tH8qTUFeUlVnyJ+P9Fr1vlDX1XY6bNiwbL1Wqgnk/ePbvCaQ1i3bcMMNs2X6fKjnyu/Bem/V9Ur30tL04mrw4MHZa/1e6edRawJpzU2vTdQq9Jjo8fLPozU/vRZWVU05/X4YkfdP+rzh90/t/3v16lW579pW/BzqdfbMM89ky/T60XapNeAiqAkEAAAAAACAduBHIAAAAAAAgBpo6XQwH5qnfDje+PHjU6xT/Xpagk5Z2rt37xTrMM+IPH1Bp8WNyIfIa4qaDierM02T8uOqQzk9VWP58uUp1jQfTxlQOpTwzjvvzJadddZZKfbh3ZpOokMON95442w9TV3xVLFGp1luVTptu5+DPn36pFiHsUbkQ1d1mQ9v1vbt14nSqTM1dS8iT/3RoZia8hCRD/30bfg5bxal/k95qkyjQ/I32mijFG+zzTbZMp3e8pprrknxEUccka2n0z7/13/9V4qvv/76bL1FixaleNSoUdkyvZZ0GO6TTz5Zud4BBxyQLdMhtZqi5kPE9TrzNN877rgjVqVSup62HU+J1PZWShubMGFCin26bk2lve2221KsqUgR+fn3KVC1P9f2Vkrl8v2t+sx6n/XX3tZXJW+zVSmX3gfpFPGe7qDTVOsQeE8zqHovnWb83WjqivYj3v/r8fch/DNnznzXbfv2u8pxxx2XYk1zjcivI7+361TF2g/pVO8RERdeeGGKPX1h7NixKT7ooINSPGbMmGy9vfbaq83t33rrrdl62qf6e2nqrN4jfTp6fc7yKZh1mmS9Jr3N6nHz56x77703moX2/QsWLEixHzt9jq9K5YnIj4NP767LSlPEl+jflVLKSqmxmnaifY4+87Yavbfo82XpOci/a+g9U9NlNYUsIj/uGns/r+egdH/WftPTkUrnW7ehn7OqvEmzOfLII7PXI0eOTLH2T37stG/R7+QReRuePXt2iv3c6P1J+3X9vhmR9wPe/+t5Kz2X63dET6XX99O+1dOBOxojgQAAAAAAAGqAH4EAAAAAAABqoKXTwUqz1+jMQhF5CtKkSZNS7EO3Ro8eneJbbrklxZoaFhExa9asFPtMNJp6NnTo0BSX0pa6Oz0fmoLnw4F1aHtpNrX28CH2OuOKzgYWkQ/51WGYnuKgf+ezSOy5554p1qHUPiRahzvqEMaI5r5mdAYJHXoekQ+J98+kQzo1pcPTxnS4rrZfTf+KyIfC6rB8374Ov9ThlhH5UFIf9q59QjPpiJnk9Jr12XB06PODDz6YLdMhtL/85S9T7G1Wz6Gml+mMbhH5NeFDmDUlQYev+5B1HepemhXjU5/6VIpLw6p9ljKfRakzeDpAKT1AUxG0j6qaFSMi4vjjj89ea6rJjjvumOJHH3208u90FqOTTjopW0/blaeW6LnT4176jKU0B/2cnjqk167OZNeqvM9TVelufuxKqStVvO/TIet6LzzhhBOy9bQd+fVYNRtcM8wcpbPglVLyfCi/3rt0PT9vv/vd71LsaVN6bHX7mnYdkc84o8fMZ5vR/tC3oanR+gyss3pGRGy66aYp9mck/Tvtb/0601QJP8d33XVXNIttt902xXr8/V7l9wWl/Z9uw9OItE3odeD3rao+PqL62aY0G6Kfm4EDB6ZYn9P233//bL1mOk/vRp8lqtLuIvL7kacZ6XO3HiM/93o9l1KylacSaYq7piR6+RBNkdLn4Yj8eVufn/Tfm9kf/vCH7PUxxxyTYu2TvB3pfcaPid4Xq2bBi8j77qqZaCPyZ1u/N+izaKkUhpYf8PuzXjN6XV177bXRmRgJBAAAAAAAUAP8CAQAAAAAAFAD/AgEAAAAAABQAy1dE6iU4671JyLyeheas+151Frn5MYbb0yx5mNG5HUG7rnnnmyZ1g/SPG+vV1Katq670dxcPV5eN6I9PI9dp1rV8+nTEH7rW99KsdYdiYjYbLPNUqzXmebvRuT5t57rq1NMaz69TyWvOdxed+TMM8+MZqXH3fNbS9ezHk/NwfXzqDnWmoutNRH8vX0/NFdec8L9POoUt1qXKqI1pkv1Kdy11o/XpRg0aFCKt9hiixR//etfz9bTWg46vXtEfg40T9trGmibmDdvXoq9TpSeJ7929LzpNeLtTc99qZ6Y1m3wuhy6DV/m+eidwd+zNKW70uN3zjnnZMu23377FHu9K81tP/vss1OsdZMiIi699NIUa+79woULK/fJc+q1hpW2ez/fpal29bxqPQCvM6M1HZqppld763jpfVLrDPoy1Z4aQO9G25/WXNC2HZHvo/bjEdU1gfxcd0TNsxU1bdq0FH/+85/Plj3++OMp9loPWhNP99vbr9ZW8VpYWgdCj5EfF32O3HfffVOszywReR0g75f12XP69Okp9hqEpXpduk09HqWaZF43UWsOrWr6jDF8+PAUez1Qr5emXnjhhRRr/Q+/H+lxbbSP92cbbVfaLv1ZVt16663Z6x122CHF+hzaGX1HV9H2os9ufg70O6LW/YmIuOGGG1Ks9zuvO6Pb1PPofZe+9jam506vC39G0s/l50e3r+uV2m8z8ecIbYvar+lzekR+D9K+MCLiyiuvTLHW7fXnea3Fo8dVny8i8vPmNeF0v/S59JFHHsnW07pj/lyu5+qJJ56IrtIaVwgAAAAAAABWCj8CAQAAAAAA1EC3TQfzoXQ6XE6HUfrwSE0fUhtvvHH2Wqc89+GiW265ZYp1CLFOQx3RmulgBxxwQIqPPfbYbNlTTz2VYp9CT4cIa5qJDxXXYXY+5E6Hb44bNy7FnhaiQ/N0yLKnGz3wwAMp/vnPf54t06HUOuTTU0JK52333XdP8VVXXZVin2pVj4emKkbkQ7WbjQ5nLA1p1pTIiHyYtKbm+LHVlC1NLfHhtHoOfMivDt/VIfZ+feq0jj7kVz+bTjXZFelBJXr8tc+JyNNVfao8nq9gAAAgAElEQVRRHQ572WWXpVj7qoiI22+/PcXeL86aNSvFmsJYmvZSj78Ot4/I+/L+/ftHFd2eXwdV7xWRD7XV69H7Dh1Kr0PlIyK+8pWvVO5XZ9G0u1GjRmXLtI/S6d39urzppptSPGfOnGyZTomtqad6nUfkx0zbjg83L03prvR+0OjfROTXifYjTs+rpuqs6Ps1I09F0iHm+iyi04BH5MPb9d7q29N7svYjEXn6vPa1nvpXSqFoZqecckqK99hjj2zZmDFjUuz9hqYlaPvz1ChtR952qtLknL6XpvD4OViyZEmKva/U5yJNn/dnam0rvr96DHSZp8Lo/dOflb0/WpXOO++8ld6GPsvp8773QXpMNA3Q+yZdr/SMpe1Z783uG9/4RuWy7qKqPICem4i8DXg6qz5babv01Fu9B5VS/PS1f6/R5zO9p3u/rNeJpxJpn6PPQa3U96qePXumWL8jeCrXQw89lGLvPz0F9m3eF6pSH6zvrcc4Ij+H+l3Cz5P2r1pKJCK/PrXv7myMBAIAAAAAAKgBfgQCAAAAAACoAX4EAgAAAAAAqIGWrglU4vmUOjXunnvumeJf/vKX2Xo6fbfWoPH8wqlTp6ZY62pE5Dm5Oi25TsccEXHvvfemuFWm8vv973+fYq/nM3LkyBR73RutqaQ5k54jrrmgnh+tea+aT+n1XbRugf6N12TSaQk9d1+n9tNlnjOq++h5opoPeskll6R48803z9abOXNmij3n9bHHHotmpbnNngOtucg+raPS3Ff/7HpstfaBX1va1r2mgeb/ahvTOjYR+bnytq77octWdU0gzRH/4Q9/2PDfNVrX6Gc/+1mKPbe8ahpgbwN6TktTB2utDM+V1jx8rUPidTk0p9rfS5c1WhPG87m9zlxH2W677VJ8/PHHV67nn1evdf182v9F5LVhPvvZz2bL9HrW7XldD+3rS7UPtI5Xo1N++3q6Tc/frzqPXu9Ba6vpfTwiv8e0Cj0mfv1ef/31KZ4xY8ZKv5fe4z73uc9ly37xi1+kWOth+L1V+1fvk6uedZphiniltXIiIg488MAUn3jiidmyj370oynWa680lXCpbqK2Nz8O2u9rf1uqxVOqXajno3QOSudDr0mtWeT769fCtGnTKrfZrEr9n9bd0v7a1/Nn57a2/W7vpfdk7cd1eu13236j09O3Em1Hes36s4meg6effjpbNnTo0BTr9wRvA9peGu2v/Nxre9H73frrr5+tp/2F177UGrV6LazqPrS9Jk2alOK99947xX69at1Kr2NYdVy9Nqw+A+v51H4rIm9vWs83Ij/m+v1W6+RG5N9VSt9jtF5tZ2uNXx4AAAAAAACwUvgRCAAAAAAAoAZaLh2sNDxSh3lr+ldEPjSzX79+KfZpVHWqN01h8rQlHWqmU7RG5MPxb7zxxhT78D5Vmu6+mehxvPbaa1fhnnQsT1nS86FDBD3NRNfz4YNKj1V3OW46BNLTL0vTHepUtjo0VqfDjsiPu6YVebvX/fB0PR02q9vzlK/SNK1K+xif9rWraaqBT6uu02p6qoxes3ocPBXg6quv7pD9bDal1AjVVX2yngMflq776imMej/R61yHI0dEDBgwIMU6tD0iv9/pe3nqmbZvvfdp+kNEPmTdU7l02LUu8+Os++QpM6oq1TMi76dHjRqVLStNLd8ZGk0ZKK2nyzwV4CMf+UiKNZXS03IapefD+7iq/rSULuppvlUpKM2euqBpdxpH5Mdi+PDhKfZp5nUK6FIqfClNR99Lyxd4O9J7mh9bbTt6r/B21Og50f3161PTaD1V6f7770/xmWee2dB7dbUVSaEaPXp0irX9VaV/OV9P21FpP/QcermBP/zhD23+TXelz/J6/PzZXe+nfh/TPkvbmKeUVaVw+jOkttlSWt+cOXPa/BwRecq8pl37PpZS5luFHks9xn789bnE074b7bt0m9ovlt7L6fnVa8lLCOh14eVh9HuSp7Z1JkYCAQAAAAAA1AA/AgEAAAAAANRAt0oH0/QIT9HaaaedUqzDxA4++OBsPU2duO+++1I8ZsyYbD2tDu4zY+gwMk190VnDnA/lbU/VebSfzj6FxugwVh8CrssGDRqULdO0EL22fbiuDmXV4ZGedqdDR33mHx1CW5Xi59v0VDHlw3BXJR0+6il32gf5EHOdHUH7Uz+u2nf58GZdV2M/rlXDoEszQvl7Ve1jKWWmtH39O1+vdH/xtLqOou8zceLEbJnOQun3CD3Helx8vzs6rU2PUaPpTRHVKRG+v3r+S9duKQ1UX+t1HFFOMesMK3KMqujn8XS2efPmpVhTUPxz699purwPo9fUEk8n0P3Q2U08tUl5WmBplsBWpedYZ2jriNna0Lw+85nPZK8HDhyY4rlz56bY0yW1XZX6buXLtB/WZyqdxS4i4kc/+lGKtW37NrpLqpje7/Re4rN96v3c+y+dsVf5/aiqdID3+drn+d/oMt13n7lV7/d6nUXkM6jqM2pX3+s6StUzpd879HuBzk7t65a+q+hzhLYBT7/U7xb+TKXfM/S+6/dqTYctpYh2ZXkYRgIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANRAy9UEKuXQa27fYYcdli3TaduvuOKKFA8bNixbT+sKjRgxIsWPP/54tp5O/Tl+/Phs2fTp01OstWY8N76EmkBodprb7DU5NJ/Wc7E1V17bhObVRuRtQNul9wE6daPvh/YJWjfHc4s1B9lzgVW/fv0qlzUTPa7e7/h0qFi1tE7DWWedlS0r3e/0utf7jE6xHhExf/78FHs9As2V17bidbF0ylzNjff1NAfe273W89Ht+TZeeOGFNvcvIq+LoLF/Lu0vvN7DJZdcEs2odJ/X+gHeT+pUwuutt17lNnSZH1c1ePDgFOuUxRHV0+n69Ll67v3ceB/9Nr/Wee5BMyjVyvn0pz+dvZ48eXKKq6a5jsjrkmjb8WnBS6qeU7T/jIg45phjUvy9732vchvdpSaQfn59rvM+T8+P3zP177S/8vOoyxqt7+b9od4zvQ6Q0noyXhNI31v7Za8V2eq8bqXejwYMGJAt0/ukHh9/3qiq1+TnQv/O22nVPc2/LyxatCjFjd7vOxsjgQAAAAAAAGqAH4EAAAAAAABqoFulg40dOzbFDz/8cLZMhwL2798/xT5log6X3GuvvVI8ZMiQbL1DDjkkxTvssEO2bMMNN0zxtGnTUnz00Udn640ePTrFmq4W0T2HaaL78qGNOv2mT9uu6ZM6hFNTOCLyqRZ1yk4feqlt27eh7UjTHHzoqHr55Zez19r++vTpU/l3QHs88sgjKf7Yxz6WLdMhyKNGjcqWDR8+PMWa6uNDkHUKcG87Ovy5atriiLw96xBzvx9rW/FpTrU9a5stTRnu29Ap0LXP0WHWEflQ7kmTJlVuf1VrNOVJ+ytP79S0dT3XeqycXiOeMqBD7PW8R+SpFnrepkyZkq2n6fJVQ+WBZqXXrPdB+hzh/aSmum+wwQYp9md47Xcb7QtL08yXviPo9wynn627fOfQvk37V0/D0s/u51jTcTT1ys+P9o/6N56qp+mx/l6aWqTn2Pv5UtkDTX3S7a9ICZJmpc8Yfl2+9tprKfYULW2beu79mOgyPW8r0t703Gu5hb59+2braRpoqY2VSlJ0NEYCAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUQMsla3s+pdJ8+MceeyxbpnnvEyZMSPHQoUOz9XbfffcUa26p59drjr7m/kZE3HjjjSl+8MEHU3zooYdm62lusdcE0jzF0mcGVhXNffXaEXrN/u53v8uW6ZTVmmfrbUyndtZpNL0uj27jlVdeqdxHzaPW6TYjIk444YQU+9TW+tm8BgCwskq1GLQOwKOPPpot89doPVrvoFQfSOsdvPrqq9myrbbaKsVaG8r7U722tD6T10BbffXVU7z22mtny/bff/8291f74Ii8JlOpHopiSni0Aq356dd2VX0fv+a93sjbSlOE+7TR2jZ1P3wbur9eS6Y7frd48cUXU7zmmmumWOvmROTPeX4eFy9enOLSc+7666/f5jZ8e1qHxrfx3HPPpVifc71P9b9TWjtQ+3at4daq9B7p16veq7TWb0R+/9Pr3o+jbl/X8zZaek7Tc6X3Mf0OE5F/P/HvEvp3pdrHHY2RQAAAAAAAADXAj0AAAAAAAAA10HLpYKUhw5qideyxx2bLzjrrrBT//Oc/T/G4ceOy9TQF7K677kqxTuMbEbHtttumWIekRUSMGTMmxSeeeGKKjzvuuGy9O+644x2f4W1dORwMaA8dXutDV3UYrl/3L730UufuWDuMHTs2xZ/+9KezZTqEs1evXl22T6iHVp6OF11Dh7b79LGadjJ79uzKbejU7zNnzkyxpiBE5Olh3lfr8PZFixal2K9hTVXx7Td6vTeaKgd0hEanZR4/fnyKfcpwTdmqmnq6rb9r62/ebf/0mUtTVzyNRdtsz549s2Wa9tRdpojXvkJTf/yYz507t804Ip8WXo+Ff9fTFKQ11lgjxaXpxXVac1+m6Uj+rDlv3rwUe3+oKYB6Hv29WoUecz0mmh4fkX9WLxOhaYGaIudplVVT0Ht707bpqVyajqfXnF8Heg5L2+/K9sdIIAAAAAAAgBrgRyAAAAAAAIAaaLl0sBId9qjpKBERX//611Osw6KdDsMqrafD7HwIp/6dDmXz4V8+TBpodvvtt1+Kq4ZARuRV/EePHp0t0xQDbSs6g0JEdTpAKVWylDZQGs6pQ3J1JsGIfIaFT37ykym+4IILKt8LADqKDisvzeijM9n07ds3W6Z9tD57eH+qaQ3+Xrp97f/1byLyYftDhgzJlulMZ8r3o5VTUtB6Gr3eNE1HUyIjqmf98u8IVe9VSgfzbTe6v5oGpW22u9KUrWXLlqXYv89pH3Xrrbdmy7Qv0hQ67f98mfap/iyrr332Nj0/+r6azuTb32WXXbJl+j3Tn19bkR4T/d7sz+2aAuazZlbN1FdK1dP25/ejUnpyVXqn3xf13Ou1GZG3za6ctY+RQAAAAAAAADXAj0AAAAAAAAA1wI9AAAAAAAAANdByNYE0r9Onpdb8TM+t9dy8RpRybnUKVKf5gprD6DWBNttssxRfffXVK7x/QFe7+eabU6x1tjzXXHOUvTaFKtXwqVrW3umCS+155MiRKfZpQLW+2HPPPdeu9waA9mq0/oc+Hy1fvjxbprV4tDaB17lo9H21n/RtaP//2GOPZcvuvPPOht6ru0xZje6lqu5PRP6soG3M/6aqXonT6740Hb3y7z4vv/xyikvfW0rTY7dS+3vqqadSPGjQoBQvXrw4W09rOz399NOdv2MdyM+Pfvetui5aidcYfZvX6dH1Ro0alS3Tmjtaw1fvTRF5e9HaTf5e+r3Da/bo93zd3o477pitp/VRdZ8i8uvRa0p1JkYCAQAAAAAA1AA/AgEAAAAAANRAy6WD+RRx6o9//GOKhw0bli3T4XM6LLpHjx7ZejqszofcVdGpBn0fdZo/n/Lv0ksvrdxmV04RBzRKhwXPnz8/xZ7y5dd6lfamdrVH6b00dWL27NnZsg022CDFP/nJTzp8vwDUU6P9nw5N92cWHUauKSOewqHp8/qc42n1Olzeh8Trs42mvsyZMydbT1MSPvzhD2fLdMr4mTNnVr5XK6WgoD60jIN7/vnnU9y/f/8Uv/nmm9l62k61rZSmr/Z0MG0fmvbkU5Drfmibdfp9p5W/f+iznPZXnrKqz69Oj0VVHJH3395/Va1XWqapRN4v9+7dO8VLly6t3J5fa61IU431fuff/6+77roUH3fccdmyH/zgBykulXHQ46+/DXja2Ny5cyv3Q9uLtsWbbropW0/TDvW+HZGXrPFlnYmRQAAAAAAAADXAj0AAAAAAAAA1wI9AAAAAAAAANdByNYFKuaqaA6hxK2rlnFzUw4QJE1Z6G81yne+zzz6rehcAoE1PPvlkin0K4GeffTbFWlPEp4PWWiG6Da+VoX2y989ah0RrGHidIt3mkiVLsmU+hfXbvG6G1tjoytpxQMnRRx+d4tNPPz1bpvV3PvShD6XY64toHVGtM6Ntynm7178r1Uq97777UvynP/2pcr2qbUe0bn2uK664IsU+7bb3e6rq83bEcSjVDiqdR603NXHixGyZ1gjSOmut6uGHH07xxhtvnGKd9j0iPx8XX3xxtkxfjx07NsWbbrpptp7W/Fy4cGGKvSaTXj9ed0nPzdSpU6MRU6ZMyV5rm5s+fXpD2+gIjAQCAAAAAACoAX4EAgAAAAAAqIHVGGYLAAAAAADQ/TESCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAb4EQgAAAAAAKAG3teVb7baaqu91VXv9Z735L9vvf/9729z2d/+9rdsvX/+858r/V6rrbZait966/8+8r/+9a8V3nZHeeutt1Z797XeXVeeQ+Q66hxGNM951Lay8847Z8tOPfXUFH/wgx9MsbcjbcOXX355tuw3v/lNirUtrkq0xdbXHdtiXWif869//avl2uLqq6+evR4zZkyKhw8fnuKZM2dm602dOjXFb7zxRuX29Vlp8ODB2bKNN944xW+++WaKZ82ala23aNGiFP/1r3/NlnV0P0xb7B66831xnXXWyV7vsssuKd52221T7N8/Zs+eneKHHnooW/bUU09V/t2q0pFt8T3veU86j83y7Obe+973pniNNdZIsT6vRuTnZ9myZZXLmkUrtsW11lore33yySenePz48Sn2+6d+f1i4cGGK//73v2frrbfeeinu1atXtmzp0qUpnjJlSorPO++8bL3XX3+9+gN0sEbPISOBAAAAAAAAaoAfgQAAAAAAAGpgta4cZtfRQ8N69OiRvT7xxBNTfPjhh2fL+vbtm+L3ve//suBeffXVbL25c+em+Pnnn0+xDpGOiNhggw1SPGDAgGxZVbqZDjWLiPjRj36U4uuvvz46UysO70Ouuwx7X3vttVN82223pXjcuHHZeh/4wAdWeNs+tPbuu+9O8QEHHJDirhyW6WiLra+7tMW6a9a2qClrERFHHnlkik855ZRs2UYbbZTiD33oQ5Xb/POf/5ziadOmpdiHva+77rop1iHwEXn6gz7bLF++PFtvwYIFKb7//vuzZT/4wQ9SPGPGjMr9bRRtsXto1ra4gu+d4s022yzFF1xwQbaeLuvZs2fl9rSNafplRMTPfvazNrf/4osvrsAed6zu3hb9XF166aUpHjt2bIo9HUyvixtuuCFbpmlL3hevKq3SFvV8XHnlldmyHXfcMcX6nVy//0fk58rvu0p/K/H1NOVZv4Pcfvvt2XoHHnhgiju7PAzpYAAAAAAAAEj4EQgAAAAAAKAG+BEIAAAAAACgBlquJpBOhzpx4sRsmU7b5jl7jU7D57V/3rYix0nX1fzDqm1HREyePDl7vfXWW7frvQv71BI5nqjWqvnW+++/f/Zac3d1uka/zrXNansured1hDTvVut/nX/++dl63/ve96o/QAejLba+Vm2LyDVrW/zyl7+cvf7sZz+b4tJzhNY+8LoUWotN+0yvTfCPf/wjxV6HRGupaR0Ef97Sfl33KSKfIlnrNnhdoUbRFruHZm2LbuDAgSneaqutsmXbbbddikeOHJlirSEakdf60Tpb/j1F26K234iIv/zlLynWtvPwww9n62kNGp2+OuKd05WvrO7SFrU/03P8/e9/P1tPaztpX+l9mfeB6g9/+EOKv/nNb6Z41qxZK7DHHatV2qLWAf7iF7+YLdP2obHfP/Vepd8fSvdFr92kr3X7XqNP7+vXXnttdCZqAgEAAAAAACDhRyAAAAAAAIAaaIl0MB3WrEPk1lprrWy90rTPpXQSVZU2tiLTuenQPx0a5kMCdaiYDkmLiPjud7+b4tNPP73h967SKsP7UK2Vhtp+9atfTfGpp56aLdNrXYdpervUNqttp9QWfZluo2p7ERFXX311ijX1ojPQFltfK7VFVGumtrjffvul+Fvf+la2TIeb67D0iHwIu8aeDuZT475NU1Mi8jQv7Z/9vUspZaXpdAcMGJDiBx54IMWHHXZYm/v3bmiL3UMztUW15557Zq+/8Y1vpPjPf/5ztuy1115L8dKlS1Psz/f6uqpdRuTtyL+bVLUxLYsRkX/P8PQUnZ7cy2u0Ryu1RT0Hm2++ebbskEMOSbGefz9+Vd85vY8u9d/6PVZLFvj5uOmmm1L8zDPPZMs6errxZm2Leu+IiLjuuutS7L8HvPHGGynW7+FeMkLp9wJvb/q6tEzbol8veu69TMaLL75YuV/tQToYAAAAAAAAEn4EAgAAAAAAqAF+BAIAAAAAAKiBlqgJdMYZZ6RY64ssXrw4W0/z+XTaxf//vVOs+ZM+1Zvmw2v+3oocJ80/XGONNVLsub+as++5g5qn36dPn3bth2rWHE80rpnzrX360kWLFqXYc6C1/el17nV6vJZEFW0TpdoUyvOC9b1OOOGEbNnll1/e0H40irbY+pq5LaJxq7otap/3xz/+McXrrLNOtp7WHvEpbvW5Qpf5evpMVHoG0vfyekHel7+t1Hd7/QSt3aCfU6fUjnhnPaIqtMXuYVW3RaVt5/e//322TK/1hQsXZsv0+4Py5w1ts9ouG33micjbcOm7j34H6devX7ZM2/MOO+yQYp3ufEU0c1scOHBg9vpXv/pViv35ddmyZSnWY+v9n36Hq+pfI/J+1Lehr/X8e40bXfbss89myz73uc+1+V7t1UxtUfmz+BZbbJHi5cuXZ8uq7oWNtrHSFPGl7zSl+qXrrrtuiu++++5s2XHHHdfQfjWKmkAAAAAAAABI+BEIAAAAAACgBqrnJmwiOpWfDtMrDc3zNBB9rcOMfTinDl3WYdI+rKtq+FdEntql0zX6kEMdluZD+NZcc80U9+jRI8VVUxICq9KVV16Zvdb24dds1XBJb0eNpmNWpXr6Mt2+tzcdMn3mmWdmyzo6HQwAIvLph/v27ZtiT3XXdBJPOfFpqt/m6WDa/2l/6n2hTq3r29b+Vbfv09HrM5Dvh/br+pzziU98IlvP7ylAV/nUpz6VYi3HEJG3TS/joN8ZtF2VpvBuND2ltJ6ml/l09NruPWWmf//+Kdb2112eefSYXXHFFdkyPXf+PVDPo26j1Jcpf17V75W+TK8NfS/9rhuRP6P6lPbnnntuik8++eQ296lVaRrf7rvvni3TshNebsXTIqvo+dDY05j1PJWmiNdrxPdB763bbbddtqx3794p9vt/Z2IkEAAAAAAAQA3wIxAAAAAAAEANtEQ62OTJk1PcaBV0H66l686fPz/FN954Y7Zez549U6zDs32IpQ7z8iGCOsRZ/06H80VUD62OKA/JBpqNz+xSGgqtQ151+GVp1oRG08EaXc9pe9NhmRF5W/d+BcCK01kyfMaaadOmpbgrZy9dFU466aQU64w8PrRdeT+p6e1V6QkReT9cNUNjRP68UTXbUUT+bOOp7poe5v2upqdov3vIIYdk61111VVt7i/Q2bbZZpsUL126NFtWmmmo0dSSqmcR7+90vdLzi7YPT0GpSjeKyNOghg0bVrn9VjVixIgUex+lqXF+XPSYVZ3TiOoU21LKV6P8POpr7TcjIiZMmJDi0047LcWl+0GrOOqoo1Ls9yo9b6V75orMuvc2L09RKl3R6DZKMxl//OMfT/HFF1/c8H6uLEYCAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUQEvUBJo4cWKKdbrpUs6e57Jrvv2LL76YYq035LQm0ODBg7NlWjfEa/1oXSHNm/dpVDWH0XNI//d//zfF1CFBs/N861IOtC7TqTj9bxrNZ24031fbW6lOhU/7OmrUqBRPmTKlofcCkDv99NNTfOKJJ6bYawLp/fnss8/Olv36179OsdbC0SnUI/L23Ew19fwZYMiQISnW+hzeB2l/5c8D+qyjtSL0mcdfa20Ff1bSPtmfS7Quhfb5vp4+9/hn0XOjffymm26arbfbbrul+Lbbbgugq+jU6f49Q9uA122pehYpPaOUahrq69I2dL1Se/a+Qz+b13XsDg488MAU+/HTPkrvJRH58SwdvyqNTgMfkZ+DUl0bXebXnV6vW2yxRYofeuihhva3mWmtOD92+t3bvy/oeStptO5W1d9E5NdF6XyW6ovut99+KaYmEAAAAAAAADoUPwIBAAAAAADUQEukg+mwrt133z3Fp5xySrbeuHHjUtynT59smU+p97aNNtooe71gwYIUv/zyyykuDTf3YV065EunIfSUGR2OeM0112TLdOg80Oy8fZSmd9ehsbqeD99sz9Db0pTSuo++v6Uh2TvttFOKSQcDGjN06NDstU6HrtMs+1B8nar4Zz/7WbbsvPPOS7GmjXmb1XQnHWYdEbFkyZJ32/VOs+uuu2avtY/T/k+fDSLyz1eaIl6fc/T4ROR9nKbI+bS7uj0/N7pf2o97mptu0/tx3f9FixaluFevXtl6Rx55ZIrvuOOObBlTxqMz6XXuqTellB1dtzSNdHvSxnx7uq62qVLb8H3Xdqr9te9H6bmqmen3O+/nNE3V+1Q9j6VjW5VKtCJpffpaz7HeI31/fZnu45577pniVk0H08+3/vrrp/jVV1/N1tN26se86vuDn0M95rrM1yt9z9B1dZm3N/3e4aE0gBMAAB5qSURBVL9JDBo06F33qTMwEggAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAZaoiaQmj17dop1mtmIPN/+wgsvzJZVTRc3YMCA7HWPHj1SPGvWrBSXpvUr5dRr7r1P3XjVVVel2KfCBZpdaVp1ve49l11zZjXftVQ7olQfqGp7TrfhNSw0d9e3oVNuonNoDbdtt902W/b666+n+M477+yyfcKKW3fddVM8ceLEbJnm72vb9v5B79V+39W6MWuuuWab2/NtbrXVVtmy3//+99UfoJONHTs2e601cbR/8s+j/DlCawu89tprKZ4/f362nh4TrYvk/Z3WXVi6dGm2TI+59pk6VW9E/gzk+6ufU5+dli1blq2ndTnWWmutbJl+TqAj6PWmNUm8D9Jlfm3rc0Vpiuqq2j+lKedLtYhK9Yd0H/X7TUT+WYYMGZJir8+1ePHiyu03s4EDB6bY66yVagJp/6X9VaM1gUrPvH6Oq64731/tY/35Vd/P7zGt6CMf+UiK9dj5cS09t5e+W1Stp0p1f0rvVdpG6Z6pbU6vW6/t19EYCQQAAAAAAFAD/AgEAAAAAABQAy2XDqZ8qJVOI6rTu0fkQ/V0mKZPFa3DJXv27Nnm3/vf+TBNHbKm++hTwp1//vmBVUfPoaf04d2ts846KS4Nf/W2U0p1UFXDaxsdkltSGnbtQ0c9ZRTto+dw/Pjx2bKjjjoqxd6frrfeeil+4IEHUuzTV3c0v0aYlvrd3XPPPSnW+2dEft8tpVuoRod4+3o6lH677bbLlq3KdDCfnv6VV15JsR4THyqu96c333wzW7Z8+fI2l+m/R+TtRVPFvD/W9EtN643IU0t0vUZT4iPy+66mnvk51FS0UrpLd6H9jU6L7NfvBhtskGJtA7fccku23owZM1JM3/XuNJW19Lyh9yf/nqFpHKVr1u8tVRpNB9N99NT8OXPmpHjMmDGVf6f7NGrUqGy9e++9t6H9bTaaYuPpVZpS5f2X9lGNpoNVfe/zvyulNOk9wKeBr1ovIu+Xe/fuHa1u++23T3GptIQe/9IxL6WDdYSqkhS+T9rG/LPo/VTbH+lgAAAAAAAAWGn8CAQAAAAAAFADLZ0OVnLNNddkrw899NAU65AsH66lw7CrhkpGRPTv3z/FPpRQt6FDM2fOnJmt19npDMjT+zwFZdiwYSm+/fbbs2U+swreafTo0Sn2lA5vV6oq9c63oW2u1GZL76tDLqu2F1Eeat23b9/KZch5CtC4ceNSrGkNW265Zbaepgr5uRk8eHCKf/rTn6b4+OOPz9bT4bSNGjFiRPb6iCOOSLEP1z333HNXePvdkQ6rv/LKK7Nlmg7h6c86xL407L2UKlE1NN+H6es2/ByvSv5cMmnSpBQPHTo0xV/60pey9XRIvM+MpWlTCxcuTLEPI9f1PKVMaVv0VDFdpn2tz4Sk++vvpTMNXXrppSn29jZv3rwUN8NsYKXUgyp+X9l5551TvM8++2TLdHYmTbV22q60LX70ox/N1nv00UdT/J3vfCdbxrPnO+k9Sa97P4faXz3//PPZMn2m1PVK6eel60qXldKTdR/9Hnzrrbem+OCDD86WaTvVz7zNNttk67VSOpimeWmf6v1QaXYwXabnwO8z2mc1mppUmmlarxkvVVK6Z+r+Dxo0KFrd1ltvneKqNPJ302gf3R6Nlp0opeF6e9b91b5c229nYCQQAAAAAABADfAjEAAAAAAAQA3wIxAAAAAAAEANdNuaQNOnT89er7nmminW3DvPy9OcQ82b1toyvr1Gax94/jA6h+ZHa26z1rDx9YYPH54t09oKTK/aNq1hUJrK2fNnta6Htj9fryrvtlR/qJSLre3S6xJpHrlPJ1mqn1FXOp2u1rbYa6+9svX0/Oox9nOo/avnwuu50lxxnS4+IuKpp55K8X333Zcte+aZZ1J8zDHHpPjDH/5wtl5VzZOIiMsuuyzqws/PQQcdlOIvf/nLKfb6AzotuZ7viOrpUUv59Y1O++ptVmsk6LW6qmldHn89derUFOuUvxERJ510UopLdXq0r9Lp1yPyujpVfXBEuZZCVS0TV7pnah2gO++8s3K9VUGvy8033zxbtv/++6fY91trq6y99topPvnkk7P1tGaWX7PLli1rc5nXW9I6QLqeTocdEXHggQemuF+/ftmyyy+/PMVPPvlkiv3aUh1RY2NFagd2NX0G1Ppy/uyv9yOtWxWR15LRbXi9q6rp40vHozTlvC5ba621smX33HNPir1OmF4z2j9svPHGle/V7PRa1/pIfm2XauzoM0ip9lxVf1iakrxU+7LUp1ZNRx+RfzY//61I26L2rX6eSs/+peNVpdHveqXnElX67uDnWtftyjqGjAQCAAAAAACoAX4EAgAAAAAAqIFumw6mQ2Yj8uFaOmRzwIAB2Xo6lE6Htpe270PDdPs6XbzvEzrflClTUuxD8TUdbO7cudmyqqGEjaYsOR3yWTVFekRzDY9+N2PHjk1x6bj4MFw9nqXhl42mHjR6zPQclKb69GWa+tmd+ZBZTfXxKd333XffFOtweT922v+Vhl83ukxTI3zY82677ZbiPffcM1umf6dDvb1P0D7f02Q22mij6G769u2bYk3rO/zww7P1ND1Aj6WnHOn59uNXNSTbrxltz6U0U13P+wddz+/xjfbZq9Jdd92VvT7kkENS7P1p1VTtmo4Skd932jNU3tfV2M+1vtbh/BHNPd20XisXXnhh5bLtt98+W7bhhhumeMGCBSnWZ8GIvH/xlJGq9MZSOyo9V2h6wfjx47Nlmho/e/bsFPtzkD4jzZo1K1um5Q20dIKngWr/7SlrN910UzQLvS9oO9I+LSI/Dlo2ICL/rPp33marUoBK/Z2rmj7er6uZM2em+KqrrsqWnXbaaSnW1LZSWmCzW2+99VJcVZojIr+2NY7Ij2ejJQsanSK+lBpYuhaq3te3od8z/b1apbSF9hOaJuufR0uxaB8UkfdDpWeFKo2mfDm9zrzPHDZsWIr9s+h15v1kZ2IkEAAAAAAAQA3wIxAAAAAAAEANdNt0MB0SGJEPldXhkj4kS4eU6SwPTof1+lBCVZq9AZ1Dj7nOeODpeH369EmxXwc+Q1HVNvTcl9IaNKVoyZIl2Xqlobw+lL6ZjBw5MsW+33osfJh6qaK/qhqG63/T6AwBpX8vbaPV08H8s2qKgqYD7brrrtl6en59hiUdaqttx9MfNFVMl/l62t68P61a5uvpeSulIFalhkVUDyGOeGdaUavQ6/e8887Llu2yyy5t/o33h9q+S6l7evx8WVUaS3vTs6rSIXx/dUamtvarGfm1p9epX9tVs9L4elUpCaX+1Pv1Uipz1Xv5TGc+21Uz2WKLLVLs7V2PS+mZT68vnzm2dNz1WDeaPqLXfdUzS1vbWGeddVKsqWLjxo3L1tPzvd1222XLqq4TT5/S9fw+4ukSq5KmnZSeB+64444U+/OZPh9q+yu1sfb2f1Vps96+dD9++ctfZstOOOGEFOusWo2282akaeL62dtbyqFUlqAqlavUZn1Z1X6UUgNLqUTaD3if4ClTzarq2vZ+d86cOSn253Tth7R/avQ6KM3wVkoV0/7f02u1bfozcEf0Ce3BSCAAAAAAAIAa4EcgAAAAAACAGuBHIAAAAAAAgBrotjWBvEbAK6+8kmLNE/W8S51WtZTTq1MLe+0gfW99X59OshVprqLnNGqeucYRESNGjEix5hvr9KQReV625zbra90PrTsSkeeda22oTTbZJFuvd+/eKfZaP5rLqTmefq5LtQH0OtD6AvPnz8/W0xxmryFwwQUXVG5/VdPPVKrB4vnLVfm+jeZbu0anbizVHyrl42rtqGai9Vc23XTTbJlO7+710bbaaqsU6/VWylH26dg131rbjm9D24u2U2+zmrtemm5adcT0p6X6JF7LZFVfB6Vcdm2Ln/zkJ7P1jjvuuBT7+amq/eDHXPtAPe7e/+l6vqyqT1iR+lxVy/zcaz6/1wrQ2hetQtuLX5dV58OPf1V9DD/G2ib8+tC/Kz1H6fHXe3qz86nUlV7bXmdKj7WeK68/pcelVFeiVH9I+1ttp41Oc93W6yp6jkvTnJfeS//O+x99LlzVquqlvPrqq9nrxx57LMVeN0rvk6XaWqp03yotq3qeKfWn+n0kImLixIkp/tSnPpVify5vJfosof1Xe58hS8+GVfWCSjV7Ss+5Ve/rr0vb1+dC/x62YMGCNt+r2eg9Ts+N9x8vvvhiir2emV4Hek+rOt6udK5L9dy0z/eaYXov9Nppug2/x3cmRgIBAAAAAADUAD8CAQAAAAAA1EC3TQfzoVZVU8SXpuFTpaG7PkxWh57p3+m08q1q9OjRKf7xj3+cLdN0CZ+aUNNO9DiUpg8v0SF9pWmeS8MwS8P73nzzzRTr8Gu/PnQbpdQI3Q/fhg5D1veNiLjsssuiWfXs2TPFKzLtb1UbK50fPd/+941Od6zbW5Fp6/X60nO6qqc61v3ylK8NNtggxXqeIvJUVu0nfT0dSuzLNMVGt6Ftz5dVHceIcnpQVcqgD5nVZZ56q+suXrw4xaVh7779xx9/vHLdlaGffezYsdmyvffeO8We1jR48OA24169emXraYqzf6aqNI5SSoHytlhKEWo0vbOUglK1zN9L27f3y62YDqZplXr9RuSfT+9VPh23tvuq5yFfVhqW7uemSldOd7uy9DOVUi48PVb7Nk1ZKKXJla5tPWal1ExdVpqW2lU9+zSaolbi11NpWupGUzO6whNPPJHi3XffPcWTJk3K1luyZEmKN99882yZnkN95vX7nWr0GbXRZX78tX/w557vf//7KdbPfN9991Xub7PTZw5Nxyndq0rf4RqdXryUDlZqO1VtsdR3NJr63h3SwfRz+3e96dOnp3jHHXdsaNuN9mOu0ftYqYzCrFmzUqzP6BH5OS2lj3a05umBAQAAAAAA0Gn4EQgAAAAAAKAG+BEIAAAAAACgBrptTSDPh9daK5rvWZqGvJSDqfmBvg1dpn/n03+3Is3v9hoZu+22W4o931FzOTX/ttEaLhF5nq0ec611EJFPg6k5ozNnzszW0xxwrw2iubNVNRci8s/ldaiqpsT2fGHdpk/hqVMgNhuvUaJK+dFVNV78fFflyvt62k4bnTbcc8BLdRH0/Otn9qlju5rW1rr55puzZaVpvPW46rXndX/69++fYq85pDVK9Jh4+9D19Dx5m62qVxIRsWjRohRrH+q1UTT/X+s2ROT9RanOhR43r8XRWbVNdJrhL3zhC9ky3Qe/ZvV4zp07N8X+2avqN0VUTyleqrOm6zVad6St12/z/HetB+A1aXTdqnMakV9DzVR3pL30OvBzqDWf9FwPGjQoW69qqmiv2VKqF6Svta2X+hjf32Z2ySWXpNjb0SabbJJirY0YEbHNNtukWPu8Rmtr+bLSdNCle2GjSve7ld2G1zXU68mvtddee61d790ZnnnmmRT/9Kc/TfG8efOy9bTf6du3b7ZMP3upvkvV81HpGajUj+m9we9b2v783jpjxowUT5gwIcXz58+vfK9mp/cqvX/4cdHz6PcZPU66nm+j6pw0Og28r1tql6UaRrqufhZ/HmsVek/TelpeW0u/p/ln1XNY+l5ZpfRdotQn67nR730R+XdQr2GkfaM+83a21n86AgAAAAAAwLviRyAAAAAAAIAa6LbpYD4MS4fIlYZp6lAuHfpcSlsqDZnWYWOl6VZbhQ5nO/HEE7NlmkLgQ9F1qkIdXunDg0tT4+nwPh1G7Gl2pfOGjqNDY/04l4Zcruxw9o44pz6sV5XSWEp/10y0X/Mh4EpTqDy9rTR9enelx63RaVhX1pAhQ1LsaTWatuPXXtVQdz2n/trTvKqGqfuwa72f6rIVGTKtr7UNezq13hP82m10GlXdpk7Z7dtoFXq8/DrQ9Ac9T57CqUPsNf2ylGZYOlb6Xn5d6T76tVSV/tAMFi5cmOKLLrqo4b/r06dPivfbb78UDx48OFtP0+Q32mijymWa2uDPjc8991yKJ0+enGJPrdJteBvQc7xs2bIU+5TSmu7k7VmPlU59rP8ekbdnTZWLeOf066uSXusPPPBAiv15QKd91vMekbcxVfr+0BFtQLfhfaamLt5///2V25gzZ85K70cz0L5I732lNuD3oEb7wKpUvtJzbelaKD1/VH039W3oet0hHaxXr14p9j5I+zy9D0a887tlI0rnsNFzquemd+/e2XpPP/10iv0+Xnom6kyMBAIAAAAAAKgBfgQCAAAAAACogW6VDqbDtXyobWlYvWo0HaA0w0zVNnzoaKvzz63DlnXWAXRPOjSzVC2/0Rm7XFVapf99KTWzqi16H6B/V5oBopVmukFr0GHMntLR6IySpZQCT8dRVTNlepvVfdTh9qV7n7cVvT/ozG46O1pEPhTcU5Wq0tf836tmwPN9bBU626mm70TkaQ56zDVtJSJPD9OZBX2mvlL6qPbrmjrkQ/H1tc+gpMP7fYa/VqXPl5dddtkq3BN0hFK6lvaTmsobUZ0O1l6l9Nqq9bzP3GWXXVJcSgfrLjQFR9PBvI8qHTN93ehsoh2RDlZKQ9N98nQhXabXYKt+59TzVrpf6/HydD+9r5Vm4Kuazbu0XmmZngu/B5dm/dLP3JUziTMSCAAAAAAAoAb4EQgAAAAAAKAG+BEIAAAAAACgBrpVTSDNz/VcPM0913oBpWlsSzVPdCpfryGir3U9nQIUaHWlXGltA55vXVVTxPNsdRuNTiVfmu64NCVoqU/QZYMGDUpxd5lSFavWtGnTUnzzzTdny7TuircBra1SqsWjNXG8fWgtkyVLllS+l25ft+e561p/yOtl6JSt8+fPb3N7EXm9Gq+RpJ9ZP4vXsdF77auvvpotK9XWaFZaz8LrnukyPZZ+XHv27JliPT4vv/xytp7WbvJ6DNoXrrnmmin2KeL1OvB7w9ixY1N85513BtBK9Frv169ftmzWrFkpbrRmYlVNEufLqp6JtLZIxDvro3Z32s9pX+b9ZqNTxFfVpoyoPo+le0yjU8T7Nhqt1abr9e/fv/JvmllV/U4/h8rvQfp8UKqZ2BH0XOn7ah2+iPwZyNup3jMb/b7TEVrvaQgAAAAAAAArjB+BAAAAAAAAaqBbpYMdeOCBKfZpcUvT2lbR9TStK6J6ylxfV4eJ+VS4up4P0weanQ61LU2r7ukYmlJVGv5a1Y5KQ229HenQWB2KWUpzcLpujx49KtcD2mPevHltxhHl617vO5oC5mnHo0aNSrEPp37mmWdSvGDBghT78PiqqVO9vWmbHTZsWLZs/fXXT7G2S9+Gvrf3HZripKlsPrRapwleuHBhtuzNN9+MVqP9jk+Fq+dDrwNPC9T+T8+NH4+q6YYj8uOqaRc+/bJeB6VtAK1GUzz8uUH7Ie2rSlNKK/9u0uiU1fp33p96aYzuTvs5PRal+0xpynU9tn5+qtLB2pvOU5UGFZGXNPHvknpf1/68K9OKOpLeM/SY+L2q9F1enzH8+3sj2yilZpbaop6LtddeO1tP+wd/LtH38xTtzsRIIAAAAAAAgBrgRyAAAAAAAIAa4EcgAAAAAACAGuhWNYE0z13rBUQ0XlOkaj3Pz9SaQ15/SPMPNdYpVSMiBg4cmOIXXnihcp+AZlQ1tWVE3nauuOKKbJm2zWXLlqXY24fWmdA6GKX26znDzz77bIo1V3yfffbJ1jvllFNS7Pnh+rpUOwjoaNquvI1p3QK97v3eN3369BSXpmMvTananilWp0yZkr3W6ZM1V75Us2Lq1KnZ6yeffDLFmjfvtY70vb1mn9Y+ahVvvPFGir0P0tfaZ3r9sqo6TMOHD8/W01pv2mdG5HWd9H1LUyc73ybQSjbddNMUa1uJaLyOYVXb8X6s1O9WPYv4v9etvWlfqeejVM+nVI+ydA4are3U6DLl3yv1fufPAvpa+3a/PluFPs/o84E+r0Tk9zg/F1VtrHRv0nNT+p7hbUyvF23D/ryl/LNU1TvsbIwEAgAAAAAAqAF+BAIAAAAAAKiBlk4H8+Fym2yySYobHQbn29C0E53OzYdW63ql6VE19mHvmpJy0UUXNbS/QLPw615p2/n2t7+dLWtPaklHmzx5cvb62GOPTbEP4dThtaNHj07xxIkTO2nvgI6jw+M17mye2qDDn3UK2FtuuaVyG56a2WjfMXv27MplrThtrvZBflyVPm/4M0vVlLe9evXKXmtarj+zaJ9fSonXofT+vqX7BtDsRo4cmWJPtdJ2oG3R00eqUpFWZIr4UvtT+jzjfUJX3g+6SqmMR9V6fvx8Ovm3NZoaVkrX8mVVKUjeT+r90+8Bmuqry9ZYY43K/W1mS5YsSbF+Bv2cEXlauZ+bUrpyR9Pta/q5nyd97vH2rP1FV94jGQkEAAAAAABQA/wIBAAAAAAAUAMtnQ7mQ5V1OJgP59MhWjrsytfT4ee6PR+6pUOmfZm+ly7zmYs23njjAFpJ1fXsKQU6E1AzpH853yedRWzrrbfOlumQ7+44fBroatr+fIh3V753s/JnisWLF6e4NIOQPntoSm5EPqxeh6X79nQbmvYekT87+fOM0ucjT8no7KH5QGfS9uJtQNNT9LuEp7VWpSJ5u9f38vas7Urbtrc3fTYbM2ZMtuyhhx6K7kaPofZf/n1RZ2T287juuuumWJ/5/PtiVfqWlyPR819KA9J0Pb9P6Uy6PnuUXnfrrLNOilt1Zjg9H3q8/PPotb506dJsmbaJ0nN7VfsrpfT5PUzvmXqNPP3009l6es35LKU6u7m39c7E3RgAAAAAAKAG+BEIAAAAAACgBvgRCAAAAAAAoAZauiaQ5+xpzqRP+ae5gxr7VGy6TPM4fWrF0jRwjea89+zZM8WeJ9oKdQtQbzqNo9cEKk373IyuvvrqFG+55ZaV67366qtdsTsAasyfB+bOnZtirSHh9NmjaprjiMbrJ/qzjL4u1U8oTWnv9TKAVqLXdqnt6DKvCaS0Hflzf6mukG6/aprxiPw7jj+ndUf6jFY6LrNnz06x1oSMiBg+fHiK9bhrrbOI/HthVT2oiLzGS6lf1r/zfvPJJ59M8dixY7NlWsNI/65V+9rly5enWOsAzZ8/P1tv0qRJKb7uuuuyZVr/atGiRSn2mllV9X29Lo/WFfLjqjWMXnvttRRPnDgxW09rOWnd1Ij8muvXr190FUYCAQAAAAAA1AA/AgEAAAAAANRAS6eD+XRxOtRKp1uLyKcK1LhPnz7ZejpUb/DgwSn2IWSl6QCVTn/r0xCSWoJWpu3Ph9o++OCDXb07K+X2229PsQ8D1SGizz33XJftE4B6KqVheUqH9leaCuCp7pqqotPnenqC/p2n1VelrpTSH3R4fMQ7h8EDrUSvZ39WqJpGWlOFfJm2sdVXXz1bT1M//fuCfu94/fXX29x2RN5mp0+fHt2dPqPp9zZPr9Jn1Ouvvz5bpn2b9ofrr79+tp5Ox96/f/8U63fMiPy7n0/vrqlP+l5+bemU4rvuumu2bMSIESnWsigzZ86MVqTHS8/htGnTsvX0851xxhnZMv3+XvquokrpePpdXuOIvC3qNvy3Ae0fNB0xIu8j9FrqbIwEAgAAAAAAqAF+BAIAAAAAAKgBfgQCAAAAAACogZauCeR5eeeee26KhwwZki0bOnRoij2vU2nepeb2eR6+5tT7dK5V+6jbjoiYOnVq5d8BzUiv9WuuuSbFjzzySLZeq9UE0rZ5zjnnZMu07c+YMaPL9glAPfkzhdas2HjjjSvX1fo+Xo9A6yIsXbo0xVpPJCKvh6HPORF5zRKNdarkiLzuwjPPPJMt81oIQDPztnjLLbek2J/hBwwYkGKd5tnbR9V3Bp8iXtuptyNdpvVE+vbtm61XmmK7I5S+/6wKek6+/e1vp9i/f911110pLvWB+vm8xo4uq4p9e36O/XXVNvT1aaedli2bMGFCirWeTqvWX7v55ptTvHjx4hTff//92Xo6bbufQ/27kqrj3xn0HF577bXZMm2nzz77bIq9hpHWFeoIjAQCAAAAAACoAX4EAgAAAAAAqIHVunIoFAAAAAAAAFYNRgIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1AA/AgEAAAAAANQAPwIBAAAAAADUAD8CAQAAAAAA1MD/B7UfIMnVD8A0AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20,4))\n", + "for i in range(10):\n", + " idx = random.randint(0, len(test_dataset))\n", + " img, _ = test_dataset[idx]\n", + " x, _ = test_dataset_t[idx]\n", + "\n", + " data = x.as_in_context(ctx).expand_dims(axis=0)\n", + " output = net(data)\n", + " \n", + " ax = plt.subplot(2, 10, i+1)\n", + " ax.imshow(img.squeeze().asnumpy(), cmap='gray')\n", + " ax.axis('off')\n", + " ax = plt.subplot(2, 10, 10+i+1)\n", + " ax.imshow((output[0].asnumpy() * 255.).transpose((1,2,0)).squeeze(), cmap='gray')\n", + " _ = ax.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Manipulating latent space" + ] + }, + { + "cell_type": "code", + "execution_count": 646, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "HybridSequential(\n", + " (0): Conv2D(1 -> 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=4)\n", + " (2): Conv2D(4 -> 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (3): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", + " (4): Conv2D(8 -> 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", + " (6): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(2, 2))\n", + " (7): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", + " (8): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))\n", + " (9): HybridLambda()\n", + " (10): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", + " (11): Conv2D(32 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (12): HybridLambda()\n", + " (13): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", + " (14): Conv2D(16 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))\n", + " (15): HybridLambda()\n", + " (16): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", + " (17): Conv2D(8 -> 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (18): Conv2D(4 -> 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + ")" + ] + }, + "execution_count": 646, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "net" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We split the Autoencoder into **encoder** and **decoder** subnetworks." + ] + }, + { + "cell_type": "code", + "execution_count": 647, + "metadata": {}, + "outputs": [], + "source": [ + "encoder = net[:9]\n", + "decoder = net[9:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get two images from the testing set" + ] + }, + { + "cell_type": "code", + "execution_count": 666, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 666, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "idx = random.randint(0, len(test_dataset))\n", + "img1, _ = test_dataset[idx]\n", + "x, _ = test_dataset_t[idx]\n", + "data1 = x.as_in_context(ctx).expand_dims(axis=0)\n", + "\n", + "idx = random.randint(0, len(test_dataset))\n", + "img2, _ = test_dataset[idx]\n", + "x, _ = test_dataset_t[idx]\n", + "data2 = x.as_in_context(ctx).expand_dims(axis=0)\n", + "\n", + "plt.figure(figsize=(2,2))\n", + "plt.imshow(img1.squeeze().asnumpy(), cmap='gray')\n", + "plt.show()\n", + "plt.figure(figsize=(2,2))\n", + "plt.imshow(img2.squeeze().asnumpy(), cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get the latent representations of the images by passing them through the network" + ] + }, + { + "cell_type": "code", + "execution_count": 667, + "metadata": {}, + "outputs": [], + "source": [ + "latent1 = encoder(data1)\n", + "latent2 = encoder(data2)" + ] + }, + { + "cell_type": "code", + "execution_count": 668, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 32, 3, 3)" + ] + }, + "execution_count": 668, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "latent1.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We interpolate the two latent representations, vectors of 32 values, to get a new intermediate latent representation, and plot the resulting decoded image" + ] + }, + { + "cell_type": "code", + "execution_count": 669, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num = 25.\n", + "square = 5\n", + "plt.figure(figsize=(square*2, square*2))\n", + "\n", + "for i in range(int(num)):\n", + " \n", + " new_latent = latent2*(i+1)/num + latent1*(num-i)/num\n", + " output = decoder(new_latent)\n", + " \n", + " #plot result\n", + " ax = plt.subplot(square, square, i%square+1+(i//square)*square)\n", + " ax.imshow((output[0].asnumpy() * 255.).transpose((1,2,0)).squeeze(), cmap='gray')\n", + " _ = ax.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see taht the latent space learnt by the auto-encoder is fairly smooth, there is no sudden jump from one shape to another" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/example/autoencoder/data.py b/example/autoencoder/data.py deleted file mode 100644 index 99dd4eb43fa9..000000000000 --- a/example/autoencoder/data.py +++ /dev/null @@ -1,34 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# pylint: disable=missing-docstring -from __future__ import print_function - -import os -import numpy as np -from sklearn.datasets import fetch_mldata - - -def get_mnist(): - np.random.seed(1234) # set seed for deterministic ordering - data_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__))) - data_path = os.path.join(data_path, '../../data') - mnist = fetch_mldata('MNIST original', data_home=data_path) - p = np.random.permutation(mnist.data.shape[0]) - X = mnist.data[p].astype(np.float32)*0.02 - Y = mnist.target[p] - return X, Y diff --git a/example/autoencoder/mnist_sae.py b/example/autoencoder/mnist_sae.py deleted file mode 100644 index 886f2a16a863..000000000000 --- a/example/autoencoder/mnist_sae.py +++ /dev/null @@ -1,100 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# pylint: disable=missing-docstring -from __future__ import print_function - -import argparse -import logging - -import mxnet as mx -import numpy as np -import data -from autoencoder import AutoEncoderModel - -parser = argparse.ArgumentParser(description='Train an auto-encoder model for mnist dataset.', - formatter_class=argparse.ArgumentDefaultsHelpFormatter) -parser.add_argument('--print-every', type=int, default=1000, - help='interval of printing during training.') -parser.add_argument('--batch-size', type=int, default=256, - help='batch size used for training.') -parser.add_argument('--pretrain-num-iter', type=int, default=50000, - help='number of iterations for pretraining.') -parser.add_argument('--finetune-num-iter', type=int, default=100000, - help='number of iterations for fine-tuning.') -parser.add_argument('--visualize', action='store_true', - help='whether to visualize the original image and the reconstructed one.') -parser.add_argument('--num-units', type=str, default="784,500,500,2000,10", - help='number of hidden units for the layers of the encoder.' - 'The decoder layers are created in the reverse order. First dimension ' - 'must be 784 (28x28) to match mnist image dimension.') -parser.add_argument('--gpu', action='store_true', - help='whether to start training on GPU.') - -# set to INFO to see less information during training -logging.basicConfig(level=logging.INFO) -opt = parser.parse_args() -logging.info(opt) -print_every = opt.print_every -batch_size = opt.batch_size -pretrain_num_iter = opt.pretrain_num_iter -finetune_num_iter = opt.finetune_num_iter -visualize = opt.visualize -gpu = opt.gpu -layers = [int(i) for i in opt.num_units.split(',')] - - -if __name__ == '__main__': - xpu = mx.gpu() if gpu else mx.cpu() - print("Training on {}".format("GPU" if gpu else "CPU")) - - ae_model = AutoEncoderModel(xpu, layers, pt_dropout=0.2, internal_act='relu', - output_act='relu') - - X, _ = data.get_mnist() - train_X = X[:60000] - val_X = X[60000:] - - ae_model.layerwise_pretrain(train_X, batch_size, pretrain_num_iter, 'sgd', l_rate=0.1, - decay=0.0, lr_scheduler=mx.lr_scheduler.FactorScheduler(20000, 0.1), - print_every=print_every) - ae_model.finetune(train_X, batch_size, finetune_num_iter, 'sgd', l_rate=0.1, decay=0.0, - lr_scheduler=mx.lr_scheduler.FactorScheduler(20000, 0.1), print_every=print_every) - ae_model.save('mnist_pt.arg') - ae_model.load('mnist_pt.arg') - print("Training error:", ae_model.eval(train_X)) - print("Validation error:", ae_model.eval(val_X)) - if visualize: - try: - from matplotlib import pyplot as plt - from model import extract_feature - # sample a random image - original_image = X[np.random.choice(X.shape[0]), :].reshape(1, 784) - data_iter = mx.io.NDArrayIter({'data': original_image}, batch_size=1, shuffle=False, - last_batch_handle='pad') - # reconstruct the image - reconstructed_image = extract_feature(ae_model.decoder, ae_model.args, - ae_model.auxs, data_iter, 1, - ae_model.xpu).values()[0] - print("original image") - plt.imshow(original_image.reshape((28, 28))) - plt.show() - print("reconstructed image") - plt.imshow(reconstructed_image.reshape((28, 28))) - plt.show() - except ImportError: - logging.info("matplotlib is required for visualization") diff --git a/example/autoencoder/model.py b/example/autoencoder/model.py deleted file mode 100644 index 9b6185c9fd18..000000000000 --- a/example/autoencoder/model.py +++ /dev/null @@ -1,78 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# pylint: disable=missing-docstring -from __future__ import print_function - -import mxnet as mx -import numpy as np -try: - import cPickle as pickle -except ImportError: - import pickle - - -def extract_feature(sym, args, auxs, data_iter, N, xpu=mx.cpu()): - input_buffs = [mx.nd.empty(shape, ctx=xpu) for k, shape in data_iter.provide_data] - input_names = [k for k, shape in data_iter.provide_data] - args = dict(args, **dict(zip(input_names, input_buffs))) - exe = sym.bind(xpu, args=args, aux_states=auxs) - outputs = [[] for _ in exe.outputs] - output_buffs = None - - data_iter.hard_reset() - for batch in data_iter: - for data, buff in zip(batch.data, input_buffs): - data.copyto(buff) - exe.forward(is_train=False) - if output_buffs is None: - output_buffs = [mx.nd.empty(i.shape, ctx=mx.cpu()) for i in exe.outputs] - else: - for out, buff in zip(outputs, output_buffs): - out.append(buff.asnumpy()) - for out, buff in zip(exe.outputs, output_buffs): - out.copyto(buff) - for out, buff in zip(outputs, output_buffs): - out.append(buff.asnumpy()) - outputs = [np.concatenate(i, axis=0)[:N] for i in outputs] - return dict(zip(sym.list_outputs(), outputs)) - - -class MXModel(object): - def __init__(self, xpu=mx.cpu(), *args, **kwargs): - self.xpu = xpu - self.loss = None - self.args = {} - self.args_grad = {} - self.args_mult = {} - self.auxs = {} - self.setup(*args, **kwargs) - - def save(self, fname): - args_save = {key: v.asnumpy() for key, v in self.args.items()} - with open(fname, 'wb') as fout: - pickle.dump(args_save, fout) - - def load(self, fname): - with open(fname, 'rb') as fin: - args_save = pickle.load(fin) - for key, v in args_save.items(): - if key in self.args: - self.args[key][:] = v - - def setup(self, *args, **kwargs): - raise NotImplementedError("must override this") diff --git a/example/autoencoder/solver.py b/example/autoencoder/solver.py deleted file mode 100644 index 0c990ce7423c..000000000000 --- a/example/autoencoder/solver.py +++ /dev/null @@ -1,151 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# pylint: disable=missing-docstring -from __future__ import print_function - -import logging - -import mxnet as mx -import numpy as np - - -class Monitor(object): - def __init__(self, interval, level=logging.DEBUG, stat=None): - self.interval = interval - self.level = level - if stat is None: - def mean_abs(x): - return np.fabs(x).mean() - self.stat = mean_abs - else: - self.stat = stat - - def forward_end(self, i, internals): - if i % self.interval == 0 and logging.getLogger().isEnabledFor(self.level): - for key in sorted(internals.keys()): - arr = internals[key] - logging.log(self.level, 'Iter:%d param:%s\t\tstat(%s):%s', - i, key, self.stat.__name__, str(self.stat(arr.asnumpy()))) - - def backward_end(self, i, weights, grads, metric=None): - if i % self.interval == 0 and logging.getLogger().isEnabledFor(self.level): - for key in sorted(grads.keys()): - arr = grads[key] - logging.log(self.level, 'Iter:%d param:%s\t\tstat(%s):%s\t\tgrad_stat:%s', - i, key, self.stat.__name__, - str(self.stat(weights[key].asnumpy())), str(self.stat(arr.asnumpy()))) - if i % self.interval == 0 and metric is not None: - logging.log(logging.INFO, 'Iter:%d metric:%f', i, metric.get()[1]) - metric.reset() - - -class Solver(object): - def __init__(self, optimizer, **kwargs): - if isinstance(optimizer, str): - self.optimizer = mx.optimizer.create(optimizer, **kwargs) - else: - self.optimizer = optimizer - self.updater = mx.optimizer.get_updater(self.optimizer) - self.monitor = None - self.metric = None - self.iter_end_callback = None - self.iter_start_callback = None - - def set_metric(self, metric): - self.metric = metric - - def set_monitor(self, monitor): - self.monitor = monitor - - def set_iter_end_callback(self, callback): - self.iter_end_callback = callback - - def set_iter_start_callback(self, callback): - self.iter_start_callback = callback - - def solve(self, xpu, sym, args, args_grad, auxs, - data_iter, begin_iter, end_iter, args_lrmult=None, debug=False): - if args_lrmult is None: - args_lrmult = dict() - input_desc = data_iter.provide_data + data_iter.provide_label - input_names = [k for k, shape in input_desc] - input_buffs = [mx.nd.empty(shape, ctx=xpu) for k, shape in input_desc] - args = dict(args, **dict(zip(input_names, input_buffs))) - - output_names = sym.list_outputs() - if debug: - sym_group = [] - for x in sym.get_internals(): - if x.name not in args: - if x.name not in output_names: - x = mx.symbol.BlockGrad(x, name=x.name) - sym_group.append(x) - sym = mx.symbol.Group(sym_group) - exe = sym.bind(xpu, args=args, args_grad=args_grad, aux_states=auxs) - - assert len(sym.list_arguments()) == len(exe.grad_arrays) - update_dict = { - name: nd for name, nd in zip(sym.list_arguments(), exe.grad_arrays) if nd is not None - } - batch_size = input_buffs[0].shape[0] - self.optimizer.rescale_grad = 1.0/batch_size - self.optimizer.set_lr_mult(args_lrmult) - - output_dict = {} - output_buff = {} - internal_dict = dict(zip(input_names, input_buffs)) - for key, arr in zip(sym.list_outputs(), exe.outputs): - if key in output_names: - output_dict[key] = arr - output_buff[key] = mx.nd.empty(arr.shape, ctx=mx.cpu()) - else: - internal_dict[key] = arr - - data_iter.reset() - for i in range(begin_iter, end_iter): - if self.iter_start_callback is not None: - if self.iter_start_callback(i): - return - try: - batch = data_iter.next() - except StopIteration: - data_iter.reset() - batch = data_iter.next() - for data, buff in zip(batch.data+batch.label, input_buffs): - data.copyto(buff) - exe.forward(is_train=True) - if self.monitor is not None: - self.monitor.forward_end(i, internal_dict) - for key in output_dict: - output_dict[key].copyto(output_buff[key]) - - exe.backward() - for key, arr in update_dict.items(): - self.updater(key, arr, args[key]) - - if self.metric is not None: - self.metric.update([input_buffs[-1]], - [output_buff[output_names[0]]]) - - if self.monitor is not None: - self.monitor.backward_end(i, args, update_dict, self.metric) - - if self.iter_end_callback is not None: - if self.iter_end_callback(i): - return - exe.outputs[0].wait_to_read() From 8369822c75d4649ac853fd0ab6229d1b5f4a31b4 Mon Sep 17 00:00:00 2001 From: tdelteil Date: Tue, 23 Oct 2018 22:15:08 +0000 Subject: [PATCH 02/10] adding pointer to VAE --- example/autoencoder/README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 3111bac438f3..3f76105f05bb 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -11,3 +11,8 @@ The idea of an autoencoder is to learn to use bottleneck architecture to encode ## Dataset The dataset used in this example is [FashionMNIST](https://github.com/zalandoresearch/fashion-mnist) dataset. + +## Variationnal Autoencoder + +You can check an example of variational autoencoder [here](https://gluon.mxnet.io/chapter13_unsupervised-learning/vae-gluon.html) + From 0318713f977d0bfdc279dd0d75f3c920c31b58a6 Mon Sep 17 00:00:00 2001 From: tdelteil Date: Tue, 23 Oct 2018 22:16:33 +0000 Subject: [PATCH 03/10] fix typos --- example/autoencoder/README.md | 2 +- example/autoencoder/convolutional_autoencoder.ipynb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 3f76105f05bb..570498fc2fd2 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -1,4 +1,4 @@ -# Example of a Convolutionnal Autencoder +# Example of a Convolutional Autencoder Autoencoder architecture is often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using stack of convolutionnal layers for both encoder and decoder. diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb index 17548ca9714a..371a62f0c0fc 100644 --- a/example/autoencoder/convolutional_autoencoder.ipynb +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Convolutionnal Auto-encoder" + "# Convolutional Auto-encoder" ] }, { From e32edca0cd04dd56fb750287fedab0fcaa14b13a Mon Sep 17 00:00:00 2001 From: Thomas Delteil Date: Wed, 24 Oct 2018 15:20:34 -0700 Subject: [PATCH 04/10] Update README.md --- example/autoencoder/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 570498fc2fd2..81f762533668 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -1,6 +1,6 @@ # Example of a Convolutional Autencoder -Autoencoder architecture is often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using stack of convolutionnal layers for both encoder and decoder. +Autoencoder architectures are often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using a stack of convolutionnal layers for both the encoder and the decoder. ![](https://cdn-images-1.medium.com/max/800/1*LSYNW5m3TN7xRX61BZhoZA.png) From 94d01534e87af6d1c492933ca0782d235f82ed4a Mon Sep 17 00:00:00 2001 From: tdelteil Date: Thu, 25 Oct 2018 18:46:26 +0000 Subject: [PATCH 05/10] Updating notebook --- .../convolutional_autoencoder.ipynb | 172 ++++++++---------- 1 file changed, 76 insertions(+), 96 deletions(-) diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb index 371a62f0c0fc..9d96f35d171d 100644 --- a/example/autoencoder/convolutional_autoencoder.ipynb +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 243, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 315, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -55,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 316, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 317, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 640, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -140,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 641, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 642, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -160,41 +160,41 @@ " Layer (type) Output Shape Param #\n", "================================================================================\n", " Input (1, 1, 28, 28) 0\n", - " Activation-1 0\n", + " Activation-1 0\n", " Activation-2 (1, 4, 14, 14) 0\n", " Conv2D-3 (1, 4, 14, 14) 40\n", " BatchNorm-4 (1, 4, 14, 14) 16\n", - " Activation-5 0\n", + " Activation-5 0\n", " Activation-6 (1, 8, 7, 7) 0\n", " Conv2D-7 (1, 8, 7, 7) 296\n", " BatchNorm-8 (1, 8, 7, 7) 32\n", - " Activation-9 0\n", + " Activation-9 0\n", " Activation-10 (1, 16, 4, 4) 0\n", " Conv2D-11 (1, 16, 4, 4) 1168\n", " BatchNorm-12 (1, 16, 4, 4) 64\n", - " Activation-13 0\n", + " Activation-13 0\n", " Activation-14 (1, 32, 1, 1) 0\n", " Conv2D-15 (1, 32, 1, 1) 4640\n", " BatchNorm-16 (1, 32, 1, 1) 128\n", - " Activation-17 0\n", + " Activation-17 0\n", " Activation-18 (1, 32, 3, 3) 0\n", " Conv2D-19 (1, 32, 3, 3) 9248\n", " HybridLambda-20 (1, 32, 6, 6) 0\n", " BatchNorm-21 (1, 32, 6, 6) 128\n", - " Activation-22 0\n", + " Activation-22 0\n", " Activation-23 (1, 16, 6, 6) 0\n", " Conv2D-24 (1, 16, 6, 6) 4624\n", " HybridLambda-25 (1, 16, 12, 12) 0\n", " BatchNorm-26 (1, 16, 12, 12) 64\n", - " Activation-27 0\n", + " Activation-27 0\n", " Activation-28 (1, 8, 14, 14) 0\n", " Conv2D-29 (1, 8, 14, 14) 1160\n", " HybridLambda-30 (1, 8, 28, 28) 0\n", " BatchNorm-31 (1, 8, 28, 28) 32\n", - " Activation-32 0\n", + " Activation-32 0\n", " Activation-33 (1, 4, 28, 28) 0\n", " Conv2D-34 (1, 4, 28, 28) 292\n", - " Activation-35 0\n", + " Activation-35 0\n", " Activation-36 (1, 1, 28, 28) 0\n", " Conv2D-37 (1, 1, 28, 28) 37\n", "================================================================================\n", @@ -209,7 +209,7 @@ } ], "source": [ - "net.summary(dataset_transformed[0][0].expand_dims(axis=0).as_in_context(ctx))" + "net.summary(test_dataset_t[0][0].expand_dims(axis=0).as_in_context(ctx))" ] }, { @@ -222,7 +222,17 @@ }, { "cell_type": "code", - "execution_count": 643, + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "l2_loss = gluon.loss.L2Loss()\n", + "l1_loss = gluon.loss.L1Loss()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -239,76 +249,46 @@ }, { "cell_type": "code", - "execution_count": 644, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch [0], Loss 150.58451856303418\n", - "Epoch [1], Loss 65.12515858707265\n", - "Epoch [2], Loss 59.445904230667374\n", - "Epoch [3], Loss 56.62768763354701\n", - "Epoch [4], Loss 54.96188484909188\n", - "Epoch [5], Loss 53.87394831730769\n", - "Epoch [6], Loss 52.72701322115385\n", - "Epoch [7], Loss 51.91863496424788\n", - "Epoch [8], Loss 51.15499382345085\n", - "Epoch [9], Loss 50.44610543536325\n", - "Epoch [10], Loss 49.78377904647436\n", - "Epoch [11], Loss 49.42993790064103\n", - "Epoch [12], Loss 48.85279147907839\n", - "Epoch [13], Loss 48.56229133279915\n", - "Epoch [14], Loss 48.0335202991453\n", - "Epoch [15], Loss 47.71448484241453\n", - "Epoch [16], Loss 47.63018746661325\n", - "Epoch [17], Loss 46.98289346287393\n", - "Epoch [18], Loss 46.91378939353814\n", - "Epoch [19], Loss 46.51542467948718\n", - "Epoch [20], Loss 46.18931540464744\n", - "Epoch [21], Loss 45.93053886217949\n", - "Epoch [22], Loss 45.839977297008545\n", - "Epoch [23], Loss 45.72159278998941\n", - "Epoch [24], Loss 45.57212373130342\n", - "Epoch [25], Loss 45.30989165998932\n", - "Epoch [26], Loss 45.123990050747864\n", - "Epoch [27], Loss 45.19418569711539\n", - "Epoch [28], Loss 44.83272643008475\n", - "Epoch [29], Loss 44.79928719284188\n", - "Epoch [30], Loss 44.52551999866453\n", - "Epoch [31], Loss 44.39976045005342\n", - "Epoch [32], Loss 44.31792534722222\n", - "Epoch [33], Loss 44.13317140758547\n", - "Epoch [34], Loss 44.093042405985166\n", - "Epoch [35], Loss 44.001953125\n", - "Epoch [36], Loss 43.874645265758545\n", - "Epoch [37], Loss 43.696017795138886\n", - "Epoch [38], Loss 43.65276108440171\n", - "Epoch [39], Loss 43.773793365995765\n", - "Epoch [40], Loss 43.58095870058761\n", - "Epoch [41], Loss 43.38808760683761\n", - "Epoch [42], Loss 43.41396651308761\n", - "Epoch [43], Loss 43.167876936431625\n", - "Epoch [44], Loss 43.35061490333686\n", - "Epoch [45], Loss 43.18432825854701\n", - "Epoch [46], Loss 43.1171875\n", - "Epoch [47], Loss 43.11041833600427\n", - "Epoch [48], Loss 42.99752938034188\n", - "Epoch [49], Loss 43.00297559428419\n" + "Epoch [0], Loss 0.21099560077373797\n", + "Epoch [1], Loss 0.09341155973255125\n", + "Epoch [2], Loss 0.08531867133246528\n", + "Epoch [3], Loss 0.08130835671710153\n", + "Epoch [4], Loss 0.0778859130337707\n", + "Epoch [5], Loss 0.07601113238577116\n", + "Epoch [6], Loss 0.07359524262257111\n", + "Epoch [7], Loss 0.07236115545289129\n", + "Epoch [8], Loss 0.07116886693188268\n", + "Epoch [9], Loss 0.06978819105360243\n", + "Epoch [10], Loss 0.0686475382012836\n", + "Epoch [11], Loss 0.06776454713609484\n", + "Epoch [12], Loss 0.06720775212997045\n", + "Epoch [13], Loss 0.06643269204685831\n", + "Epoch [14], Loss 0.06566705051650348\n", + "Epoch [15], Loss 0.06555396823559777\n", + "Epoch [16], Loss 0.06497157740796733\n", + "Epoch [17], Loss 0.06442272561228174\n", + "Epoch [18], Loss 0.06406494694897252\n", + "Epoch [19], Loss 0.06352333737234785\n" ] } ], "source": [ - "epochs = 50\n", + "epochs = 20\n", "for e in range(epochs):\n", " curr_loss = 0.\n", " for i, (data, _) in enumerate(train_data):\n", " data = data.as_in_context(ctx)\n", " with autograd.record():\n", " output = net(data)\n", - " # Compute the L1 loss between the original and the generated image\n", - " l = (output.flatten() - data.flatten()).abs().sum(axis=1)\n", + " # Compute the L2 and L1 losses between the original and the generated image\n", + " l = l2_loss(output.flatten(), data.flatten()) + l1_loss(output.flatten(), data.flatten())\n", " l.backward()\n", " trainer.step(data.shape[0])\n", " \n", @@ -333,12 +313,12 @@ }, { "cell_type": "code", - "execution_count": 645, + "execution_count": 50, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAAD4CAYAAAB7VPbbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztvXfcX0WZ/j+sSm9ppJEAKSQkJCQQpIW2CgEEEVyB16ICC4giqFhfXxFxYVFRiiu6VqSodARlQToSBCWGUEJCgPSEkA6BUKz8/thfxmsunhnO8+Hz1PN+/3WfzDznzDlTznxO7uu+13vjjTcCAAAAAAAAAAB0b/6loxsAAAAAAAAAAABtDx+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqAB+BAAAAAAAAAABqwDvb82LrrbfeG+15Pfgnb7zxxnrNOA992HE0qw9DoB87ku4wFzfaaKNojx49Otr/+Mc/knp//vOfo/3Xv/412u9617uSeoMGDYr2FltskZTNmTMn2lOnTm2wxc2Fudg96A5zMcemm26aHPfu3Tva8+fPb+gchx56aLSvueaaxhvXRLrqXDz22GOTY33WP/rRj9qrGeGjH/1otGfNmpWUTZkypd3a0Z3nYl3oqnMRUpiLXZ+qfYgnEAAAAAAAAABADVjvjTfa70MdXwU7Dr7sdn34X5buQVeZi0OHDo32u9/97qRs++23j/aGG24YbfcEUv7lX/75fw7rr79+UqbHK1asSMre+c5/Oqy+8sor0V66dGlST70bnnzyyaRs1apV2XY1AnOxe9BV5mKJnXbaKdqnnXZatE888cSk3urVq6OtXnkvv/xyUk89Uvr375+UrV27tsW/+9znPpfUu+GGG1q8lrPeev98/I3uRbvSXLz99tujPX78+KRs2bJl0Z44cWK0X3rppaTeO97xjmj//e9/z15L11tfl3v16hXtu+66K9p9+vRJ6l1yySXR/ta3vpW9VjPoDnOx7nSluQh5mItdHzyBAAAAAAAAAAAgwkcgAAAAAAAAAIAawEcgAAAAAAAAAIAa0K7ZwQAAoPOw4447Rvvwww9Pyv7yl79EW+PyhJDG49F6m2yySVJPY1YMGDCgxb8JIYQXXnihxb8JIY2BobGDevTokdTTeBb77rtvUvbQQw9F++677w4AnYGqMXE+/elPR/s//uM/kjLNrKfne/7555N6f/vb36KtGfg0018IaQyfefPmZdu08cYbR/vHP/5xUnbxxRdH+9FHH03KDj744Gi3Z0zKzsCf/vSnaGsspxDSZ3HjjTdG+4ADDkjqleIAKaX4bFdeeWWL9Txr46uvvlrpWlBG32Eh5PvwzDPPTI533nnnaPs7U+e69pPO8xDSjJpPPPFEUrZo0aJo6zve+93j9AFA9wBPIAAAAAAAAACAGsBHIAAAAAAAAACAGlAbOZi6uZZSlo4YMSLaO+ywQ7Q9jaq6TqprdQhpymR1u3VU2uCungAAbUG/fv2i/cEPfjDay5cvT+q9/vrrLdohvDnF+zo8FbtKHDRFtaYvDiFdT9XN3dHzvfbaa0nZlltuGW2Vl4UQwq677hptTSU/e/bs7LUA2pqcHOqUU05Jji+44IJo+zzVsa5zx+eYyn5Uzult0L2Sy0BV1qJrwiuvvJLU03bst99+Sdljjz0W7XHjxoU6MW3atGi7XOvPf/5ztCdMmBDtz33uc0m9Cy+8sNXXVTlhCCEMHDgw2rr39HX+N7/5TauvBW+mJAf7yU9+Eu1jjz02qffiiy9GW+WXIbz5d0eOk08+uXI717Fs2bJsO/y9e/7557f6/ADQOcATCAAAAAAAAACgBvARCAAAAAAAAACgBvARCAAAAAAAAACgBnTbmEAeVyIXB+iEE05IjjX2zw033NDQtUeOHBntK664Itqe/nHx4sXRLun3uwonnnhitO+6666kbOHChe3dHABoAU05rPNSdf8hpDEHNM5ZCGkaWrU9VpDGmNC0sx5rRPFz6Fqudt++fZN62n6Nr+Hstttu0SYmEHRGPA38ypUro+0xOXzvsA6PM6ixf3JzKoR0Pvu+SeMF6d95zJNSqnqdt1tttVW0PdZRd0SfrfejrrFz5syJ9tlnn53U+/a3vx3tPfbYI9oa6yyEEG655ZZo77LLLkmZpqrX63ofeGwYaIxSnLvLLrss2oceemhSpmPE57PGAtM+9PVAj0tzXfHfHxtttFG0BwwYkJSV7g0apzW/CQ8++OBo69rxzDPPJPV0/fa+z8Wng+4NnkAAAAAAAAAAADWAj0AAAAAAAAAAADWgy8nBVEagaRZDyLs7e9kZZ5wR7SVLliT1chIwd81T92d305s1a1a0P/vZz0b7M5/5TFLvrLPOyp5Dr9eZpGFbb711tG+77bakbMcdd4z2okWLkrIHH3ww2j/60Y+irWmd/djdFdeuXRttdY11N0aVneg5/Dmqq7vLR3LPvNQXJTdcbYe7x2+++ebR9nGrqXwBGkFduUMIoWfPntF+6aWXou2SL0377PItdStWXOKgc0zHuaci1npepmvCpptuGm2VyISQrg9az8/Zr1+/aPfp0yept2LFigDQEej8c8mFzg+XXumxztOcTCyE9J3ZGhmA7rn0ujr3QkjXB2+Hzk2VM/3617+u3I6uiq7FvkapnHWTTTaJ9owZM5J6+twvueSSaPveRMfCww8/nJTptXVs+Xo4bty47DmgOajs2t+f+o7bbLPNkjJNGa997/vm3Ls6hDf/hlqHS890Xzp37tyk7Oqrr472VVddlb1Wd6D0O1Dxfbwe+7PNnS8n1QshhB/84AfJ8UknnRTtiy66KNpf+tKXsudA/gUh4AkEAAAAAAAAAFAL+AgEAAAAAAAAAFADOqUcrCTlKrnIqfur19OMXZp95tprr63UJne1LcmC9PyrVq2K9i9/+cuknmZvOOywwyqfvyMZMmRItK+//vqkTDNL9OjRIynT7BSaDUElJyGkfe2usVpWcqlU99rc34dQdqGt+vxLmRcUdeX1DBya/cOfh2dKAmgtO+20U3KsY1bdwX3MqzzF54dmFdN1tyQb0+vqOhJCKpF0aYlKNTUjimcuUldqd3PX9ULn2IgRI5J6yMGgo9A9ir/DdNy7vFNlljovNdNpCOkc0Hm6wQYbZNvkZfqO0+sOGzYsqadricuflVGjRkW7DnIwXbN8P6LHuuap7CeEdE+gY8HXb90/uSRIx0JO4hdCCP3792/hLqCZ6Dzy56/9W5J36t/5nlHHnO9RdR0o7al1jAwfPjxbr7vTmt+BjaD7LM9++rOf/Sza22+/fVL2kY98JNrXXHNNpfMDhIAnEAAAAAAAAABALeAjEAAAAAAAAABADeAjEAAAAAAAAABADeiwmEClFHolneV73/veaN9///1JmceIUDQV6fnnn5+tl0v5V9Jv+72o7lLjamjq+BBCuPfee6N9/PHHJ2WXX355tFUL7DE3Smn+2kL/+Yc//CF7fo090qtXr6RMUzRrrILHHnssqbdmzZpoe0pMTU9feiaKxlLwcVVKnVlV66t9XxoHej6vd99991W6FkAjuIZ/8eLF0dZ4BD4fND6Or60HHHBAtJ999tlo+5zVFMOa9tpjjUybNi3ac+bMScoeffTRaGuMCl/7dL55OzTOkMYEGjRoUADoDGhMIH//6DzVtOAhhPDVr361bRsm6H5mxx13jPbUqVOTej//+c+jffjhhydlem/bbbdds5vYZdC4PyGka6zub0rxCnXN9noaE8jHk+5BdG/m67zHJYHGKO3TdV+bS9keQgivvvpqcqzjZ8GCBdH2OE6lfa7uxXVMbLnllkk9bdfq1auz5+su6LMo9Z2uyzvvvHO0d99996Re7969o33HHXckZbq/OfbYY6N9yCGHJPU0lmijcZlK91KKOQXdF3odAAAAAAAAAKAG8BEIAAAAAAAAAKAGdJgczF3PSm6Qn/nMZ6K9ySabRNtTj6qMQF1cQ3hzuvEcpXbkKLnYeTuUiy++ONruMq2oK28pjWN7oO7CX//615MyTU3pUj11bVRXU09frf201VZbJWX6LFVO4m7Qzz33XLRV0qKu7CHkU2X7scrNXMpVcqHUdqnb7ZFHHpnU22WXXaL9yCOPZM/X3Sk9y5I8T1PourxHx+vcuXPfRuv+j379+kXb0yL/8Y9/jLaPyfZ2tdXrbbrppkmZzrElS5ZEWyWzIaTrqcs7999//2gPHDgw2u56ftttt0X7nnvuifZll12W1DvssMOi/dGPfjQp07moUi4fE7qu+PPOzUWXO+hYcvd7aBtKEueq72M/xxe+8IVoH3PMMUnZiSee2NomtgujR4/Olun9rVy5MltP34ulNVPP589Y547vX3SNOOigg6LtcjDtQ++b0ju+u6P7V1+jtO80LIHvObRfdS3zfaiew/tAz6FlPmb0/QBtg84B7yd9n/o40Hl0/fXXR/sDH/hAUi/37gshhPHjx0db5WW+JuhY8nN0R/S562+uD3/4w0m9s88+O9qrVq2Kds+ePZN6+tvD+6dHjx7R1j3Hgw8+mNTTNPCOjptSGJDS+6EUTqWO+Hwr/c5vNrpH0T10CG/+7vF2wRMIAAAAAAAAAKAG8BEIAAAAAAAAAKAG8BEIAAAAAAAAAKAGdFhMoJJe/ZxzzkmOd91112irLnLixIlJveOOOy7amrovhFRfqRrMo48+Oqk3b968aGtsGUfjbHg6Rb22asAXLVqU1FNtv6cDPOKII6J97bXXRlt1pyGk2lW9Vggh3Hnnndn2NwPVIYeQpo321O/vec97oq3pmj1Oj5Zp6ukQUr2sxu7wsaQaXu2bjTbaKKmn8Xdc+659qG0qxZrSdPT+dzqWfLzouPDU1t1Bf+2xD3L65dKaoOy1117J8YEHHhhtjU8TQto/GtfmiiuuSOp52k5Fx6jqcU8++eSk3he/+MVov//970/Kqt5bs9hzzz2zZar91vGsMb0cTzur53jqqaei7THL9Jy61m6//fZJPX0+X/7yl5Oy0047Ldq6dvvaoX3tsYlUz622p6rfe++9o10aE9B6NK6ExpwoxTBwRo0aFW2NraZxA0NI1+Lbb789KSvF1OlIBg8eHG2PP6DPyONNKDqe/Rw6x9T29Vn7yd+Z9913X4u2o/sXjzWh7dJ7rgMaO8ljTvj+bR2lsVBC+7FqPb8WMYGaQymWZ58+fbJlpViCW2yxRbRPOOGEaPt7XNeEZcuWJWXa96X4Q1o2f/78bJu6C7k5duONNybHU6ZMifYzzzwTbY+huGbNmuy5v/vd70b79NNPj/bq1avfdnsdjfsEzUPXbt2X+u913b/813/9V1J2ySWXRHvo0KHR1u8aIYTwzW9+8+011sATCAAAAAAAAACgBvARCAAAAAAAAACgBrSrHEzdFN098vOf/3y01c0xhNSF9sc//nG01eU4hFQ+5O5xKkHRFMTvfe97k3pLly6Ntsp5XF720ksvRdslO+reqekfXQ6mbpouM1J3bU0h7lKim2++OdqTJk1KyjSNc1vgKZSHDBkS7TPOOCMpU5mTuuO7bEP73t3etU9VDuZ9nUsf766Qmu7WpSX6d+oa69fS9mubvB0qVXE37QEDBkTbZTLXXXdd6Aq423JOehBC3jXaU5lrKk2VfHkaVT1fSXal9b7zne8kZb/4xS+ifd555yVlWnfy5MnRXr58eVJv7Nix0f7pT3+alJ100knZdrUF+hx8jm2zzTbRnjVrVrRd+qHHW2+9dVJ28cUXt3itCRMmJPUGDRoUbV0T/ud//iepp+uDr8mHH354tPX5b7vttkk9lZ24i30u/alLOEsSYHgzpXnvVE33rv2v774Q0n2Cyrz+/d//PanX1lLotkD3Cv4cdc3TfYmj76pSSlvtN5d+5M4XQvqO03N4m+bOnRvtYcOGJWWvvPJKtPv27Zu9dndEww24xFb3h9r/pb2s4v2tfefzNFfma2odpD8dTe/evaNdmrM6b/xY55H+Ngkh3Vf53vPFF19ssV5Jwl+HMZF7j+k+PoRUAqa4DKjEpz71qWiPHj062oceemhS79RTT618zhy6Pzv33HOTsmbLjLoipfdnTs4eQhruZMSIEdH232/6jndpocqr9VuJh13R/ZHvlRsBTyAAAAAAAAAAgBrARyAAAAAAAAAAgBrQrnIwlWOMHDkyKVOJlrvBqeRJJT2eUUuziqmLpZ9fM/w8+uijST39O22vS1jUjVIjv4eQulXOnj072p6VRN2BPTOEupupa7W7aWqmpKeffjrbjrbAZXDaZn0+IYSwcOHCaKvMy7PzqHTFn1fORdqvpdI67TeX3CkuhVH39lKGBnUZ9KwM+neaLcDHy8c//vFoL168OHut9kLb7TI5lwCuoyQDcSnlbrvtFm3NouWygZkzZ7bYDnePVwmPyo9CSLNkaZ/62FK5ma9NKkdVvvSlLyXHOv/U7bMjeOihh1q0Q0gzFOga5K7OKtGaMWNGUqYZG++///5o+/jVjIFf/epXo+0yrP322y/a7kqtY0RdYz0TnLbX5WAPP/xwtKdNmxbtume/KUlGlJyUq9Gsdyr1POigg5IyzTbn5z/mmGOifc899zR07dJ9diT6jnBXdJVjuCxE8XdLs6kqN9N3oUvKdP1WKXQd0P2rZ/9RuUEpa2Yu06Gjz93PoXNAr+tSotbIWqAx9L3l0m3dv2pmTEf3tt5n2tcui666fmu7XAZfJ0qZFEuyWu1Hl3PqXNfsYL7n0n2pyvhDSH9TnXnmmdF2ObVmY/R2tEXWzKrvi6rncBo9ZyPnK8nZ77777mjr3t+z9Kqc2n8v6u8k/Qai3ytCSKVnvgduJJxB59wNAQAAAAAAAABAU+EjEAAAAAAAAABADeAjEAAAAAAAAABADWjXmEDKN77xjeT4iiuuiLZrXzX1uKbRvO2225J6K1asiPaCBQuSMo35orpn19fnNOoeC0Xji3g8GY1fom0qpWD2VKmqP9Q0hK7j1HN4XKFcWuRm0a9fv+RY9ZQeQ0m1tPrMXWOrz87vVeN3qC7ZY8QoqmV2DaZSSjOvz9HbVNK8qt5a4yf5OTQeykUXXZRtY3uh7c7FAHI8ns/RRx8dbY0BFEKqPdZraQygEELYYostov34449H29MRa1rboUOHJmV6Tu1THwvbbbddtD2ej/aPxnRQO4R0beqscUdCSJ+J2h5j5bTTTou2x0Xae++9o6395OvYlltuGe1f/epX0dYYbSGksYk8LoWucRo3xftQYxqdddZZoavQDN187nwhlNOB67pXNYV7iXHjxkX7gx/8YFKm8Ql22GGHaLuuXeNN6bwv0ZpU9Y3GMWprdGw72mZ/7yoaL8DXJ8Vjj1Ql9+x87a6a+r0zr5NtjcZJDCGdB/re9bTe2gdq+9pRWkv073Q/4msvNE7VdV33sr4W6vzQfY6fU+OG+NzTPVFp/deyZcuWJfV0D+wxSrojub7z9a+Rd0np94quo7fccktSdt5550X7ySefTMo03qL+TirFgPIYkG0x96vGLCvVa3bcn7ZA12v9favp4kNI41F6/NJPfepT0b7wwgujfeeddyb1jj322Gh7TON99tmnNc0OIeAJBAAAAAAAAABQC/gIBAAAAAAAAABQAzpMDqYpYkMI4Ygjjoi2pgQOIXVp0xRrLvnStMPu9qgutepe5u5yeqyumO6Spq7zngJbXe5UouVyMK3nqV011bLKX1yupino3b1MU0+2BdoXIaQu5p6eXvtD5UAlF3iVkoSQ9m9uTISQ9o3WczfM3JjwY70vd1/Xa/k5VNqmUiR309dn0xlSVut4VilmCKmMY8cdd4y2SqZCSOdm6Z5U0uPuqCoF0Xk0fvz4bJt8zOicU7fopUuXJvU0HafLYsaOHRttdeG/8cYbk3o6n//t3/4tKXO5XEdS1Q1XZQIq1wohhBtuuCHa+oz/9Kc/JfV0Dmgazc9+9rNJPV3XfMzpOqbzzyWnvubk0Pv390RHSIWquju7jFTXJXXtLr2rSujccUmBrqPbb799tD/xiU8k9fTvSjJpfW+pFLNROqvEqzXoultK6T169OikTPujT58+0Xapu86XkgxLy0rPVfvT9yUqg99mm22Ssq7g3t8euKxGpUCNyCNKqZRLMiDdm/ieGhpH1+tSaAaVebkMS/EU3rp/1TVe04WHkO51dA/tf6fjSlPOh5Du00typs6MyyoVX+caWaNK+6pcX5X4zW9+kxyff/750T7yyCOTsnPPPTfaGorB98PaLv/dWpIPN0rpmVR9xtpOH3tVw1W0J/r+vO6667L1fO+ke2ot87TvxxxzTLR9nnpImCrgCQQAAAAAAAAAUAP4CAQAAAAAAAAAUAPaVQ7mbsxV66mrnrpVuoulup6pi2sIqaSq5BadkwF5No1Spil1/VPbZUvqwu/uiOrSqS6c6kbv7fBzlNyDm4G74qkrmrcl97y8D0vubFtvvXW0NaOC32fOxdXlFKWo/3qOUgYOvbaPEXVdVKmT32NJEtUefOxjH0uOzznnnGh7/6hrscpvPEr97373u2h7tr958+ZFW10dfYxopHuVU7lcSHH3SI3Or9ctuce7C63em7rwqwwthDfLkxQfex1JVTdclZP42vXiiy9GW+Va7s6uUh99/r4+a5t69+6dlOmYK2Xqq3pfWq+t18hm4q7QVd3yVS7kY1bff7p+eeYifdaf/OQnoz1y5Mikno4ZzRoXQjpO9t1331a3PYRUCqoSJJcrqizN2+j31lnQ56PzK4T8niKEdM3Td7JnUcy9C12eUJKD5eaYX0vXdZeD5eSYPp+7quykKp6dR8ll73IaXctyMr9Vq1ZVPgeUKfXHoYceGm1dqx577LGknmYq9Xmak/a4rEffn/7ezWWO9Hr6bnAZUWdG76812S9zz8X3+Llz+tpVVa58+umnR/srX/lKUqZ7n9LY0syomrE2hHQt8f1qM7KDOqX1qbRfU2nst7/97WjfeuutSb3JkydH2+9VaXYG1hIqqVV5dggh/P73v4+2ZwLcaaedoq3vBs8Opqgku1HwBAIAAAAAAAAAqAF8BAIAAAAAAAAAqAF8BAIAAAAAAAAAqAHtGqhCU79r+mdHU0+HkOr5NO2sawxVM+maVtVkarpDT5moqdo1dotrPDXegWtwV69eHe2SzrKkwVXdosZx8HTbGqvD9aqqJ24LXNOuGlN/rho/Ru/bY7joPXiKYdWzqhbS+0bPoX/jutyq8aVKsQlKsRr0HHr/rvEvpb1uKzSexoQJE5Kye++9N9qedlvj+2j8Cde3HnjggdHW+RBCGttJ42D4vWtsGI8vougc8Ho6Fg455JBsm1Tn7nNRx7KOIY+J9fLLL0fbY43tv//+2fZ3VrQ/fK3V+ad9//GPfzypp/Gb5s+fH+2DDjooqafn8BhSTz/9dLT1GXs/VUXvpTOkFq+aPtbH0PDhw6O91157RdtjWulYdw35M888E21dzz//+c8n9XQu6nzzca59p2nC/VrHHXdctD/84Q8n9fT9P3PmzJBD+87fffoe93VZx2FnovSu0ufs96Ox1ErxDnJxJEqxtbws98z93BrTqGosiH79+iXHixcvbrFed6G0flWNQ5iz3wpdZ3Rs6foKb4/SXu7EE0+Mtq6TPgd0jJTil+r+pTV7SB0Hus/1MaexKmfNmlX5/B2Brku6r/d1s/Suze0L2iJuzoc+9KFoX3TRRdG+/PLLk3onn3xy9hzjxo1r8d+9H7X9/jzaOgZb6d3kMSd1P6jp0j0elcYIOv7445OyadOmVbp2jtJ6Wjqfxv3xmIZHHXVUtB955JGk7Ne//nW0NdaR/zZtNngCAQAAAAAAAADUAD4CAQAAAAAAAADUgHaVg6kM6zvf+U62nqcIVtc8dWdz13Y9dtdJRV2cXTKlqU132WWXaGvK9hBS1zlPj6ppNt1NXdF7cTdcdfHWa/mzUUmKuzC2tRzM3Qn1Xv35673qvbm7uUrrPJW6ysNU8qBpib1dubHjx1VlIVVT5joqqypdq73kKeqO7GNbU3m7a7H23cqVK6Pt41Lnupdp2kSXm+XQ5+JjS9vkrpP6dyovcLmipnX0e9b5V5Lu6drRHuk32xq9B1/HdG6qfPCYY45J6mnf6Jj72te+ltQrpcKdPXt2i+dzSmt+Z6bq2DjppJOS46lTp0Zb06i6TFGf9UMPPZSUaar2PfbYI9ruCp2TruiYDyFdO/y+dMycdtpp0b777ruTep/61KeivXz58qTs9ttvj7b2t/e9SixcHteZJC85ebs/O32nqTzSKaXC9fd1S38TQrre+bwvyZQUfSf7+XPvuLrJwVSSHUJZupKjJFkojYVcWUl2DW+Nylp0HR45cmRSr3///tHWkAgqjw8hfd956ATtQ5VflvZApfenrvF+Lf1t5WWdDb1/bfdVV12V1Bs/fny0r7nmmqRMpTkajkN/24WQ7hs1xInLllRO52U//elPo33TTTdFuyT/crbbbrto6/utNTIolVC3BaNGjUqONWTE7rvvnpTNmTMn2k8++WS0XbKmeyKXg+lvkLvuuqvV7W00lbyGu1CZfgjpfuaEE05o6PzNpmvumgEAAAAAAAAAoFXwEQgAAAAAAAAAoAbwEQgAAAAAAAAAoAa0a0wgjcOhOj9HtXwhpJpW1Xu6NlX1rqX08VrP05Br/IClS5dG2+MxjBkzJtoasyKEEM4666xoa8pc1e2GkMbccK2jxkrRMq+nMXU8vorH1Gk2rj3W5+ra8lwqU48JpNpZP7/GJ1CtbymmRiklYikVrtbVMr+WttH7Ro9L91yKBdFWaFyJoUOHJmUjRoyItscX0dgbgwYNirang1ZNr59Dn5n2qT8XfX46tkrpk0vkYvu0hlIaTY19pHGPQghhypQpDV2vI9Hn7Gutzg9dd/77v/87qXfBBRdE+9RTT422x0jIrfEhhPDAAw9EW98NGj/M21GiUa13W6GxGDQ1agghzJ07N9p+f6effnq0DzrooGj7fNNn7Rp1jWGh86+U8ltTBHtFgr/wAAAgAElEQVQ8PH0vakr4EEK4+OKLo62xfUr4+1njKaxevTrarZnPnSl2lK+96/A1TvtDU9CW8D6set86t0vx1xRvb+kcuTg2HhOou+N9r/tjfxc2G+0TXW+HDx/eptftbvh88LV3HZdccklyrO8gPYev8bof9LhsuTnmcbz0WqU4YVpWigXpsVg7Am2375l1H3bppZdG2/cVf/rTn6Lt+7X3ve990T700EOjrb/nQkifk/529N+Ezz//fLTHjh2blC1cuDDamkLc0T7w/tGYiqVYYLl573/XLPTZ7brrrknZL3/5y2gvWbIkKdO2bbvtttGePn16Uk/jMPkeW2NA6V5E4zi1BRMmTIi27480bb3v9TTGqt6/90uzfyN2nt0QAAAAAAAAAAC0GXwEAgAAAAAAAACoAe0qB7vvvvui7ZIvxVPV9e3bN9qltLB6XEpfrnhKRnULVLd3TRkYQuqGNn/+/KTsk5/8ZLRLLs7aRncbe+2116KtboB+X+oW6G5injq92bg0Rl0P/XnnXBlLMjh3V9T7qZpmPtc+P65aVpKSuNuePgMt83Gr9aqmhn27XHfddS3aIYQwevToaO+zzz5JmY7nIUOGRNtdXPfbb79ol2QI2v8+B3ScqBypJMny/lGZgkpLSmtHqb3qCu0SCG2/ymzeqs2dlZJ7sPaHpsS84447knr6HM4+++xo+zhX6e3555+flD3xxBPR1nStVaUqTslduiMYN25ctDWdewhpuldPlz5jxoxoq2uxph8Oobze6rGuvb6G6jtZ35E+Bz72sY9Fu6psqcSkSZOSY22jtknd4UNIx6c/j8GDB7/tdjULb9s6SmnVPUV8z549o639VlUWUpKN+Z5C37U6h30clN6Zen4tc6lFd2SbbbaJtspHQkjndyPPtjRmHO1HnSuexlll/W2dQrot8GeSC0vQ0vE6/D2j66nLcpTvf//72XPouq5rmkpcQ0j7piR/1rnubdKy0j5Xx4u3V/c23/ve95IylQC3F1WlS/pu9d8TKi3ytUf3thqiwmXx2o96/gEDBiT1NB29y/pOPPHEFtteGnfOsGHDsmWKruftsSdVGZzK+kNI72ennXZKyrR/r7322mjrb+sQ0j3QD3/4w6RM9wTHHHNMtFWSFUL6W7skh9U12ceS/rZQKaGHgFFpm0sQdWxNnjw52j6W9FtEM9ZkPIEAAAAAAAAAAGoAH4EAAAAAAAAAAGpAu8rBHnrooWh//etfT8pURvCLX/wiKVN5gEbfd8mFumi5K526cqnbVcnVVl0CXeag2c00Y0kIqZxG3ShdAqEuuS5Ly/2d37O2390Mb7311tCWqCukX9/LFHX1c5d17TeXean7YCnDm7vUrkPd/rwd7vaey5rj59C/cxdV/Tt15fUMEPp38+bNa7Ht7Ym6WKrdGvQe/X7VDV7tUqa+UqY7dWv1+ZxziXdXWB2vLqPUuhrB38+RG3ch5LOGdGZKWfG0TJ/XCSeckNRT91d1B/Y186mnnoq2Z45SV2qlNe7SnZmHH3442gcffHDlv9N1Q12LNWtfCKnkyMt0jmkfu7uzSp7/+Mc/RlvdvR1/3+WyWpTqeRZRzfgxc+bM7Dly0uEQ0ne5j9f2RmXxJWmP3p/KE0JI+1fngO8HdL0qySBLGWQUbaOv8ZrVzt+ZOclz1ex+XZkvfvGL0V62bFlSpvtSfd81KlUvycG0D3Rv4uf49Kc/He1zzjkne77OSunZNQOVQocQwuc///loq3T83nvvTeqpLDAnyQqhnNFU147S+qB7WT+HrrW6F/dwHbqu+LvbQwE0i1J4j5KUSfuktA5p//j+cu+9927x3IsXL67UDs30F0K6tt1yyy1JmUp/lNL8dVT6VFoTtB89y1tbZAd75JFHKtX7z//8z+RY5W26r/bzaVZU/72oexOVuXqIFt0PrFq1Ktre1yrtKv2m0XqeEU3HsWdPVentgQceGG3NYhdC82W5eAIBAAAAAAAAANQAPgIBAAAAAAAAANQAPgIBAAAAAAAAANSAdo0JpHisEY2FoOmCQ0i1karrdD2makg9nWIuTaJrJvWc+jcTJ05M6qlmz9uhukJtr2s89fyuz8zFOXFNr8Y+8Ha0dcpV1+mq9tjLcun1PE6Elnksh6op17UdpTgIVVO/q1a/aowER9vosW+uv/76aK9YsSJ7jq6ExrTy1O8+v6FzkovhEkI5FpmiaVgfe+yxaB9yyCFJPY2/pnGE/FqlNPBV4z10hrTwzUDvQ9NLeyr5jqI0fqrWmz17dnL8kY985G21qbOhcQAUH+cay2HJkiVJmabX1dhjHiNB34Wld1UuXoyfozSPfv/730f7K1/5SlKmeyI9h6fM7Y4cddRR0fbYDtrnOif8Oef6rtF1TdfvOXPmJGUnnXRStLtiTCBH99kez0fjfGi9vn37JvU07fjAgQOTsvvuuy/ad911V7T32muvbDs0Hqjv4XWuePxMba/GAfLYhL179462v6v1nBoXx6+lbfT1R2PENRN977cmPs6kSZOiPXTo0Gg/++yzST29D4+jpHPswgsvjLb+7gsh3dvq7w5fyzSWZC4l/NtB49zobxQfT7qu+Hu3Nc+42Xg8R433p/zoRz/KnuOyyy5rapuawTXXXNPRTXhL8AQCAAAAAAAAAKgBfAQCAAAAAAAAAKgBHSYH++Uvf5kcf/SjH432oYcempTlpAfu2qgyG5ftaF2V5rgLnLr3qUugu8mWXBX170qSo5xEKoTUVU/b6y58mtra04t7Krxm4ylOVZpWuh91cS25JLpLqv6dusJqer4Q0udc1bVd3V1DSN3qq0rASu6U6u7o57v44ouzf+ftAmgvVJ7gbsU6r0opvXXc63rkc0XlI56uVWUtpfXBJbU5cuszQHujEgJNLetSrtK7Rce9Spddkq3nLMmp9djnor679Bw9e/ZM6i1YsCDa/o7Xdun802fRXfD3tz4nDRsQQn6dc3J952tZqUyP9bq+N9E126VPzz33XLaNnYXzzjsvOdZ3hktN9feDPmMfv7rPvuKKK5IyleLus88+0R4+fHhST9+Luof3eaSp5H0/r2NL2+7vQT3297jvidehe3nniSeeyJY1Ew1noanAQ0jXOU0DH0I67vV3wsiRI5N6KutzOZjyuc99Lto333xzUqZSXF0rPeTDoEGDsufP4bLP0l5F186q4St83W+LFPHQ+cETCAAAAAAAAACgBvARCAAAAAAAAACgBvARCAAAAAAAAACgBnRYTCDXvF955ZXRVi1tCPm4KJ5GVTWTrqnWeDKqx/V2qF5d4wiVYsaUNO8l7b3qNavq913jOWzYsBb/JoR8mr1m4enM9R622mqrpEyf0ahRo7LnzMUOCiHtU71Xv+9cymFPx6u658033zwp03txHXWOko5fNcce+8D1w4rqewHak9waFEI+9ojPMZ2LOj8efvjh7HU9pkHVWBm+hgJ0dvQ9mYtlF8Kb0z4rGltG4wp5vA+dO7k9SgjpfCulrNb9kb+nnnnmmWh7PMUBAwZEW9+LVWN6dSU8jo5SivFR2jdWjWOm5yjFF1Hb+1uvPXbs2KSss8YE0jgt+++/f1Km+3aPEaNxrDSd+Pz585N6GsNnzJgxSZnuxzW+j/9+0Pg+2223XbRLqdm933V+6/zzdNs6x6qmAfd6ul7oPbYl+myPP/74pEyfk+//9XfhmjVrou3rocZ/HTx4cFJWdY7pOS6//PJon3766ZX+vlH898rEiROjrbFa/beFPjf/HUJ8xHqCJxAAAAAAAAAAQA3gIxAAAAAAAAAAQA1oVzmYuhS6K5q6LE6dOjUpe9/73hdtlRe466qe010E1V1SXWM9vbjKrXr16hXt3/72t0k9deP2e8nJvFy+5m6bOfSe/W8eeeSRaN97771JmbqGtwVPP/10cnzsscdG21279RmpG7naIaTPq6qbZ+/evZN673nPe6Kt/e7yslmzZkVbXXz9nKXUteo261I97Tcd3+7KOWPGjOz5AToKnW/q9hxCKhMoSRdy0hJN3Vqq5+j5/VpVXd0BOgv6binJwZ566qnsOVTK4HISJScB83mjc9H3G3p+Pd/222+fva7vS4477rhol1IYdwf69++fLfN1Tp97Tq5Voqrkq6W6Vc6h++HOjMrWfD5o2nFPxz506NBo77ffftEupdL2PWruHVQKO6HjIBfKIIQ3/35QqZi+n33fr3O4lAY8N7f9HKX9cDOZPHlyi3YIqey8T58+SZnuLfSZaQr3EFJJXml+6O+cxYsXJ/WWL1+ev4G3SWkuekr7M844I9oapkNDXoSQysMWLlzYlHZC1wZPIAAAAAAAAACAGsBHIAAAAAAAAACAGtCucjB1lXR3NuWHP/xhcnz11VdHe7fddov27rvvntTr27dvtF1yo+6Y6t5Zihivbsw33HBDtr3wf9x5550d3YQQQgjf/OY3O7oJTaO7u8tD50Xdj90VXV3YtZ67s+dkY+4er2V+LT3W90bVrIzeRoDOgsoadDy7jEVl37oHCiGEyy67LNpLliyJdmmOKVXnrNctSYVUav3Vr341KfvYxz4Wbc3W5JkFuwOtuSeXHa2j6tpVkrRUzTDWGklZZ+XnP/95tKdNm5aUfeELX4i2Z7DVY33nlGTHLukrya0UnUe6x3Npk2Ypmz59elJ26623RvuQQw6J9imnnJLU0zXB56nem645LnvSearZ/ToKDQehdneiNfL273znO23YEujO4AkEAAAAAAAAAFAD+AgEAAAAAAAAAFAD+AgEAAAAAAAAAFAD2jUmUKOaYtV8atyZzhKDBgCgu1FKI60xDTQWj6eW9Zhr68jFv2gJvXYplby219tRSjsP0FHceOON0T7ooIOy9R577LFoewwMHdsa16OULl7nStU4JiGk80rXAD/H/Pnzo+2xTF5//fVo657wD3/4Q+V2dBU8LlMpBbjGXVF87dVnVrXvSntv7dPXXnstKdOxpWnCuwozZsxIjo8//vhsXU0tP2TIkGjvsssuSb1BgwZFe8stt0zK9Dm//PLL0V6wYEFSb+bMmdF+4oknsu2tym9+85to77XXXknZ3LlzW2xfCOlcVFavXp0c65pDanGA7gOeQAAAAAAAAAAANYCPQAAAAAAAAAAANaBd5WAAANA12GSTTaK94YYbJmUbb7xxtEvSrpycwCUOLt/KlanExaUQm2++eaU2AXQWVNK+wQYbtGiHkI5tTb8eQgjbbLNNtHWO+ZzKyYh8HpUkRjr/VOrk81lTTI8ePTop22ijjaKtqbg15XV3QfsmhPT5DR06NCnTZ1GVUgr3kgRM10ftO5ekaV/16NGj1e3rSqgsS+2bb765I5rTMGPGjOnoJgBAF4GdMgAAAAAAAABADeAjEAAAAAAAAABADeAjEAAAAAAAAABADSAmEAAAvIlLL7002qX4Fbn4EiGksU00XbynSq6a6riU6l1T8nbFdMZQP3ROXHnlldH2+Cv3339/9hzLly9vfsOaiKe9vuCCC6Ktscaee+65dmtTe/HAAw8kx9/97nejvWjRoqRM4wUppVg/uvZ6DChdUz1V/V//+tdo61rpKc/79+8f7SlTprTYPgAA6JrgCQQAAAAAAAAAUAP4CAQAAAAAAAAAUAPWK6WRBAAAAAAAAACA7gGeQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANYCPQAAAAAAAAAAANeCd7Xmxd7zjHW+ss//xj3+056Vryb/8yz+/8f39739frxnnfOc73xn78O9//3szTgkF2qIPQ6Afm8F666Xd8cYbb2Rqtk0/NmM9fcc73hHt9ddfPynbcMMNW7RDCGHjjTeOdv/+/aO99dZbJ/V69erV4vn1eYQQwuuvvx7tl19+OSlbvXp1tFesWBHtNWvWJPVefPHFaL/66qtJ2Z///Odo/+1vf4u2P7f27sP//7zxoqXrQ3Noi35cb731OqzjdB1617veFW2fszq2/vrXv0bb5+Jmm20W7UGDBiVlOocXL14c7eXLlyf1dL619Zh+44032v296Gu/Huvz7NGjR1LvyCOPjPa4ceOSshkzZkT7mmuuifaqVauSes14nrp+v//974/2fvvtl9R75JFHWmxTCCGsXbv2bbdJn9s//vGPpvTjBhtsEBvzl7/8pRmnhALsUbsHbdGP66+/fuxDfefAm/F3So5m71HxBAIAAAAAAAAAqAF8BAIAAAAAAAAAqAHtKgfryhKwqq5aIXQel/62eN64ZbYvbTVn6Me3T2vmeVv0YzPOucEGG0R7yJAhSdmwYcOi3bdv36RMj0ePHh3twYMHJ/V69uwZbZWSqFwkhFROsnLlyqTshRdeiLZKxVRCFkIICxYsiPasWbOSsqeffjraKilrzTxoq7nYWd4XdaEr70NCSCVfIYSw2267Rfvkk0+OtsuNdJypxGiTTTZJ6qkETOevn2Pp0qXRvvXWW5N6l112WbSnT5+elHVmWUDV9cDnrB7r+HJZ6sSJE6M9adKkpGyPPfaI9u9+97touxysGYwcOTLa559/frQHDBiQ1Nt9992jfd111yVlzVi32mLt68zj661waaa+n52crLkt1rdSP7FH7R60RT925bnY3jRjLWykD/EEAgAAAAAAAACoAXwEAgAAAAAAAACoAXwEAgAAAAAAAACoAe0aE6groHp7jWHxznemj0pTK7sOT7W6mqKSdJUA0NFo6ugDDzww2vvvv39ST9MI65oWQhq7QOP7zJ49O6m30UYbRVvXzNdeey2pt2zZsmhrqvcQ0nVTYyT06dMnqTdhwoRojxo1KimbOXNmtO+5555oz5s3L6mHhh06IwMHDoz2D37wg6Rs1113jfamm24abd2/ODp/dV6GUI5/qPND59/RRx+d1Hvf+94X7VtuuSUp+/KXvxztV155JXut7kAp9pmX6Xp7wAEHRHvu3LlJPY8zVAXfvx511FHR1rHg/bFkyZJse6E56DvtsMMOS8oOOuigFuuFkPaHxo3y96ei7/4Q0jgkOq6ee+65pN7DDz8cbX9ndvUYawB1Bk8gAAAAAAAAAIAawEcgAAAAAAAAAIAaUEs5mLrGekrMoUOHRnvOnDnRdhdLlUe4i2Xv3r1bLHv22WeTel3RvVZdxT2lnZZ5qstcClUAaFtcCqCyr2OOOSbaLh9Rl3BN0x5CKufSVK4up9L1T8/v0tjVq1dHe82aNUmZrpMqXdlss82Senrsaa811bWm1NaU8yGksjTWKegoPL37TTfdFG1P256Tb/n41bmjdkn+5efQY32nu1RF5/3xxx+flOmeS2Vk3XG+uYx26tSp0f7Qhz6UlKl0VtdlT5V9/fXXR7uUPl7Pt/feeydl+g7Q87vU7Kqrror266+/nr0WtA6dcx/5yEeifeaZZyb1tthii2j7e1yPS/LOqnNd390u116wYEG0VUoYQvo7CTqe0m80AAdPIAAAAAAAAACAGsBHIAAAAAAAAACAGsBHIAAAAAAAAACAGlDLmEAaO8I1k6rZ1nSZJb362rVrk2PVTm+//fbR7tevX1Jv4cKF2XZ0Vkra45EjR0Z7jz32SMpUG//AAw9EW59BCKkuuWqsglJsIqUZMYwa7Se9Vum+AJrN5ptvnhxr2lmNneMxynSs+7jXOaFz1uNX5NbNd73rXcmxxjfw+aHn1FhCfi1dd/1ettxyy2gPHjw42ttss01Sb+XKlW/ZdoC2QOPoXHrppUmZpn5/6aWXsufQeeUxRPR9rWX+Hi+943TO6Tvd/8bfp4rGoxk+fHi0n3766ezfdBc03XtpH6Bxk0455ZSkbM8994z29OnTo+39vfXWW0d71KhRSdlWW20V7VKctT/+8Y/ZNkLjaN/vu+++0dZ5HsKbY0op+n4q7cur7j31Wn7d7bbbLtr9+/dPynRMQ/vgc33EiBHR1jhhK1asSOr5ngkATyAAAAAAAAAAgBrARyAAAAAAAAAAgBpQSzmYulN76vdG5D4uG9Dzz5gxI9ruaqsunF3FTU9TwY4ZMyYpO/vss6M9bNiwpEzTlS5ZsiTaU6ZMSeotXry4xb8JIX1GS5cujbbL8dSlVt1aPc21ymS8bzR1tKavVolgCGkqTR8HPXr0iPa2226bbYemZZ0/f35SNm/evADwdiilUtc5VVqDfGzrOqmuye7OrnIztV0uojIWv5a2S+elpyzWv3OXeG2XzvtevXol9fTvPN09QFuicuo+ffokZTru/R2k7xOVPa6//vpJPZ0fOme9ns5Nl4/ovNd3q8s79Zw+1/WcRx55ZLS/8Y1vhO6OrmW+v9E+0b7y9VvlOPvss0+0WyMzz/Wxy0x8f9wV6AqhFbSNKt9xtJ9K8ygXvqB0Pq9bCnug70IkRu2D72F03h9yyCFJ2YQJE6L9rW99K9reVwAOnkAAAAAAAAAAADWAj0AAAAAAAAAAADWglnKw9nRfLMmFumKWKHXzPu6445KynXfeOdou1VDXxpJbo+Kuq6XMQLm/K2U4yrm2h1A9I1ipTF3kta/dRVOfjWdL+9rXvpY9P0AOHW8uO8iNbZ9T6gKuc8//TmWPLl3ISS5dPqLnUNmYo1m/Sm3yeanrlkrDXL7mcgiA9kIz1ZWyAvk74sknn4y2yht9f/H4449HW99BLokcOnRotDUrUAjpfNY2euZTPae/x/Xvdthhh1Anxo8fH21f53RtK8l0dW3LSYJaOlZyMiPvK9bDtkH7RrPi+W8E3RuW9rylDGCl3xkuOVqHv5/XrFkTbc2gGQJZNFuiNI/8mes6oJJgzQIYQghDhgzJnuP3v/99tBctWhRtpHrwVuAJBAAAAAAAAABQA/gIBAAAAAAAAABQA/gIBAAAAAAAAABQA7qt4Nc1maV4Ee2Fa2c33HDDaHva16ptVG2op3otxRVoFH2uw4cPT8r0fjxeh/fHOkp691IsgdK95a5Vwp+3nr80drRP/bo5rb0+Jz/efffdkzKNnwRQFY0DsNVWWyVlrvdfRyl9rKdL13VH01L37NkzqafxiNT2NmiZx8rQuGqaDtvXDm2TzzFt4xZbbNHiv4cQwgYbbBDttWvXBoD2QuNi+X5A+dnPfpYc33vvvdHWOeFzVuP0lfYXunZ47AndY2iMr0mTJiX1vvCFL0Tb1wRdZ+r2fhs4cGC0Pd6O9ldpD5Pru6p9GkLar6WYQBrbaenSpdnzQ+M8//zz0S7tL/33Q26vXIo96vNZj0txMJ977rlo8178J7nfQyeeeGJST/dgPsdy+xGfs/PmzYv2Nddck5Tdc8890fbfXtC1KcX0asa3DDyBAAAAAAAAAABqAB+BAAAAAAAAAABqQJeQg+XSH7pro6Yv9bSnq1evjnZJUtBstL3uFq3ugzNnzkzK1OVSJQoDBgxI6k2YMCHanpb9/vvvb6DFZdT9rJTOsuR+rHZOmhJCWdJXcpfOuc/5v+v53DU7l5qz5H7n4zHXjlLaVZexeHpveHPf6/xw6ZM+z8WLF0e7JLeoio9dbUej8s7WUEoPrGNMU0+HkLZT8fvRY18ntUzlWyWpo9bzOaAuzN4+7VO9Z3d71nP6vWy88cYt2j6WVO5SWi+gc1Fae9tCFt0WlKRRm266abSnT5+elGn65mbI3vXv/Nnp8auvvhrtW2+9Nan3iU98ItoqgfJz5Nai7spjjz0WbZfr5VK/N0opbXjuuqU9HbQN+l7095b2m4+X3G+hUp+VQhYovnbo7xFfE+r8XlQJ7wEHHBDtYcOGJfVK+xZ9nn/+859btEMI4cEHH4z2Aw88kJQ1QwLWjDWnO1NVotvofMiFDPF3pO7FX3755YaulVz3bZ8BAAAAAAAAAAA6PXwEAgAAAAAAAACoAXwEAgAAAAAAAACoAe0aE6gUw0J1rJ56fO+99462ptPz+B9DhgyJdu/evZOyJUuWRPuhhx6K9owZM5J6qnPXNrkOVmMMlVKxDho0KNonn3xyUm/HHXeM9uzZs5MyTck4YsSIaOv9h5CmaV25cmVS5vfWDPQ5aIyVEN6sJ8+V6Tlcy6pjxDWYqoUsxXloRFvv59M+rRo3qpR+s6TZLsVFqrPeWuMh6Zqwyy67JPV0Ho0fPz4p0zhczzzzTLS///3vJ/WmTp0abZ/Pqtl/97vfHe33vOc92Xpnn312UqbrRbOoGhNIY+CEkMa90b9rTXw07Rs9n19L47Rp+lPXOWsaeJ+LupbrmuCa+dJ6rXV1jffYTV0lfkx3wtdoHUMeY0rfF7pu+rjT/l61alVSVnpPtTd67zvssEOlv3nppZeS42bEI3i7aFyiENK1duTIkUmZtlH7tw4xuJ588slo6zrkVN3flFKI59LAO/rc/Rw+1qD56P7e94aNxCz1eVM1lqbi469usbuqovPjqquuivbdd9+d1NO9j+4TQ0jjvOreVn/bhRDC008/HW3dL7WGUkxdSPHno/3hfaPrpv7+99+3Ov80nlQI6W8c/Zbx/PPPJ/Xmzp0b7VmzZiVljawXeAIBAAAAAAAAANQAPgIBAAAAAAAAANSAdpWDlVwRR48eHe2zzjorKRs1alSLf+PuWipLcPdFdbncf//9o+0uyNpGtd3FUl153YV24cKFLbajT58+2fb369cvKdN70XovvvhiyOESuF69emXrNoq6mz377FaHeEYAACAASURBVLNJWTOkFCU5WM59seQ2XjVNail1Zkk+UHKvrJp+U3Epkh93B/S5qFxon332SeodffTR0VaXWZ0bIZSlT5paWWWl48aNS+qpHEzdOUMIYeedd462zlPvR72v3/72t0nZ7bffHtoTHbPuTqpriMoxfG3R9JP+zHVt0WesMjE/VrvkXu4yCV3X9Bz+/HMuuSGka5VKVVSeEULjbtbw1uj6WHovTpw4Mdo+7lasWBFtnfc+ZtRlui2kmM1Cn4nK20vvo6qSjvbE363qBu99qPsELSvJv7sLKlMsrYElmW6u/1szZnLydN/Dlfab0DjaHyph977W/V8phEZpn1vab+o7MyczDCGVriAj+ifaP/qe8XeO9reHf+jfv3+0Bw8eHO2hQ4cm9caMGRPtKVOmJGVV9y0aTsR/c2rIFHjzPNJx37dv36RM57D+znDZmM4jl4PpGNH967Rp05J6kydPjvacOXOSMuRgAAAAAAAAAADQInwEAgAAAAAAAACoAe0qB1NXfpdtnHLKKdF2+ZfWVXdVd3FV91p3QVYXvJLkSI9Lbo96fs9S49nN1qHu6y0dK7mMDR5ZXnEphj+DZqAuowsWLEjKXIJR5RyNZgDRfnIXuJxLXMmN3t1fc1k3/BwlOVhu/Pi19JyerajqM+1o3HVSx6Jnh3n/+98f7T333DPanu1Pn9/atWuj7fNNn6e72OfccN0V9gMf+ECL9ULIz1NtUwjpOrXbbrslZffcc0+L52gr1E350UcfTcpUAqYyu9Jc9LVFXVlV0ufur5oVQzO1eT/ps/R2qPRM1z+fXzoONLtiCKkkTiUOKnkLIR1b3TE7UVuj/apzO4RUkq1jxt9TOiaXLVuWlGkfa2YWzwCm62hn7kddn3R++DwqZeCrmgGzLZ+DZy3V9cclRtqHKiX1THD+LuwOqEzO9ym6nuVkOiFU7++qf6NlLgnxdxw0B32fanZTp+qcrRr2oGroBEfXJp+npSx38H/ofPb9q+5NVLauYUtCCGHSpEnRfuGFF5Kym2++Odq63qrULIQQDj744GgPGzYsKbvkkkvyN1BDfH3WZ+5jXtfJsWPHRtv7UKXvvgfWd4PKCT1Do2bl9rnoY6sKeAIBAAAAAAAAANQAPgIBAAAAAAAAANQAPgIBAAAAAAAAANSAdo0JpPrv7bffPinTlM2uc1M9vNoeq0NjeTSarlu1m1VjB5Vi++j5vU3aXj9/Li25Pxtto2sY20Krq/ejGsYQ0jaX4h/pfft95tJe+nEpbbs+h1Kq1dzfhJDqavVapThRJb111fhPrsHviBTxOhY9NoXG0tFYLa5rf+973xvtbbbZJnt+fZ7+/LQPtJ7HxdI5oWuM11Udvvej9kGpHTpOSn2jcU1CeHOcoWZQGm/aTo/zoOnrNWaPp73cdttto+1xzlTPrGPbn6uWlVIWl+J16TlL59AYIh6vbPny5dHOrQ/QejRWRAghnHrqqdH2mEAay2bp0qXRfvrpp5N62ncLFy5MylauXBlt1eh7jAR9N5XeIx2Njm2N3+BrnI5ZL8utob7maFkzYl9pf3rcN33+pZg2uj707t07qdcdYwLp+93jkWmcrGavS75fyo2TRYsWJfUaSTkMb83WW28dbd1jleJnlVK/l9K7l8pyvx9Ke3uPDwhvj9xvRN/f6N72Qx/6UFKm+7NSGnjd72l8mhBCuOKKK1rT7G6Pr8F6/NprryVlmqr96quvjrbO8xDSGEH++2HFihXR1n2O2iGkv+tLMWqrgicQAAAAAAAAAEAN4CMQAAAAAAAAAEANaFc5mEq53BVN3YJLLpEl6UFJLpRLuVlyVS6lo9fzlVxmS9cqSZpylGQUpbR1zUKfj7ovh1CWt2m/lVLXl2Q5elySweUkYK1JnZlzofX7KrnaKvp3pft3F/6STObtoP3h/bjvvvtGW1Onh5DKOPU+vN36LNztUcdpSWqnkiMt82upHMyfbU4i6mMhJ/nyMrVff/31pJ7KNDzdfanP2xq/H5UhaF+sWbMmqadjZMiQIUlZ1XGvz7y0dpf6V595Tl4WQpr63VOGd4SssiuQk2aWpNY6tj/84Q8n9SZOnNji+UJIx6G6PqsrdQiptMvnmLZLpWieblVd531t93HekehzVVd9H9sqz/B7zUmUXbah0gBNS6zzJoT8e9avrRJ+Xx90XfH1J7dP83TGLunsDuh4VklkCKm8rpHU4KW/Ke1vtH90XLSmHdA6dt5552jr3qAkw2q0L6r+BilJ3fXvOnIv0x3RdV/lQj169Ejq6XtR/yaEEI444oho636+FIaiFHalo9F1Td85KnULIX33+dzRtVZt/77QDHS+PPHEE9G+8sork3raH943U6dOjbbKcnWvFEK6t20kJbyDJxAAAAAAAAAAQA3gIxAAAAAAAAAAQA1oVzmYujir62sI1TPMqPt0M6QzJTlYKRNNScaSc+EsZcxqNMq3/p27w7VFZge9nrskljJnVZUdVHVvLmUi03HRyHMslZXkeKVzlFxyO8LlWvvuvPPOS8r222+/aHsUfHUZzcmk/Nhdi7Ws6vwoZQUsydJy487Rei5vyvWr11PXzIEDByZlbZFRoxnjRtcIz8bjMhFF77XkXlu1jVXX2pI7rbr81k3+pc/M54C+awcPHpyUafYKlTO627WWaba/YcOGJfV0nPvaq21USZnLgNRN3eeNZrBTyZdLoXXdctmNZu/oaPRedTyXsvg4ub/zeaTPXJ/dzJkzk3o6t116phkhdSy5bE+zurnLem7P4tkJuyO6HrpcX9fiUj/mzlcqq5pJEtoHzbyp76pSZq+SlKuURaxUpuj+qCQNcpnS/Pnzs3XhzXgfHHjggdHeZZddou3vNJUI+Zqg7+vSfswlYIqv4e2J7+V0XzJmzJhob7fddkk9DW3g73l9Xiot9n1uI2FZSuj77qmnnkrKpk2bFm3/BnLvvfdGW9vr789SKBSygwEAAAAAAAAAQIvwEQgAAAAAAAAAoAbwEQgAAAAAAAAAoAa0a0ygUopmpRR3Rc9Rqteozq9q6veq5GIMeVkpZXIJ1QmX9J7NQtvl8SU0FkXp2ek5SjGZSvpofZZ+jty1/XwlrbSeX8u8Xmkc5/6u1N5SuvtmMmDAgGgffvjhSZn2o6fpVd2walU9HpWWuaZVj/U5exySzTbbLNqluD+leEF6fn22/lxVl1+Kb5RLOxlCGofEYwJpLI3Ois8P7VPXL+fSyZbiP6ldSh/u7dBzajs0rkkI5TWhq6Lrht/vTjvtFO0JEyZEW+dNCGlcHY/nkJsfHotH56amZlc7hHKaa+1XfVdpStsQ0nnlced0Humz8dhlpX3C3XffHToLuXS+pXdV1X2Jr2P6XPW63odaz8eLxu3p06dPtBcvXpzUW7lyZbR9TdA4Q9pPGgeiu6J9rLG1Qsjvc0t7jtw+JYTGUoPXIS5TR+B9o+upxijxuV2KDZXbR3u90v4yt0f1tUPnrM/Txx57LHQFGomXEkLz9xKjRo1Kjk855ZRoa5/ecsstSb0777wz2r6fPOuss6Kt725vu64/nnpc1+xmoffj7zTdx/uYmjRpUrQ1lp3GJgwhTZfuv0GWL18e7UbiBTeKXst/I0yfPj3aPh41htELL7wQbZ+LpZi3jdwnnkAAAAAAAAAAADWAj0AAAAAAAAAAADWgXeVg6rrkLsJVXe4adc3Luc2W5DclSVlVV9vc34SQuuaVzpFz2fcyd4fz42ag7n2a5tLLSv2bS20ZQvVU7YqfoyQ3U0oSrarpVUvjpeo963FVadvbRWUbLiPUa5bStleVOpZSVmtfuQQlJ4ks9ZU/L50DJdf5klRM0b5ymdtLL70UbXfXdVlLZ8TvW59XSc6mz85dV/X5l9YjLfN2aKp6ff7uGuyyoq6CyhlVphlCKtXcfffdkzKtq+PZx6U+W5/PuXnq8j89VrmZ1yutvSrZ0jZ5GnIdQ35+vbae38/hx4qvRx1JVQl3ycVc50QpPbC6mJfWXT12ybeOOXXhdynB6tWrW2xfCOm96HhUt//uisrrfE3Vfi3Je3JUlab7ObV/ShK1ZqdSrhPehzrHNM2173lKfZ/7HVOSlFUNZ1CSoPTv379yGzsaXa8OO+ywpEzfLS571Wd23333Rfvhhx9O6uXSqvv756CDDor2qaeempTpGvu73/0u2pdeemlST9dUfy+uWbMm2hqKwPtRf5e5jE/3r81Cx7mvH4MGDYq2ytlDCGHEiBHRfvXVV6Nd2ts4ud8nPseq/tbLnTuE9D2mUk+X8Jf2PVpXx5Xfo7Zf944hhLB27dq3bLvTeWcvAAAAAAAAAAA0DT4CAQAAAAAAAADUAD4CAQAAAAAAAADUgHaNCaT6RI3zEEKqi/UUt/p3qu1zLWrV+CylmEB6LdVP+vlK+utcHJeqsYP8/FW13poSL4RUS9ks9Jl7atlSiuac1rI1KddzaX9L59A+LMV/KsXiqRr/yeNtqI5a215qR2lMNxPV/06ePDkpGzt2bLQ9ZkXVuCul55KLxVSKlVRK4a6aWU8VnZuLJV1wLhZRCOmccv1tKfZKV0xZrvfgMY30uepYKsUH0OfjcVm0r12brqkztczPoVrsRtPBdgQaj+DMM89MyjQOkI8p1ZCXUojr2PP4L6pLV325P1u9dmnt1fkxY8aMpOymm26K9h133BHtpUuXZtu74447JmUnn3xytMePHx9tj0Gnx0888URSpmllO5rc+ldaL3x+6HpYiiGneyztd7+WjgN/x+uxxrTxsalprx1dX/XvPM5Fd6RPnz7R9ngOGu8it9cJIR/jpbTmVY2N2K9fv6RM1wGPxwHV8bGt79PSO03nh48XrVvq31K8w9zvIl9PtR0eP6e0X+oItH1XXnlltD2WkT5P7x+9X33nzJ8/P6n3wAMPRFufs8YACiGNd+axYJ588slon3feedH2FO6Kr6/Lli2LtqagL+2Vp0yZkpR5nzcDHef+W2LPPfeM9s4775yUabwgvTf/Tav35+NQ66qt8ZNCSPfxuW8NIaTjxWP96Jjr3bt3tHW9DyGNo9u3b9+kbNiwYdGeN29etPX+Q0h/4/hYmjNnTmgteAIBAAAAAAAAANQAPgIBAAAAAAAAANSAdpWDqSuapisNIU0x6i6pOTfpkjSnJLUqpb3MXas1qcxzlK5Vkq+VUjBrO5YsWZKUtYX7rl6vlB7Yn09JQqBUlXE0kja1lD7Xx5LWrTrm3B1RXUq1rHSP7vLbVixevDjaZ5xxRlK26667tmiHEMLIkSOjrbJNT9etrsouIcu5D3ufah+oy7TLIfSZ+Tl07qgbpc8NdYX1PtD2quTyueeeS+ppv3obFyxYEJpNTlbXLNzlVdH7U5lJaY7pXHHXYH03uBu0PjtNk+r3rOfsSnIwHXu33357UqZ9MHz48KRM51xJiqu4bCeXOtVdw7VPdNw/++yzSb1f/OIX0XaZaS4Fdonnn38+OVb3+6FDh0Zb0+KGkN6Xy8F0DHU0OblyaS3U+eZ/V/VdpX/jc0XnkUvztUzHks97dbH3MafHavua0NbrW0egErrSfrC0v8lJeJySVCz3d35dlSwsXLgwey14M/osNVW5l+lc8T11KXSFzp3S/Cj9jsldqzSu/PdZR8vBfH05/fTTo60SMH+n6R7QU73rPenzU6lPCCEcc8wx0db3cWk/rPKvEEI499xzoz179uxQBe9vlQXptXxd1mMPH1IaG42iz9HHSSm9u96PPnPfm/u7UNE9gY7Z0nV1/ulaHUJ5f6nyPD2/zxXds6hE0FHZ4fTp05MyXYe9Hf6bpAp4AgEAAAAAAAAA1AA+AgEAAAAAAAAA1IB2lYNphG7PCPLUU09F293e1SW+qotr1UwJVV2mS65yVd0hS9cqRe1XuyS38GxFbeHeV8rOVvV62jcl2ViJkpuhuodqH5ay5njbcy72fo6SC3dOAlaSFpay9zQTHSsuXZo7d260r7/++qQsl9nFXXK1nrtwal11XfVz6FhXKZe79aqbpkuYctlN/BzaP+6SrcelLEx6Ts9A5NkQOyO+ZmrGA193VM6r67pLudTlWLN3ucxEXWhVqujHJZmJzpVG5LodhWar0AxaIYRw2223Rdtd0T3zxDpc6qjj1KWZOne0nrsV6/ta+6ot3jEl1G1fs495JrKuIiXS56f35lmC9Pl7hpSqfVB17da56e+fnHzQ9x7+TlH03vR955KZ7ohm+/N9S25vVXWfW1rzShk61fY2HXXUUdG+4IILsuevK/5cdT3Vsa0Zm7ysFO6h9BskF07Cx0vV9S83t73MpbftFcIgh7dn3333jXZpfpR+f1XN8Kznz2XQDCHt13POOScpu//++1tsUwnvY92jVr1nzzDWFu9J3Se6DEtDwEydOjUp06xiem8ajiKEEEaMGBFtzSgWQrpfUgm4Z9vSd5W+x/wbhZZ5OBst0+eoGb9CKMu6tR26j/ZsZnrse2VvVxW6zk4ZAAAAAAAAAAAaho9AAAAAAAAAAAA1gI9AAAAAAAAAAAA1oF1jAmmsAo+RMXPmzGgfeOCB2XNUTf1bVUft2tecLtI1olVTnpfaVCIXr8bboe33FKuuV242nmpX+9f1n9rO0v2UdO1V9e+5GD5+rWbEjaiaflNx3bf+nce08RhBzaLU1lIMJD0upVrsLDTSx82Yz505DkkOvx9NYeljVuOSaLym0pgoxc/SeCiuVddzlmKi6Vzxta8zj9Vc/IEQ0me7aNGipMyP4Z90lfmXi6uj8bhCSNMKl8aL4nNM54fG/fH4QxpLwfcU2t5cmusQ0ngH/q7Rualrjse80vNXvefOzr/+679my0oxWZTcu7tquvhSXU+VrSmwL7rookrt6GhKcSs1vojHTtN3hK4fpfgr2223XVKm+zddu32OaZnOxVJcSS/L7YdLMYFKMW1KMVW1r31t8jWiWeg9ldaQPfbYIynTtPAar8jnVCmuqF5bn5n3Yy6mpcdS0/gyd9xxR1LWjHmUi4Pq+x6d3x5bri3Q94Lfp7bFY2jmmDx5cnKs/eu/nfSZ6LV83uueMhcLtqXjKmX6XSOEEH77299G28dc1XW99PuskX0PnkAAAAAAAAAAADWAj0AAAAAAAAAAADWgXeVg6rqk7pAhhDB//vxoe/pmdWNWNzt3zasqJSql686la3QZQsl1shGXrJKbYcm9r3QvrZGfVUXv7ZlnnknKxo4d22K9EPIuuu4SV2pzI2mfS/3UyPMppeks9XtJlqZui+6i6a6L0DoamYtV/6arSE6q4vNr6623ztat6sKsa7mObXchrzqPFK9XkrgAdEZya//mm2+e1HvooYeiXZofOoc9dXO/fv2irel0fS7qPPJz6PtaXew9Na3u7zxdvKaCryrx7qr4/mbMmDHRLkl/1C5JeEqUwh7kzuHXGjJkSLR79eqVlGka486Ejt/dd989Kdtrr72i7ftXlVyqPEXlXyGkz2TbbbdNynR/rqmot9hii6Se9ofOsdJ8q4r3bWle5WRkpf27rxdt9a7VtdF/E6r0Z7/99kvKNtlkk2iXfnPq3tqfcy7de6k/9Fqa/jyEEP7f//t/0W6GDMv7R+8lt+cKIV2nXXbfFjRbMuq/nbRPvX87A95PnTEsQfd76wIAAAAAAAAAwJvgIxAAAAAAAAAAQA3gIxAAAAAAAAAAQA1o15hApbgPqqH0Mo0DpHbVNPAtHa/D9bI5/afrXrWslE5R78XjCpXSnub+rpReXOMGhNA2Gkk957XXXpuUjRo1KtojRoxIyvT56T24ZrSUEjOXjrFqqu6qadFbOl6H95lqcUvpq/VevF80na6nQNRYWQBtia9xGhOoFH+tNGc1bohq1X1+6fldN51bL/xaGgtC4wKEEMKaNWsCQGdD4x0qPrbnzp2bPUcuDpDHMtFYPAMHDox2KR6hx+JYtGhRtJ966qkW/z2EdA7r+83bq/O5PWIatjd9+vRJjj02jFJK852rp7TmeeX2N94H2v877bRTUnb33XdXvl57oinCP/vZzyZlW265ZbTHjx+flB1xxBHR1ng+Pgdy+9AQ0v3g6tWro63vphDSmDZ6jtJcLMWQKvV9s+dRe83T0nm1Db6+6J5D63l8HK3n81J/Z+pz9/2/jhONMXX55Zcn9e68884338TbwOfvs88+G22dp6XYQaXfK1Af8AQCAAAAAAAAAKgBfAQCAAAAAAAAAKgB7SoHK0lz1F3fXfcbcXusKgcrpd8spWKt6gKZSzkfQuqa526G6o6o8qHly5cn9RYsWBDt66+/PilTd8dmoW35wx/+kJSdfPLJ0d57772TMk2lqdI/d+XU9JPqMhtCCL179462uvz27Nkzqad/p8/1xRdfTOqpe2gpfaQ+R3/+CxcujLanwlU3X21TaexPmzYtKfPUuwBthad+VRdpH7M5OWZJLqnzyNdPXe98nVR3bLXdFV9d/V2G8fzzz0e7agp6gLamR48e0S7tFXTMuixE562mlncJis4PlYq5/PK5556L9vTp05MylTzo+7MkLfB0ybl9oO9XukPK+EMPPTQ5Vvmfr5WNyGr0bxp9XtofvjZq/0yaNCkp66xyMJUC657Ry0rSq6FDh0Zb32F+7H2mv1VKMmmVbep1S21ycr93WjOOcr+tvL2ldO1t9T7VNcWvob8bvve97yVlKk3V8Ttr1qzsOQYNGpSU6e+LFStWRFslsCGkv7/0fKVQH23BTTfdFO2JEydG28dCbj8G9aXrv2UBAAAAAAAAAOAt4SMQAAAAAAAAAEAN6DA5mLv3qZTm3nvvTcp23nnnaPfq1Sva7uqm7oPq5li6trtCq/xGpT4eWb5fv37R9kw0em11v1u1alVST10J1eUwhNQdUyPQP/7440k9jQrvmaRK2bAaRd0cvQ9nz54d7VI2k2a4jzZD+le1HaV6jdxLqb1t0WfQPWm2G7bLwUpyVXUP1/XO19Oq6HrnLvAqoVBZZUm+putzCCHMmDEj2mTFgM6CyrfUPd8lKPqOcBmkSil17vic1WxFKunQPUQIqeRL/yaExuaOysv82mq/8sorST3fw3UVtN0HHnhgUlbK9JrLnujrvParjgt/XlX3SHr+kpx37NixSVkuy1tHo/vsBx98MCnbY489ou3vGX23lDJCuRxKye09S5mB1S7Jv/wZ699pe/33iOIyr6rSMb22rxe+VjWLqtl89XdUCCF8//vfr3Q+PceUKVOSstz86KxS8ieeeCLaF154YbSHDx+e1NPfZZ7RsbPeG7QteAIBAAAAAAAAANQAPgIBAAAAAAAAANQAPgIBAAAAAAAAANSADosJ5Kiu9Cc/+UlSpmmzd9ttt2h7CtS1a9dG22P4qLZdU5a6Xl1TCWvKP2+7andVkx9Cqs1W3a5riTV+RtWUgqW4Nu2h6ax6jbbWiHdl/WqjsYkA2hKfs6of97VW6+bSzHqZ2poiN4Q0zom3Q9dajQ/kMYH0/B43pTukm4buR+496bFBdI/hY1ljCant7xXdA2mZx+LJxaZpFI1pGELafp2nPXv2TOr5HO4q6No2cODApEzvyZ+tr4nr8Fg/ub1io/sKHYP+zHXd97W9s8YEWrp0abTPPffcpGz8+PHRHjNmTFI2bty4aGvKcO8XfQdpTK8Q0meiz9+fj8YI0hhG+psjhBDWrFkTbf+tovNK4wD5fWkcVX+P671o3/uaoHHC/PeZtrGZNLr2NJKevavvyfW35P/+7/9G2+ez3pfHqepq9wzNgZ0xAAAAAAAAAEAN4CMQAAAAAAAAAEAN6JT+tirrCiGEBx54INqays/dZNXl0l0C9VjrNeoGqC7TLj0DAOhqeHr3mTNnRrt///5JmcpVNt5442j7uqsuxyon8GtpPV//1d1cy1wOprgEBVdn6IyozKKULn3FihXRdjd+3c+UZDk5qVhbz42HH344OdZ7U5lbW6Wabm90DdS9awhpymaX5uh6VpLYVu3vUj09Zynlue5t/V46kwRM0fvR0A8hhHDfffdF29PHa3+UJFR9+/aN9rBhw7Ln0Hekvxe1XZreW6VsIaTyMJeK6XzR/vT26vt50003Tcpy8urXXnstqaft0rUohDevR9Cx6Lz0fRaAgycQAAAAAAAAAEAN4CMQAAAAAAAAAEAN4CMQAAAAAAAAAEANaNeYQKqRbY1WUTXrOR2s16uqc+/OsSL8+TQDTTmIFrjtaYs+DIF+bG/aoh+bEU9DY094WmpNSetxejRtrsYc8PTVur7qM/DUpapj93goem2NUeHXWrJkSbRffPHFpEyvl4sP91Z4DLpmoc+9FJ8DOi86tluzp9D00FdffXW0e/fundSbPXt2U9tRWo+avSd6/PHHk+Mf/OAH0R48eHC0H3rooew52uo96DTjvajP77LLLkvK9FlobJkQQthyyy2jrSm/PfZZLtaPr4e6zmk8KC/TvbhfS9feX/3qV6HZtPUe1X9nlJ6JvkNXr14dbW+jvgcmT56cLfP+yLVD32mltN3+rsrNU3+HvPDCC9H2e9E2apnX0/Z6fKPSfb4d9LydNf5Ud6It5qKuJz7foPk00od4AgEAAAAAAAAA1AA+AgEAAAAAAAAA1ID1urMcCgAAAAAAAAAA/g88gQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAJZc6CwAAACNJREFUAAAAagAfgQAAAAAAAAAAagAfgQAAAAAAAAAAasD/B6wkMU2XMwyxAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -374,36 +354,36 @@ }, { "cell_type": "code", - "execution_count": 646, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "HybridSequential(\n", - " (0): Conv2D(1 -> 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (0): Conv2D(1 -> 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", " (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=4)\n", - " (2): Conv2D(4 -> 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (2): Conv2D(4 -> 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", " (3): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", - " (4): Conv2D(8 -> 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (4): Conv2D(8 -> 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", - " (6): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(2, 2))\n", + " (6): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(2, 2), Activation(relu))\n", " (7): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", - " (8): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))\n", + " (8): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", " (9): HybridLambda()\n", " (10): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", - " (11): Conv2D(32 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): Conv2D(32 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", " (12): HybridLambda()\n", " (13): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", - " (14): Conv2D(16 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))\n", + " (14): Conv2D(16 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", " (15): HybridLambda()\n", " (16): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", - " (17): Conv2D(8 -> 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (18): Conv2D(4 -> 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (17): Conv2D(8 -> 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", + " (18): Conv2D(4 -> 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(sigmoid))\n", ")" ] }, - "execution_count": 646, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -421,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 647, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -438,12 +418,12 @@ }, { "cell_type": "code", - "execution_count": 666, + "execution_count": 45, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -454,16 +434,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 666, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -499,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 667, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -509,7 +489,7 @@ }, { "cell_type": "code", - "execution_count": 668, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -518,7 +498,7 @@ "(1, 32, 3, 3)" ] }, - "execution_count": 668, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" } @@ -536,12 +516,12 @@ }, { "cell_type": "code", - "execution_count": 669, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 911d937c2c2f29c4fec9eda11951421589b559ad Mon Sep 17 00:00:00 2001 From: tdelteil Date: Wed, 31 Oct 2018 21:39:35 +0000 Subject: [PATCH 06/10] Update after comments --- example/autoencoder/README.md | 6 +- .../convolutional_autoencoder.ipynb | 247 +++++++++--------- 2 files changed, 131 insertions(+), 122 deletions(-) diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 81f762533668..566e028b9d52 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -1,6 +1,6 @@ -# Example of a Convolutional Autencoder +# Example of a Convolutional Autoencoder -Autoencoder architectures are often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using a stack of convolutionnal layers for both the encoder and the decoder. +Autoencoder architectures are often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using a stack of convolutional layers for both the encoder and the decoder. ![](https://cdn-images-1.medium.com/max/800/1*LSYNW5m3TN7xRX61BZhoZA.png) @@ -12,7 +12,7 @@ The idea of an autoencoder is to learn to use bottleneck architecture to encode The dataset used in this example is [FashionMNIST](https://github.com/zalandoresearch/fashion-mnist) dataset. -## Variationnal Autoencoder +## Variational Autoencoder You can check an example of variational autoencoder [here](https://gluon.mxnet.io/chapter13_unsupervised-learning/vae-gluon.html) diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb index 9d96f35d171d..7278bc343037 100644 --- a/example/autoencoder/convolutional_autoencoder.ipynb +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Convolutional Auto-encoder" + "# Convolutional Autoencoder" ] }, { @@ -18,12 +18,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this example we will demonstrate how you can create a convolutionnal auto-encoder in Gluon" + "In this example we will demonstrate how you can create a convolutional autoencoder in Gluon" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -55,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -104,43 +104,50 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "net = gluon.nn.HybridSequential()\n", + "net = gluon.nn.HybridSequential(prefix='autoencoder_')\n", "with net.name_scope():\n", " # Encoder 1x28x28 -> 32x1x1\n", - " net.add(\n", - " gluon.nn.Conv2D(channels=4, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", - " gluon.nn.BatchNorm(),\n", - " gluon.nn.Conv2D(channels=8, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", - " gluon.nn.BatchNorm(),\n", - " gluon.nn.Conv2D(channels=16, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", - " gluon.nn.BatchNorm(),\n", - " gluon.nn.Conv2D(channels=32, kernel_size=3, padding=0, strides=(2,2),activation='relu'),\n", - " gluon.nn.BatchNorm()\n", - " )\n", + " encoder = gluon.nn.HybridSequential(prefix='encoder_')\n", + " with encoder.name_scope():\n", + " encoder.add(\n", + " gluon.nn.Conv2D(channels=4, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=8, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=16, kernel_size=3, padding=1, strides=(2,2), activation='relu'),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=32, kernel_size=3, padding=0, strides=(2,2),activation='relu'),\n", + " gluon.nn.BatchNorm()\n", + " )\n", + " decoder = gluon.nn.HybridSequential(prefix='decoder_')\n", " # Decoder 32x1x1 -> 1x28x28\n", + " with decoder.name_scope():\n", + " decoder.add(\n", + " gluon.nn.Conv2D(channels=32, kernel_size=3, padding=2, activation='relu'),\n", + " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=16, kernel_size=3, padding=1, activation='relu'),\n", + " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=8, kernel_size=3, padding=2, activation='relu'),\n", + " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", + " gluon.nn.BatchNorm(),\n", + " gluon.nn.Conv2D(channels=4, kernel_size=3, padding=1, activation='relu'),\n", + " gluon.nn.Conv2D(channels=1, kernel_size=3, padding=1, activation='sigmoid')\n", + " )\n", " net.add(\n", - " gluon.nn.Conv2D(channels=32, kernel_size=3, padding=2, activation='relu'),\n", - " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", - " gluon.nn.BatchNorm(),\n", - " gluon.nn.Conv2D(channels=16, kernel_size=3, padding=1, activation='relu'),\n", - " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", - " gluon.nn.BatchNorm(),\n", - " gluon.nn.Conv2D(channels=8, kernel_size=3, padding=2, activation='relu'),\n", - " gluon.nn.HybridLambda(lambda F, x: F.UpSampling(x, scale=2, sample_type='nearest')),\n", - " gluon.nn.BatchNorm(),\n", - " gluon.nn.Conv2D(channels=4, kernel_size=3, padding=1, activation='relu'),\n", - " gluon.nn.Conv2D(channels=1, kernel_size=3, padding=1, activation='sigmoid')\n", - " )\n", - " " + " encoder,\n", + " decoder\n", + " )" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -149,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -160,41 +167,41 @@ " Layer (type) Output Shape Param #\n", "================================================================================\n", " Input (1, 1, 28, 28) 0\n", - " Activation-1 0\n", + " Activation-1 0\n", " Activation-2 (1, 4, 14, 14) 0\n", " Conv2D-3 (1, 4, 14, 14) 40\n", " BatchNorm-4 (1, 4, 14, 14) 16\n", - " Activation-5 0\n", + " Activation-5 0\n", " Activation-6 (1, 8, 7, 7) 0\n", " Conv2D-7 (1, 8, 7, 7) 296\n", " BatchNorm-8 (1, 8, 7, 7) 32\n", - " Activation-9 0\n", + " Activation-9 0\n", " Activation-10 (1, 16, 4, 4) 0\n", " Conv2D-11 (1, 16, 4, 4) 1168\n", " BatchNorm-12 (1, 16, 4, 4) 64\n", - " Activation-13 0\n", + " Activation-13 0\n", " Activation-14 (1, 32, 1, 1) 0\n", " Conv2D-15 (1, 32, 1, 1) 4640\n", " BatchNorm-16 (1, 32, 1, 1) 128\n", - " Activation-17 0\n", + " Activation-17 0\n", " Activation-18 (1, 32, 3, 3) 0\n", " Conv2D-19 (1, 32, 3, 3) 9248\n", " HybridLambda-20 (1, 32, 6, 6) 0\n", " BatchNorm-21 (1, 32, 6, 6) 128\n", - " Activation-22 0\n", + " Activation-22 0\n", " Activation-23 (1, 16, 6, 6) 0\n", " Conv2D-24 (1, 16, 6, 6) 4624\n", " HybridLambda-25 (1, 16, 12, 12) 0\n", " BatchNorm-26 (1, 16, 12, 12) 64\n", - " Activation-27 0\n", + " Activation-27 0\n", " Activation-28 (1, 8, 14, 14) 0\n", " Conv2D-29 (1, 8, 14, 14) 1160\n", " HybridLambda-30 (1, 8, 28, 28) 0\n", " BatchNorm-31 (1, 8, 28, 28) 32\n", - " Activation-32 0\n", + " Activation-32 0\n", " Activation-33 (1, 4, 28, 28) 0\n", " Conv2D-34 (1, 4, 28, 28) 292\n", - " Activation-35 0\n", + " Activation-35 0\n", " Activation-36 (1, 1, 28, 28) 0\n", " Conv2D-37 (1, 1, 28, 28) 37\n", "================================================================================\n", @@ -222,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -232,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -249,33 +256,33 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch [0], Loss 0.21099560077373797\n", - "Epoch [1], Loss 0.09341155973255125\n", - "Epoch [2], Loss 0.08531867133246528\n", - "Epoch [3], Loss 0.08130835671710153\n", - "Epoch [4], Loss 0.0778859130337707\n", - "Epoch [5], Loss 0.07601113238577116\n", - "Epoch [6], Loss 0.07359524262257111\n", - "Epoch [7], Loss 0.07236115545289129\n", - "Epoch [8], Loss 0.07116886693188268\n", - "Epoch [9], Loss 0.06978819105360243\n", - "Epoch [10], Loss 0.0686475382012836\n", - "Epoch [11], Loss 0.06776454713609484\n", - "Epoch [12], Loss 0.06720775212997045\n", - "Epoch [13], Loss 0.06643269204685831\n", - "Epoch [14], Loss 0.06566705051650348\n", - "Epoch [15], Loss 0.06555396823559777\n", - "Epoch [16], Loss 0.06497157740796733\n", - "Epoch [17], Loss 0.06442272561228174\n", - "Epoch [18], Loss 0.06406494694897252\n", - "Epoch [19], Loss 0.06352333737234785\n" + "Epoch [0], Loss 0.2246280246310764\n", + "Epoch [1], Loss 0.14493223337026742\n", + "Epoch [2], Loss 0.13147933666522688\n", + "Epoch [3], Loss 0.12138325943906084\n", + "Epoch [4], Loss 0.11291297684367906\n", + "Epoch [5], Loss 0.10611823453741559\n", + "Epoch [6], Loss 0.09942417470817892\n", + "Epoch [7], Loss 0.09408332955124032\n", + "Epoch [8], Loss 0.08883619716024807\n", + "Epoch [9], Loss 0.08491455795418502\n", + "Epoch [10], Loss 0.0809355994402352\n", + "Epoch [11], Loss 0.07784551636785524\n", + "Epoch [12], Loss 0.07570812029716296\n", + "Epoch [13], Loss 0.07417513366438384\n", + "Epoch [14], Loss 0.07218785571236895\n", + "Epoch [15], Loss 0.07093704352944584\n", + "Epoch [16], Loss 0.0700181406787318\n", + "Epoch [17], Loss 0.0689836893326197\n", + "Epoch [18], Loss 0.06782063459738708\n", + "Epoch [19], Loss 0.06713279088338216\n" ] } ], @@ -288,7 +295,9 @@ " with autograd.record():\n", " output = net(data)\n", " # Compute the L2 and L1 losses between the original and the generated image\n", - " l = l2_loss(output.flatten(), data.flatten()) + l1_loss(output.flatten(), data.flatten())\n", + " l2 = l2_loss(output.flatten(), data.flatten())\n", + " l1 = l1_loss(output.flatten(), data.flatten())\n", + " l = l2 + l1 \n", " l.backward()\n", " trainer.step(data.shape[0])\n", " \n", @@ -308,17 +317,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We plot 10 images and their reconstruction by the auto-encoder. The results are pretty good for a ~25x compression rate!" + "We plot 10 images and their reconstruction by the autoencoder. The results are pretty good for a ~25x compression rate!" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -354,36 +363,40 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "HybridSequential(\n", - " (0): Conv2D(1 -> 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", - " (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=4)\n", - " (2): Conv2D(4 -> 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", - " (3): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", - " (4): Conv2D(8 -> 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", - " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", - " (6): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(2, 2), Activation(relu))\n", - " (7): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", - " (8): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", - " (9): HybridLambda()\n", - " (10): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", - " (11): Conv2D(32 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", - " (12): HybridLambda()\n", - " (13): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", - " (14): Conv2D(16 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", - " (15): HybridLambda()\n", - " (16): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", - " (17): Conv2D(8 -> 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", - " (18): Conv2D(4 -> 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(sigmoid))\n", + " (0): HybridSequential(\n", + " (0): Conv2D(1 -> 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", + " (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=4)\n", + " (2): Conv2D(4 -> 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", + " (3): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", + " (4): Conv2D(8 -> 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", + " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", + " (6): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(2, 2), Activation(relu))\n", + " (7): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", + " )\n", + " (1): HybridSequential(\n", + " (0): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", + " (1): HybridLambda()\n", + " (2): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", + " (3): Conv2D(32 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", + " (4): HybridLambda()\n", + " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", + " (6): Conv2D(16 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", + " (7): HybridLambda()\n", + " (8): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", + " (9): Conv2D(8 -> 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", + " (10): Conv2D(4 -> 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(sigmoid))\n", + " )\n", ")" ] }, - "execution_count": 35, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -396,17 +409,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We split the Autoencoder into **encoder** and **decoder** subnetworks." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "encoder = net[:9]\n", - "decoder = net[9:]" + "We now split the autoencoder and use separately the **encoder** that takes an image to a latent vector and the **decoder** that transform a latent vector into images" ] }, { @@ -418,12 +421,12 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -434,16 +437,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 45, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -479,7 +482,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -487,18 +490,25 @@ "latent2 = encoder(data2)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the latent vector is made of 32 components" + ] + }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(1, 32, 3, 3)" + "(1, 32, 1, 1)" ] }, - "execution_count": 47, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -511,19 +521,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We interpolate the two latent representations, vectors of 32 values, to get a new intermediate latent representation, and plot the resulting decoded image" + "We interpolate the two latent representations, vectors of 32 values, to get a new intermediate latent representation, pass it through the decoder and plot the resulting decoded image" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -531,9 +541,8 @@ } ], "source": [ - "num = 25.\n", - "square = 5\n", - "plt.figure(figsize=(square*2, square*2))\n", + "num = 10\n", + "plt.figure(figsize=(20, 5))\n", "\n", "for i in range(int(num)):\n", " \n", @@ -541,7 +550,7 @@ " output = decoder(new_latent)\n", " \n", " #plot result\n", - " ax = plt.subplot(square, square, i%square+1+(i//square)*square)\n", + " ax = plt.subplot(1, num, i+1)\n", " ax.imshow((output[0].asnumpy() * 255.).transpose((1,2,0)).squeeze(), cmap='gray')\n", " _ = ax.axis('off')" ] @@ -550,7 +559,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can see taht the latent space learnt by the auto-encoder is fairly smooth, there is no sudden jump from one shape to another" + "We can see that the latent space learnt by the autoencoder is fairly smooth, there is no sudden jump from one shape to another" ] } ], From 8816eaa8a5505669279d3a7b2750ee4fb2afefea Mon Sep 17 00:00:00 2001 From: Thomas Delteil Date: Fri, 2 Nov 2018 09:56:20 -0700 Subject: [PATCH 07/10] Update README.md --- example/autoencoder/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 566e028b9d52..9d8b691ca547 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -6,6 +6,7 @@ Autoencoder architectures are often used for unsupervised feature learning. This ([Diagram source](https://towardsdatascience.com/autoencoders-introduction-and-implementation-3f40483b0a85)) + The idea of an autoencoder is to learn to use bottleneck architecture to encode the input and then try to decode it to reproduce the original. By doing so, the network learns to effectively compress the information of the input, the resulting embedding representation can then be used in several domains. For example as featurized representation for visual search, or in anomaly detection. ## Dataset From 2f57a1aa0232cd3a1dd2eb1b84fc070b07a80642 Mon Sep 17 00:00:00 2001 From: Thomas Delteil Date: Fri, 16 Nov 2018 10:26:40 -0800 Subject: [PATCH 08/10] Update README.md --- example/autoencoder/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/example/autoencoder/README.md b/example/autoencoder/README.md index 9d8b691ca547..960636cd7d59 100644 --- a/example/autoencoder/README.md +++ b/example/autoencoder/README.md @@ -2,6 +2,7 @@ Autoencoder architectures are often used for unsupervised feature learning. This [link](http://ufldl.stanford.edu/tutorial/unsupervised/Autoencoders/) contains an introduction tutorial to autoencoders. This example illustrates a simple autoencoder using a stack of convolutional layers for both the encoder and the decoder. + ![](https://cdn-images-1.medium.com/max/800/1*LSYNW5m3TN7xRX61BZhoZA.png) ([Diagram source](https://towardsdatascience.com/autoencoders-introduction-and-implementation-3f40483b0a85)) From 30b7b85bd56c29ad2fb0648a952389a416fcfd26 Mon Sep 17 00:00:00 2001 From: Kellen Sunderland Date: Sun, 25 Nov 2018 18:26:01 -0800 Subject: [PATCH 09/10] Retrigger build From 5798d258dcf96e453fb02b5c1991cc7807c8e779 Mon Sep 17 00:00:00 2001 From: tdelteil Date: Fri, 18 Jan 2019 21:47:57 +0000 Subject: [PATCH 10/10] Updates after review --- .../convolutional_autoencoder.ipynb | 52 ++----------------- 1 file changed, 4 insertions(+), 48 deletions(-) diff --git a/example/autoencoder/convolutional_autoencoder.ipynb b/example/autoencoder/convolutional_autoencoder.ipynb index 7278bc343037..c42ad900ec98 100644 --- a/example/autoencoder/convolutional_autoencoder.ipynb +++ b/example/autoencoder/convolutional_autoencoder.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -31,7 +31,7 @@ "\n", "import matplotlib.pyplot as plt\n", "import mxnet as mx\n", - "from mxnet import autograd, nd, gluon" + "from mxnet import autograd, gluon" ] }, { @@ -40,7 +40,7 @@ "source": [ "## Data\n", "\n", - "We will use the FashionMNIST dataset which is of a similar format than MNIST but is richer and has more variance" + "We will use the FashionMNIST dataset, which is of a similar format to MNIST but is richer and has more variance" ] }, { @@ -361,55 +361,11 @@ "## Manipulating latent space" ] }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "HybridSequential(\n", - " (0): HybridSequential(\n", - " (0): Conv2D(1 -> 4, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", - " (1): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=4)\n", - " (2): Conv2D(4 -> 8, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", - " (3): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", - " (4): Conv2D(8 -> 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), Activation(relu))\n", - " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", - " (6): Conv2D(16 -> 32, kernel_size=(3, 3), stride=(2, 2), Activation(relu))\n", - " (7): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", - " )\n", - " (1): HybridSequential(\n", - " (0): Conv2D(32 -> 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", - " (1): HybridLambda()\n", - " (2): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=32)\n", - " (3): Conv2D(32 -> 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", - " (4): HybridLambda()\n", - " (5): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=16)\n", - " (6): Conv2D(16 -> 8, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), Activation(relu))\n", - " (7): HybridLambda()\n", - " (8): BatchNorm(axis=1, eps=1e-05, momentum=0.9, fix_gamma=False, use_global_stats=False, in_channels=8)\n", - " (9): Conv2D(8 -> 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))\n", - " (10): Conv2D(4 -> 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(sigmoid))\n", - " )\n", - ")" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "net" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We now split the autoencoder and use separately the **encoder** that takes an image to a latent vector and the **decoder** that transform a latent vector into images" + "We now use separately the **encoder** that takes an image to a latent vector and the **decoder** that transform a latent vector into images" ] }, {