From c15993f82d8d567465a4ea157f5fcd7b807daf01 Mon Sep 17 00:00:00 2001 From: Al Rigazzi Date: Sun, 20 Mar 2022 18:08:35 -0500 Subject: [PATCH 1/5] Add surrogate notebook, remove old notebooks --- smartsim/ml/tf/__init__.py | 2 +- smartsim/ml/tf/utils.py | 30 + tutorials/ml_training/surrogate/LICENSE | 165 ++++ tutorials/ml_training/surrogate/README.md | 8 + tutorials/ml_training/surrogate/fd_sim.py | 130 +++ .../ml_training/surrogate/steady_state.py | 504 ++++++++++++ tutorials/ml_training/surrogate/tf_model.py | 133 ++++ .../ml_training/surrogate/tf_training.py | 92 +++ .../surrogate/train_surrogate.ipynb | 747 ++++++++++++++++++ tutorials/ml_training/surrogate/vishelpers.py | 32 + tutorials/ml_training/tf/data_uploader.py | 30 - tutorials/ml_training/tf/training_service.py | 16 - .../ml_training/tf/training_service_hvd.py | 39 - tutorials/ml_training/torch/data_uploader.py | 30 - .../ml_training/torch/training_service.py | 56 -- .../ml_training/torch/training_service_hvd.py | 75 -- tutorials/ml_training/train_tf.ipynb | 494 ------------ tutorials/ml_training/train_torch.ipynb | 575 -------------- 18 files changed, 1842 insertions(+), 1316 deletions(-) create mode 100644 tutorials/ml_training/surrogate/LICENSE create mode 100644 tutorials/ml_training/surrogate/README.md create mode 100644 tutorials/ml_training/surrogate/fd_sim.py create mode 100644 tutorials/ml_training/surrogate/steady_state.py create mode 100644 tutorials/ml_training/surrogate/tf_model.py create mode 100644 tutorials/ml_training/surrogate/tf_training.py create mode 100644 tutorials/ml_training/surrogate/train_surrogate.ipynb create mode 100644 tutorials/ml_training/surrogate/vishelpers.py delete mode 100644 tutorials/ml_training/tf/data_uploader.py delete mode 100644 tutorials/ml_training/tf/training_service.py delete mode 100644 tutorials/ml_training/tf/training_service_hvd.py delete mode 100644 tutorials/ml_training/torch/data_uploader.py delete mode 100644 tutorials/ml_training/torch/training_service.py delete mode 100644 tutorials/ml_training/torch/training_service_hvd.py delete mode 100644 tutorials/ml_training/train_tf.ipynb delete mode 100644 tutorials/ml_training/train_torch.ipynb diff --git a/smartsim/ml/tf/__init__.py b/smartsim/ml/tf/__init__.py index 1ed341a9d..73ab55787 100644 --- a/smartsim/ml/tf/__init__.py +++ b/smartsim/ml/tf/__init__.py @@ -24,4 +24,4 @@ from .data import DynamicDataGenerator, StaticDataGenerator -from .utils import freeze_model +from .utils import freeze_model, serialize_model diff --git a/smartsim/ml/tf/utils.py b/smartsim/ml/tf/utils.py index dd8cfbc0b..a43cc8b8d 100644 --- a/smartsim/ml/tf/utils.py +++ b/smartsim/ml/tf/utils.py @@ -50,3 +50,33 @@ def freeze_model(model, output_dir, file_name): ) model_file_path = str(Path(output_dir, file_name).resolve()) return model_file_path, input_names, output_names + + +def serialize_model(model): + """Serialize a Keras or TensorFlow Graph + + to use a Keras or TensorFlow model in SmartSim, the model + must be frozen and the inputs and outputs provided to the + smartredis.client.set_model() method. + + This utiliy function provides everything users need to take + a trained model and put it inside an ``orchestrator`` instance. + + :param model: TensorFlow or Keras model + :type model: tf.Module + """ + + full_model = tf.function(lambda x: model(x)) + full_model = full_model.get_concrete_function( + tf.TensorSpec(model.inputs[0].shape, model.inputs[0].dtype) + ) + + frozen_func = convert_variables_to_constants_v2(full_model) + frozen_func.graph.as_graph_def() + + input_names = [x.name.split(":")[0] for x in frozen_func.inputs] + output_names = [x.name.split(":")[0] for x in frozen_func.outputs] + + model_serialized = frozen_func.graph.as_graph_def().SerializeToString(deterministic=True) + + return model_serialized, input_names, output_names \ No newline at end of file diff --git a/tutorials/ml_training/surrogate/LICENSE b/tutorials/ml_training/surrogate/LICENSE new file mode 100644 index 000000000..0a041280b --- /dev/null +++ b/tutorials/ml_training/surrogate/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/tutorials/ml_training/surrogate/README.md b/tutorials/ml_training/surrogate/README.md new file mode 100644 index 000000000..823d27500 --- /dev/null +++ b/tutorials/ml_training/surrogate/README.md @@ -0,0 +1,8 @@ + +# Training a surrogate model + +In this example, a neural network is trained to act like a surrogate model and to solve a +well-known physical problem, i.e. computing the steady state of heat diffusion. The training +dataset is constructed by running simualations *while* the model is being trained. + +The notebook also displays how the surrogate model prediction improves during training. \ No newline at end of file diff --git a/tutorials/ml_training/surrogate/fd_sim.py b/tutorials/ml_training/surrogate/fd_sim.py new file mode 100644 index 000000000..8b128a319 --- /dev/null +++ b/tutorials/ml_training/surrogate/fd_sim.py @@ -0,0 +1,130 @@ +import numpy as np +from smartredis import Client, Dataset +from smartsim.ml import TrainingDataUploader + +import numpy as np +from tqdm import tqdm + +from steady_state import fd2d_heat_steady_test01 + +def augment_batch(samples, targets): + """Augment samples and targets + + by exploiting rotational and axial symmetry. Each sample is + rotated and reflected to obtain 8 valid samples. The same + transformations are applied to targets. + + Samples and targets must be 4-dimensional batches, + following NWHC ordering. + + :param samples: Samples to augment + :type samples: np.ndarray + :param targets: Targets to augment + :type targets: np.ndarray + + :returns: Tuple of augmented samples and targets + :rtype: (np.ndarray, np.ndarray) + """ + batch_size = samples.shape[0] + augmented_samples = np.empty((batch_size*8, *samples.shape[1:])) + augmented_targets = np.empty_like(augmented_samples) + + aug = 0 + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 1 + samples = np.rot90(samples, k=1, axes=[1,2]) + targets = np.rot90(targets, k=1, axes=[1,2]) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 2 + samples = np.rot90(samples, k=1, axes=[1,2]) + targets = np.rot90(targets, k=1, axes=[1,2]) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 3 + samples = np.rot90(samples, k=1, axes=[1,2]) + targets = np.rot90(targets, k=1, axes=[1,2]) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 4 + samples = np.flip(samples, 1) + targets = np.flip(targets, 1) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 5 + samples = np.rot90(samples, k=1, axes=[1,2]) + targets = np.rot90(targets, k=1, axes=[1,2]) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 6 + samples = np.rot90(samples, k=1, axes=[1,2]) + targets = np.rot90(targets, k=1, axes=[1,2]) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + aug = 7 + samples = np.rot90(samples, k=1, axes=[1,2]) + targets = np.rot90(targets, k=1, axes=[1,2]) + augmented_samples[batch_size*aug:batch_size*(1+aug), :, :, :] = samples + augmented_targets[batch_size*aug:batch_size*(1+aug), :, :, :] = targets + + return augmented_samples, augmented_targets + +def simulate(steps, size): + """Run multiple simulations and upload results + + both as tensors and as augmented samples for training. + + :param steps: Number of simulations to run + :type steps: int + :param size: lateral size of the discretized domain + :type size: int + """ + batch_size = 50 + samples = np.zeros((batch_size,size,size,1)).astype(np.single) + targets = np.zeros_like(samples).astype(np.single) + client = Client(None, False) + + training_data_uploader = TrainingDataUploader(cluster=False, verbose=True) + training_data_uploader.publish_info() + + for i in tqdm(range(steps)): + + u_init, u_steady = fd2d_heat_steady_test01(samples.shape[1], samples.shape[2]) + u_init = u_init.astype(np.single) + u_steady = u_steady.astype(np.single) + dataset = create_dataset(i, u_init, u_steady) + client.put_dataset(dataset) + + samples[i%batch_size, :, :, 0] = u_init + targets[i%batch_size, :, :, 0] = u_steady + + if (i+1)%batch_size == 0: + augmented_samples, augmented_targets = augment_batch(samples, targets) + training_data_uploader.put_batch(augmented_samples, augmented_targets) + + +def create_dataset(idx, u_init, u_steady): + """Create SmartRedis Dataset containing multiple NumPy arrays + to be stored at a single key within the database""" + dataset = Dataset(f"sim_data_{idx}") + dataset.add_tensor("u_steady", np.expand_dims(u_steady, axis=[0,-1])) + dataset.add_tensor("u_init", np.expand_dims(u_init, axis=[0,-1])) + return dataset + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description="Finite Difference Simulation") + parser.add_argument('--steps', type=int, default=4000, + help='Number of simulations to run') + parser.add_argument('--size', type=int, default=100, + help='Size of sample side, each sample will be a (size, size, 1) image') + args = parser.parse_args() + simulate(args.steps, size=args.size) \ No newline at end of file diff --git a/tutorials/ml_training/surrogate/steady_state.py b/tutorials/ml_training/surrogate/steady_state.py new file mode 100644 index 000000000..21e7fbf04 --- /dev/null +++ b/tutorials/ml_training/surrogate/steady_state.py @@ -0,0 +1,504 @@ +#! /usr/bin/env python3 +# +def boundary ( nx, ny, x, y, A, rhs ): + +#*****************************************************************************80 +# +## boundary() sets up the matrix and right hand side at boundary nodes. +# +# Discussion: +# +# For this simple problem, the boundary conditions specify that the solution +# is 0 on the left side, 0 on the right side, and 0 on the top and bottom. +# +# Nodes are assigned a single index K, which increases as: +# +# (NY-1)*NX+1 (NY-1)*NX+2 ... NY * NX +# .... .... ... ..... +# NX+1 NX+2 ... 2 * NX +# 1 2 ... NX +# +# The index K of a node on the lower boundary satisfies: +# 1 <= K <= NX +# The index K of a node on the upper boundary satisfies: +# (NY-1)*NX+1 <= K <= NY * NX +# The index K of a node on the left boundary satisfies: +# mod ( K, NX ) = 1 +# The index K of a node on the right boundary satisfies: +# mod ( K, NX ) = 0 +# +# If we number rows from bottom I = 1 to top I = NY +# and columns from left J = 1 to right J = NX, then the relationship +# between the single index K and the row and column indices I and J is: +# K = ( I - 1 ) * NX + J +# and +# J = 1 + mod ( K - 1, NX ) +# I = 1 + ( K - J ) / NX +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 12 March 2017 +# +# Author: +# +# John Burkardt +# +# Input: +# +# integer NX, NY, the number of grid points in X and Y. +# +# real X(NX), Y(NY), the coordinates of grid lines. +# +# real sparse A(N,N), the system matrix, with the entries for the +# interior nodes filled in. +# +# real RHS(N), the system right hand side, with the entries for the +# interior nodes filled in. +# +# Output: +# +# real sparse A(N,N), the system matrix, with the entries for all +# nodes filled in. +# +# real RHS(N), the system right hand side, with the entries for +# all nodes filled in. +# + +# +# Left boundary. +# + j = 0 + for i in range ( 0, ny ): + kc = i * nx + j + xc = x[j] + yc = y[i] + A[kc,kc] = 1.0 + rhs[kc] = 0.0 +# +# Right boundary. +# + j = nx - 1 + for i in range ( 0, ny ): + kc = i * nx + j + xc = x[j] + yc = y[i] + A[kc,kc] = 1.0 + rhs[kc] = 0.0 +# +# Lower boundary. +# + i = 0 + for j in range ( 0, nx ): + kc = i * nx + j + xc = x[j] + yc = y[i] + A[kc,kc] = 1.0 + rhs[kc] = 0.0 +# +# Upper boundary. +# + i = ny - 1 + for j in range ( 0, nx ): + kc = i * nx + j + xc = x[j] + yc = y[i] + A[kc,kc] = 1.0 + rhs[kc] = 0.0 + + return A, rhs + +def fd2d_heat_steady ( nx, ny, x, y, d, f, source_centers): + +#*****************************************************************************80 +# +## fd2d_heat_steady() solves the steady 2D heat equation. +# +# Discussion: +# +# Nodes are assigned a singled index K, which increases as: +# +# (NY-1)*NX+1 (NY-1)*NX+2 ... NY * NX +# .... .... ... ..... +# NX+1 NX+2 ... 2 * NX +# 1 2 ... NX +# +# Therefore, the neighbors of an interior node numbered C are +# +# C+NY +# | +# C-1 --- C --- C+1 +# | +# C-NY +# +# Nodes on the lower boundary satisfy: +# 1 <= K <= NX +# Nodes on the upper boundary satisfy: +# (NY-1)*NX+1 <= K <= NY * NX +# Nodes on the left boundary satisfy: +# mod ( K, NX ) = 1 +# Nodes on the right boundary satisfy: +# mod ( K, NX ) = 0 +# +# If we number rows from bottom I = 1 to top I = NY +# and columns from left J = 1 to right J = NX, we have +# K = ( I - 1 ) * NX + J +# and +# J = 1 + mod ( K - 1, NX ) +# I = 1 + ( K - J ) / NX +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 12 March 2017 +# +# Author: +# +# John Burkardt +# +# Input: +# +# integer NX, NY, the number of grid points in X and Y. +# +# real X(NX), Y(NY), the coordinates of grid lines. +# +# function D(X,Y), evaluates the thermal conductivity. +# +# function F(X,Y), evaluates the heat source term. +# +# Output: +# +# real U(NX,NY), the approximation to the solution at the grid points. +# + import numpy as np +# +# Set the total number of unknowns. +# + n = nx * ny +# +# Allocate the matrix and right hand side. +# + A = np.zeros ( [ n, n ] ).astype(np.single) + rhs = np.zeros ( n ).astype(np.single) +# +# Define the matrix at interior points. +# + A, rhs = interior ( nx, ny, x, y, d, f, A, rhs, source_centers ) +# +# Handle boundary conditions. +# + A, rhs = boundary ( nx, ny, x, y, A, rhs ) + + + u = np.linalg.solve ( A, rhs ) + + u.shape = ( ny, nx ) + + return u + +def fd2d_heat_steady_test ( ): + +#*****************************************************************************80 +# +## fd2d_heat_steady_test() tests fd2d_heat_steady(). +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 27 August 2013 +# +# Author: +# +# John Burkardt +# + print ( '' ) + print ( 'fd2d_heat_steady_test:' ) + print ( ' Python version' ) + print ( ' Test fd2d_heat_steady().' ) + + fd2d_heat_steady_test01 ( ) +# +# Terminate. +# + print ( '' ) + print ( 'fd2d_heat_steady_test:' ) + print ( ' Normal end of execution.' ) + return + +def fd2d_heat_steady_test01 (nx, ny ): + +#*****************************************************************************80 +# +## fd2d_heat_steady_test01() demonstrates the use of fd2d_heat_steady. +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 12 March 2017 +# +# Author: +# +# John Burkardt +# + import numpy as np + from mpl_toolkits.mplot3d import Axes3D + import matplotlib.pyplot as plt + from matplotlib import cm +# +# Specify the spatial grid. +# + # nx = 64 + # ny = 64 + xvec = np.linspace ( 0.0, 1.0, nx ) + yvec = np.linspace ( 0.0, 1.0, ny ) + + source_centers = 0.2+np.random.rand(np.random.randint(1,6),2)*0.6 + + Xgrid, Ygrid = np.meshgrid(xvec, yvec) + u_init = np.zeros_like(Xgrid).astype(np.bool) + for center in source_centers: + u_init |= (Xgrid-center[0])**2 + (Ygrid-center[1])**2 < 0.05**2 + + u_init = u_init.astype(np.single) +# +# Solve the finite difference approximation to the steady 2D heat equation. +# + umat = fd2d_heat_steady ( nx, ny, xvec, yvec, d, f, source_centers) +# +# Plotting. +# + PLOT = False + if PLOT: + xmat, ymat = np.meshgrid ( xvec, yvec ) + + fig = plt.figure() + ax = fig.add_subplot ( 111, projection = '3d' ) + ax.plot_surface ( xmat, ymat, umat, cmap = cm.coolwarm, + linewidth = 0, antialiased = False ) + ax.set_xlabel ( '<--- Y --->' ) + ax.set_ylabel ( '<--- X --->' ) + ax.set_zlabel ( '<---U(X,Y)--->' ) + ax.set_title ( 'Solution of steady heat equation' ) + plt.draw ( ) + filename = 'fd2d_heat_steady_test01.png' + fig.savefig ( filename ) + plt.show ( block = False ) + plt.close ( ) + + print ( '' ) + print ( ' Plotfile saved as "%s".' % ( filename ) ) + + return u_init, umat + +def d ( x, y ): + +#*****************************************************************************80 +# +## d() evaluates the heat conductivity coefficient. +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 23 July 2013 +# +# Author: +# +# John Burkardt +# +# Input: +# +# real X, Y, the evaluation point. +# +# Output: +# +# real VALUE, the value of the heat conductivity at (X,Y). +# + value = 1.0 + + return value + +def f ( x, y , centers): + +#*****************************************************************************80 +# +## f() evaluates the heat source term. This function was modified to +# include circles of radiust 0.05, where the temperature is 1 +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 23 July 2013 +# +# Author: +# +# John Burkardt +# +# Input: +# +# real X, Y, the evaluation point. +# real centers, the centers of the heat sources +# +# Output: +# +# real VALUE, the value of the heat source term at (X,Y). +# + source = False + for center in centers: + source |= ((x-center[0])**2 + (y-center[1])**2 < 0.05**2) + return float(source) + +def interior ( nx, ny, x, y, d, f, A, rhs, source_centers ): + +#*****************************************************************************80 +# +## interior() sets up the matrix and right hand side at interior nodes. +# +# Discussion: +# +# Nodes are assigned a single index K, which increases as: +# +# (NY-1)*NX+1 (NY-1)*NX+2 ... NY * NX +# .... .... ... ..... +# NX+1 NX+2 ... 2 * NX +# 1 2 ... NX +# +# Therefore, the neighbors of an interior node numbered C are +# +# C+NY +# | +# C-1 --- C --- C+1 +# | +# C-NY +# +# If we number rows from bottom I = 1 to top I = NY +# and columns from left J = 1 to right J = NX, then the relationship +# between the single index K and the row and column indices I and J is: +# K = ( I - 1 ) * NX + J +# and +# J = 1 + mod ( K - 1, NX ) +# I = 1 + ( K - J ) / NX +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 12 March 2017 +# +# Author: +# +# John Burkardt +# +# Input: +# +# integer NX, NY, the number of grid points in X and Y. +# +# real X(NX), Y(NY), the coordinates of grid lines. +# +# function pointer @D(X,Y), evaluates the thermal conductivity. +# +# function pointer @F(X,Y), evaluates the heat source term. +# +# real sparse A(N,N), the system matrix, without any entries set. +# +# real RHS(N), the system right hand side, without any entries set. +# +# Output: +# +# real sparse A(N,N), the system matrix, with the entries for the +# interior nodes filled in. +# +# real RHS(N), the system right hand side, with the entries for the +# interior nodes filled in. +# + import numpy as np +# +# For now, assume X and Y are equally spaced. +# + dx = x[1] - x[0] + dy = y[1] - y[0] + + for ic in range ( 1, ny - 1 ): + for jc in range ( 1, nx - 1 ): + + ino = ic + 1 + iso = ic - 1 + je = jc + 1 + jw = jc - 1 + + kc = ic * nx + jc + ke = kc + 1 + kw = kc - 1 + kn = kc + nx + ks = kc - nx + + dce = d ( 0.5 * ( x[jc] + x[je] ), y[ic] ) + dcw = d ( 0.5 * ( x[jc] + x[jw] ), y[ic] ) + dcn = d ( x[jc], 0.5 * ( y[ic] + y[ino] ) ) + dcs = d ( x[jc], 0.5 * ( y[ic] + y[iso] ) ) + + + rhs[kc] = f ( x[jc], y[ic], source_centers ) + + if rhs[kc] != 0.0: + A[kc,kc] = 1.0 + else: + A[kc,kc] = ( dce + dcw ) / dx / dx + ( dcn + dcs ) / dy / dy + A[kc,ke] = - dce / dx / dx + A[kc,kw] = - dcw / dx / dx + A[kc,kn] = - dcn / dy / dy + A[kc,ks] = - dcs / dy / dy + + + + return A, rhs + +def timestamp ( ): + +#*****************************************************************************80 +# +## timestamp() prints the date as a timestamp. +# +# Licensing: +# +# This code is distributed under the GNU LGPL license. +# +# Modified: +# +# 06 April 2013 +# +# Author: +# +# John Burkardt +# + import time + + t = time.time ( ) + print ( time.ctime ( t ) ) + + return None + +if ( __name__ == '__main__' ): + timestamp ( ) + fd2d_heat_steady_test01 (100, 100 ) + timestamp ( ) + diff --git a/tutorials/ml_training/surrogate/tf_model.py b/tutorials/ml_training/surrogate/tf_model.py new file mode 100644 index 000000000..1c538796e --- /dev/null +++ b/tutorials/ml_training/surrogate/tf_model.py @@ -0,0 +1,133 @@ + +# take code for VAE from Keras https://keras.io/examples/generative/vae/ +from tensorflow import keras + +from tensorflow.keras.layers import Conv2D, Conv2DTranspose, BatchNormalization, \ + Add, SpatialDropout2D, Layer, InputLayer +from tensorflow.keras.models import Model + +import tensorflow as tf + +activation = "selu" +padding = "same" + + +# Next function initially taken from +# https://towardsdatascience.com/building-a-resnet-in-keras-e8f1322a49ba +class ResBlock(Layer): + def __init__(self, downsample: bool, filters: int, kernel_size: int = 3): + super(ResBlock, self).__init__() + self.conv1 = Conv2D(kernel_size=kernel_size, + strides= (1 if not downsample else 2), + filters=filters, + padding=padding, + activation=activation) + self.bn1 = BatchNormalization() + self.conv2 = Conv2D(kernel_size=kernel_size, + strides=1, + filters=filters, + padding=padding) + + if downsample: + self.conv3 = Conv2D(kernel_size=1, + strides=2, + filters=filters, + padding=padding) + else: + self.conv3 = Conv2D(kernel_size=1, + strides=1, + filters=filters, + padding=padding) + + + self.bn2 = BatchNormalization() + + def call(self, inputs): + x = self.conv1(inputs) + x = self.bn1(x) + x = self.conv2(x) + y = self.conv3(inputs) + z = Add()([x, y]) + z = keras.activations.selu(z) + z = self.bn2(z) + return z + +# Next function initially taken from +# https://towardsdatascience.com/building-a-resnet-in-keras-e8f1322a49ba +class ResBlockTranspose(Layer): + def __init__(self, downsample: bool, filters: int, kernel_size: int = 3): + super(ResBlockTranspose, self).__init__() + self.conv1 = Conv2DTranspose(kernel_size=kernel_size, + strides=(1 if not downsample else 2), + filters=filters, + padding=padding, + activation=activation) + self.bn1 = BatchNormalization() + self.conv2 = Conv2DTranspose(kernel_size=kernel_size, + strides=1, + filters=filters, + padding=padding) + + if downsample: + self.conv3 = Conv2DTranspose(kernel_size=1, + strides=2, + filters=filters, + padding=padding) + else: + self.conv3 = Conv2DTranspose(kernel_size=1, + strides=1, + filters=filters, + padding=padding) + + + self.bn2 = BatchNormalization() + + def call(self, inputs): + x = self.conv1(inputs) + x = self.bn1(x) + x = self.conv2(x) + y = self.conv3(inputs) + z = Add()([x, y]) + z = keras.activations.selu(z) + z = self.bn2(z) + return z + +class DiffusionResNet(Model): + def __init__(self, sample_shape, depth=4, downsample=True): + super().__init__(name = f"DiffusionResNet_{depth}") + filters = sample_shape[-1] + self.skips = [Conv2D(filters, 3, (1,1), padding="same", activation=activation)] + self.res_blocks = [] + self.dropout1 = SpatialDropout2D(0.4) + for i in range(depth): + filters *= 2 + self.res_blocks.append(ResBlock(downsample, filters, 3)) + if i < depth-1: + self.skips.append(Conv2D(filters, 3, (1,1), padding="same", activation=activation)) + else: + self.skips.append(None) + self.res_blocks_tr = [] + for _ in range(depth): + filters /= 2 + self.res_blocks_tr.append(ResBlockTranspose(downsample, filters, 3)) + self.dropout2 = SpatialDropout2D(0.4) + self.bn = BatchNormalization() + + def call(self, inputs): + x = self.res_blocks[0](inputs) + res_outs = [self.dropout1(x)] + for i in range(1,len(self.res_blocks)): + res_outs.append(self.res_blocks[i](res_outs[-1])) + x = self.res_blocks_tr[0](res_outs[-1]) + for i in range(1,len(self.res_blocks_tr)): + y = self.skips[-i-1](res_outs[-i-1]) + x = Add()([x, y]) + x = keras.activations.selu(x) + x = self.res_blocks_tr[i](x) + x = Add()([self.skips[0](inputs),x]) + x = keras.activations.selu(x) + x = self.dropout2(x) + x = self.bn(x) + return x + + diff --git a/tutorials/ml_training/surrogate/tf_training.py b/tutorials/ml_training/surrogate/tf_training.py new file mode 100644 index 000000000..fd2c16d83 --- /dev/null +++ b/tutorials/ml_training/surrogate/tf_training.py @@ -0,0 +1,92 @@ +from smartsim.ml.tf import DynamicDataGenerator, serialize_model +from smartredis import Client, Dataset + +from tensorflow import keras +from tensorflow.keras.layers import Input +from tf_model import DiffusionResNet + +import time +import numpy as np + + +def create_dataset(idx, F): + """Create SmartRedis Dataset containing multiple NumPy arrays + to be stored at a single key within the database""" + + dataset = Dataset(f"ml_data_{idx}") + dataset.add_tensor("steady", F) + return dataset + + +def store_model(model, idx): + serialized_model, inputs, outputs = serialize_model(model) + client = Client(None, False) + client.set_model(f"{model.name}_{idx}", serialized_model, "TF", "CPU", inputs=inputs, outputs=outputs) + +def train_model(model, epochs): + training_generator = DynamicDataGenerator(cluster=False, batch_size=50, shuffle=True) + print("Compiling NN") + + initial_learning_rate = 0.01 + lr_schedule = keras.optimizers.schedules.ExponentialDecay( + initial_learning_rate, + decay_steps=80, + decay_rate=0.9, + staircase=True) + + optimizer = keras.optimizers.Adam(learning_rate=lr_schedule, + beta_1=0.9, + beta_2=0.999, + epsilon=1e-07) + + model.compile(optimizer=optimizer, loss="mean_absolute_error") + + for epoch in range(epochs): + print(f"Epoch {epoch+1}") + model.fit(training_generator, steps_per_epoch=None, + epochs=epoch+1, initial_epoch=epoch, batch_size=training_generator.batch_size, + verbose=2) + if (epoch+1)%10 == 0: + store_model(model, epoch//10) + + print("Finished training", flush=True) + + +def upload_inference_examples(model, num_examples): + client = Client(None, False) + client.set_data_source("fd_simulation") + + for i in range(num_examples): + ds = client.get_dataset(f"sim_data_{i}") + u_init = np.expand_dims(ds.get_tensor("u_init"), [0, -1]) + frame = model(u_init, training=False).numpy().squeeze() + ds = create_dataset(i, frame) + client.put_dataset(ds) + + print("Finished upload") + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description="Finite Difference Simulation") + parser.add_argument('--depth', type=int, default=4, + help="Half depth of residual network") + parser.add_argument('--epochs', type=int, default=100, + help="Number of epochs to train the NN for") + parser.add_argument('--delay', type=int, default=0, + help="Seconds to wait before training") + parser.add_argument('--size', type=int, default=100, + help='Size of sample side, each sample will be a (size, size, 1) image') + + args = parser.parse_args() + input_shape = (args.size,args.size,1) + diff_resnet = DiffusionResNet(input_shape, depth=args.depth) + diff_resnet.build(input_shape=(None,*input_shape)) + diff_resnet.summary() + inputs = Input(input_shape) + outputs = diff_resnet(inputs) + vae = keras.Model(inputs=inputs, outputs=outputs, name=diff_resnet.name) + + time.sleep(args.delay) + train_model(vae, args.epochs) + + args = parser.parse_args() \ No newline at end of file diff --git a/tutorials/ml_training/surrogate/train_surrogate.ipynb b/tutorials/ml_training/surrogate/train_surrogate.ipynb new file mode 100644 index 000000000..8d895cd5f --- /dev/null +++ b/tutorials/ml_training/surrogate/train_surrogate.ipynb @@ -0,0 +1,747 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4061d9f5-cdfc-4396-bc7d-eaecb9472558", + "metadata": {}, + "source": [ + "# Training a surrogate model on the fly\n", + "\n", + "Simulating a complex phenomenon can be computationally intensive and expensive. In some cases\n", + "the computational model is too expensive or too slow to be used in production, for example when\n", + "results are needed in real time. In other cases, a correct computational model, capable of\n", + "predicting the behavior of a complex system, might not even exist, see e.g. [this article](https://arxiv.org/abs/2104.09355).\n", + "*Surrogate models*, or simply *surrogates*, can compute the outcome of a given experiment\n", + "up to a reasonable degree of approximation, while requiring little computational power or time.\n", + "\n", + "In this notebook, a neural network is trained to act like a surrogate model and to solve a\n", + "well-known physical problem, i.e. computing the steady state of heat diffusion. The training\n", + "dataset is constructed by running simualations *while* the model is being trained.\n", + "\n", + "## 2D heat diffusion and steady state\n", + "Throughout this notebook, the heat equation will be solved on the two-dimensional domain $[0,1]\\times[0,1]$,\n", + "setting the initial temperature to 0 K, except\n", + "for some specific spots (of radius $0.05$), where heat sources at a constant temperature of 1 K are placed. Since\n", + "all boundaries are kept at 0 K, after enough time, the domain will reach a steady state, which is the outcome\n", + "the surrogate model will learn to compute.\n", + "\n", + "The problem can be solved using a finite difference scheme. To this end, a modified version of the code\n", + "written by John Burkardt will be used. Its original version is licensed under LGPL, and so is this example.\n", + "The code was downloaded from [this page](https://people.sc.fsu.edu/~jburkardt/py_src/fd2d_heat_steady/fd2d_heat_steady.html),\n", + "which explains how the problem is discretized and solved.\n", + "\n", + "In the modified version of the code which will be used, a random number (between 1 and 5) of heat sources is placed.\n", + "Here below, the solver is run with different initial conditions and the results are displayed.\n", + "To keep the solution time reasonably short, the domain is discretized with a 64x64-point grid." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6a49acfb-2585-4423-9de9-3b26bd679a90", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from steady_state import fd2d_heat_steady_test01\n", + "from vishelpers import pcolor_list\n", + "import time\n", + "from numpy.random import default_rng\n", + "\n", + "\n", + "size = 64\n", + "\n", + "for _ in range(3):\n", + " u_s = fd2d_heat_steady_test01 (size, size)\n", + " pcolor_list(u_s, \"Left: initial temperature. Right: steady state.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "4a7b9944-b87c-4e48-9a62-52df744fa83b", + "metadata": {}, + "source": [ + "# The surrogate model\n", + "\n", + "The surrogate model will be a Convolutional Neural Network. The \n", + "training set will be constructed on the fly, by running\n", + "multiple simulations.\n", + "\n", + "## Model topology\n", + "\n", + "The initial design for the CNN used in this notebook was inspired by the NN2 model\n", + "defined in [this paper](https://arxiv.org/abs/2102.05527). \n", + "Half of the NN computes an encoding of the initial image: each\n", + "convolutional layer downsamples the image by a factor 4, and doubles the\n", + "number of channels (the input has one single channel). The second\n", + "half of the NN reverses the operations, by upscaling the image\n", + "by a factor 4 at each layer and halving the number of channels.\n", + "In this variation of the model, residual blocks are used instead\n", + "of convolutional layers, and skip connection between\n", + "layers which are \"symmetric\" with respect to the center of the NN are added\n", + "(the output of the 1st layer is added to the input of the $n-1$-th layer, the \n", + "ouput of the 2nd layer is added to the input of the $n-2$-th layer, and so on).\n", + "\n", + "The model is defined in the file `tf_model.py`, and its depth is parametrized:\n", + "for a $64 \\times 64$ domain, the maximum depth is $6$, but with a depth of $3$ or $4$\n", + "the results are already noteworthy (and require less resources).\n", + "\n", + "## Integrating SmartRedis and SmartSim in the simulation\n", + "\n", + "As in the Lattice Boltzmann tutorial, SmartRedis to stage tensors.\n", + "For each simulation, both the initial conditions and the steady state solution are put\n", + "on the DB. Since the data will be used to train a Neural Network, \n", + "an object of the type `TrainingDataUploader` is used in the code: it puts the data\n", + "on the DB in batches which will be consumed by the training process.\n", + "The function `simulate` contained in `fd_sim.py`\n", + "is the core of the computation. Notice that samples are augmented\n", + "before being uploaded as batches: for each simulation,\n", + "eight rotated and reflected version of the original samples are \n", + "uploaded.\n", + "\n", + "```python\n", + "def simulate(steps, size):\n", + " \"\"\"Run multiple simulations and upload results\n", + " \n", + " both as tensors and as augmented samples for training.\n", + "\n", + " :param steps: Number of simulations to run\n", + " :type steps: int\n", + " :param size: lateral size of the discretized domain\n", + " :type size: int\n", + " \"\"\"\n", + " batch_size = 50\n", + " samples = np.zeros((batch_size,size,size,1)).astype(np.single)\n", + " targets = np.zeros_like(samples).astype(np.single)\n", + " client = Client(None, False)\n", + "\n", + " training_data_uploader = TrainingDataUploader(cluster=False, verbose=True)\n", + " training_data_uploader.publish_info()\n", + "\n", + " for i in tqdm(range(steps)):\n", + " \n", + " u_init, u_steady = fd2d_heat_steady_test01(samples.shape[1], samples.shape[2])\n", + " u_init = u_init.astype(np.single)\n", + " u_steady = u_steady.astype(np.single)\n", + " dataset = create_dataset(i, u_init, u_steady)\n", + " client.put_dataset(dataset)\n", + "\n", + " samples[i%batch_size, :, :, 0] = u_init\n", + " targets[i%batch_size, :, :, 0] = u_steady\n", + "\n", + " if (i+1)%batch_size == 0:\n", + " augmented_samples, augmented_targets = augment_batch(samples, targets)\n", + " training_data_uploader.put_batch(augmented_samples, augmented_targets)\n", + "\n", + "```\n", + "\n", + "\n", + "## Starting the Experiment\n", + "\n", + "SmartSim, the infrastructure library, is used here to launch the\n", + "database, the simulation, and the NN training locally, but in separate processes.\n", + "The example is designed to run on laptops, so the local launcher is used.\n", + "\n", + "First the necessary libraries are imported and an `Experiment` instance is created.\n", + "An `Orchestrator` database reference is initialized and launched \n", + "to stage data between the simulation, the NN training, and this notebook where results\n", + "will be analyzed." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "253f9c3e-95c9-49ad-b2d4-4fa409aeb36f", + "metadata": {}, + "outputs": [], + "source": [ + "from smartredis import Client\n", + "from smartsim import Experiment\n", + "# Initialize an Experiment with the local launcher\n", + "# This will be the name of the output directory that holds\n", + "# the output from our simulation and SmartSim\n", + "exp = Experiment(\"surrogate_training\", launcher=\"local\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "38c45f55-e7a4-4141-a445-85a6158eb12b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Database started at address: ['127.0.0.1:6780']\n" + ] + } + ], + "source": [ + "# create an Orchestrator database reference, \n", + "# generate its output directory, and launch it locally\n", + "db = exp.create_database(port=6780, interface=\"lo\")\n", + "exp.generate(db, overwrite=True)\n", + "exp.start(db)\n", + "print(f\"Database started at address: {db.get_address()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9bd9ef13-ae00-4888-b81b-d059736a1c25", + "metadata": {}, + "source": [ + "## Running an ensemble of simulations\n", + "\n", + "To run the simulation, `Experiment.create_run_settings` is used to define how the\n", + "simulation should be executed. To obtain a larger number of samples, we run\n", + "an ensemble of simulations, i.e. multiple replicas of the simulation,\n", + "each one producing different samples. To set up the ensemble, the settings \n", + "are then passed to create a reference to the ensemble through a call\n", + "to `Experiment.create_ensemble()` which\n", + "can be used to start, monitor, and stop the simulations from this notebook. \n", + "Notice the call to `enable_key_prefixing()`: that will make sure\n", + "each simulation adds a prefix to the keys it uploads, to avoid\n", + "key clashes with other ensemble members." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "537a1489-b4c3-4736-a628-b7af433a9cbf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17:55:20 prod-0001 SmartSim[61617] INFO Working in previously created experiment\n" + ] + } + ], + "source": [ + "# set simulation parameters we can pass as executable arguments\n", + "# Number of simulations to run in each replica\n", + "steps = 100\n", + "\n", + "# create \"run settings\" for the simulation which define how\n", + "# the simulation will be executed when passed to Experiment.start()\n", + "settings = exp.create_run_settings(\"python\",\n", + " exe_args=[\"fd_sim.py\",\n", + " f\"--steps={steps}\",\n", + " f\"--size={size}\"],\n", + " env_vars={\"OMP_NUM_THREADS\": \"8\"})\n", + "\n", + "# Create the ensemble reference to our simulation and\n", + "# attach needed files to be copied, configured, or symlinked into\n", + "# the ensemble directories at runtime. \n", + "ensemble = exp.create_ensemble(\"fd_simulation\", run_settings=settings, replicas=2)\n", + "ensemble.attach_generator_files(to_copy=[\"fd_sim.py\", \"steady_state.py\"])\n", + "ensemble.enable_key_prefixing()\n", + "exp.generate(ensemble, overwrite=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6008d8ae-d56f-4888-a7da-f9adcd45632d", + "metadata": {}, + "source": [ + "## Using SmartSim to train the neural network\n", + "\n", + "The last component of the workflow is the model training.\n", + "For this notebook, the neural network will be trained\n", + "using TensorFlow and Keras, but PyTorch is supported too,\n", + "and a corresponding notebook will soon be available.\n", + "\n", + "In the code, an object of the type `smartsim.ml.tf.DynamicDataGenerator`\n", + "is passed to Keras's `Model.fit()` function. The data generator\n", + "will download batches from the database before the training starts\n", + "and then, after each epoch, it will poll the database to\n", + "check whether new batches are available for download.\n", + "\n", + "The core of the training code is in `tf_training.py`:\n", + "\n", + "```python\n", + "def train_model(model, epochs):\n", + " training_generator = DynamicDataGenerator(cluster=False, verbose=True, batch_size=25, shuffle=True)\n", + " print(\"Compiling NN\")\n", + "\n", + " initial_learning_rate = 0.01\n", + " lr_schedule = keras.optimizers.schedules.ExponentialDecay(\n", + " initial_learning_rate,\n", + " decay_steps=80,\n", + " decay_rate=0.9,\n", + " staircase=True)\n", + "\n", + " optimizer = keras.optimizers.Adam(learning_rate=lr_schedule,\n", + " beta_1=0.9,\n", + " beta_2=0.999,\n", + " epsilon=1e-07)\n", + "\n", + " model.compile(optimizer=optimizer, loss=\"mean_absolute_error\")\n", + "\n", + " for epoch in range(epochs):\n", + " print(f\"Epoch {epoch+1}\")\n", + " model.fit(training_generator, steps_per_epoch=None, \n", + " epochs=epoch+1, initial_epoch=epoch, batch_size=training_generator.batch_size,\n", + " verbose=2)\n", + " if (epoch+1)%10 == 0:\n", + " store_model(model, epoch//10)\n", + "```\n", + "\n", + "Notice that each 10 epochs, a copy of the current state of the model\n", + "is uploaded to the database: it will be used in this notebook to\n", + "look at the evolution of the model prediction.\n", + "\n", + "To set up the model, run settings are defined with the parameters\n", + "chosen for this run, and used in `Experiment.create_model()`.\n", + "To allow the training process to check for data produced by the\n", + "ensemble members, they must be registered as incoming entities\n", + "by calling `Model.register_incoming_entity()`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5ce5c68d-38f3-40a5-a0c8-a7297036022f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17:55:21 prod-0001 SmartSim[61617] INFO Working in previously created experiment\n" + ] + } + ], + "source": [ + "nn_depth = 4\n", + "epochs = 40\n", + "\n", + "ml_settings = exp.create_run_settings(\"python\",\n", + " exe_args=[\"tf_training.py\", \n", + " f\"--depth={nn_depth}\", \n", + " f\"--epochs={epochs}\", \n", + " f\"--size={size}\"],\n", + " env_vars={\"OMP_NUM_THREADS\": \"16\"})\n", + "\n", + "ml_model = exp.create_model(\"tf_training\", ml_settings)\n", + "ml_model.attach_generator_files(to_copy=[\"tf_training.py\", \"tf_model.py\"])\n", + "for sim in ensemble.entities:\n", + " ml_model.register_incoming_entity(sim)\n", + "exp.generate(ml_model, overwrite=True)" + ] + }, + { + "cell_type": "markdown", + "id": "925266c2-d014-4047-9a06-8c4657ddcfe5", + "metadata": {}, + "source": [ + "Once the ensemble and the model are defined, they are started by passing the references\n", + "to `Experiment.start()`.\n", + "The workflow is started with the `block=False` argument. This runs the ensemble\n", + "and the training in a nonblocking manner so that the data being streamed\n", + "from the simulation, and the training process can be\n", + "analyzed in real time." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8a2b2061-5de8-4039-a431-c895e0a8940b", + "metadata": {}, + "outputs": [], + "source": [ + "exp.start(ensemble, ml_model, block=False, summary=False)" + ] + }, + { + "cell_type": "markdown", + "id": "9fc14430-a7e0-4621-a86b-0d7fbd5aa97c", + "metadata": {}, + "source": [ + "## Progress Visualization\n", + "\n", + "To monitor the progress made by the training process,\n", + "the intermediate models are run on samples drawn randomly\n", + "from the Orchestrator database as soon as they are available.\n", + "\n", + "Notice that the inference happens on the database\n", + "through a call to `Client.run_model()`, and only\n", + "the result is downloaded displayed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eb96f840-0a52-47d4-b5e4-3f2f2a3a2ebf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAADqCAYAAAAYlLi0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAD3ZklEQVR4nOy9d7glVZX+v3eFk9ONnbtvZ4IoSpvHLIqCYEDFgHHUcZxRUBBRlKCAIAKGMY5ZzMKImJAZw5gIYiDnzt03nxtOPlX1++M09b7V1qbPFfxy7vzW+zw+Lop19t21a6+96xzW2h8dBIESiUQikUgkEolEIpFIJBL1lqyHuwMikUgkEolEIpFIJBKJRKK/lfxoIxKJRCKRSCQSiUQikUjUg5IfbUQikUgkEolEIpFIJBKJelDyo41IJBKJRCKRSCQSiUQiUQ9KfrQRiUQikUgkEolEIpFIJOpByY82IpFIJBKJRCKRSCQSiUQ9KPnRRiQSiUSih1Fa60GtdaC1fvoCPnOW1vrmf1yv/nH6e/qutf6y1vqqf1Sfek1a661a61Me7n6IRCKRSCR6+CU/2ohEIpFIZNC+HwsCrfUXYv7dBfv+3aL8MaHbH0/+AT8QXaSUetoCP/MOpdSrH8I+/J+T1vrFWuurtdbjWus5rfW1WutjY/xeorW+VWvd2Pf/L3o4+isSiUQikag7yY82IpFIJBI9sHYopV6mtc7ef0Fr7SilXqOU2v6w9arHpLVOdOMXBMF8EASTC2k7CIKZIAjKf1fH/v+jpyml/kcpdbRS6tFKqR8rpa7QWj/lfget9ROVUt9WSl2mlDp83/9/V2v9+P/nvRWJRCKRSNSV5EcbkUgkEokeWH9VSt2llHoZXTtaKVVXSv2SHbXWltb6/VrrHfsyGW7SWh+3n89jtdZ/1FrXtdZ/Ukr9zRdmrfUhWusf7cuYGNNaf1NrvXQhndZaf1hrfYfWurav3OZCrXVq3797nVLqTKXUofuyhYJ91/Zvw+i3z36b1vpyrXVFKXWe1trWWn9Ba33fvr97l9b63Vpri9qMZO7cX/qktX6H1nqX1npaa/0lrXVmfx/6519qrT+ltT5Paz2xb4wu2u/vLNFaX7mvH9u01q/XWt+stT7rAOP2Ano+92mtz+UfpPaN5Vla669rree11nv3L2XSWq/WWl+x7/nN7Rujlfv5PH9fNkxNaz2ptf7h/c9nn1Ja689qrWe11ju11qc+UL+DIHhHEAQfDoLguiAI7g6C4Gyl1B+VUi8kt5OUUr8IguDcIAhuC4LgXNWZwyc9UNsikUgkEokePsmPNiKRSCQSHVhfUEq9gf75DUqpLymlgv383qGUOlUpdZpS6jCl1BVKqcu11ocrpZTWOqeU+pFS6l6l1Bal1HtUp1wolNZ6mVLq10qpm5VSj1NKPVsplVNK/YB/lOhClX39PFgp9a9KqROUUu/b9+++rZT6qFLqDqXUsn3/+3ZMGwfyO1N1MjoOU0r9h+q8V+xSnR+4Dt73996rlHr9Afr6FKXUI1TnXl+ulHqR6ozlA+lVSqm2UupJSql/U50fHl5O//4rSqk1SqlnKqWOU53yqjUP1KDW+rmqk33ySaXUoaozfscrpc7bz/WdSqnblFKPUZ0xOE9r/eJ9bVhKqR8opZYopZ6x73/LlVL/pbXW+3yOUkpdqZT6uVLqiH0+v1LR97KTlVI37fsbFyilLtyXKbMQ5ZVS0/TPT1RKXb2fz89UZwxFIpFIJBL1oJyHuwMikUgkEi0CfUMpdZHWeqNSak4pdZRS6t+VUufs53eKUuqiIAi+se+fP6C1fuq+669WSr1SKZVQSr0+CIJ5pdTNWutzlVJfozbeqpT6SxAEp91/QWv9GqXUlOr80HNdNx0OguCD9I9btdbn7evH+4MgqGmt55VS7SAI9j5AGwfy+3YQBP+537UP7Pd3H6OUeoXq/PBl0qxS6l+CIPCUUrdprb+rlHqWUur8B/jMrUEQ3P+37tRav2nfZ76ptd6slHquUuqJQRD8Qakwa2jrA7SnVOdHpo8EQfClff98j9b6NKXU17XWpwZBcP+PdNfuy1K5/28/VnV+yLl8Xx8eqZRaHwTB1n1/+5VKqbv3/btrlFLvV0p9LwiCM+hv/3W/vlwdBMEn99mf0Fq/fd/nf3+Ae1D7/ubblFIrVXRuLVVKje7nOrrvukgkEolEoh6U/GgjEolEItEBFATBtNb6CtXJvCgrpX4ZBMH2fYkTSimltNYF1cmo+O1+H/+NUur5++yDlVJ/3feDzf3a/0v4EUqpp+77sWR/rVdd/mijtT5edbJPNqhOpo69738PpW6I+bv/opT6Z9XJakkrpVyl1LYDtHPrvh9s7tduFVM2tp/2/5Fjt1JqeJ99kFLK5/4FQbBDa737AG0eoZR63L4fau6XpTr3sVQptWfftf2f2e+VUi/eZx+slNp9/w82+/72vfv+9iGq86PNo5VSXz5AXx7o/h5QWuuXKKU+opR6eRAEBxp7kUgkEolEPSz50UYkEolEou70RdUpuZlX0WySbrR/GdUDyVKdEqo45PP+WRKx0lo/QSn1LaXU2apTZlNWSh2r9ivFeghU2e/vvlwpdanq9P13qpNB8zbVKXd6ILX2++dAHbiE++/5zIFkqc6YfTfm340/yLaVWtg8+Lvub9+PdV9VSr0mCIIf7vev96pO2RZryb7rIpFIJBKJelDyo41IJBKJRN3pv5VSTaXUoFLqv/b/l0EQzO7LpnjyPt/79U9KqVv32bcppV6ntc4GQXD/Dx5P2K+pG1XnTJhtQRDs/8W9Wz1ZKbWLS6S01vuf59JU3WXedOunVOder6WyHqW1Xt/lZx9K3a46P3AcoZS6dl8/VqpOJtQD6Ual1EFBENx9AL/9n9kTVOfZqn3/v1xrPULlUev2/e3758GfVKfU6fMHvJMFSGv9MtX5YfG1QRB8L8bl90qpI1UnC+d+Hak6P7CJRCKRSCTqQclBxCKRSCQSdaF955k8Uim1NgiChsHtI0qpU7TWr9Bab9Jan6M6h+zen+HyDdU5PPeLWutDtdZHKhwOfL/+QylVVEp9W2v9eK31Oq31s7XWn9Na57vs7p1KqRVa61ft+/xbVedcGdZWpdQarfVjtNaDWuukoa1u/e7/u4/RWj9Pa71Ra/1+1UFR/z9VEAR3qM4Bu5/RWj9h30HQX1JKVdUDZ7uco5R6pdb6HK31I7TWB2mtj9daX7if3xO01qfvu8c3qQ7+/ZJ9/+4a1SltukxrvUVrvUV1Dje+UXWQ3Eopda5S6qVa6w/pDinsUK31yZqIWQuV1vqEfX/nPUqpX2utl+77Xz+5fUwp9Uyt9Xv23dvpqnMI8qV/798ViUQikUj0j5X8aCMSiUQiUZcKgmAuCILZB3D5uOr8cHOh6tCfXqSUekkQBH/Z9/l5pdQxSqmNqvMl/iLVIU3x37g/W8dXSv1UKXWL6vyQ09j3v276+cN9/bhUdX5AOFL9bUnX91WH/PTfqlP6s/+POgv1U0qpzyqlvqM6P05dr5QaUR361MOh1ymldqoO0vpK1flBY0x1UO2xCoLgZ6qDc3+G6pwddJ3q/AiyfT/Xi1XnB7w/KaU+pJT6wP2ZLft+3DtOdcbqF/v+t1cp9cL7DzIOguDHqjM3nrevjV/t+5v+g7jff1GdDOpLVefsnfv/dznd3+9UhyL2OtWZF69RnXNvrn0Qf1ckEolEItE/UBogBJFIJBKJRKL/m9JaD6rOYb6vCILg+w+ina1KqU8GQfBQnw8kEolEIpFI9DeSM21EIpFIJBL9n5PW+plKqbxS6ibVoS6dq5SaUJ3sJZFIJBKJRKJFIfnRRiQSiUQi0f9FuapTurROdc6y+YNS6ql0ALRIJBKJRCJRz0vKo0QikUgkEolEIpFIJBKJelByELFIJBKJRCKRSCQSiUQiUQ9KfrQRiUQikUgkEolEIpFIJOpByY82IpFIJBKJRCKRSCQSiUQ9KPnRRiQSiUQikUgkEolEIpGoByU/2ohEIpFIJBKJRCKRSCQS9aDkRxuRSCQSiUQikUgkEolEoh6U/GgjEolEIpFIJBKJRCKRSNSDkh9tRCKRSCQSiUQikUgkEol6UPKjjUgkEolEIpFIJBKJRCJRD8pZiHMq0x9kS6uU1jq8FrUP3IbuxqkLcTNBEH/dpIX6ixa3+HlHr9O/INOn677nh/b06E0TQRAMPdT9eyiUyvQH2eL+sanI5n84cHvsHxgG8KGK5YdKPdadB6Vuxt/k32vqpv9R//jPBn60Hd9HbE7t7c3YTGX6g1xplVJq/70yPh67eY49/Kh7eh4udnWzDi801hbeh/j+cGxyXCrVw7GZHQhj0+LYtBb2Tsta9POfu9/NVPpH+y9Ui73/D0KReOQ4pdj0vP1j8689G5v5+/dNikfLio8vU9wZw9Fw3Ry9B/6A6bM8TRb56tCV/tH321XYcSzQ5W760137C/ssx6AxNvffN/fEx+aCfrTJllapo9/4U+Um8DG2bZuCy4lP4jFtjiaZgo6D16cbtyIbbvzLTDf+3Yjvxe/iZckytM+f7cbnH9H+Q+X/QH3yI5vKQ/MC2o2/78dfbzW90PY8+DTrrdCuztVC+1sfWbPtgB16mJQtrlLPe8NPVILj0bVD2yGbwy7ygsqbYxdz2zQ3uB1elEzxvv+X8QP5d7MmdCNTvJvuPbp2wT+IrrXxf8uQ08ifZZ8HEwemtZFlGivT2miSqX1W9MudoR3y4bhst2A3Gu3IZ6pz9dD+5gWrejI2c6VV6uh//plSSik3eeB907YxCUxfHrt5Lt3MbeNnFzhXu/m7kT48iLn3UP3HGlObD0YPVX9Yvv/Q75nG/iwwNvkLYKOO2KzMYs9Uqrdj87h/+blSSqlEyg2vJxK8b2Ki21b8pDet2yYtdJ+K/C36KL+zPJj2I78fG/Zu09w2+Rv/1gLbX6j+X/bfN4x/xN9wL/+ItYL3R54bHJuzU5XIZ77x4ZU9GZv50ir1wrf9t1IqGo+pDOKU45HjlMeT99boO1L839WGdzzju66Ot1ndPOvuvs8euH1T37rxN3124ftUfDsP1Tunad2L+PB/RCD/btbnbvZQ/n0l8tuC4aPNOvbNVht2vWbeN7/2oeWxsSnlUSKRSCQSiUQikUgkEolEPagFZdpYWqtkOqFG1pXCa+Pj+HVo88ZcaO/c3QjtjeuSoX331ib81yVC+677cH3jWly/dzuyHjaOoLt3b8OvVZvW4pfYe7bjJ7D1q/Gb1F3kv2E1/O/b6dN1/Ap393b8ZLZxTfx19r9rW7z/vTtDU61fpRbkv24l7Du3PjTt37PjoelPN+0/0D3ws7l3R/wzuGMrrm9cs7BnzP58fe1KXL/tLsy55cswR2/663Ror1rXc5mjsbIsrVKZhFq1phhem5pEJsKGDYjNXRSbG9alQvvue+G/eQNdv4/81yZjr3OM37sN47phBLF8z7YWXcd/Mbnj3nh/bqebNeGeHfHPn+eLKZZN1zeP0HWa2xtXweeuHfDZQDEVic2V8L9np469fu9uzOWNK9Hnu3bi+voVuH7Prnh/bmf9Co+u27HX794Zf33bKK6PLMX1O3fg+saV8e2vXYb+3Lk9/n553EaWh6a6+U7814flS/Hc//xnxKVSSq1aN6B6XdqyVDrbiY01awvh9YkJxNpBm7KhvWMX5vymdYiRe7ZhTDatxZy/a+uB98FNI3//3L59q4r157m9gfzvpme6eQ3PVfRtw8r4ubRplRfrv3EF7v3Onbj3zatw/e7duL5hOa7fsQPXN63E9Xv2xPtH28c6c/dul/xx/Y4duG5qf/2yA/fnrl24zvd761Yan9UUOzvjY//2bTrW/+7IGoXrdxj8OWZ5D7/pDvRtxTKKzb+UQ3v1+kG1GGRZWmXyndhcuzYfXp+YQAwesgn3uG0XxvmQdWjn1nthH7YB9i10/eC1sG+7D/Yj1mPMb9uKZ3rIWvytW++Lv37Lvbh+8Ai3g2d36DqaG9z+CGKN59iha3H9lvuc2Ou3bqPrI4iFW7YmYq/fug0xcsgaXL/5Xlw/aCS+n9H+xPeT+3PImjb503W639u2x/tH+8nX4/1vupeur13YOHc3/vH+N9P1g2nc/nwnrq9ahr798c+zob128+J4n9WWDrNqDjkI++aeUcTmIw/CPW7fiznPc4zX7UNXYc+9c086tA9aUQ3te8cyob1pyXxo3zOeo+szob11Cn1bP4Drd4zhPXzzMK7fM1mM9b97Atc3DZVxX2VcH+nD+89dE/2hvWEA17fPlEJ7TWlh/quL+Lt3kv/GQfjvmCnG+t8+Rv5DuK9tZYzP2j743zddouvw5/tdU4L/HePU/0HMZx7PkX5cv3U3rm9Yguyye8bwrrWRrt+yE9d5Pty5B/Nh41L81nHLDpo/KzGvbt+J703rlmIe/ulOrI2rliFOb/jTXGgPb+xu35RMG5FIJBKJRCKRSCQSiUSiHpT8aCMSiUQikUgkEolEIpFI1IPSCzm4bvnaI4I3nf0HlUzit55CHrbrIEUtjWoJ5TqmA/Ti/46lg1ifyKFGOt7/wcATIgdYWfF9eDCHOEX6bzhn2jecb73Qv8viv2Vq/8H4sx6on0FgOij5wO3y8+YD8Ls5xM2nv8ufrdQxd+lsKDVVJirNFNIxL3hz+o9BEGw58F/8f69la48I3njm71XC5dhEGp7rmmJzYX9HU6yZzgyzIge48SFdC5vb2hDj3L7NsU9zVav4+O3mjEaLYt/uYm1Z6AF0PIbGPnQ1r+P9o+sn97+bA2z//gXU9w3P17CGND08SP7sPMVls43rk+Vo3zg2z3tjqidjc8W6I4J/OfdapZSKxGaR9s0EMrhVOol7NO2bxrgzPDv2dyysbQ/mUF8WzxnHWtjci6wnXew79oOY26xuYpPXENMcNrf/9/eH753bicIOF9a+aY/l9vne2/6BY7Pt4foExebUNNLClVLq3NcnezI2V67fErz9wuuUUkolE7iXYh520sV9pROInYQdf2qzKXZM62oECmDYs0z7jmeYY920udB13vS+alJ3/T/wfzM2jtuDeEc1tWOS+Z38wRwoHb92dfNcOB55DszV8TIXjU18dmo6epj/WScmejI2V23YEpz80euVUkrls7iXUg5xl6T9MZvEmuNaeJmPvhfhsw7ZfJ3F110L42baFyKxZrB9Q56ErdHnhbbPMu0LC+2PqX2Tf2SfUvE2t8ljy9e9AN9ZuhH7e9Q3Y38WGLPtLtYoVtNDDPr02dl6gnw4NuEzPhWNzQ+80o2NTcm0EYlEIpFIJBKJRCKRSCTqQcmPNiKRSCQSiUQikUgkEolEPagFFUd4XqDK03W1YiVOWi7h0P0IuzyTwj9wSnM6gTSwZhupTdpQEpV227H+nObN6U9JJ97flK4Z8afUJpvStzg9MmWz/9/fvik9MmHH+7O6ad8kU/sPVX8Sthf5d3XjZ2hM6R7qbYd8Yj8auedGm+8hvk88V2otIq8QAWtkBdGsyki1zGQWWD/0MMlr+2qmXFdLl1JsFjAgXP6VSlA5gx2f/t1oc3q8In/YadeL9efSQlbKgX+dYpPnAqfxZxP0nL342De1z7Fp81phmHfdtJ+gFNmmz2sFl4CRvyF2TOUt3H7Lp/ExpJgmbczThkc1NiSbUoU5bdiUxslpq9x/j/oTvXe0yePG/ef2eXxyNN+qLaSP3rkd97J6GRFwytH00cUQm+12EFLcVtK+2V/AvXMqezZJadsUR7wPtrz4/9bC8yrj8tw48NzmuWSaq/zs0k68v6m8iOcSzw3TfzVyqT8tw9yOpLtHYgf+plRz12rF+pva53ne9g8877g/7M+xEC0r4+eL/vDT4s+a1iJT+jePv2mt8E17Zhv+t29DnK5dwSVRaD+dWliK+8OldttXk5MdAuKqlaB+DOR53aP9gva7JL3npDgW6Fm0KO5c8s86oC6angXPjZSNMtBaG7XNkTiiuZpzQTOpe3he0VKp+PbZ36SMTf3349uPvJNb3D76byrvStP4NKk/8StXtD+m9vl+Tf4mpci/yu378d9fMk78+Jv2WdP4m8qmeB/n+XDLVswlpkxOU+liapHEpucFqrzvPby/iDEZzOJZcHld3sV1HtuMDeJPO3BifXhtT+gG+WM8uQwnaeH52j7WCl/TO5LCc0kq+FsB/pan0Z+GwvqTDkA1Mqmm8S6R8UEgCjTtLwG9X1n4op72QcUytm+BlmXy57/V1Oi/rTAmfL88Pm2FsU0GeEa8bngWlfvRs3AV4oWrwVqK14r4Nwv+LPvz87VU/NxoUR98Q9lUzsG91DyMCdOmmCp1xzStG+nuYlMybUQikUgkEolEIpFIJBKJelDyo41IJBKJRCKRSCQSiUQiUQ9qQfnljqPVwGA6UnpSa/BJ+7jOPjZl/XBqN6d/8ynufJ39TWUXXP7A1ANT+5TVFUlzMqWOu5waHXB/DKeOU/uR/hhOKef76sZ/oe1HU9wPfL+aS8MM/hEaBbW//2nbjqE0RRueWdQ/tnvKMzxjFpescBollwMdtBb9aVLlxaoVSG2cKkfLvXpVjmOp/v505FoFmXoqSVnP/Oy4pIxLnHjO2HYQ699NbEbaN5QTRgkyhvYN1CrLQDzh2IzGfrx/hKpD/tF5RGUmhlhjek5XsRY5yR/isiYWjw+37xr8TWWPUX8v1p/F/UkafLh9Hh8vQg3gUrj48TloBHaT5uSaldHU/Ymp3o9Nx7HU4GAnLgMKPCbXMaGGY9PV8fugaf5zSa8pdoxzm1L9TYQm2xhrROtA1yL7kWlumMqp/CC+fROBgtOqudSIZSrfMPnbFJF+F/4mRcYniL93Hp+oPy+Uhvvl/TpCqIQiz4veZ7idbt4TDllLc4zIbiOrEJuT06ZClt6S61pqyZLU31yfr1MphNvNvoYXX1N5KccOl1CZqVJUqmxsPz52TP4s7g+XB9pd9KdlKDPhOczXm358f7QBtdUy+RvKhE3tW4Z3DPbnWDOVFjYN42NZ8fumaTy57KIbf2VYG1uRtRp9OGwtl6wiflctx/Oanl0YBezhkuNoNTz0t6WDlRaucckwz3IuHfVU/Fg5mkp4DIV3jsZ4JhSVX/n03Gk951Igm9pnn0j7AUp1XGrf5M/Kq2nyp32EYorX9rx3YH9WzivH+rN8+iKd5HWArtt+K/a66X65hIofS+Q7Ao1z5G9RWZap0CigXdHhMi4DzYrLrEyELxZ/R2D/R6yuhjYf27J2JWJzHI/oASWZNiKRSCQSiUQikUgkEolEPSj50UYkEolEIpFIJBKJRCKRqAe14PKo4UFH1RtIDTp4OU663jGdCe1DB/eG9ra5odBekx8P7Z2VwdBel9uF67Wlob0sPRHae2rwX5OG/67GstBekoT/WGMgtFcm4L+7Bf+hxCT8m2h/pbMT7bdXhPYwtT/eRPsrbLS/x4P/ALU/Sf7LyH8X+XN//tHts/9ya0do7/ZXPSTtK6XUWANjusKhz7TjP8PPYIW7O7R3NuG/JIk5tLcxHNr8jNl/BfnvqmIujpRw6vq2cim0LYvSoxMG1E+P6f500lqNUtlXoj5q2yRKpx6xFHN4a7k/tNeV8By2zeL6xhJieescxnt1Du1sn6dYzlPszy8J7ZXkv5P81+bwnLdVEZsrMvDfVSX/DJ7zjjr8l6Xgv7eOubomSbHcWh7aQ4mp0B5v4n459nd78B904T/Vgj/Hwl4f/v0mf4329waYp30u8iNnvUJoDwd7QntUof2CPRvacz7oAEt8jOdejfbzNigAFR9r9bL2drTvIPaz5D/nof3lPvz32itDu2jNhHbZK4X2CoX+7A7Qfr+LuBxt0B5RwH1tm8VzTLrR/8aQTvX+f3NwXaWWDHXWk8i+uQxjtaOMsT20H3NjWwX74JosYmpXDTG4LrkV7bQwtsuT8N/TRAyOWPehHbU6tIft0dAe99D+Kv9e+NsjoT2ox0J7IqA1uI32d7tr4B+g/SkN/2VN+O9Nov0+H3OjbCH2l9bhP5qCf8mfiPVfUt8a2mMp9KfoY62bsTDHhuvb/rH+DfjvTa0N7b4A9zttIRaWkP+eBPz7Axp/C893eQv+u9yR0F6m4D8ekD/F8k4N/yEb/vy+tK5QDu2ts+inYy++PdN1lFq+7xbmqujzI5dgvb13Bvf4qNStuO5vCO311l2hfV+wPrQ3t/+K68lDQnt1C/7b3Y2hvbZ+S2hvTcF/VevuWP/1VbS/NXso/BvUfnIT2q/cfED/XUnc18jcX0J7R+ERob2siv7szqA/q2ZvjvVfXoP/zhT6s2burwvyXz1P7efR/xW1u2L9H0z/txcOO2D73P9u/Ln/23Poz8r6nbie2oz+z9+E/tP9rq3fE9pbEweF9sYcYvmeCvYCmyg8iyk2l/R39ksmn24u4l1rlL5bbGphrPY4iMHhJr7XlJNY95aUbw/tqSLW1VwN63YtWQzt0jT2nXIf/JMtlL20bZSI5mfwd2dL2GfddiPWvzC9Ff59I6HteCih8ul7Sa6M9udL9Kw9lCN5lrsgfy5Nys7sivV32iBh+dR+uoL9YrYI/9w89v1mCu+0qXnsd3Pkn2riO1k9gfei/DzeZyZK60I708S7YsPBO+3AFGJwqh9rWq6O5zuXwvwZmMaaMN6PGCzW0P/pNPbB4VlaQ4oH43qD3qWTeB8Yod8Ntircr+sQ2S3Z3fts77/1ikQikUgkEolEIpFIJBL9/1Dyo41IJBKJRCKRSCQSiUQiUQ9KByZET4xWrt8SvP3C61Q6hRS7Yg52gk7aL6ZxMnPCiT+hnU+ETtpETDDQi1hMcGAPz9C+iVjB7ZsIDiaqBcvkz6dJs0yn+jPFY6Htm/rPMvZfx/ub+t/N6dn7y3RCd9uPr9IzjVHb9MwM1JOmh/b5s422QzauT87h+mQZ7ZzyIuuPQRBsie3Uw6wV67cEbzvvWpWkFLsCxSaT3fJpIgE58YQUJi4lyIcJNUwkYUVITJSN6xnoDOxvItTw83QNscCn5bNM/t2sLaa1gmU8ed7UviHWWNpAnWAFBpqGyacdOdkebbpESYjEJVFCuvlbHPumucTXOe4jcUn0E47RibkoTWISFUbq7cf0Zmyu2rAlOOmi65VSSqWSuPe+PKXFJnjfRDo074meYZ1jUkY3+6Zr41kzHYnnRiTWmIJhoCqwHJN/F/tOZF8z8B+Y+MAy9cc2+HuGynCTv2/oj2Ugr3lBfPvG2KH2I0QnQ+y3H0z7hnckFhNz+J2kRrHJFIyJeaT6T5SjbfVqbK7euCU47eM3KKWUSgMYqUo5IjTR3teXQmkAk6E4NnkWJmzEcmTfNLwj2Qa6UCQ2VXxsWpH2ad2OrBvx79imdzbeF3getg2xw30z7SMs01ph2ndM+6yp/yZCEPffRLximdo3rV2m/nfj3037rQAxyHOj3kYMMqFsbA6EtMmZ6Dr51qN0T8bmyOYtwZmf6cRmPkMxmEFMpR3Mz5KLspro+wxTRCmuPRwdYBloTUw1sv34fYHpS0xZ4r/LxCIucYqQp6h9vh5Yhn2H/HmOmfy1H//OGfGn/jOhiRWhOzEJVPN90ffudo2ux98Xf5av87i1HCzQnj7wqS4OUav473pUKsjkqQiRit9RrUSsP4v9Wwr+vG7UffS/7tFeWUFJ19hM9Nm96dnxsSmZNiKRSCQSiUQikUgkEolEPSj50UYkEolEIpFIJBKJRCKRqAe1MHqUrVRf0VJtyhTbOIzTm3fN5kJ7RQ4klKkGkUcyOGV6Tx2nN/cliITSRsoQk4KYRFRwQK2q+Uj/G7aI7kQUjJSNU7tblI44QP6TPtpPWQvz51RVTgXvs9D/qQAUiQSl8HEaVb9NtCZqn0sqOKVzwe1bk7H+tiE1tE8TAYf8kxppik1K1+TxUUqpCR/0BR5T/sywgxO6Jzz4Z2yk1nF62VIb98zPmP1rHubEsiTa390AkaU/hTk0VsHc9WkodHzFTc+pE5u2ajSRmrh5Ge5vJ5HdRvoQm6MVnOg+ksO4Mg1qSaYc2hzLqymWdxKVazgN/8kG2l9BJDgm4AwmUecy08JzWJlG+0wJ41TYiof7GnQo9lvx86jhIzVxkOYRx1rCohP1KZZNscOxxmUa/Qr9mVJo31SKWAjwXOZUKbRTGv3n9osN6n8SVCkrkpqLCcyEnSmF8Zxs4m8NJtGHrMI4zymQFLh0gmO6pIiYo0HL4v5o6n8fEWoia3UC83aSqFj7azHEpmMrNVDqdLSBJVNtHsY475jB2C5LY70tt3DvK2gNYxpUyUXszHvZ0F5igYAzFmDNy1qgXTQDxMISojtNKrTPJQY8l/raRDuyEWumcoxiG3NvxkUscGlAUqP8pNDCXJp1EWv1AOt6xsI8yTcxbvNuKbSrPsYkZ2E+51oTsf61AOtJTrN/ObQrCTyviof1Km/hHSbXJDpGArHQDLCPJS3cL/ef75fLmrg0bKANmsa0i9gxxX5fC7E25eD5JiL7OObDUkVEPItolQ7WolG/hH4u0j1zoNjZL5stdPrQAdz7fXNEXnOIdKYwJiPteBoUU/kmXaIi1kAL2pUBXWhpY2tojydBGFlZBelmZxa0ICbjTCXR/qr529B+DiQUJqlNpkH9WzZ3R2jvKcC/v4E1ZJZIKyvK6P+eIvozWKP+pDE+K2dvifXvr4MqOJPCHF4xG9/+UI3Gk/s/e3us/0PVf26fSTEDdcyTcgprLN8v+3P/I+MzByoZj/9gHSRBbn/pPMg1O3JofzBB73X0XantcTmkWhRKOoFaPdhZH+fqeN9Yn8YYjrURmxkF0iWXsvbNYwxnsxhDLnthAlGqjjGsp/pgu7SP1LB3uHWiF2WwzjN5KlvH2u7UsGfV01jndyZAvGKam9PCett2QYC93XpkaB/kg2LmNLG/t8j/PhfzZF0L880impVPpUP3uqDXrW+CehbQuHHJ0rgm4jOte3Uah1wF7xi/9Z8e2k/Uvw3tNrWpqfT41WfA/sY57ENlgzauzzl4dkXa63NV2vcziJG6g+ebauMZleZpjcphjeVyKi7XGqpuDe2xLChjJbsc2hP0XcOn6mSry9iUTBuRSCQSiUQikUgkEolEoh6U/GgjEolEIpFIJBKJRCKRSNSD+rvoUZk0pdxT9nrSQI9KOvEnb3NqExNkmPQUX7QT9eFT300EGdPJ85GTtw0nyXPpEPuYCCkmiofJn0kB3bRv8vfoNzgmEXTTH7sLAk43/fH2o4Tw59mP+8f9jvgb/oaJ+MWK9InoFy0mYbSZhEH0qHlcZ3rUycf1JgVDKaVWrNsS/Ot516pUispPChgblwohmR6Vcg9MdnNtik2KU983jT3sbmKTaTiWIdYi/kSDchYY+920303ss3isuqE4WYbYNI0/l0U4iogelKIZOYGf1zR6GEy0MdF5In2OrC3wN/U/EpeGZ8Fi8oVnoGDUifw2VcF1pZSaKOPv/evzepOCwfSoDFEX+wpEj3IxhsUUylVSRMcw0buYjMZxYZqrXGbL5UuROcP7goonzpj2TW6TSUxMgojGQjx9idvkz1pMwAkM/TEQPYzxQv7cpjZQRfiz3KbpvSJC3CBF9ll94D0t0gcDbcrYvmGPNYnjvUUkmlqbKRjxsclxqVTvxubqjVuCd3/sb2OzPx9PVywkUUqQchCnxn2TSgu5zNA3xAI/L1OZm2kf4biLtG94p+2mfY59juXIXKJ5EqVH+bE+5vv1FuRvfIc3jU8X/Wdxf5g0Z9zHDf3nv2V6vqb5EC0rjifrcXlptY1yGKZHjc+jpHRiNnq/bz6yN2OT6VGlLMa2P4sYzFAM5h2URyUVyk4j6zPToAKKTQ/tMJUp8lmiL1lMYuI9wkAXYjE9KjCQpEzyLHwvMdGdWMbYMfwtpiOZfNo25hKTmCLvJESMcpsoNTISrEw1e9Qfz8b+4ttENjSUa9kGGhfvxb6JtBXE78s8/iZxqVRbwb/qU2wyPapK9KjZaPuvf4bQo0QikUgkEolEIpFIJBKJFo3kRxuRSCQSiUQikUgkEolEoh7UwuhRjlL9JStCwdgwBHrFHqJHrcvhZPVddZzyvSxFhJcGTtte6eCU770eSCiDLk7enm7jROhlGv5jGqc6F230Z9YDuWapB/9RGye3F2yiVnmo9Vriof8TDtrP2kjDYzLFUBunTI87yx9y/8E2TsIft+P9mWQxTP03tV/zibzD7ZM/EzcqQS7en/pTIIKGUkrNE/1lyMM98zMoWkQP8nHa+BKf/DX+Rskpw79N/gr+ewLQBQYSIJEwgWxpBifFb5/FSe4LqBjsGTmOUgN9tqrU0PkNS5CauKuMZ72pD6e4b5sD+WV1HrG5u4LYXJPBs95ZwynxyzPw31vH+K1O4TnsqCN2OPbHGvBfmaC1oonnPJRE7DPhaIVNZBMf/n0OnueMh3nBJJQxhf5w7M/7FDs+7nfCwv0yrYYpMxwLkw78k5ppaUiJNJFfOJ11vkW0AiLltSjlkolqwwp96JsAHWNsCSgDO4nWtzwFus1F30WM/vvxWNx3ztP6nMOz6PPiyUEmEg3fL68teRtrC6/V/Nx3VDE+i4V8wWJ6VB3TQW0cxFzdPYd7X0d0jF0tjNWyBGKWyWgrg62hvUeBODOoiRZE5LJlLfiPJeDP5LJ5jdgZrm/D302vDu2cjzW7YqH/JgJL0idqlYUU6/4qYnMqA/+EjxR3pkL0VbC2lDOIZU535/KEYnXvAf25hKRQw7jNpik2KU2aP5uvjR/Qn1PZuf1Ifyidm9PO+X4nM3heaR/7eN3CWjFQxfiPZ9aEdtbHWmd6XmMp+JcColhqzDemeW6rov+Lcc90HaWW9Hc6PlfFHDi4H2O+bR7vrpsCUIG2BaA+rWljvWUKzJo5UF12Fg4N7eU10H/2pIkaM0P+xcNCe1kV/qPZdaG9cvqm0N7V94jQZrrQWA7+yyfR/p4BtL9k7p7QHs+DeLJsAv6jQ+j/4AwoWpPFEbQzTpSoQew7w3P3xra/dBJUmr0Dj3jI/ZeN/wX9H4Z/N/3fOwj/bsbHdL9jeYz/skk8L+4/t8/+yyfQf25/6Rye7+4c5uEKC3vHfT7a8boot+w1OZZSfbnOuulT/9ck8T2OiZ/LZkD4mqJnmm7iHaPpYN/JVrG+zWWxbnOplONTCSSV4bgteq/OgbK0ehbP12qiRMhL4F2Ry2+Vh/LnF5yF97orzsX6f/6v8dzf95Q/hbbdov0xgfV/PoX36nydKFdUpsT+5QzeV3mvYSpWM10KbaZosd70IbzcfOV0lAIddzru8cdnYzyP+SB8fnIq9sRjP47vbVecineSyP7bRjuJJnyaJexfqTreT2op9J+faUtjPuRnsA/OUDtJetb1BN6TS9O0hvSDGMj7+3Qa72/8e8IOhTXk75Fk2ohEIpFIJBKJRCKRSCQS9aDkRxuRSCQSiUQikUgkEolEoh7UguhRqzZsCU7+6PUqS/SoYi6egtGfQfpWwqbUZQMdiH1MRJIoNYP8mUQUxJ8Izafrm05i5+smfxMhhf1ZC/U39Z/HxNQ+q5v+dNP+Qvtj8lcq+pwin2FagIF2wM+gFcRX9THRitX0kXrYpvuPUGra6MMU0aPGkX2nTjq2d+lRK9dvCd52/rUqTfSoYh5jmUrEk90SRMfgpYBLUTg27QgpzECoseKfm4kkxgQobWifZ61jdbFWGCgeJqIKi6kZrIWS6czktPj2+YR502czFtJuMz5SfxdKE+BT9Ln8pB3QyfwUy6a1yzSepjhmMfmCSVJ1Ol2/4aE/UxX0UymlRqfxmbce1ZsUjNUbtwTvurhDqMlmiLqYw5hkiOBWSmPfTNpILTbtg0mbyBcGIgnL1UQf68Kf56qJCBOhQBLdzERtiLRPpUYs9jdRP1jG2KS44BTrbvwj7RvIIJH2F0iMMvmbSqvM/vH0K/Y3E3C4ffzdVsB7Jj5b9xCDNYrNyQpSzcemo2PVq7G5ZtOW4D0f7xBqUrS0DBYwx1IOxWYKa2/SQtx5BkIQ+yw81uLfUVmRWIvsm/HvRxF/0zsw78t+fCybKCom4gyX+7FMpLaHyv8f3X8uaTT5R8h6/Hzpb7V1fH9M/i1N+zXFdc1DDPIeOjaP8pz96VFvenZvxua6g7YE53y+s28WMxiHgQy9/zjYK/mIBdfDdRbP+TaVO/EaGymP8hqxPlyeY5FP5G918b06Qk0y7E2RfcewB5kpSAcmUpn2NWMs2InY65H3QJr/6TmUdTtllA5521FeZGVRcuXPoezXXolyYJXCHK73o4SKSVItl8vQ4ve1CL2L90HDvt+m+4360z5Lz5HnVdviowzSZCN+x6s4lmFsJjq2r3260KNEIpFIJBKJRCKRSCQSiRaN5EcbkUgkEolEIpFIJBKJRKIe1ILpUUN9WrUoK3DDQDm098zjdOV8AmlsnOLO9IHxJk66TlhIZfQoFXzAwgnY0wFoJlzykrKQolbUqGeZVSX4BwZ/H6SSOQ3/uRbSlgouyhCyimhKCvc730aKV95BilcuQNoeUznYn+kw+aAc68+pjxm7dkD/2Rb6ttD+d9OfShupaFkHZBCmkCgVHdMGEWWSRJopBngGMxrPmMugEpTW36eJKEZzglN7OS110MacG2uDBlFM4j6bRK9pe5w6vziwGLatVH/JVs0W+rt5KZ71zjKe77I85uRUHfN8ZRaxtrMCYkh/kig/RDVaTrG8t4ET+Isu5v8czZOlSaRHMsWL51vVQxrhEpdIc0TM4dJIXiv6LRABygFIc1x6w6VSBVXGfdFawemLvFbkFBFYKHbYn8uXOPYrGvPr3jmc2M/p92tTRH9ogNRzxunXhfYlFz0qtN94CigVn7sEJ9i/+eS7QvubF2Pcvv6nzaH9msNvDe1SGUSGiSKoE6VWObQnXZBiTGtdJiCSHY2PaS3KK4zPtEIc5xyMYdPDGrAoKRi2UsP7bq2BJUxt6sfc3jWPucqxw/NqiUW0vgBrGJc7cQnVgIe05CkbscllL0w3K7bQnxkXsVkPaN8helqhSfQNF89ulOJ0iYv1Id3Cc6+7WHN2tzCvVjggLKTaNAccrAl31jE/N6Uw/7lsytOYM3c3QefZkAClhUtpudTothri6OA04sikW2ugtxySBkXI1J/tLcT1KhfEimQbeyiPz7iHZzdkY/3k8ay5iK9pD3OpZJdDO9ciOpgLn3qAseX50NfG32J6Zp7np1cKbe/Amfg9J8dWarDU6XijhbXloBLm4fYqYm2Fwvo8obCGr6mDXLMzhfkw2EA700n4L5u9I7T3FuDfX4N/OU3+M5iHo0X4l2ogo82lEXdD5dvgXzootJkmU0liDgzPIC4mShtCO9MohzaTUwanQS+a6IN/ro41oZLCmjA8RTTDfvSfyWsPlf94H+LX2H/yn6D2F9r/bAMxVUtgfx+YujfWP1ej9nn8y9R+ifwbeM+tJoiSOgP/3cWDQ7vPRn/20rrR9hffvpmwfbW6v7Mm1tvYs9bYW0N7UiE2W4roTgrlUVka82oaz/TuGghBI1lQk155Cvy/fSHG/GWnYGyvuADvtCecA/uqNyOuj/ok9p2fvfr60H7u1x8b2j99O8iMl469LLTftv6a0NZUtuNTuc32HOhjTKnznGgJ+f26yUGVzSNb6E/bwbjZVE745i9hn/rc67DuvfB0fG/7wfnoD1OifvZe7B0X3nV0aJ/mnxfaU09/ZWinv/bR0P73+pmh/aUl/xXaz/4M5vmPzsbfOvZ92HiuuABjNZkEuam/gXXSRJUqJ+j7C70LMWVsPoP3ooqDuZHx8L2gUMHfmsqjvIu/O9QV1mqfYtPv8qumZNqIRCKRSCQSiUQikUgkEvWg5EcbkUgkEolEIpFIJBKJRKIe1ILpUe+6+HqVyxI9Kov0JKZHFVJIo2IKhkkJKnlwiE7iGygP7MMn80dO3o5QEuDDNJMIkYHSy9lnoe0bCREGyoDJn+1u/E3976Z9U/8jRBjDszC1322f2KebMWIfEw2LS6W4PKbtI1W9SvSoRhvXJ4keNVFGm28/pvfpUZk0xqOvgGfhOhiPfBqxw+U5JjE9islQXIIWmUv0nJkM1Q1tKhKbhvaZXvSPXit4HrFMdCRT+0xi4rIXVpSohT7z/LWp/f4AaahNG2UOS3f9EW22UfLQzqMc1aOT9isZXDedft+i0kZtKBk0rUV8XxFqCd1XZHyIUFOn8qipKkp1lFJqfAafefORvUnBWL1xS3DqpZ105BzTo7IUg7xvJvG8Ug72UJO4rNih0r9uqIJ2hBxkiDUVT2lkYoKJkGIiHzGxglOyu5lXkT3BQLjg9tnH1L6JVBX9W7TH6fixMinSvqH/3GcupzL5m2hTJpneQ4LIfktEGxVPj+Iy7RqVLXBsclwq1buxyfSoLJZP1Z+Pp0cVEii7SNmIUz+ydzDhlGKT4sj0ThV5RzVQvaL7IFEdiWRkohdx+1y+F5lL3H7A7bdi/buhpJna5/WBbVP73fib1pZu2jfFGtOmHkz/uX3253g3keDYn/dlpj1WPOzpfCTFRBXXx2eiJ2K88Vm9GZvrDtoSnPuFzr7Zl8Vz7CeCG8dg3kL5ScKDj+UfmApkooAxhYpjMDOHUmVnO0rV/CrKh1vjKKtR9BzdfpTFWQMot1H5Umg2+1COyurm+1c3/hGfLuhU3P/AQKpipXeg9N7bhdL75gTK/Xb8FiWc7QbGvzmPd55DX/200Hb66LiDgx6D/lC8eA72IO5nJH45NrugbnH88rpqGnOOZX6XrgVEv6L3/6kajhrYOxP9XvCapwk9SiQSiUQikUgkEolEIpFo0Uh+tBGJRCKRSCQSiUQikUgk6kEtjB5lK1UqaOVTVvK6/nJojxI9ak0SaVFMiBhKIEWq3MYJzEsDnJw/oXFyft4m2pEHqsJgGylqTDdIaaJWEfmivw2axrSLk6JdhXSslkY6U3+TToFOLI3192j4TPQNTklllZoobZhO4BR0RyEVkFOUSy2cnM/tR/w1/PuadL9dtG/qv8mf2zeNj1LRMe1r4Z6nHPQpaSENse4jT3mwhVPdx90VoZ22QNqo+kgv4zkxasO/aBEtyScqQAonwu+Yx4nei1H306PqDaTtbRiOp0dtKGJu832vzGEO7K6iZGZVCuO6p4nnNpRELE80kb640qHY93CK+2AC4z3ZKoX2sI25xLSUklMO7XIb/ksUzQuieOQskE14XvT5iJ2yhbmdIIJZk8p/mJzC8zRSfkKppFkfqblVC2ugqWQsaeHvbp9Df879wO9C+/OXgsrx1pNBJ/nipWtD+5WnlEP76xcijfNLFZAI3jh7YWgf+xmQKa46Gc/0nJ8+MrTf/2KMreOjn76N9vm0/Dkbz53XCo57XrumHTzfpEbcVwM8r34X82qXh/FfjLJtpUr5zjxoU6b2+j6kT++tlkJ7jbM1tPcEK0ObyUFTPmJzSRMEovEE1jwT9W+oRgScNOgGqQBrakNjDWZCzUwGz8JUjlGssD9i01R2kW5iLjGBpW5hPqR9xHW6QfSHJNEYLdh5D+sMU5kaDlKUed4WPMy3RIv8XfSh6qBvTGJitWwq6zP0P9XEmlxNlkK7qfGu4gZI+8/W0Tcm2pjKRgpVrKXlLNZeHvOA0sX7KzR/MiCq8Jo2qzFWgw5Rz7z4NP7FIsdWaqivsy7XGljPDypiTHZUMYc3tG4K7W02qEyrG0TzSYEas3LqL6G9t//Q0F4yB1rTWB40tOUT5D8IOszQ3H2hPZHHM1oyfktojw+CrjJYBr1osoj9YskY+j8+dEho989sDe3pAqgxg2Nof2oI91ucI8pVYVWs//gw+m9sfwL72uQgyIZ9s9tj/YfGbo5t3+Q/MI4SDFP/Z/IrYv0nhvG8TP3n/rD/Qvs/MIPny89rmPzHIv7oz1gB7wkrPFy/V4Gi5S1CepRtBZEy/vu1zKZnR6RZHkN+plxmyCUtbzgL3xO/+n6spS89FfvL5RdgDX/xaSh9uubt2LuP/v5TQvuKJ3wrtH/+lEtC+7CLnxfaH3/st0P7I87HQ/s5XwAV9Mdn4b3oBefiffKHZ6APe4qYz8tmEEfX2k8N7ce3fxnazjz2rGYB72AX3vjk0D7t0f+L+zoTe8RV54SmesEZsK/6IMbzmPdjjl39Qrxbvu72fw7tj6n3hvbIB08P7dGLPxbaH33kZaH9EQXa1FGXPx1/973Ym27PPiG0N1dBxXIqRA0r4T2KxWVQmTm8t8wXMH8cj8pgqZyqUEaMl/sQs/w+M5fCuz1/l91hYc3vpoRtf0mmjUgkEolEIpFIJBKJRCJRD0p+tBGJRCKRSCQSiUQikUgk6kEtiB61euOW4LSP36DyyDKOpLClE7CLSaR4MX3GRBPikgEmXDBVhMWlCiayUMRfsT+dDq0MJ+er+BPFA0P7FvWZSROeoQKN/aOUnAO3z/KD+P5zWmDEX8WPJ5MIFto+99k0/p3PxJeKeYZnYPQ39clAHmL6RYvsOtGjmFIzOY/r42Xcz789vzdP2leqQ496+4XXqXSKCDV52KkExqaYxrNO2BxrTKbAHGb6G5Oe2r4h1gw0KM8nkgK1z/HO1yMEogiVI55oYyKP2QZ6VITiYaBBPRAZLWzfEGsm6o1viBfug6sx5ly6NdREenC6ilKFVhKlo+oHXwvNxjTKMdLDSCdOHf5ofHYA6aCzlBrKJRh8Ej6XhvH60A0VhcVxyWtAwyOqG1EwpmpRetRoGZ9/07N7Mzbv3zOVUpF9k+lRaRfzuUR0DKbPmOZSZN+keWjeB4moYoiFiH8QT3cyUWNMNChj7FDZjonQxGIaCJMvuvFnmYhLXGrEMpGquqE4GT9L6dam8TT1J0qcoXcqA7Grm36yv4kexeQLE6GG41Kp3o3NNZu2BO/95P30KMy9gRzTo2AXkyid47jj2OGY4vJPjiMuY+d3p0hsGmhBLMdAR+K5weJYi7ZPZECaq6b22xEaS/zcY5nmqmmteDD+LJdKG9i/m/7zWmTy5/LhbvxN/efx5xiMtE/+TIrkOK3TcRBMYByt4N1gf3rUG57Zm7G57qAtwXlf7JS79EfoUSgRytjYK7kcmJ87i/cCm8eWrvtU6msigmX//Atcr2FNqNyLkpmd16FEsVWlfdzHc1woHSkiXsMN+4vu4ru9sX3D3+qmnCe5847Q9kZRKtUcQ8nS1B0YK23Ru42Fv7Xkn/COai1HGWZrEOVOkf7zeylTohzEl4kkpU1rlx0fm6Z3G6aScVzXFWKW99DJGsrf9pSFHiUSiUQikUgkEolEIpFItGglP9qIRCKRSCQSiUQikUgkEvWgFkSPSjhKLR/w1HwdaUUjfTiVerQCwgKXVHD6ENMHpjyk68+3kT6Ud5ByllM4jbmikEo03cTf6k/gxO9MAFJDTeP07101nJi9Ig0SRzIg2hRRM3bVQcpYmcbJ0q6PlFcmpNw3j7KCtbld5N8gf6Q/7ayBSmBqn4kSO6rLYv0TQbw/939FCkQJ0/3eO8f9x0nXTLLg9nfXMZ7LUnimTCFRSqm6prTpBk7THk4iVS4dIOWRn9lMC8+46GIe5AI8byajVD3cT5qIVEVN1KIAfci76GvTw9xajKftO45Sg32WqtaJHjWEMds1ixTZoQyuzzQw3iszoPzsqWGcsg7RvSjtdjiJ5z7aAIUqZWPOcKnLkIv2J9pon1PNGz4R3GyQU6Y9pI+2fCxbCSohKahyaM+qUmjPtXDveRfrA68VvLbMtzEmOQdz0zhP2zRPHYwtxybH/htPQursZZdgHXjVyYhrpkS95WTQSX50Nu7XHaMU0360c+fLcOr+wdd+OrRP3v220L60BdLByz4Jysx/4oB/dcpncY8X/Aue6RQ9u5KDWOTY5/GZbJZCm9fqrELpFj+v6PxBOuv+cbmAyt6HTUk3UKuHO2UJ5Qrm7boSYmFvFXObU765lHMoIJqhxtrLpStc1ldoI3ZmHeyzsx7PVXoWTdgVF2vqnhbm1TIXfTBRme5tjIT2uuRW9M2Qan79DCg2jy3eivui1GIuE/jtDEhnTy7+NbQ98ue/9aNdh4f2U0ZABepvIG2b+39XGzSWgzX6s9UCjWWtj/RvJjMyJe1T14Im89bHox2mk3zvI3gWH/guxvmsE9DOX+ZBCXlkDn+XS13a/B7SBF2ICZ4Jj9Zwh9YuH8+6YGPtKjSxPzNtM2vTc/fwWS7tXCxybaWGS525Umviv19uitCj8N7FhNOywhq4sgJ6y+4sCH35JmKwmiCC2wzRo4qYV9lGmfwxN4am7wrtiRLmZ4b8mbw2wPSoEkglSSKjtRzsR/3T6M90CfsOl0rxO3xxhsgppZHQdtv0rkvt95VB9pnqA10r2cJ+yqQ2k3+iTfsptz+N+53uw/2yHqr+8/gs9H5N/efxZ38u82Ey3UAZ/qMlomIFmG91hXnbatPxC4tgz1RKqaTjqZH+zno028B7/TKNNW1GgaLI9MCSh/UzSbS+toN2jjsd71H8TnXsmZjzV56HfeqFp2MPuuaVuF5/4vNDW2/7fGj/+h0gMR33X8eF9oUHfxW2Oje0n/t9UJ9+9D68l/5KPSu0n2L/JrSZ1sQUp+POwV7ws38Gfey5//mI2Otv/N+jQ/szLwFd7nlnY6yYZnX0WfgO+OOzMSbPPxN/9+pT8FysHNalhI918vaz/ie0n3rRMaE9ccxb8dnbfh7aR34adLkfnYn+7CjgvpZX8J58i4uqooN8vCfYHvrM82FnAnG3orU1tFN17NfVNL1HOXhny7fx/TJfIcpnHiVdTGOsK3xXav8d3zUl00YkEolEIpFIJBKJRCKRqAclP9qIRCKRSCQSiUQikUgkEvWgFkyPevfHrleFLFJ6ChmkIqfceHqUqVSKxWUOtoonILBMRBj2j9Kg6GR4A82ET/I30aD4tGpOCWbqzT/aP9JnA3mK75E/+2D8mTzFp2fryPhHfwc0EX1Mp2934x+h7wTxvzvyPTBtiksOam0iYbSJHlXF9fFptP+vz+vNk/aV6tCj3nb+tSqTRn/7ixjXpEulE2mmYzDFDO3xoeyuRafuW+wfH2sOlWmwv+lZcVmHiQDGMtGjTGsF+0TaV/GxZqJHmcQ+Jmobz0emcnAKeuTEeyY3ESFixdiN+GwTa2xkDdmGdHq/hnKb6jak9xee/ET4Z5HCOr38MFynScCEDj6Bn6lPJhKfSRzHXOZjokdN16P0qDGi1LzxWb0Zmw+GHsVlgyYxRZH3RNP4m+hRLH7uFs1PE5moG0JKpNSiC2KLyb8bMd2My6xY/Hc5Hm0DMedB1RUYCB0R6iKRpDwrvmq9GxqUiVTFPibaDoupl22yTfSoKaZHzURpR71KqFmzaUtw+ifup0fh+mAec4DpUYUkYpPLr02xxgRAjrsoZY9ih4ilXP4WedZM5aP52Y0/+9g+bJ5vJn8m77A//61ILBtIcyZ/U/mk6X6tyL7JFLn4tcXUf1PscPum8TH1xzQ+0bXlwP7asPa2bOyD/G5Q8zGJucx8vILSs7HZaGy+/hm9GZvrDtoSnPuFDj2qj+hRg+l4ehQfmcCloJExpDnvtmp0Pf77Kc8N38a4ZXbehut7UK7VmkYf9lwLHyZGpfuwTg4/6XD0YcXq0G4SHclEROLriRmULetdKM3zplG206S+JYdQ2mkPofRVFekIgiKuL5hgRdfdMvVtEqVDfgUlYNZSHM3BClKYt60C+hx5RhQ7nhO/15ueaYQeZXgXMq1dpncSjuVu6FFTdRzdsD896sSnWkKPEolEIpFIJBKJRCKRSCRaLJIfbUQikUgkEolEIpFIJBKJelALokfZtlLFnFYeZRKtLpZDe6IGAssKB6n4Yz7ICCUH/kyyGGyD5jDpwD+liXYUIC2QSQ1lF6cxc8o3p2jmW0TTcHG6Naf3O5SemmnitGc+yb/mI70tbVVj/Zm+0aRUqCSl1Jr8WwFSqhIap8cz3WPeLYU2p0dyCm6uVf67/edcnJLNqbw8toUmyEEzCYz//uJnUGzSM0sg/c70zEpNpNMxpYP7zQSv/iZS8SZcEHEyGimVswHNuQTSB3e1cQ+L5YR9lm0r1V+yVb2Bzq8fwsn5u2aQarguj3HaVcV9L8uAGLK3hhhZnoT/7gZiczBJVC4iBC2zEft7fTwHJg2V25jzSxRoZaMB/As2+j/nIY1wwAMNbcrGPEpSvDQCxF3Jw1ydtnG/XFrCJQAm8g6L52naJ2KdhX5yH3gOMiXqmxejP68+GWsgU6VeczJScH90Ntpv//zHoZ19Asqd/uefLwvtZ33/7aF905PPDO0n7wU96vjLHhXanz8VsXjj3MGh/eg8Tv7P1vDcp9Lxqa0sjuOpBO7LVXSSP41/n4v293iIe3+/k/b9RRCnjq1UX77T0baH/q8tEXmtWgrtlcFWXFcY2z5Nc5JIW0MNkG4mUkirNlEU+2qYY9NpEEa4fJgrAgs1PLvZNKVMG8oE0rSvMdGmbuPdIOPBx0RgKVNc97cR720qzeMYHFVYN3g92dbAmPQlMCb/+k6kr3/jYvytl52CufeT98P/ZZ8CCeKKl/4utJ9DVI6r3wRK1JGfRez8+AysYzdmnh7ah2hQPBoOxifRxjuPS3Y1WQptpslweVe2gf7PpSilnMtAeE+uYD5MZTFWKR/rVcUiMpHCHr4rwPz0uyiH7DU5tlKDpc56V2tgfDYWsN4y5XNdDXSVXVnQTJbX7g7tvWnQi5ZN4fnu6cc8GZpHCcNEbiS0l4yh/bFh+PfNgnY0XUAZxdA45tvEEOZbcQ7770wez2hg7y2hPbUE/oU5xMtsHnHUNw4ay9QQ7jdHhJTZHNaQ/lHElKn9SH/G4D85fGB/bn96CahJ+Xnsp3M5PK++UexZ3B9T/we66D+PT/84aG4L7X834zM4huc7viR+PowXQL1Z2sJ1pt15XMa+CPZMpZSyrUCVMu2/uT5s4VnPK7xD8pyvZLGe+7RfJKk8iulLPzob9tFnunSdqFLvw3vRz95L313S2FsTu7aF9o5f/3doP+VTbwztsUcehc/eBcLU6Xe9PLTPHvxtaH/sjmeE9tsO/X1sf645EevVi68Bienr6z4Z2hcMXxrab/ndS0P79bPAhTJV6gN/+Cf054noz/NN9CjD9SMvwXr183fhHa95L9pMrAdBsl5CPFpttFNPo3Qr2cD7w88qoG49rf8voZ2p4v2qmcL+xaWFDpGkUvPY16p5rCE6cmYEzEIZz7rcB6Jcimhl8yl8hxogWuVOB/77v9N2I8m0EYlEIpFIJBKJRCKRSCTqQcmPNiKRSCQSiUQikUgkEolEPSj50UYkEolEIpFIJBKJRCKRqAe1IOT3mk1bgvd+8gaVz9BZMWlCfhM+uJ/QbIzzbgeM2UI7jDflM058w+9KfP4M47l9ap/FOEWWCWfGSMSovwExbUBtRjBtpAhO9P9h+yZ/E9rYN/THMvSHzwj6m88YsGqe4Wglfq4R/yAewWi6h1ZAiGKaH3UP5wLUGF9awfXRafi/9ajexCMq1UF+v/3C61Q6hfEo5WGnkxj7vgzVctp0rosByc3Ib8ZhM8Kbxz5htw/oz4htJ4LwJlS7Af+eIJSqsX1GlxrmkQlBzmfdmND0LBPmm8XIb9fDOR6MVe0Gk52p48yKVBl1sprOBuE6XJ8wiFwj3Mqj3radxDk51XT8GT4mbCJjDb0I8pufnR97nc+x4bhs+ojFOuG/p2rE5VWLA/l9/56plIrsm4UM5kzWxXzuS+EcFZ7nviEWGCscweya/OkcIRNml2VCeHfjb9ojTCjbqA/FnQmZ3QUKnPvJ5+GwOAa5zr24E2eMqCbOo/PHccYO47y1TfvSKpxtEiRQR18toGafP2vCf3PcmdDALNN4eoZ7N6HVeazatH826cw93j8nazjrb285il7tVazwyKYtwfs+1YnNdBLzbSBHZxsmMJ/7kzivgM9PM73zRGKN1kB+3+G1MeFjjvFzNGHrHR/tc2yakO6MQmYEdttG+/y+x2clsXhu8Jzh2In0n9qPnoVFZxkaENgs3jd5fYi0TzFleoc3rQN8v9wfU/+5fR7/B9N+FBEe3/8mI7817ZUBYYUpNser2N9HZxYH8nv9wVuCD3/pOqWUUn0Z3h/jkd8FD2e+8TlpLE1z0mlTLHjx8zzyWcN3i8Q03sGUR2tveZKcKH7zpdAMCCPeyse/d5mQ36l7cX5LexT70fx9ON/Ga+K+9v6V0ORVXF/7dDqrah3On7HX4UykVh/OeInsxV3sv92800bOW6O4YMx65J3Wjt8HPYojx4ufA1FsOu3dvuE7AsUy78td7Zu0bjc0YrPmI34n6zjLTpDfIpFIJBKJRCKRSCQSiUSLWPKjjUgkEolEIpFIJBKJRCJRD2pByO+EE6jlA21VaSBNaE0BaWmjVUJX+5TmR+UJJasc2jM+/KcasAeS8GF0aVUjzW/rPFK2RnLAwDEOmvHW98wDZ7k+h1QxTkHktMzrJzaE9mMHgXT0I6lcSNm6ZRbp0I8o3AsfQ1rdDZNof8sA2udUW8aw3jSD9g8rxrfPqWg3TqH9Rw/An8WpbreXkRp3UBHoQB4fTsW8ZWYktA8pAn/mBNFUQ/7MvRU8g7U5IPo4LbipkTp23zzwhyNZYBGTAdIi6xpp2RNNYOEGEuXQzgewywplIRmH2vG4VGMR4ksdpQb7LFWjrMCNw0Bs75xBGl5fEimm8y2M97IUMHl76sDFFlzybyPNb0kSmLzRBtDVXLLEZVD9NtaKyTaeg23wZ8zxdID00ZkW1oGii/Uho2BXFO53vg0sY87BvWQV4fkUsIDjDfytoST6kAgwTzndcaoF/34X/hy/XP7zyncCOfq1SzHHTzxp1wGvMwr8q1uBZXz9SiAmk+OIR5VAP7eOPDO0h6tbQ/u4M7CGfPVi+N9cHgntR5Tg/5cpIAsPG6DYp/RvjuM9dSAyl6aQNpz1gW6c1YR0pFJZLo9ajMjvhBOoFYOdNXS+jjmwroA5MFrr+5vPKRVdz/t8xFrZQmwyVj6lMT8LLYzzrItY293A/FmexL6ZbFfRpoM1dUcLqOtVLvDiXKrA+Om/ziPdem0R95gOEHf8t66vATf/+NSNob3LxRxb0QIiuZIohXaG8OIvPwux9s1zMGcY4f29jyDGjz8Vn/3mxVi7XvJurCFXH4998GW/OT60P5f7YGifs/RTof2hyimh/Wn73aF9aho+l40fF9qv2nB9aN8WAHu6SQG1fI+PNPURC+PAJV2chn17De8Jm9LY97mUpmXhee1uY51Z5mI+ZJvYO2ZczLeEpthUaOfvQZc+3HJspYaKnXlTa+K9bnMBz31nHfEy4KEMYc5BzC6dx/vbniyeV7GJmJ1LIgaXzOD5jhY3hTaXL3FMDZTxHCf68F6XoBKPlgP/vjLmyXQJccSp+/zin5/F+/BMcbWKE69FRcLdTvdRGSCXctBnCzNYN8qlEfSB+s/v3kUDTpfLiPi9NE/tz5TWhHak1ILKIkzts4+m+y2Ut8f6m8pLuX3uz0Lb51JTvneeD6N9WG+LAd496gplmC2Py9LVolDC9tTKYmctrrcxb5cFmKvlAOvSuEacLrXg47bxju/THHvxuXg/ueK9GBRGgV/1QVw/mq7/1/l4Fs+/FM+XUdfb1z0vtFfPoszWqWHfaWawhnz6rqeF9r9u+AX+LiHIrzoH8+2obz4htK980rdDuzpeDu3C6iWhvfuiX4X2oZ94YWi/fhz71PcfdVVoP/vjmIc/ORNjGEF7n1WPvc6odFP/j/kAYiEyznSdx/mFp2Nsv38h3lH/d/bRof2Uwp9C+077EaG90bsltHnNabn4XrDNxbq9xrsrtN0W3lvqSfxGUU5gbIstfG/KEWp8Oo/vu2kf7xU1hbHy/IXnzUimjUgkEolEIpFIJBKJRCJRD0p+tBGJRCKRSCQSiUQikUgk6kEtmB71no/foIq5eHpU0kE6YiGJlKqUjdQm02nSTMow0V4iJ7dT6QHTW5jSwuJSJlPJkqlv3fhzqqSpZMl0SvaD6Q/7RNMvD/xcuyEvRftP/l3OG6aYmOhR3G7QRWlShLTRxe+OXJrC5We1NtLUuDxqqorr4zPwf/ORvXnSvlKgR2XSTI/Cv0+6eF7FNFKLkw7Riwxjz/Qom2wTDcrkzz48r5geZUfIcfH+LtGdrAiZKN6ffXh9MPWH1x/TnGVx7DDxzDSekf4YYpmvm9aKha4hUcJFPJGES0pNVD4m8Zli138Aihx86NR9IsIx+aLp43q5hrhUKkrCeMMzezM2mR5VyGL8SxmMYYpiMLJvWihBMu0FTI/qJhYc3me7ICTyvsa2ad/hMgfeI7g8J0JPYwKLgXz0oLRAQlPfrr/i+h6k2de2ouShTTWomtp30pT23MD95h6DEjB/COVIlT6UnrGY9MRjy7HG19k2UikNz8skfo5Ma6wT+aLhYw2ZrpvpUa99em/GJtOjsinM1f4cYoSJqEUqK47EpmGdZwohl+3zusdzkn24NCY6B5ju1CT/+DL/yL5GJXVMj+JYMNGLTHSniL+h/Uh/DGuLqf+m/phKk/xI+/GUOlP7kbVugePzj+iPaX/nvbulYdcCxGCDyoonaigDGZtZHLHJ9Kj+LOZ5KYnSWo5BPgLBREljUptNpDMTOagbkm/ke6WBJmaS6VmbvifydRM9auYOlEZqC/6zO1Eu3aphbVn2GJQ3ZtZgb9JrUS7ULqB8mNUNScr03hLwnOe9mGONKXL8fdNAfeLPaj/++3h0LeXvywemMy903+Q4rWnEIO+bTI8anYnSo171FKFHiUQikUgkEolEIpFIJBItGsmPNiKRSCQSiUQikUgkEolEPagF0aMsS6lcRqm2h/SklYVyaE9Ukeqz3AbtZ9THSeYlB1SCio90vv42UrymHdBGOP2bS1vyLZyUPueC3sJZaUx74VTSpo3Tp+sBbKbPsFoaaUuTrVJoD7jl0OYSLU4Jm/CQWjZogybA/eE0qrE2TqVe4oDmEEmn1FQyEOAE8qLG2KZadFq1i+dSCUDeyWr4MNGj7iCVqxrAziikB6dbIO9UXJyqzeOplFJpC+2mm/hMNQGSR43mQUqjPCDfxDOeSWAcTSl3pSZoJVMJnCaftDAPqj7uZyCBlMFdNYz7YpTjKNVfshRl5asNQ5gPu2cxB9bkEGs7qxjX5RmMx2gNMbUigVje3UIsDyZAZmFy11KK/b3e8tDuo3gptzFnhgLM8wmN55CzMD/nfczbfg/PedKGP9NzmKpT8GkeWaB4MAmlGSAGC234zzoYB1N5Jq8zLYV2OBZ4Xpe9Ev6WDZrAm07HfX3ufMzf15+8NbQjVKmTMW7fuBhrJtOp+Por3on150uXjqD9k9D+Fy5FuuwHv4R7ec9rsbAmAyINWYhdXp+5VIdJRmUX8y1K+sOa1u9g/Pc08Hz3p7otBhKGbalIOfH9WpPHsxirI3aW+yCJjGo8ayapMemsv45Ym0oh1lL8jIh0VqxSKnUmfs3jNP4MUYSqCcQs08F4/n/2aqwPr34W1vt/fedtoc20ppeeivZ/8n7E+/PPxT3+/E03h/ZzvnBYaP/odHz2eR/E+nDFh9G3S36P0qSTn/Dn0D7+VOxlTJU6kqgZPz9hT2i/ftc7Q/uyw74U2tt+dl1or3wK+nbXSz4c2o+842uh/YXyi0P7hBI+e0PzMaF9RBKp766PdaNGe2bDwjNl+mK6Qe9XKaxd/M7A7xL5OmgXM2nMBybB8Wf7A6wtuwOUdy0Gktv+cmylBgudsWi0iR6VRwzuqGM+j1RBIdmZPSi0V9RAG9mbxvq5bBLUmNEB0MEG51BqN5EHfWZo/NbQHhs6NLT7Z4nWVADdaWAMMTU1RBShOdAGZ/K0hoyDWjU5fHBoF+awhszmsYaUxu7A312C+y3MIy4eTPt9o7eHdnkY/c/PY1+bzdF3B+rP1JKDY/3ncktj/bn/7B/pP/Wnq/a5/9R+rjJ6QP+ppZgPkful8ekfR/8nhuFfmgUta6KE+ba0gXmyzUZ5y2Iku1k6ULlkJza5/0sUzSWF9Y3n/HwO6xgT05i2druDfeGg1p9D+5xfgUZ05lP/GNovOAN9u/wCfId48WnYR350Nnyef2aCrsfTlK48F2vOse/zD+jPdKpnfxn7xTUngkLobMM45DdhL/vTJ0FmfNbX34g+rAbx8Nj5r4b2UZ8Cpe6H78GectZ1TwntM5/wu9B+w1fWh/YXX3tPbP8j9CiicV15bmiq407HvV9+AcbwV3O436eUsD/OJhFf/TUiEjfxLtFIYt9sE5WPyxtT83gfq+bRpkm5WVpjiRCXJNpUK4X3kMEG/Hc4GKvIkQJd7qGSaSMSiUQikUgkEolEIpFI1IOSH21EIpFIJBKJRCKRSCQSiXpQC6ZHvfeTN6h8Jp4elXb5pH2k9boWUp5YtkZKWDcUjAg5xUBs4bRePnnbpG5ITCaCg4mOwTKdQN4N5aGbfnZzwjn7PBhClulUc9YDnbBtuuduxpflLayqL1J6wSQpPsW74SGNb7KK1PPRMj77pmf35kn7Sim1asOW4OSPXq8yKYwfl2UwPaqQQowkbKQIMg2KKUtJm8luRDHw4+ce06MsinFT+wkrPvb5WbGYysHtcPss7kPkJHlDf7j0qRu6k2Wi3VHqI7dvRegDB6YGmIhR3cQj+3CZAxNMuG9MimGxv0tlZRyjJiqKjqzn1B8qp+omLqdr0dLLxUCPGtm8JfjApzuEmnwG45BPYQ6nXdjFBNJrmahomnuRfdNA++LxdwLaH7uY20yxMVEYupl7JopNnkonEnvuRfuTSFfmOjidIPrJ0pWwmXaURqlULYfywG6UqqKUz51GmYO/cyvsOqgljQmUraXXUH9YI5vQtwxSteuZgThvI/EqQnTqgsjD4tjvhk7C/rzfctkpx+kUEWr2lKMUjF4l1KzdvCU487P306MwDqU05jzHZsGl2LSwBvI+wntNUhHFxlDezu87/O5q8ucYTLTxjs2p/i0H4x+JOwPdhucSy/Hi1/m2jefO/bcMxBYuUYmsXW2isNEaxccFmOZ2lGaF9lmRtauL/ptpWfHtR8eHnhe3byDMsrh903iyWlTiwWPF5dgNKvcer2LNGd2PHvWap/VmbDI9qi+D59iXQgxmbDpKwUOpPtMJWRFaWRf0KNN1k7rZB5myFJl71B/VxfdWVqKMfUo1sOaoGYyJsgykp75B/FkH87BVwHWTAgOt2EiMMnxX5f74tmGf4mehF/b9lxWJZROFivtj2GdN+yavdRybXKLe8BG/43WOTaFHiUQikUgkEolEIpFIJBItWsmPNiKRSCQSiUQikUgkEolEPagF1ZkknECtGmypmRo+NlJEOvFYDXQJ21AywBSMWVUK7ckG7KEkpRz7OAW6biEFd1uFTmVPgpTBpRZ9CmSEP83gdPojCjilv2ojPSntgXbxP7twevzTV+JU/O/9Badqv+jwraF99Xb4P3c12m9qpEi5AVLgrrwbp8EfvRHtMxkkr3Bq98+2ov/PXQNqQF2D3pIMkC74+3GcZv/EYbTPJCw3QBrhb/cihftJS++K9Wfay62zOJn8kMJ9ob1/mRWnyv1hDCfaP2H4rtjPcKrx1ipO0h/JUho90TI47WyyWQrtgUQ5tLM+CD2zGqSWJKU4cxlGEMSn9/WyXEep5UNKzRAAbf0A7nvXLEoGhtOYV9NNXF+eRknCnjrSI3MO5lW1jfEeTiK+xhrwT9pEZfIxrgMO1orJNkoD2lTK4dDQF3Q5tJmSVvWI+EYpsjmF++U4alEfuFQzq4hmpjAOTMIaSmAtYkoO03NGG6DhDCcwJlzqxfP6p3dhDTlq492hfcH3MCanvwSUlle/C/bXP4pyj1cRPeqyS5bGXv/qpSjZeM1JO0P7i5cift94MqgTX7wYdJKt82hzdQ59uGsWbW4soE2XSkQ5Lkcb6PNwEnMg42P8u4nLxUiPSjqBWjPUmTdTFewFJnoUlwzz2tnnwb9sI9aYwMi0tVwLqdHzLtpnOuGwg7TqhEdz28bcvqOBubo5iblqSj9+xan4u9+9ADF1/KmITaZHHX0O+v/zE+DzymtPCO1PJc8M7Q8MfiK0P+F9JrSfe/nTQ/vH70EfXvQe3Ne3Por4OuFdmIdMm5roxz44SGnPOz799dBefdo7Qrv+zctCO3HUcaH9/mufhj73/Sm0mRLy/QvxHnX1+BGh/ZwhUEt+N3d4aD+uhPcKk26p4T3h4AyeF5ek8Z6+uw16zjIX6wbTIZnOycS9BpHyTKWyvSzXCdTK/s47ULmGdWZjFuvhribeQYY9EEDKFlEX5/F+tTePeMk1sHcweW2wjOcy3od3Iia11V3EzsA0/Kf6QB7xrfjyhEIZ9Csmm3D5D5dEsf9sCet/tPSAaIBljM9M38gB2y9N3xfrz2VcXCrFZJa5IghlppIE7s8s3S+LS1FM/qY1zeRv7P/Mzlj/wFDmbBpPLufhctS+MsZzvB/xXvLw7jFqYd4y7XexKGF7ak2pswbNNLA+LwswtuUA+yBTQft97GtJoui2HLyTbEuAzrauCSrcV+97cmi/bvWvQvsFZ2L8f3gW3iGP+QCu/+hsPNMINemDeO7czg8+hOfy/DOwljIlqhsK1VXn4H3srN88LrTPedJv0WbjOWgzdU1o6zb+ludifN78dVDJPvsamv9ZvBMWiSL33cmnh/bxA78M7fkMnlG2hj33Ruvxof0Y/9rQbrr4js8EqD8GuK8jFKiLHNesu1yQHDe0sW9yGVqb5sPOJO53RWtraCcb2AdrqVJoTxOduNjGffE9lnPYW/l3jIbCuuHRvin0KJFIJBKJRCKRSCQSiUSiRSz50UYkEolEIpFIJBKJRCKRqAe1YHrUez5+g8pn8ZlSFil8KSeeHsXp7kwq4ZROJsIwvSVCLyK7FSA9jEuxUoqoVZTyHSWwLCyvPtDxfeCURdPJ8KwHIivF/90D02FM/qxuSE8melSkfcOp4A8k0z2baVgHpkexD9NuTPdgotTU6RRvLsMo16j0ZREQapTq0KPeceF1KpvBHCjl4+lR+STRo5wDz1umQTlMgyIfLilzLPwbjs3Ic474U+xzeQj5+PRZl9YKy+AfoTYY6FGsCGWD1h8rshYZ4otGgte3SPvUNy6bMpGhTOrmlP7I3zUQfEz0qMhnI+PJhBSmeMTTo3x14LVlofSocj1Kj9pb7v3YHNm0JXjfpzqEmmKWUuLT8fSoQgKlvkkqRTEpsm+SbSrxjMztLvYsE7GFFaVNxRNYIkQG2hP6b/5vXJ9DedTUDTeHtpOmMoQs1mYnh1Tq5MEoT1Z1vAO0V6CcxJlC+Y9qE9GSyBF+P9KevRTaN927XUPac3UQpRCWh/ZrKZSndTOepj2Ty2FM7yGm9cREwzSJfdoKccb0KC59na6b6VG9SqgZ2bwlOGNfbBaI7NafxbNLOZjPORexmbLiCTUspuwxGSpCyzRQ1WyTP8URE0s57qLPmulLPtnxpTcmepHJn+ekiR5lap/7zJ/thoxmmtsmf26f+2x6hzf5m2hQpvFhWo2pfb7fSMlbEB/LTL9iQk0tQKkp06Mma/nQ3rsfPerEp8YTah5urT94S3D+F/+WHtWfBj0qbeH7XS5AaSGX+kYonDSeloHUZqq5jpC8Fkh3Ming2KH9wujfxffBbr7HmcTUs8jfjfST1hlD7EfGx0DL6kb8d4218Dp+HzS2GelPPGGTZYpl0/ibYrOumB6F69N1lMHumcG7jVJCjxKJRCKRSCQSiUQikUgkWlSSH21EIpFIJBKJRCKRSCQSiXpQC6JH2ZZS+WygfB8pSSvzIDVM1pGGt0zjlO8JBWJFViN1uUkpfKUW6Bgz7mCsT91D2u3KYGtobw1w8vMl/4k0swv+FelGJ56EE+k/cTFODn/7KSAxffXiZaH9nk8jFeqityAl7+46qCubiKZRdyhVu4002nGNdOuhAOnZZ3wD9IEzT8QJ1fdWcRL4+jRO9W9ZuBemUO1uoc/LXZzmzeKUsNE2+rPUBpGJ0+o8jWkxHYAcMaDwjFicNjYf5CP/Lk9pi9yPFpEn6j7uLUlpx0yXaVicXgZ/plkUmjg9v5wAsYapV1zC0W+D7rCbxsX/O8rAHm7ZtlKloqUaVFGxluhRe4geNZLDPNxVwzgtSxN9oI7nzvNqTwvjxIQuJndx7O8NcIJ60SGKl4d5wnExpjCfcxbijik5/W3QAaYcrC2uxnNuU9mcaW2J0J1oXuRbmBdMTuE2+W+lPPSzbmMd4HTltMaa4PqY4y0La1qZYq1oIW5MqddTHvx5LrM/J5WWvVJol+xyaDt8oj6ldFZ8zJmsjTKQNBEZqg6eI8e0o5BGy+NZdrHucakOl0px3/Z6mJ/706MWgyxLqXym8xSY4rEqB8rARANkmeVtkBrGXcQOkwSrGs+lr47YLKcQm0wGbGusz/kaYmE+BeIGE4WSPpVotWA3XMxnpn2VfKwbZ/4XSoTOOQ6UE6ZHff9C9P+5l4Ei8dMX/U9of+uZ3w7t11z/utD+w7n/G9pPOudZoV2/mcqpcujn5M9AABl+Ov7WMVfisz946uWh/bwvPTq0f/ZuENOe82GsG5dfgBj/7hSyl1+QxLvE0I4bQntmNda0CQ/zf4XCs75y++Gh/fy1oF0k2nhf8uh1rWJjzjCZIt2geZIshXbT8P7A86GcQT+5VIfnT59PhMEA7yr+IoxNx1JqIN9Zg+otrP/rsztCe3cDMbV27i+4XkQ53tJ5vAeO5fAuumQcVJqxQdBC+2fx3KcLoDUNjWIOTwzDvziHd9fZPKhAfeOgVk0NgSKUq2DezmexfpZGbw/t8hLQRbPkXyH/4hjanxkGVS1TnViQf66C/Xo+i/26MAaCaDf9Yf/ZYaJuUX+qRKspjN4B/yWbF+Q/10X7ee4PtZ+uTsb6m/qTrdKaTOPDz2t6KeYbz4epAtbbJfWtob09ifFfjLFpW0FYpsjl28Ma74pzRB8uzeGdk8dQ0fsSv+c4RPvyHCpXoTWwv4pxbhMpjAlE2zKI05EK4r2Swd6areD53pbCfnFwHXvEd6aeHdov6wfd6TWfBz3tK2/BXn80UauYTnX0+/GsTRQq0/Urz0Obx77Xo+uhqX44+/TQPqaIvbVF5CmnjfK03VnMw+UVrA+m0qeJLObzYBXff7l8zHOxl82liHJbR9wlGnjfaKTxrtIkYhTPh/Q8rWl5zAFTGRQT7pjQl2riOyu/Xw008Ox2OvgNoS30KJFIJBKJRCKRSCQSiUSi/xuSH21EIpFIJBKJRCKRSCQSiXpQC6ZHvfeTN6gC0aOKRMHIJGCXkkjZTej4k7E57S2h40/jr/tIZ+KT2020KS6F4ZR7LmGYs5Eutfaeq0PbzxZC25ovh3arH+lSnoPUrEoWqc4mdUNAMtEEIu10Qb3phkRjosl0c+q4iQbSLVXKRLAwnSrOtAMTYYopKSYKDhOmeE7wKd51j1Ika0ivXwyEGqU69KiTP3q9yqQwHsUcxiPlYixLaaQFJmwqUWHCET2SKN0piPenvrg2YjBCkQjifyN2qX32bxNRyKLrrkUn/xtKnFhcqsOKEJSYgENrC8evaZ5GKA8RakZ8f5iawTLR30yUH9Np+Sb/aAwdmETQDfkt6k9rgiEu+TqXe3DpWZPIgEyP4rhUanHE5sjmLcEHPt1Jg84ToYb3zZRDdIwk0mu59NM0Vx3NFAwmqvDzJX8izkTK6BY491jcvm2ichiU34VSIE6Tbt6MUhS/FR8vbn8Jf7dEKdA7UN7SLFO68m6kQPttunfKSx4+AmUa7iqUrrRWbgjtei5+3zdRbEyEGtMeGCEK0VoRbdNEsjPFZvw7holGx2WSHKdcrs775xRTMBYRPerMz3RiM5dG7DCtJuMiXkouxybeV02kPC5RND13FlNv2L9N5ecsJlLxGu6Z/KkcgGkpJn+OZY5NE2Vmof5R2hTRkax4f167NNOXjO3Hk+x8w/0yUSiyjzPNiimKfvz3Gm4/SuOK7w/3n2PcNrTPJR48Vg1NRwgQ5W2shlLK0ZlobJoINQ+3Nhy8Jbjoq9cqpZTqzxAlyoWdtmEXPJRgu+3475I8x7jEKUIm4nc8pk2Z6E6mdfghesdb6He0bmR6D+SSJY4v0z2ytGGfMn7WQJhiIlWkfdP3WSt+zzWSKw2xrA3jH4lNAzkucuyHjfiKxKbC7wZN2jfH6/jNYf9900R2k0wbkUgkEolEIpFIJBKJRKIelPxoIxKJRCKRSCQSiUQikUjUg1oQPSrhBGr5QDty0v7qAlEw6kjDq7WR6uO6SJ3KKqSY1hQoDHeUcUr2piJOAr9uB0qTDl4GMsIpp/45tL98KdKYmRL1vY8g9ehlp6M86qsfoZQnF7Y1jVPrT7vn1aH9oSf+OrSPoVO7v3MR0tVedgooWt/+KKgu7/k6Uqk//GqcIn7ZTSBYveownDr+lo+g/f84DfY7P4GUy0v+DWmBZYUTqksKz+KrN+K0+dccgVPrxwOcrN5vwf/P0+tD+9F9REPw4M9UoO/cgvZffgj6/0D63G/xN/75n7aG9qtPwsna/Czf9TF89qPv4NIvKqFRGJet8yA9jGRBxkoGIHBUFGg3LpXB1Il8sxgpNY6t1GBJqwZlcW4YRLzsmsV996VQulhpIaV2WYroUQ06ld3B+NU8pPkNu/Afa8GfxSmFfTZihMlHHpVN2ZrS1DVSXpliNkW0nf4k7jEdIMZrGmvLWAMxMpzEnOd5wanFd85gLdpYwJyPlJ/Q791bqyB6rM3sivXnsrwbp1Bq8eiBe0Ob57JNJV1/nUHcHFaEP7fJZWK/G8WJ/U9Yes8B279lFsSTQ4tbVZz4fm+jtfqQPjrhn+6X/9aOCgggKzNYY1MByETzCmt1JC6pHKPtR+NyAZW9D5tcO1DL+jpBWWvhea3OYRzG6lTa42PcHJsIXB5iZ94uhfash3Fj4limCXpCNQGfe+ojob0+tTW0TanXdzUxVzcmsC9w6i+XLbzk3VhbmBLF15m+9OyPg6Tws/fiHk9tfiC0P3bQ10P7M9a/h/a/JL8Y2hNX/Sy0C2sRj/ZLXhPa7hc/Fdq/OP5bof20bx4f2i/6wytC+6rNfw7t530Q93LFBQr+p2EN4ft6ybsx/t+5CM+XKVrf+ijWpdtqoNUcnAaV5vr5w0J7Sx77bLQME/Pq5gqe1yMyoHVEy23w7HYRfXKZCzJLuoX3NCboOZE9k1LBfS5ZVotCrh2oJcVObDbaWN82ZraG9q4W0ZraRGVy8UyXzGCcR4tYe7PNcmjXXOy/A2Ws4ZMlrL2REh56psUZrLEzxdWx/qxCGXSqmb6R0G4RAYdLSLKzeFeaL4BYZ4rx3Az2xLki9oKGg/JVJqia/LkUwqJbyc+gvHGWyCx1FzGYIoJhpP9FEM1aVEaUaOHdIDOH981KAc+3ksI8z9bx7pGeA/2qSmSZegLPlKkx3D73p0brcJrWZ2P/bbxrcWlboYz5MNWPeGdKY8OhIx3+DkLNwy3X9tSKQmdMmx6+pi7zMTemLbxXjCo8x+UWxsdl+h7N55usx4T2Yf6N8KFyGC6h+uHcM0ObqUnzGXy/yxP17Cd10AmPSv8C/kRDyxGV7N+vAIXqYy9CyfDp16CfFzzr+tBm6tOPzsZL/9Fnuge8ftU52AtecBau/+BDWMNfeQnWt2++A/1k2l0fEbuYfvXSwV+GNlO0MjXMz9/6Tw3tJ1u/DW2P1iguJ/yj97jQfoz9x9A2lXptc/H9dE0b67PTonf+JJUm2SOhzQTPJFGoqmmsD2Ubz51L83JEgpvOIZYj3024VKpNR4b43X3vlEwbkUgkEolEIpFIJBKJRKIelPxoIxKJRCKRSCQSiUQikUjUg1owPer0T9wQodKUMkzBgF1MIj0yafGp9VTmQlQRJrxw6j6fvt4mqgiXA/Ap/az+mfvQfgWp414aaZbNn/xXaLfm0GevidSygWchlSvIl0J7ejlSl7mf2SpKMJzGHPngNzLPRepmNTNIPvEUiW7EKbUmKoSJasGptpxKzXaUTvXg8ixN92kiK5jIU0y24NPhWezjEZGo7iMVr+nDp1zHs9lbRhri65/RmxQMpTr0qJMuul7lMvH0qKSDscmn4mPWlDrrWkRnozxmJgHxyDtU4mTTZ9k/QkjRHtmm9mFz+Qx/1hQvTJczxgX3h9YfE5EsiJCz4ucdi8uL2L8bKlw3FB4ToSbS5gLJcZG45JP2dfw6wD5BF/89gP2ZHhWJSy8+LpVaPPSoMz7VIdQUs/H0qCTFYF+CqIu0b5rEtESe5ybanrNAuhPvC93QK2wDISXaJtPW4n1S80gzZpIF0yJ8SqVOTqPEQE2gzKd6F8oDq6Mov+IansAnst7BKFdxV6GUo7WC6FGU8q0i+1g8BcMjYoVp34zSbXhfXhh9shtqpGmPZXmayG5U6miiR03XURq2GOlRTHbryyDuUlSiWKTYTBI9yrTvuArtcHmRieTFPhxHPB9MZDETnYo/G/GnmOqmfR2hpcS3b3qHNL27md4zmWbF/hEyXYRWY7hfL56UF6W2cf/j+9ONf4RWE4l9Kkk20LUWOp5ctsa0mppF32soTidqKAPZO4vSDKWUeuU/9S496sKvXKeUUmogi+Mg8i7KW/h7ZT4ohzZT2CL7V4Ry2Iz1MYn3oK6++3TRZoSs1I0/f7QL/24IoV3Ro0ztd7FPsUxzu6v+dEE4NZG5ou0b9mUDednvyp+O66B45zitBSgd5X1zsoaY3TvT3b4pmTYikUgkEolEIpFIJBKJRD0o+dFGJBKJRCKRSCQSiUQikagHtSB6lKWVyqSUarWRQrkiR0SYBk5TH9I4cX06QPlP0kJaKafHp3ycrtywkAb/r2eWQ/s/P4DUvle+Eyd1f+VjSGN+7TtwuvjP34lTr3UDaXXWBE53v/sV54X2hh+fH9onzb4ntP9DfSe0Lx0/IbRfswKnfNdspDn1zYDy8PJvPCq0v/PyG0L7xO89PrS/9jrQIn5hHRXaRxTQfstC6hSn0d5eB3Vic5pSwS08i7SPtF4m1zxyEKdkv+6dGJOvfRTEKB7nb16ME7NfcwbKvn5wWjm0j/kQ0qSVUuqnJyNt/bkfxYn23/sw0sV+vPeI0H7OipvQ7zranc2gT/UA84NpFrkWSuCYeMHlLm2a8kwz2kOULH8RkjBsW6liXqs2blWt68fJ57vnMD/XZFE+sKuG0+yXplHWx0Sb5S7mxmgbhK4+txzak61SaC+xyN/HMy866M+sRzQNhVKIyQBzLGdh3s77FF8endBOp7i7GunHXG6T9TEvKjbIU6YSoSzNI6aEcMpxUiMF1w5oflF6ZN3HPE1ZWH8SRDRo2vCZ9ZHGXLAwVqa0z7JfCu2SLsf2h9cNU/uctm1K6eT7TRO5o+rgObaIwMalOoUW5tWMi73AVFYWics24nJ/epS3sIzih0WWViqb6swtj/q/Koc5PF4vhfaSNvavCRdEDKYuMums2EA7sykaW04npjUs0yiHdjWJv8u0tayPucHieJm2EHf9PvYIpjR+9zz000SVevG7EQtXXAB/pjWZKFRMh2Q6xjVvw/44ccv/hPbSxx4U2tdecE1oP+6UZ4T2WfZZoX3Okp+jP+dgfK74cGiqP7ewvx/u/iW0X3Y64uWbF2DN+UsVVItHZm8P7Z0BKFqrfJR1c0o5a87GupTzyqGdJEoO02qaFt6d3IBIQHXE5mwae0FkTdMY25KPd6o9AegYfrD49kzHUqov11mneG3ZkMZ70W6ia62avTm09xQxl5bM471rIjcS2sNj8J8c3BzapVnEeLmAd9f+cVA+J4cxTwpzeIeay2H/LUyBQjXbj7K+LBFM5rNYPwtjeM+cGQblKkMUGy7Vz02g/flBtJ+qT8f656n92SW43zQdFxDxp/Znh/Beyv2pMJ1nHOM8O4z3Xm6/nkZcZCcQR5VBxBcTYRopxGZunO53GMTGRB3+zRRiKtL+EMYnWcf7Q42IM7kx6v8SjH+aqDrdjCc/35k8aF9DVczbnSm0z3TOxRKblg5UJtFZg9pEvxpWeLecVRjb0iyIUXN57JvRkii855hKbmfSiJdSdU+sDx8psjON57KqeltoVzLxlKj7so8I7bUVrA9NIhklmtjj7kofHtoba38O7VlaB/LzeJ+/PY3vUgfVQFniuOD5eSf5byJ/nodMfdqZw7q3ooL1ylT6NJZDXAxVtoZ2YNjXeA/K1zFuTpN+H0iVYLvYl5lYZ4pBk7JEfJslwh1T9tpEFiuWt4b2dAlrC1PhZtNYuwZaeEY7NPx5bnf7PiuZNiKRSCQSiUQikUgkEolEPSj50UYkEolEIpFIJBKJRCKRqAe1IHrU6o1bgtM+foMqUAXMQA4pZ9kk7GIC6UwJKltgWUSKMVEw7C5oFyYyQv800hHdWaRaqTbabN6GUiZFFInaKFIui095Ev5WrhTa9T6k4aWYXrETaZPeLKWa8wnzbTqp/rFPRhcSKEngND+W38Up2SaZTtvuhhKSrWFM0pNIR9Q1PGtVmVMR2ShTCUpIU2vnQeBoJzChqpTKxun4fAo/ky2YDGXp+PnB1DGmRzXpetND6tvUIqZHZdMYs1IezzHlErkmhfT4hE3UBiYiUSVK0qbY1OzPKaNEwbDi6Us+penyHHOoTfbnNlmuRWsCldhECEfUPq8nPEf8ID5FM0KPonZMcWeZTsI3UEW6Wce68je0b4pfEzWmm5P5u2nfUwZ/wzNlKg3PJT5dv+HBZ7KGtVEppcbKiP03Pqs3Y5PpUYUIoQZzOOPCLiWwfnK5n6mUj/dNK0J4iZ9LXFob8e9iLukI8UTHXo+koBv8I+0bSFJBJJYXVgfH5Cl3DPuUmqOSQ3oH0ENINfczSFNnymSEGGWSgei0ULKbSSYKpOlZmAhTprlk2m9N9CimvE3VsId3S8F4uLV285bgzM/GxGYaKfFpF/FSdInsRvQo3kd4rqY8vBcxiYnT7FmOF09ZZWqJ0Z8pfobSAxO9yDe2j3vkPcKj/kfi1EBT8gz3G4mFLvpjGch0Ps1VHn+mR3E5zIPpD8edaTy7ab+b8TERfNoOSh0j5dg2YpCPEJioowRsz8zioEetP3hLcMGX99GjMpiHTCVO2yhBLXgo4eG4YBnpUTzOvE+RP9PWIqQn07r9IGhQkb3AQJhaKD2qm71+obSpbuhXpjIo0z5l8o/U9Zn2Nf6s4XcNUyyb7rcdWeuY6BrvzzQ301EJvG+OV/GOMTYTXQde+3ShR4lEIpFIJBKJRCKRSCQSLRrJjzYikUgkEolEIpFIJBKJRD2oBdGjEo5Sywc8NVdDGtKqAtLSmB7V9tG0ayOtkSkYNYV0vt11nBq9Ig3y1IkGetEr3jkee/1VJ+OU5ssvQJvuVpzsrbLo57Zr/hTa618KikT92LeGdnHbtWj/8seG9tdegdO/p5cdGtp9u7eG9r1X/SG0Vz3lkNA+J39haJ8/8ZXQvrT6L6H9+kejdOtlp+DE/m9/FCVEu/zVob3cApXgk7/Cafz/9rS70f9TUCZ22UU4IZwpUd+4eDj2+s/eiz48/9No/ycv+VVov+3O1yvWhcH7QvvttTND+3MvwJi+gMgc3/4oPnvCu1COxX2yqNyFS6W2V0B6WJlBv1MBUirnFdLfXSJP1Yl8wyd6L5bT9l1HqSUDSs3jVo30qL4U0rwrLaTtLUthbow2mPiGVNKmj5S/AQfPZ6IFfy53alPq+ICF9id9It1QmSSXUBWIiDQblEJ7poV74ZT1TEBUIw0fJmStSGNecGkJk49unVkT2geXqAyQU6bp9+6753Ha/PrczlgfLuO6YRKxc8QgiBVchsAlWn+cAinj0QPw5z67Cs/od3tAvnjiMpSIcvkS9+f2OZxmv7mA+zWVtNxexpqzuYQ1x6F08ZZGCujOKsZ/eRrrdjpA+cCcQgp3gsrf6lS22PYWHz0q4QRq9WDn2ZSrWKuYHjXZKIU2p846tG/m21h75xyQIKY92P029uKEF08ou62KuXdwBvuCSVtbiIW1Ds09opIlPKSpn3Am+vzNc/DsvnHH4aH9qk03hvaLT8McuPyC7IKuMz3q+FOx1l1xAd4HXnQJaCA/+HfMbXsK7xjtPvhc2TomtI/MXo8+7HxcaL9wFSgb518DeshpR2I8Jx2UXA22Qab41t2PCe2Xb/xzaDNVjWlrN1RAGzkiB5pk0yYalI/yAaZTHZYF3YPT4yN7ZguxvCKBEu8UEeKYxMgle3VFqeB/BwXj4ZbrBGp5Xyc25xsYk/WpraG920OJeqmFmK24WK+GZ0D5GS9i7eWSKC5ZKs1gHk4XEV8sTsUvlOE/W8LzMpUYZGfxHOcLoAu1eM4QwTA7syu0K0X4V5JYW5g6l55D7FTzeOdquihfZUJipD9FEMc8Q6kR+1cKGH8mxaSa+B6RIf8q+U9nYfdVaG5X8B5Sy2FvmiHaS7G694D+8ymUTGYbWJ/T83jHqOWxtlQSffH+s/hbtQLWDab7MZUmN4N3jHIf9u5cqxzaDSqhanmL7302YXtqTalzzzMN7F9LA8zVGYXxH9cYtyUaPkmaJy2an3faWFc3KXyP84ie6dC+dk3jqaH97OSvQ7tGJCOm3V5v4ciLx3n/G9omitP/tPHd85nOL+BPdLNkA/fyhe3wf8MafP+ayhONbg7vZhf+5Z9C+5TDfxfa5Rytb/OIkR/Oo/1j8mh/LstULKyHP63A/6gcxqeZwHu428KXkz9q7KeP0dhnuVSQy9Zutx8Z2gf5fw1tLpnkcqSJJO5roIX9l8lctRSexYyL++J1Pktkulki8TGFNuPjueSriP3JLNbqjCaqYxAfm0KPEolEIpFIJBKJRCKRSCRaxJIfbUQikUgkEolEIpFIJBKJelAPKT0qk0CqUiGBVCgur4jQKIgqEiFGUdkKn9IcOa2d1A2RgclHyQpsu0pECUM5AJOOWimkZGd2I/1YNZBK196xLbT9Fu7Fq8GnNob0yP5nIHUtyJdCe3r5YbH9MfWTT9I2nYZtokWYTtLm60P3oaRJNXEvrfuQNl/bi9QypZTym5QiTMSs/mch3TDIYkz5niOnihvIFi0df/I+iwlT7QA2U2qaVM5XXqT0qHdceJ1Kp/G8+gvx9KhCGnGUohIM06nyTINyDKVMPNvYx7bo1Pog/nlGKHI63j/SH1ofmGYVmc9kR+hRiv2tWH8r4s+xQO0zaYt8zPEVf/K8KdZMhJduTvXvxsfUfsTf0H9tOplf8XxgosqBaVMcl3UPZRdMj5quR8kXe6fxmTc9uzdjc2TTluB9++hRxSyeSymDOcz0qGKCCTXxFAyWQ+UqXI5hohF1Q2NkmehRJpkIKd181kSPYnVDoTK1aZKJVMX7TIT2YrhuitMHE5vGPhvoUUZ/w/5pEpdQcdlmI+DYxN44XUfpwWKhR41s3hJ84NOd2MwTPWowi3KzlIN4KbhIcU9ZKP8xUQgTAd6ROO5MtFMmu0VKqyLETx3rw3SbbuhRXHrA1JUI6YzbD7h9J97fQF8KDP2PkOMi5Lt4f2N/mHLI7dM9mvxNhJ2uxsew1nXVvsnfQMAx0aaYVlOzcewDx+lipUd9+EsdelR/FnFRYnqUhfjKB+XQdg3UMxaTxbraB31+drTXmL5ndUHj7Uam72hdfdbi74MH7rORhGVqv4u92EiGMuzX7NPVPmiITZMiVEfD+ET3+vi1jsXPt03ldXx8Qd1H3PH3zokqURfL0X35Dc8UepRIJBKJRCKRSCQSiUQi0aKR/GgjEolEIpFIJBKJRCKRSNSDWhA9yrGV6stH05pW5lHmM93ESdFDGifMl+mUb0755nT6tI+08LqFlKGv/Aanzb/+n3CK/okn4YRwE+3o65fgZPtj34eUpyvPA6khwemLHtJHK304hZtT6T572xND+9/WorRK/QEnfrsr0OfRn+J6aRNIAZ8/4quhfZr6XGgf9QmcBv/N89H8f4/i9OxnLcHp2TfMgVr16CLKtWYsjHnRRznYy98FwghTqE4w0LiY0nXNv1FaXRWpwtrFNJp9AwhRSik18J2PhPZHl10a2mf4nw/tYz4LOs7XzsZnb61tCu1D0neGNp8SzpmHhQbuczqJk76ZxNOmKV+yy6G918Mc8n0ug1GLQratVKloqQZVVKwdwPzcS/SoNRmcps7UtiUpzI3xBubGMgd0g90txNRAohzaUy2k4C6l0/tHA5ziXrBxyvqsh1Te4QD9GVegAGQtpMLWfJSs9bUR42UXc5XLoLj0Jt/Cfc26iAsT3SnTRj+rDvpZpz6kNNLjmdTTcFAmUPEw5lkb65tLVAIm+8z4GMOiBbIAp7VzaQOTg3guu5Rmz8QQbr9gYW5E+m+j/9UA63Ba41mk2oh9Hh9OB3Uo5gpN0DemExyXRBmjuOxzsafsasN/f3rUYohN21aqlPvbdGQTPWpJE8SHiQRiJ6Mwfxoac6ZYxT47m0Ysm8rxmEJSS6AsdV7T3PARL6ayi1GFvjHRo+4Q4YXmyWnfhv8FLwf95Pfzh4f2k7OgMpnoUS95N8bhux9Bn1/67plY/xedhrl9xQXp2Osm/+9fiPvlv8v75l+q2H8flQGh8rYWKE6HurjO6wNTt+4LQB0a0Sg3NqXET9qIi34f6yFTe+ou1h9+p0r6iOVcHXvmTAZrrx3Qnqmx5pQC+O8JQBrygsW3ZzqWUv35zvxuttH/tWnE4J4WxmTVDN679pbwfIfn8Lwm8njHGxzHc58Ygn9xjgg4eYxh3174l5ccFNrZCp5vhegthTFQq2aH8Q6VJuIJ02pyYyAJzg9jvjHFpkG0mtz4vbH+bmM+3p/an6P+JImqE+nPOGhr80MbuvCn/gytC+0EUXWadHxBdmJrrL/bxNrSSiJGMmP3hXbF5J9AHGXGHxp/Jto0kuh/bgzjM7cElLp0DetzK4f3scH5raG9I4P55hnKzHtZthWovkznvceil/xhjXfROVUK7eIsYnYuj72Gy174PcppYZ1su/QOlsG6WiKCGKc38JEiuzOI0xUVfP8azWH+L53B9WttHAvxhDa+GzaIQpVsYI+eKGGeDJURX88/E+9aP/wQ+vaO7+E708eOp+9MDsrl+Pvsziz6v7Jye2j7NtZ8/l68J0v3VUV/TO8JU1l8F+6vYt1z2nS8BsUIE9mYWJfiNS2L7+9cjsRlSiaCXoSiSO+cBZo/M0VQn5Jt7JXVBNa6/mnc+0Q/xjzXIJp2kmLTx1za5o+E9t9DdpNMG5FIJBKJRCKRSCQSiUSiHpT8aCMSiUQikUgkEolEIpFI1INaED3qfhIGUzAK6XgKRimBFEHXiqc+cTpThPCi40/q5tSmyEnsBmKL6W+ZThQ3+UdOd6f2OdU8M4sSD3scaWD+FEoDAqpdCTw6nX7LU2DbSNmap9RHk0yEpW5OLDcRN0xt9k0iXZPvMZhBOUNtG9LMlFIquQTlK5F7fgwRs7q4Z+4Tky349HzTqeXtAKl+HpEeGgGd9E2UmqlFSo86+aPXq0wK913MYTzSCcz5vgxO108QGYppUCzX4thEO+2Ay4vI3yaijWJ/Oq2dyHEu0aAicWf4TZlLLLmsyTfQoBxF1Az6u14QXx0a8e+CBsUUD5bptHkuPWCZSAFGOl4Xa91C2zf5ROhaEdIHk1A41ZPWIhpzvs5UGhPVrd6GPVUz06PefGRvxubazVuCsz/XIdQUMhi3XBJzIE2Emr4Ela1pxKmJxuUG8DESVUhMqLEihKP4ucRpzywTEakbEgerG6pUxL8LGlQ3MtGpIj76wLEQJXYdmPTB49mNfzd0uW7Ij5HYNPwtbpPTzjmNvBkwEQN771QNKe57ylF61Guf3vuxmUvT/phGTKVdxEu/izIiJkMxYYTF5W+RtHx6f+FY5tK2iD+VxEb2NQMlxzfQwRzqD9NwmEbEc8NEa2V/FpddRPy5PwYalImOFGm/bbhfO358Ftw+9Z/XJd+Of76WZ9j3u/Hn/jvx48/PiMetTSXPLSp74dJULuWeaDA9CteVUuoVT+5NetTGQ44ILv5ah1bL8ZhxMIfTNuyCh7IUl+aJiVbGsRCpSzGsyZHvjCZSoYGWqCPz0EChWqAi+/WD2BeMxKguCFOBgdTGPiaSnXFf64LUxjKR7Exj246sdQd+h+ejOEz94f43KTb5e2eN6FF1L54eNVaOrhtvfJbQo0QikUgkEolEIpFIJBKJFo3kRxuRSCQSiUQikUgkEolEoh7UguhRrhOoFf0tVW0hTWhVDqc6cxpe3aPTqqncKatw0ntNIzVooolT4ocSaPOuOZw+vSmP0ptXn4xyJKYdMT3qa5fi1GimTX3rozih+oR3TcZeZ8qSqf3LLgFZID9+Q2i3h0GeKl/9y9Due9WrQvv2/qfhvuavC+1zrkOp1DufiXKkE96DtPnLLgS9YtRHOdGwhROq3/MFUF0ufEMZ7dD9MgXDSJUif6Zu7Rl6fGivv+fHod34862KZR39cvTjxieH9tsL8HvnlzG+5/8zyure/RmklJ37VqTTcSkdl1vwXFmfx/xgMtmsxjxLaKT/NrhUw1/4id4PtxxHqaE+raqU9bme6FG7ZkFJyLtEGKFUveEknvVoA88648C/5uGZDLso/Rtt4hk69Ex8SkHss4k0R+SjJqURJqiUsqDKoT0TwH93DX1blkGfUwHRpmht2VoBTWBNFjGSDGgcNKguf54Ewe1Rg1tD25Ry+acpkDUOHwAhwlRa9YudIEE8bRVinIlXPMf/dw9Op/+nZSCGMNWF/X+xHSSOp69G+1yOxCVgvx9D+49fglPxfUPq7I2TaJ/Hh8tt+G/tqIB4siIDalI6QKzPEgkiaSFNvaawj/BJ+0op5T80lTL/ULlOoJaVOunalSa221VZ7CNMaptvY94WXSqn8sqhXbGxz+5sYo9bmcAex6UZTCy6YQZUkS1F0Gq4HMb1kV5+/fxhof3Y3E2hzWnA/Lcuu+NRof3KzX8O7UkHe+VAGzH4tdvgf+LBfwrtayuHh/YTMrhuoj4xbaobShT7f/9CrI1MiWL/H+5+dGgfvQL39bU7j0D/N4F+NZcohXa2hbKa/7gB9/vmJ4DWMWtjDhTbWNN+Sn/3ecvxd5kMxfS3P8yAMvm4UnQvvl+8Fm1tgpSxOon5k27hPW3ORd8cKmUNAirToNj0F8me6TqBWt7XmetzdcTm+tTW0N7tEcHNw37K1L/BMqhG40XsBVzuxGXcfWXsEVN98Oc4ZWoJk1Dmini3bLhEBGthPmfm8O5TzeP9cDKDz/bX8KxTFezjtRzWaqbR5evwSc8ifitFrD/zRB8r1LC+pedh1/Kg81STJfSZSDHcfq2ANiezmKsDVXwXSFbiyTLlLJ5dqYIxTM1jD+L+jOWI1FPZGtqJCt6NGzm0HyGFzW2L9W9m8N6yN499c8k89tlEFe9FjSy+g8xk8ex4PDM0H2b68a6Sa6CdOhGRFuX7rOWrpbnOWtz0EJvLfDz3KQvPbk+Ad/8VFp5FsoX1vOVgTP6isG4/SmPd5lI+LuH5xnZ8dzlh7fWh/eLTsVdecS720BeejneYH5yPuD7+HLzj/fiteDd77scxl65+5bWh/Zxv4HvWT08CdfGdf3huaF/4bHx/5BK8NpHRvrztGaH92jW/Du1KmmhNdcyfK6eeHtrH9f0qtOtJvHskm9gjrprD99mj+36DPtB7gk2l2de1cV9bbIx/pOyI3knusA4J7Q0BaFwOrbHtBL7zTrrx7xtpusf5DL6zlB3ENdOWeUxmiSzG6zmXVvXROjOaQWwyrbXWxt9tthGbXpfvs5JpIxKJRCKRSCQSiUQikUjUg5IfbUQikUgkEolEIpFIJBKJelALoket2bQleO8nb1B9+Xh6VMpBalMhgfROTnePUJyIKhKhR6n4k6KZFMMEloUTKwwnaRtkat9ULpGpIpXUbiN1PHIyNqVXVdNIP2aZiB7dEF66oWV1Q5gy/d1sDSlkfHK4WytHPjPfh7Q/Hq/5JNJGu6GeMBmI5wGTLZgswnQQ/myLSnGaPttop7xI6VEnXRSlR5XyGO+kC7uQQmkMk2v4+XKKO9OjHIvGnsqguEyN/W0rvpSN/xbTo7iUMkKDos9yij7TrFgRwgutJ0YaVMSfTvvXB44RK0INODDtpZu4M9GaTOrmpH2Tv2mtMNFnTOJnxLQjk7gcjOlRXFrbYKpbNUqPGi3j871KjxrZvCX4wKf30aOIulikGEzQvtmXQDp30kLqtUkOlXhGSUbxz4uJMCYCIytCweB5boijhe4pxr3JQAJ8MMQNk7pp37S3mGhWkf2H9n3T3m3qTzf0Lo5N0/hzvJv2WBYTjrjUsU4UDKa8TddRAsB7plK9TY8687N/S48aILpi0kFMFV3EZspCWn50X8OzYMIUx12ERkrPjslukVg2zBmHaEcWtW8isDAdyfTOxZ/l9zojTTVCbImnu0bmm4E4001/IjQoprAZ4iuyD/J6YhofGsNI+xHaDrVvoEGZ6DkmulBkfTDQdlgelY0wPapmoxymQaWLk41CaO+djdKjXv4kuydjc8PBW4ILv9Ip+xnIIo5yLmz+XplXRHajkhnTeujQ9zITCWihNE/TuxOX7znbUNrTnsL19gxKjViJQXw3tAZRrqhyeKbNvnjiromSZpKRlmXy57lq2pcpXrrZd0yxGWnSEDtM8TPtmxF/A8UvQpoz0KOi/YF/SyMe2/TdtOoh7viddrKK66P70aPe9GyhR4lEIpFIJBKJRCKRSCQSLRrJjzYikUgkEolEIpFIJBKJRD2oBdGjLEupTEqptoeUpxU5nK481cDpzUN6NLTLCidUJzRS2rwA6UYpIonULZyKz+UsSY2UtitvBfHkxQeDwvDGs1CW9YWzkLLL1CemRL3inThJ/hsXDx/Qn2lKP/xQaKoXnAH7mrdvD+3nfhr9vOo9GKszf/Ok0D7tKNAEfjP1iNB+8sAtoX1LDcSZgzI4ef7sb+HU67NOwL1MKNzLoMa9nHg60gi/fh6eVzdUKaZo8f1+42Kk5/147JmKddTwnaFdmsPp55UESAZvPRnP7/OX4oT9sz6N9NOz3krlEz5S0HIW5k2uVQ7tGRfjwuUuLUr1Ltnw3+thvBbjafu2rVQxr1WbMnZN9CgmKO2q4b6XpjEHxuooX1vugkaxp02nsrvl0J5slUJ7iQV/ppsVHfRnzkN/BgKsFVMa/UlRvNcV0n1LHsoPp22iVun4lPKshzk/Z+O+TKmzmTZSVSsOEfEo5ThD847TqpnCM+Pjs0WL0neJ9lJ3sNaV26XQZtIWp+NyuiYTuNif0+yZclL20D7Pfe5Pw8aaWQnwjDKa6CRNPMd5F33gcicuYSy0MK+mXTxfV6GfnEra5+BedrVxYv/+p+svBnqUpZVKJzvzLLJvZuOpi0vaoGOMuyCz5BTGnEln+TrW57kU1m1TmQ9TgWou1v95jT5wfLVpvrkeykYmHMT1YBvxXkmgnTSRO+5obgztg1ykiE+6ILwMtkBe+EsL1KpHJm4O7ekk5kOpiX3tuiqoTI/L/CW09zggzixvgSrym/nHhPbjS9hn9yqM+Qof/j/diyzlo4dA97jbAo1rQ4B97Fb/0NA+RKH9116I9eFz78Oc3+URBUxjDphKqHjdY9pFokUEvQRS6BsW5gyX7eTq+OxMGmPL5ectjT73KcyNXQH6zHN7sdCjbFup/lxnbW376L+JHrVqFvNwdxHPnUlAE7mR0B4cB51tchDvb8U5kJvKBbwH9Y3jXWlqCP65CuZ5JYvnnhsHfaYyBPKR20DcNVKIx8zktnj/JuZMM4E1Pzt5b6x/so69jNvPjcN/fpgoWnWibiWx5mQntqL9wRHqTyXWPzOO9+T54Q2x/m2iJqUnEUfVQZTpO3S/rUT2gP6WR6VnVCKRnMZzrPevJJ/4mE1N4f23Ru1HSrFoD81M4HnNDWP9TBHRpp1FzDLBalcO84ffhRaLtA5Ueh89seVhTIYTeHedUdjv+mbxnaucx7NwuOSNyli41M6nspr5FL7r8dr4+ksxD790MuKL6YQ/OB975XGn4+/+jOzjf/780P58AV8gLxj5XGi/5ZcvCu0Pbfoy/J0vhPZz/hP744/Pwnr+/LPwjnrVB7EQew7WcB6HaSKsMfkoMORzMJGtWMN7u0skqWYS+w4T4tL03pisl0O7TgQrUylxbo4IegU8X373NvnPFPEOwFS+Kr2rMNFvog9rS66B96vZFL5TDpWx5o8W8R2/1MCYjCfQz2GNebstQOzzvtntd03JtBGJRCKRSCQSiUQikUgk6kHJjzYikUgkEolEIpFIJBKJRD2oBdOjTv/EDaqQxWf6c0hPyriwSwmkLLoWpTDRSfvd0KNMpAYniKdgmGQ6HbobigorR2So1CRS8tQMUhZVC2nkgUcn8PcjtdUrItWqlS6FtokkxeqGKrVQmWggD1amVNGWhRInpgQxDYrJKKZ50811pl9wSV6TSu/4RO/FSo9618XXqzTRo4o5jEfKZXINylISNpXe0JhZNAUSFtGdiAbl+fGnqTvkz3QnP6BYpmeVoOccoVQYflNmwhSX4fiRtSJ+bWGZqDcWtW+myZC/Yf0x0QdMa4spVrpp39Q3lun0e1P7EYqHYawixDGmfRmeHfub6FENDzFXJ3ux06PyGYpBoi7yvlkkehSXEkeoKLwPqvh90DTfTNRFy0CK6YbuxOK9yTSfTRQV077Wzd81+puIgoY0bJZloOE8mJpZLq/ohirVVWwa6FeBgdxhul/+u1wW53FsBti3mfI2WTPTo3p131x30JbgnM9fr5RSqpDm2MT7W9pGfBVclAC4FJs+vVPw3sGp+EyDahuoLkyDMtGaOHYS1D6X2DA1JojQkah9AyGFxaUHLOM+QvfIMhGR7HaTnGgfd+LHR5tIaob2I3QnEsedkQZl8I+spUQgivrTePI6bKD7+Tb7U2zyOkPX+flyOXbDQQxyCe1koxTae+ZwXSmlXvqE3qdH9VE85hMY87QNOx+UQ5vLeE1rKdOjzORE2vvoWfBeaSJ/tYkOXPzrf4d2YztK8Lb94qbQrk2jzIoVUK3poa9+Gvrfh7L09kEo9Y3soSYSFpWD+abY6YK+ZJyrEX/8LdM7SSQWuvBn8dploi7y823Rc+mGesnx1Y1/S1FsBvFHevA77UQF8Tg2E30WQo8SiUQikUgkEolEIpFIJFpEkh9tRCKRSCQSiUQikUgkEol6UAuiRyWcQK0eaqlyFR9bmcPpykyPqlLqbJ5SRrMKKaZVopPM+bDzNlLEo4QRpELdNrc2tA8q4NR0Tk9iSsL/7sYJz09bhlP9TzwNZU1fuwApZ68gmlKEmnQmUph+/vpyaJ9wzfNC+0srLgntd7XPDu1Lsueind++NLR/cBbG52WnoD/fuQj9OfFM3MvXzkaZwHY6iXqVhXItpj4xDeqEU9Hnb36k78DXaRwWStd6oM984VLQCN54EqgD/3kpqAPfug739orHbg1tTgHnEou9dfytoSTuP+Njzs1q3FuSUpwbNLcWIz0q4Sq1YjhQ5XmiYAyA8rBrFrHZl0J8VVooBVuWQunfaAPlexmHaEcU14Mu/Cda8HepPMqjkqh+iyhCAeYkpw6mLEqFVUR9Ujjpfb4N4kPewb1kAtg1DR8mWzHxiteHlkYftldAxhnJgBBh0l9nMGcPL4AA4mmsk5zeefv8SGhvzlOJJYlTMX+1CySIp65A+9xnLpP5wyj684Thu0Lbj6SbYmL/ejfa/6cVd8f6s+6cBfFkYwFEDCY1NDXWqIkmYm4gUQ7trA+awIzGfEjZmAOcSsqEF6UWBz0q6fhq3XAnfsbm8LxW57AWMqmN44XHv9hG7Mw58GdCWckq4+9S6QSnzf+pjGe9rgTaYFFjveT08ruCg0J7M1GQ/twCrelwF7SmmQRoJoUm1ocf7z0itJ+37E+hffx7ELPf+zD6eWP9kaH96DSoPR/5Jfp/6tOxj++08T6w0gMJ4pyfwP+0FyCW5y2i3vhYZ5gmaaIo/uhszPNjzsYz/eHZ2MdfdB7W1e+cGZrqd5VHh/aTshgHLl1h6tOPdmAcjl7119DmZ+p6WMf+WsXzekQOsc+lAZzyvbuFtW5pAnOSCXGzbjz9s65w74tyz3R8tXagU8Y/VcN6td7F+8huH2tdqYW5wZS0JTNYk8dLWHs5jjiNvzSN+Vnuw7y1I0QbvNcUpreG9lwJJJSpNOhd/TXM7cwsaG7zJfSfyThZos6l50A8qRVAh6wliQTXQIyk5jEOjRz2/fk07FwNsZ+cn4j1H8vjHXBoHmOSqEzF+pdzmKt98ztj/ZtZxOxUflW8fxXv2M1MX6x//9yOWP9WGmNyZ+5xob2pckNoO0TvYv8xoswMz2Kf5fb5futEzkoRnSc9CxINP1+O2UYS689ipEclbE+tLnbmXLmBtW6ZxnOcIkJuxcKaWQhobhOlqJHAeO5MghC0soFnERHtv8e9F2v+VR+Ey7Hvw0vIledhnF/ybsyBa96Ed1H/OceHduI6UBR/cOI1oX3kpSALf+X4q0P7QoXvj0dd/nT057147jelnxzah9V/H9rX2U8J7SP0daHddjBPHNpHflJBKdZz87+J9ec96xYL7wOHBNinouRTrGm7E1gnl7bwDpxo0jt8CrE56+I7eKFN3+1qRM/MYj7MEdU055VhV7F2zWSxnnDJJ5eQFytYS6eyoEElfPruQCVXA1XMz70prO0Fm+ifHmK8KfQokUgkEolEIpFIJBKJRKL/G5IfbUQikUgkEolEIpFIJBKJelAPKT0q7SKtqJBAejaXoZhkIsIY/VU8BcOkhRKmTBq67Rf4hwZSpCq33BbjrZTXohPpKZ+/8Ixn4HIWqX2cHslplm4ZqcutEtLAPBfpatUMPsv6R9CmTNqfGGI6fdtEBvKp3IlLPkzqhljDJVRMj2r46FvTRynLYqVHvePC61Q2gzEo5ePpUYU0xjVlE9HAMB+YBuUQDSpyIj2Rp6L+dNI++5PtGGLf1J+FrhXso7vwN32W1xATPcp4Kr6BuMGKxAf5m9auhRLfAgNNwEQLivbfRAKKp31xHJtkokdxCR5T3RYjPWrNpi3Bez/ZSZ1nmlspE79vFom6yKWCpr2JCXu2gd7Cc4npfEy6SVBqNJd1RCkM8TSNBcu4H9H8NFCoTOQplonK1M3+HolBaic3jxKSRBkp03oC11UGafD8buAPI63aSyLVv5ZDKRnfL9OFuqF0mehCLPbpZi3yiOLRZsqiH0+PmjLsmUr17r65dvOW4MzP7ovNDOZ5fxbzP8n0KAexmbTiyUEsjiMuHY3MbZpvHL9GYiDTcDg22d8wNyxD+yZyGdOjmNwUecczEGRM+wj760j/aR/pglBjRfrDZByKBUP7rMDYn4URHs33a/jv4tx+hCRlOLEiMj7wYZJU3cUREw2NeJxqoURrzyx8lFLqxY93ejI21x20JTjvix2yW3+WqMRJlOpzGXXeQvlJwoOPNsxJh0p7TNQzluXFx4Lp+fIcTt+M8qLWGMpzdv4KZcXVKXxf9proZ/86lDSueNZj0Z/lKItrDWJ/YXEsROiBvD92EcsRmfadLoilQRf7jm/os3FfI//IcQSGd1ouUzW1z5/lNiN0Wh1/v7xX8jttzcO7K3/XFHqUSCQSiUQikUgkEolEItH/EcmPNiKRSCQSiUQikUgkEolEPagF0aNsq1NyYVFq0IocTj5netRQgBPOpzVOfk5qpLRx+hCf8Fyxkc7XonQjJhfwCc+c5jTawt9a6tCp+BbSAtM+yo6YaMSUKKZI8PXnfhn0h5+d8Dv0bQCnVbfnkUabXo0T/gMqlWrfjZPD1RE48fsPPk4Of8bMZaH9hv85MrS/+JSrQvsl33p8aH/nnTil/5dtnP79uAKoH3e1cWr6Bvee0P7yjYeE9msfg1KvM76Be//gq0Aw4fFhehRfV0qpr12K+3/j6ejfp8/H9d9vR3rfU9eA3OB4RA6jMqtagJSypEaaMtNKygmUkNmKTjCnkoySXQ7tvR78ff+hLxv7R8u2lSoVLVVvIDbXDiBllNNi12SQ3r+biFtLUjiJfaKB+bzc3h3ae73lod1HJKZym2gaCv5jCie05y0QEOaJFjfgIU4nbZQM8FrRDPD8meIx48aXBHKKY7YN8kXVwRrVCJCymLKQUstp6kxBqgS4x36NWJggisGQwro3p0uhXfAxttfsfkRoP20VyAXvvAR9vuQkzNntDcTKqhSe3ayPssqixjocLYXA7/Iz9Ix47nOqcNPG/c56aJ+fXbaF8ay4tFYTuc+h8lWOy2miC0XJgNgL+l2M1a42/L1FQIvaX7aFsiimXa3KYf5MNjDOy9ogKUy4iDWmLnLqe7GK2JlN0xpG/z2G1786zfmWhzF/+7tAS4nQAE/FGvLdj+BZv/RUzAETZemKC9DP48/AfPjeBzE/I0SbRjm071EgraxTiBFe10tN7N1Mm3pMCvSKH+wgatVa7Gu873/vIxh/vq+rzsG4nf/HfwrtM1MXhfa9l6NcevWRSF8/rfqe0L6o/0fow4Xo/+UXhGaENsLjbCpRnLdLoc0UtmQL7x5MoWLCBa9vhRrGYTqL+cblPC1Na6/CvN0VYF3iPXOx0KNsW6n+XOcZN9ro/0gSsTDaBk1p5cxNuF4CpWtoDuQjJhANjGO+TQ3BPz+PPaKSxftVcRy0r9khvKelakQXSmFuZMtYK8qDG+FPpCHPwftzdgL9nKf2mRrj0RxLj8O/NgQSSqRUitaZ9CT6UxsA5YpLmbicITUF0kptEKTQaCkWlZkY2o+UTtDkS03jPaTWj3dMu03ln/Se4M4gFholvLdwKZlF76RWC+NWzyOuWXwvSaJu1YnSxeVOXKqTofGv0vgzYYfnQ9/M1tDeWzoYbXJ/FsmrrW0FKpfqjF2bCDvD9J2uHOAdtZ/ufSaPdcn18axZbhPlSC06YmI2jXgsVRGnLzgDn73qgxjRY96Pvv3wQ/BhqtTVL8I8GX3BO0I7/dd/D+11rwB9+Pb//EFon7Hs06H9heZnQvu5nwYV8UcfwL38Rj8ztJ+k/ze0OUZ8jTWhTGt+qYp3S6dNdKQEyn55v87Qfp2kNaqewftAk2hTLsVdmsqNKwX0IVJmSHGRnwEdb6aEtYIpmTUX7/al8tbQnuzDWseEtfkk5s9gGd87x/uwluYb2O9mkpgbQ9NYq3kv6G9gDMcTWHOWWLi+3cPa5cUvXQ8oybQRiUQikUgkEolEIpFIJOpByY82IpFIJBKJRCKRSCQSiUQ9qAXRo0Y2bwnO/MwNqphFTk8uiXS+lEOnfBMFw7Xo5HyizPAJzJxOryMEGSv2uhPQad4GiorpBGnTSdcmH26zfxQpr9YkUp6a9yK9qllGempqKVKqnNVI6/LzSM2yKkjZCspIxwrqSFGbuQXpWOlhpJ+lDke5VmsAaYFzeaScmdQNVaqb0/JZ+5MpTJ+PnCpuIN+YCArRE8kN90DzjIkpXJLXpNK7FlNqFik96qSLrleZFO6baTXpBJ1Ib6Bj+EH8s0oQDcoiehT7cywnKN6ZvsTkLvaP0p3iaUR83dULi307srbE+3dDIWOaGZM1TFSpbmSKtW6oNyZihYlCFflsN6f9R/oG2zLGPvXBsM7z9baKP2mfqW71NuzJKuJSqcVBjxrZvCU441MdQk0hg3ErZeL3zf4k9g4uB+ZnwfHiBpTqHxgILyTTum2iobGyFaT3O03s784s9izVQJkh14P5JeyDXgrp1vUslTdGqDrxJCkTBaYbmfYKk/Jj2HOtUZRytEaR2j11E3z8Nt1vG2O44miUKqt8KTTn1jwK17u49yj5gn2IKGR4dkzBMNG4+Hrb4tiEzWWqTI+aqOKZjs7AX6ne3TfXHrQlOOdzndi8vxRDqej+mHEQg0WHCDUB3s1M48mlGVySZtynqPTGFKesyJpveCfSEeJS/L5pIhW6FOOsyJ7C9+7H77O+FZ0Pcf6R9u14fyb4sLiMIvov4smPfD1CjPLjYydSt8BxSv30DX3QQXypF/fZRMuyW/FzzHcQg7wmNF0cG9CwYU+18X1h9xxKJpVS6rjH9j49ikmLxSTGJO0gvkpUHs4kRBbPAY41E0ktWhZHc5tjmZ87zavkDPaI1o3XhvbsfSjZq05gPWlVqT8O5kNmAOvq0JPwXc9aiu96zWF8r2SZ6EjGuUcyvlsayIzGfYfmZxDpTzztzkR3MrXfXqB/i8r/IwRbP55wHaEfd/EOzEcERIiofjwRdbyC5yv0KJFIJBKJRCKRSCQSiUSiRSz50UYkEolEIpFIJBKJRCKRqAe1IHqUawdqaaml6i381rMiSxSVBk4yn2shPa+UQMp3RhPdgChA4y2k8A0lQKDg9G8mudw4hZSwRw9QaZJCGlIyQKr2tRM4bfsJgyA3MUWCqRlMwWA6xnOI/nD1KUjBOvZ3IEf89MQ/hvY38v8W2i8c+k1of20riFFvcb8Q2tt/8MvQXvUckKH+47Avh/Y7d+LU8WO+jBTrH74Z9/Wys1FK8J2LUIplokf9ZMdhof2c1SgBm9X4bF4RWeNu0KaO2Yi/O6+i6Zc5hRTA6ydxKveWARBBOLWU03lvmlkX2oeWtsGHUm89SkHbVcOzWZHGc2VaGN9PgspsGopLpSgVdZEQa2xbqf6iVk3KIN4wiLHfRfSovIu4qHtI5xtOgPIz1kTZQtJG6mDLx3gPOETAaSN2GtQmf7agy6E9G5RCu0ljn6SSEJ5vcwpry546+rYshT4zjYjTFG8pY63gecTlOUwVSwdYo5jUc8ccTn3fnAfJ4pUnYa596dKR0H7jKaCQXHYh1pATT8d9ff08nHjPJQycrrm1DXLEiAOixL0tXF/vYg2sO0i5dD2snx/7Ofr/9ueg3OPV70L/v/5RxNDWBkgoy1MojfnTxEhoP3poa2hz7HJJ4q4KSmNWZNAOj/OsKoU2l9fVaD1v70d1WwyxmbADtXKg8yznGxiT1TmM+WidaAs+5qRjIw077yH9m+mKu1ugnKxwkXrN84dTfE373QnvQix/4+LhWP+fnV4O7ed9hPbBl90a2kf/4Bmh/YOnXxHaz/8S9qmf/Tvm8EvOx718/1z0c4zIC0MtkCM+9gfsU29/4s2hvcseCe0V3la0T1Qmplm96DSsgd+/MBfrf80/Y215ydVHhfbX1/5HaP/utbjH5/z8TaF9mvvh0P6k+mJoH/lZUF0uPy801V0a1zcE2E//WAMV65E5XDeVQ95UxXvOIVns70zbbFpU/kvzZ0kCscmUDSb0cWlqjUhkHJuLIS6V6sTm8r5OKUW1idjk96LdAdbAQgsxwqSSwWm8y0yW8M6SaGOOcep+vox9Yb6E9rkkgcs3mIJU70PZO5dgNAuIx+Q04mV+Cd65eM7YRIdJVUDJme/DXnlvFu94myo3xPatTeSd3QX4L5+7Hf5UZtVOItbGiiDEDc9iDN0a9sdmBu9ruxbafh73nvHxHaQ0jfVHUbnHtgGUn6wdBRm2mcU6mahgDswR9SZDpaOv/DzG8LK3YJ89+kys7T8+G2O4N4938qEa3it2Fg4N7RXziP1EFXtBLQ+6YqIFkg6XR3EZu79IyG4Jx1erSp3nWm1h3FY6GM+xAASuqsZzt6mcP1vH97g60fT2JNaH9qoGSlxZHLPHvh/f9X50Nnyi9Cj4H/lRzI2rX4i/+4bya0P7P6z3hXb/BReHtvuNT4T2dRf9NrSf9lhQR4/5yuGhffkpmJPPPwtr8lUfxMP+cRX78nPz+B7aJrqTTe8MN/qPC+1HW/g+G6FQ2divb1XYpzYr0Ip5rWi6tL/beBdd0sZ6mGxg36mkEXdlG3tQ0cf9ZmtEd8piL+N3Ht77ihUcaTKVxTuGia7IRK3JDNZqK3KEC+bAQA3zczQ1EtoFG/c15uFemkRG8wzVmftLMm1EIpFIJBKJRCKRSCQSiXpQ8qONSCQSiUQikUgkEolEIlEPamH0qE1bgvd96gZVyiE1KJ9iCgbyewoJpOolrfiTmVmOJkKNis+v5TQkm/27OGk/QngxUKJMJ06biBWZGlLv+GR+Zx7pi5y22kogZTG/4yY0VEFKdu02pH26JaTg1keRBuZTHlXhyU8K7SAD/+llSK00yUSgYJnoNia6wf7tmMhQps9050+p2EH86ecsLn0xUWqaHq6XI/QopGa+4Zm9ScFQqkOPeseF16l0GmPZlyeikwu7lMZcTTvxRAZWgso0bB1/0j5TgRyL/f1YHxYTqUx0J1Y3awWL1wqOZS6hMtF5TOuMiZSUa5VDO1VHmndiFmUmXgbpsp6DdNZKBumgpnuPEvEWSKoy0HNMxCg+yZ9LyZjiZyJD+ervj0um0vBJ+1NVjJVSi4MetWbTluC9n+yUFjDNjYkYvG+WktgLUhZK21gRkhqVBHIasEm8xzmUuhwl0TDJCPbg7b8KbX8a+9H0jUiHbs5RSQgRlPIrMLcLjz0CPkuQolwpwWaihImA1o1MezqLaU1M0ygwPWoCadLeJEoh5u7cGttmfRrlGEuPRCl0N/Qovt+IbRmuGyghLKO/gSLHscnrpImCMVXFu83+9Khe3TfXbt4SnP25+8luRI/KMKEGcZp3EJtJBR/T+ySXpnKseVQOHo1Hok0ROShCfeI1n2lHJqqRYW4wvYX3ICY32W16bze979GcjJCYuqDPRO6F29fx8WhFSE9E8DG033JRJsx7lt3GOLsNxKlF96vb9F60UGId77NWfN94nAOiQXG5WXQ8icZlY/54VKLScBCDTRvtTHsoMdufHnXsFrc3Y5PIbn05KldJ4dmlqPS+5JRDO+ljD9IRghjRh5ke5ce/A0fIbjw3DHOP521iBiWH3l9RXjR3L8pnKmN4P0zmEYOpATyj5iy+Rw88DiVIehilQM1B3jcpdgyUNxOtrJt9IUruZf+/f9/hZ2QiJJrEbfJnTfsgr7383dGi7zU8T3gf5HdaS5E/3Tu/J7eIuljz8Hyj9CjE6fh+9CjTO61k2ohEIpFIJBKJRCKRSCQS9aDkRxuRSCQSiUQikUgkEolEoh7UguhR2lIqlVCq1UZK1fJsObSnGijPGVZIJ54IcMJ5xkLqWjNAah+f7l610I6pbCHhIX20aSP1qNwuhXafTaesa6RKphVOm3/lyUhj++bFoJy84p1IgTZTNnBfTNm47BKkPb+K2v/GxbivD93+stC+YPO3Q3vqDpwe37cJaW/Xno8Tv5/x+VeG9uimp8F/Fp/9+K9xMv/bn3pnaF83i7KpLUVQongMOa13t4dT0Jc5uBdTyvq4Nxz550FnItaPNR9gXDIWnk2qTaQxG6fDt2je2JSmlm+hXG3WHYj1adOU5/mxp41nySQMb5GQMCxLqXzOUs0W0g7XET1q9yzGeE0Wz3F3HXN+aYpJcEipXWIhlsd8nNhfdIgw0kZK51CA9scU0jhz9GwrPlJ5+wI8t7LGc0tqIsfRM2eSzqwN8k6kRIvKmng+Ny3M80svx5j824uwLv3zyaCHfPVSxOCJJ4HK8eVLcfr9605C3P3gfKQ+fvbup4b2v45cHdo/aj43tI9p/zC0X04kAtOaw/15zUlItWUyzotPx/3+8Cyk/h5/IZ7RV86OPy2/bUVLG+KUaWOtnndKoW0q6WLqStnFfIvQviiVtM/B893ZwnxbjPQoy1Iqs2/KNVvo/6ocxmS8XgrtJR7m2KTGvWc1SjMaCnM400IMMtGG03QTAfbKbvY10/Vr/gVrfvNRmNv56XJoX/uM80N786dfEdrvL14a2h9r/Wdov/Iy0KA+/zY893OuPgiffQ72r0qyFNrpFubhbS34H+KAZsWUKBM96vIL8G5w/KkYz6s+iL0sNQrChZUiiuV/gKrz9E9jXy4tA2nCT6H9D9xyTGiftgYl0ndr9H+dQllWoo30+CrdO+/XHL/ZRjm059KINRaXvxWrIBBNpVfg79KcYSJnv8Z82OnDv+3jv/8tlj3TtlAW5dPesTYBwuCoT3S2adDKxvrxfjUwh3V4Nov3iNIYiD+zQyAEMdltlwsC4Oa92CPmloACxkpX8J7pO3guTh3z1r4P87+9Bu1Ydey/XrYU2sd+AM/uynOwX/ykgnfLo3K/Dm0u1eHykOQ8+tagYwFMZfWJufFYf5OSZbyHNEp4Lh6VF1ke+s+kudc/DQSu152G/frKc7FmHnsO+nbNW/HsnvN5UKt+fORVoX30NceG9s/eBvrViy8Dhep7r8dxB76LmOV+3tePctGV8/Dn8an1IdacJtaENq0DhTnsHWMlzE+mR5lK1HtNllYqleg8j2oD/T+kiHdLJpYOziFmp/N4R0q1sG9yaYxD3x+5xKyaAM0wQ2vpcfRuFqFHfQB74lXn4HvGcy7C/Lzmn0ETO+F/jgvtKx71ZfzdMex9hcMxb8uHPTO09b3Xh/Z3Um8M7Reqn4X2n5M4LuOwNvYmp4X9zkvhPbCSxHt+moiBXDbYJH+mMnGJU3Ye3/MqOayBLF4HcrNYM+cKeF4uPZe6i+98pRnELBP6ss1yaM+mQGUanNka2uNFkMKKdcTUdBLvV4Nl0FfHiqDOlRq0PybxTIdnEO97i1hj+xr03SeBd4BhC9e3tvHd4e+hLkqmjUgkEolEIpFIJBKJRCJRD0p+tBGJRCKRSCQSiUQikUgk6kEtiB61ZtOW4PRP3KAKWXymL4vU3LRLp3wTBSOhkQro0+9EnF5lIsIYCTKKTtTvgjgToUcZTsY2UQBY3L7pBOxuPpurIp0sOY20Rj2D9GPVMpB9+pH23MojRdBLIA27mu5XcTKRQaI+8TQnvs7jafLZ/9+ZnpPp73VDtggi88mPvW6i1DR9lBDwid6TNZTu7J2G/5ue3ZsUDKWUWrl+S/DvF1ynMmmMXx+BAjJJitk0ymeSDuKO02h57FMOEWrolHXPQO5yOZaJDMXtsx4qepRp7vBawfO2reNLgSL0KCLycEkglyGk55FCadeIRlHDGqgaVG5wH1IxEwejXJEpALN5Kj2glFQuCXFbSJPO7EY6t2LyRRIlIV6uFNqtNGymVkVO49dEqbAOXEnLp/F3E/cciyaqG8flRGU/etQ0/t6/PLc3Y3P1xi3BaR/vpCnnsayowTyeUTYJu5hACYOJusjz00SPipQV05znUkG+7nVRFtd/zx/wDxXMw8otVGY7R6n7NVpn+lCGUHgcHpM3hPLbahFzPiID9YzXeBMZjUs5TPtDxN/gw2Up7jTiXZVpvy4hjlSNSlHoHrlEop5FOjcrSuigfYzJFwYqh2lf5ufbzR7LxCjeP5keVW/DZ4LpUeXoWtGr++bazVuCMz97Pz0Kz30wi1KCrIs5XLAx57l8jMXjz6UZTCCaTiHNvu5jPiSJFtdHafmJBpU+UZmDRRQkTURRI+2oC6qR0TYQqVgmUptvWlu6IVLRvUQoPxE6VXx/Ao4XAzGHiVGpCZRgePeiRLE+ipIKy6U2G/hschixbOdR1qHzeAnz+1GOEThoJzK2tD6Y6D9cDubTPTYd7PVMj5ry8F1gsdCjmLrI3zeXFhB3+QRsEz2qq32Qykt5bjC9y2mz/4GJqyy3jNIY3cKcad+NdzZnFUqoVApraZDAfOA9rp1DWZOJGMWEMiav+aYY74Lcy7HM/THFPr+7soz+VKpmIt/xnsjtd7Ovcdm4iUbNa45Hx2mwv+n3By4l5ndaEz1qbB5xOlaOrmOmd1rJtBGJRCKRSCQSiUQikUgk6kHJjzYikUgkEolEIpFIJBKJRD2oBdGjEk6gVgy21UwVaTwrcjj1erKOFOham+gkLlKb8momtOcUTuqeaSFtr+giHTShiPxCqUd3zuFk5o0FnERt0t0VpJ+tz4IEcdXtOFn62M2gVLzxTKS2fuEspKtFKVFId3wVUTlMFCq+fgydRn7luThN+toSqFJPL38ntK9wQaY4JnNNaH976sjQft5q0A1OPAPp2V88H2nbE22kcS61cKL+d245OLSPfwTROhSRnRTG5KfbcKL+kSPwb+poCQOn7982i2ewuYBUVFNq+x0zGBd+xk6A1LSGRnrZeAP3NpQEkSgdYCxmAqQVJiy0w/OV6WhefBZfz8lxlBros1StjlS99YNI594zRyexp4ji1ML4LUmiZG+UxtJU4sT0rak2UnBbtKy4CmmHBV0O7ekA/lzuweWTprVitoU5yWtFMkBaLM+Lm6dHQvsRfVtD+5q7Qe543nqkqkaJb6BanEjXf3w25vWxF2GsfvhOTJhdn/tqaK94y+tC+7Q7Xx3aH9378dBuL8cp9Nkayi5ecEZoqivPxfi86Cyswz89HuvMK37zktD++iO+GNrH/frFaOftiKcLfwV6xbuftzW0uTyKtaNKRJU0lY0EWKt5/CeaiLn+BJ5pVmF+TivMh5SNdmptpJK2vOg6sYDK3odNCVepVUOdOTE1j+e1poBYY3qUQ+WHTPooefCfdTBWMz7iomSV8Xc9xAKnEL/0VIw/U5Nedgpi+TsX9cVev/rduD5x5U9De/jIp4T23Rd9K7QPeskTQvvC/gtD+319Pwjt59LedMWHQ1NdNfb40D56CSgYTIT59yeBkjPlgFjR30Zpyes/gjn8pVMRsy95N/ay71+ItfHF78a4MUXrxedgrH5yJub/+HpQtIbHbwntT829NrRfV7oxtF9BhJqvnY29ctRCCRXT9/40B6rU4QXss5HSNorT7S3smSsS2N+5VKeawLvWVAtziUsMmMTIY5u2UJJQo/exlkflG4tkz0w4vlo71Cnnm6TSy/Uuylf3KpTs8ZgwvauvfF9ol0sjoc0kmnSTiHse5tJEDXvZOWf8PrQ/ewnoP285Dfv1Dz+EufqCD8L++bvwrJ//KdBVfvKSX4X2ydvfHNqXrPxsaFcOQ/ymZ4jQlMO+5jQwfz6343mh/eZ1vwztPUXM1SWzKC+ym+h/O4k+z+YwtsV5/F2XSFgtItdsLyD2V83iXZfLxDwX+85x52Ddu/IMlG0efSb2lCvPg8+Rn8R3gR8946+h/ZbJ94T2+RP/FtoXH/6N0H7frW8K7Ys2fym0P5z4VGhfnca+/Jz65aFtV+h++/CdoppH3KUaWLeTlUnywVqUaNP7j43vLJ5PJTCLhB6VcAK1eqjzfj5dwfq2JoN5zvSoyHEItB4WiI43n8Z8LifwXldq4h3GobIpLj2Lfl9D7B/7PqznV56HcT72vR5dx3vmy87DZ3/4FqqXrmJ98HJYN5gQx7FzyZ+fGNr//tg/hzYTlPJ1rFc31EE0frwDChWXHflUmrTHHQntpS18V3NojjUT6M+4i3nI+y/PWz6yY9qi8ad3m0yNCMBZxIJP7zC89xUrWDemskQN87DmNByM80AF3/3HM/g+6lDJGxNUTf4sLh8eqOG9ek8K63DBwfMd8zBv6y0qbRN6lEgkEolEIpFIJBKJRCLR4pX8aCMSiUQikUgkEolEIpFI1INaED3qfhJGMYfPlLJIVWJ6VDGBNKqkHU/BYNkK7TChxnSiNftb+sD5uFGKxIGpT6brpv50Q4zqxl8bTtTvpg8tStmNpL3RKdxMGDH93f0JUHHtmPr5QJ8xKUK0ovRNrePHiCk1fhe/OzLliE/0rntIPWz6uD5VpbR1OtH7zUf2JgVDqQ496m3nX6vSKYzHQAljmUrgeZXSSAXkmPUNS0HCho9r0Sn0VCrFz8210b4dKX2KJ5exj+mZs0z0KJNsKtGKrBtBvG0Sp932z25Df2pIb7bqSMtUY0jdVEWUlsz86n9DO3/IRviMICV+dglKpWouUuiXbr82tPUsSldqN6M0o1XF2us3ce+pwRLswx8N/wGkqc8WYPMz4rUlSn6DbYpL03rFcdmKxGU8PWqqgnhVKkqPeutRvRmb3dCjMgkqIUwgjT9FNBmOCxMZjec2i+d2so327QVSMFLzKMFzJ0A8ZFJShFxGNCU/gzIHL435XM/EUw5ZTD7qZt/h/Wuh/t3s193ufffLRObiNGxun8vZHD/+3Yn72c0eG6GKdLNnUolrNxSMySrKUkb3o2D06r45snlLcOZn7o9NPNPhXDw9Km+jRCjlY86b5oaJUFNJYi/g8nNeA/sVSgZSLfyt3ARKt6y9KFtQCcyZ1jbsTX4T82duO8oW+rc8Au2kiFi0EiVCkfcyKhUJ7HjyEctIBzWQoSKfNZHg/APv10Z6rIdxMPVZ/fonoelVMAd2/v720M4OorRt5w1YAxvjWPce/RaUdiaHsL7Zj3ps/N+l+/WSRA6KUKLQZ6ZHebRWNFx8lsv3yu1SaC8WetTIpi3B+z7Vic1cOp4elXXxTLlMPhVgj2NxbHI5jGkf5Plp0zrczXclluUZ2vcN75yGNttUKhUhKNm4zvsF7zs2zX8TYdCP7Efxe5yJWmhaA7kPPu/LEX+iNdE6YyrP589GCKe0Z2nDdwqP1tgIWYz8rQghl2hxtG+yf2Tvpj60iE5cpe+avG+OzyNOJ8rR5256p5VMG5FIJBKJRCKRSCQSiUSiHpT8aCMSiUQikUgkEolEIpFI1INaED3KsZXqy0dTGlfmkaI/UUPq3RILpQETAU6KzllI9az5SKktBjgRfdZGSqGpLCjjIR2uauPvNgKkIaU0UhyZOMQpVTdMbAjtLUNIPf3M/4DC8G/PAB3gwh+C8vDuF+Akc6ZEMXGGaVN83eT/indNxl7ndkx0qi9citOq33gy7uXLl+JedjZwwvbqJNI7OamUx3nSx2nkTAtyKQ2vaeM5zvtI91VKqaxFKcVtPPu6gzTTOs2DhEa72Sb+3pyLOREYymxKLYwFEy8SmghkAVLT+txyaO+sYqybRKlZLCQMx1ZqsN9W1RrRo4ZwYvmuGYz3mhzSpHfXMJeWpjH3xupI4V7qwH9PCye6MwlomuhvTD8Z1/Dn2J/30Z/+AHN7QuG5ZSzEb91HGmHep3lho59cosUllgkfKbVNC+2ceDLmf4QER5QoJsi8+p3/X3tnHiXZUZ35yPdyz6zMrKytq7q6u7olISEEtLpbS0vCQjY2gyyDMeuAsNGZwcPBNkgIARKbjbCwLAQC2xh7bCOMPIYRWGYZ9jNexjaLQFLvknqr3mqvyn19L9+bP0p63xeaF1bV8cyQdXy/v0KpW5HxIuJGxMu+N35Y0x66m274/y5oOPG9oMk88ntfDMo7/8svoP3PAU2A9e3Ua4Lytd1/Ccqvvg1r3XdvoXSzIvoqNohb60uvfxe+67MfCcrvVXcG5fscUH4+8si1QfntLz4WlD//GIhyb7wU5BoO168kMH9Moensl8tR9HMiQuPiY90oxjCvzjjwS9fbePSoqK1UMbfa0B5FHJvoUeMeaAXLFvmOjznQjiAMfqAL2kItzmsk/j0mSt3Gc4mpSUxTMvnCQ3djrD99GgSZ39z8VXzBQZCevB1IwZgpgvwy2MF68r0VkMteUvxJUH6k+4KgfEkac4/DrZmWcsLDPr4jgjn8WAffe2niQFB+zR342wfvwv7zauoH0z5r6rcv3YM1kPvZ1J/a57diDfyLj2O/TngI9eeUBw4jtygcPddCPZXUGNmE06aKLayBSykQOTnFoKoKsI9ivp1xQQxh31wrBeOnrait1NDAar/wnr89jvSiBR9jNF4CrWxpEPNtsIa1t57GeSlbQj31QZBHbroD+9cXfgd7NM+lz943FZTf8B6M6fd+E/a/+DfYa772tumgfMf0m4Pybz0CGun9L8E+9ZZ/wF7z5jLoSN/+Vfivuwlt0FICe5RiTykP0Sp8pFPEXDKlO8WreK52AXOJ04V4kU/UYd/NYl92iKoTJ/LUq+4pBOUv31YOykyP0iiQ/4Q+eehSkB9rcxiX4QvRzkv+Gv02fTPKb628LyjfP/aZoHz9p9An33g71vnqCOZStozPYwuYP00iS8aIxtVLIj0qX8XfLhSQar0R6VFRW6mR/Kpv8j4/lab1iki4Y7XjQXllAP2c6ZaDcjuGeZJuYv9tEdWI11VOodrnYJ+61AYN8A13Y01+4Hassb9CxLeHfg82r3wvzjxf+wjGhQmhX8ORTfv8v328gO+l98Ev3Iuz9NfP7gzKN0w+FpR5zrC/dKPY+6KUQpWqo38aRChjcYpWtoK5V8uj/7lOTt/Ll6eDcqmA8zCfLeuURjpSAo1ucRBXCgx08M5STmC/G63gDDCfhy8MdrD/riTGyR71L+QvCLVfTuDdf7SK+mdz8M1iF/azUezjYzGsjSccvIN3HXrXFHqUSCQSiUQikUgkEolEItHGlfxoIxKJRCKRSCQSiUQikUjUh1oXPerpG70H0vibbBIhYckoysUkQgrjFsLMmDjDilt0uzXdzNxT4WSEmAq3N5ERTLc9G+lURFlay23ha6HPsEwECr6R20TB4M9Nt2fHfYTh8TOant3UflN71mL/r303i8eYw/pNVLC13OitkW8oJYoJDXyLt0bCaBA9agX1v+1l/UnBUGqVHvX23/+RSiUpXWwgnB5VzMB3kkSG6hlCZ5keZdNN7K5H85M+TxItzo6QLzNtisYnSuPMc4TXCq4/FsF6YhpzFtOjTLQpE0nKSKkgXygugi7BZIro8qwKVR0h3M4UUpCYFlHLIiyffWpk+keop4MUj+6TTwTlXgf971E5mkUYbeKFoEd1iwgTrWdR1ughBloNp6uwH+s3+YevOWvxy7aLPll6Bj1qsdT/vskUDN438ynMSSa4FRNIf+A90bSOMj1K84UIr+34PN7DnLGIXsFh4SwOEWd7rt9EgTHJ0wgy4ZRD9i+mTnB71rIvr5f0xM9iSutgmchTGgWDKR7UfhOJw43APuFhvFimvzWtV3xO4D2T11VOnXAU/M5EXDRRMBaeQY9660v70ze3X7jH/50/fco3U+i3oQwTapBanbeRtmkaF+7/mIu/1egz5Ec22bhxwsuRPJpL2Ue+h3pySNFVCer/h/5HUF45gbD8c3+HlIrnvhEpAKOXXYz2PBfphH4MdSqL/JH2OCZJsZgSxVQajYxj8E3+WxYTcLS/NdQZoTQu7nNus0akOoK0l84sUjjLR5H+ZkXxXaVppGbkJymV4/LnBeXoKO3jI0iv0ER9y8+u9SGNhRtDSotLKZPdKJXpyoJSD23bKPSoHRft8T/8Xx9WSimVT2OMcknMgXQU5cEoUg45Hd70DqXtawaakrbPuqiTSXC+YS/jnC7eN017H4vrdCh9ySFKVJzas5Y62Xe0MzZT4Xhf4H2E6WbkyxoBlvqE5dpEQDPQo1iOFU7I4jHiZ+Q+YXopn/n5u3hfY/E5ymTP+6aJ1MnXs/CZtuXSvuni88U6Pl+u6GcY05lWIm1EIpFIJBKJRCKRSCQSifpQ8qONSCQSiUQikUgkEolEIlEfal30qFjUV5sGXdXoIAyJ6VELTYRrtnsIK+IQ3LyFENOKB/uVLsqDcaQPpHzcJt1QIIycaGwOylNZ3NjMYU6uQijXdAOhiduzRE2iMDYO6X9kGTda7xoGPYrr5O+6489xI/dd/wmpYe/6I/TDvW9DSBtTokx0ic/fh2d8k+HzX3snCFZ/+nHQo955D0LIPvVutLnpIwQ3FQEh4u/P4YbtF03iZmzPEHb+zzPnBeW9m0+G2iilh6w9UUG7L8rjtnEONevSGJysIVWDiUcJH6HJTYV+X3EwhwoxpBlkFebTso8b59M2QpMbDsLU2l2E/bm9DYCoUU+R3fKW6nTD6VFny0iNKSQw7vzcY0mQQWZb6KdMFPO24SIEdyROtKku7F2PQi4tjG3BKgfllR5u7FeR8PDUXAT2ZR8hvnUiVRXieMakItqUQljpUgcUmLEEwsW/+fhUUL7+uZjDN74DaU0PfAJz8MZbwj9/6UdBsvj6hyncOltQYbpr4c1B+d3RfwjKR7MgFIypcDLdt96HfrMSGJf4xSD1LPztN4Ly8N6dQflzYx/Es+QRQn/9b2NMv3gv+n9f/aKg/LwcaHQ/XERo/aWj8GPT2strez6GtXEtftlysH46rp6u0vP63zef3jOVUqrVxVq6bQBjOt/C3PY4xYbWzrwHX2NiWsfH2CWJtpZy0M8tomZ8dwbpDy+ZOBiUf/330Jd/8H6sFa9/B8bXRE0yff7fP4Z2vvZdRMwhItvrDbTEf5zD3PuZTUg/fOAwUjneePH+oMx0waxbDsp/v7QzKF83vC8o378f/XDTC1DPq96NOfngPZi3r7kN5xYTJcr0XH95H2gRb7w1nB51sIq9+7mF00H5WBvnkB0pfB7rwUeYxHjOwTlnUxzpMExurEcLQbnZwzqZsrCe5F1a2y2sdRkbe0fTRT0dF3Pb3SDExVjUV5sKq2kDzS58bUcMe8GcjzNLxsEc4LD8wQooP5UcxtqkV3wA5W8SxYypRt/8IMbrZR/G+H7nNpCGXvN5rPn3vwNty04ihTY5CN986Mb/GZSf94+vDspHXnJHUH7+4w8E5a+M3BiUf0k9FJTPjuwKyhPlQ0H5RA6fT9VBarMplcNJ4AxfTWOuFurY72JEgOqmCkH5TA7PO1nF93K6Cqd7XH8n1sZv3475/B9+F379rffju37hyy+G/Q3fwXPd8vGgvPfhjwblQw+ADnnRg28Mys4I6DmqgnX+04uvCspvmcJYcFpcvIl1crqIzIjJBtbAeAPntG4B38VrQieKOrs9StX0nj3lsx8Usz21ubA6bxoO/GJbAqlqcy5oQfzu5lpE1GrhvaGaIkIsUUTTLp0hO/CjVrIQlL+zvDcov2z4h0H5Ez/YGZTfdfnDQZl9/CsfQdtefgcWx698FM/1ittxdnrobrT/1e/Fenv/J7Cf/tV+7IM3XYy0vogKTzd+wsJ+9xwFCp6t0Z2wVszboN1t6qHPEx34SyM1RPZYJ0c9nJO5P2tp6v8I+p+v8sg1MV7LGdCXLItTt3BWKTSxnzL9MEbpVJxuPNTCsyymUD+L0/yZrriQRJ8kFcaFaZ6jXdR/Joo9nd9HZ12cVZod3jfXdp6VSBuRSCQSiUQikUgkEolEoj6U/GgjEolEIpFIJBKJRCKRSNSHWhc9ausFe/z3fOrHKp9lehTCsRJRlPNJhDwxTcZEeGHCFKfL8I3N/LfrJcjo9CjDrd0GcpGJjmEidKyXWGHSWqgQGnWCUhKYrmWibKyF7MTpUZzqZCI7+c8gEHkUamYZbtxmG41sYWoT2XAKgfFGcrrFm1N3mkSm4RDSpToRa8qo57d+0erLm/aVWqVH/cZHf6jSKfRNnuhRiRiFFKbDyTWmpSBmY/7YNO5GEhzRpqIWhS4b7C0iTNkaCS6cXhSLMM3q2WPx2fdN6wCncLK/a2QBA4lA+y6Dn/LcXDfRhv4200SYt0UEhPgCQvQV0TF6GaRyeBSG7cQRcs9hwCZKFKcDsHhNMPmlSUylMd6030M9Kw395v8Fokf95vX9SajZ9pw9/u1/sEqo4X2T6VGJGKUQUupi0kK4O0ujWpAvmNZXVswnmhgRbUxiKoSJgsHS5g/TT9ZJO+LP2Z7bY6RvrMFP/2/ZmwhTGmGNyE2mdcBEhNSoGUz90PrTRM4KT/02ETZZ7Jtdoryxb2p7JpHdmOqmVP+S3bZfuMf/0J+s+mYujbEYzlCaYRRrbC5KaRQ+/JTHkceLCTUxF3XGukh9srr4XJsP5DsurdVR/luiB/oxrI3+PqRvuBW0uXIcoftDL0Q6fHQT0t+8UUrvMlCNmB7lRcP3Bc1HmIhk8DUTtY3/1tJoUHRuMVBmLIeIP+6zr3Usa4nIjy4R3+q1EGulrMmp0M+d/Gjo5xp1yEDlY+oW93mPiDwu7cucEuVE8HnZRTrYuSrS05RS6pWXR/veNwsZ2h9TGMeEjXHhtOsEpXmyeI7FPCa78VwKP3OyLzMBUJMfvrab6Jka8ZD3EaqH0/26RJLiVDgT1XEtvmbao020Jo0WSm0zPa9GN6a/Ne2zGnXRD983+d3Tpb3JRHfic5FpHzTRpTUiquFdk8u8V/K7ZoP3TRf18LvmMjLJlFLm902JtBGJRCKRSCQSiUQikUgk6kPJjzYikUgkEolEIpFIJBKJRH2oddGjbEupTEqneGzJI6Znvo7Qu4kYwgtnHVAShuLloFxxEbqf93EjelnhVuoUETFaHsLDcj2yt0Ee4VQLDkVLeQifa1sIN+1p6Tv42xTdKN62Yd/0UE5bCFVlcZhZ3UOfZGy0gcPb+LZzJmrlLNzUzSlEHI7F9kzm4tB3x0JoFreH25/soczP6/hoG4ecpbtoG5M7nhl6raV2EH2hGhsKteExKzi4eX85ijkUj9CzUTjasIebxDXihYVQ5lKvAPsE2nOqBsIQz+/eBqFH2bZSg3lbtTto7/mjGNOzZYTOTuVAFTlTx3NPZpaC8kwT47M1Sb7cxo39Iwn44GIHc2DMgv28h3HIRzFn2PdHIrgxfslHOPEA+Uud/K7goZ1lC77PqSIcyphSNLfppvfDy7ht/pIhhI5/8iG07dZXIh3pV2+Gzec+ib/9NSLsmEhwGoXqnegfJua84Z0YF1P9X7gXz3vbn6Gdf3Qj0RCeAD2kPY4w+HoSY8r60RJoUJcNgxw346DNA0SaG+phvCpR1GlKax1y0Q+LNoghvP6UXJARhhMgaJyuo3/cnp6Ksp7U3p+WrKf2TKX0dWVrDvNqvlUIyhMeCEGLEfQVk9SYojjgwAd5Heb0WE6bXeyhP9lP3/sX2Efuvgn9/9rbMUYP3oX9l6lJX7wX3/u6W9Gev/441hYmoDH98LunLgzKP7/tiaC84MOPNvlMe6T0SQrtXohgro76eK4e7a0cBr9k0ZnEx3ymLEmt/pKFZ+GzCtfJod1NC2PEqTTpLvacZhx9zjQNprBlOhgLk/9ySvJgC8++nEKqCxM6WhGspcNtrGkLCdA0TGS3kTie/VQDfajtmRuA6qbU6nn26dQLl6g62+NINZ3z4IPjFRB8FgugZxZrWJ+ZkJKpop5WFvvmKz6E8f36nfDNGz6ANnzzA9j7bvgg5uFX78I6+favgjb4x68EAe3Mt7H+Z3//D4Py6FlQZnpp7B1/snBDUH5T4Z+DMqdpRIkAFemh/T1Kj0otY+1qDYO0oqX/kE8lK9jv2gPoN1PqRLyGNaSTo30hCt/h1LPrP4Jn/Nb74HdMj/rbj2J9+OXbsWZ++3aMxZsfvDQof/Z1oGL1KN3Y7sLHowuYD70h+FTyNIhXtfMvw98SwYf7nPuzPoY9Ok50rU4WvjxYhf1sHvS9To9SSPzwdM5+k2UplU2tzgP2zS1pOlsSFXRT83hQXsxMBeVCF3OsFsc+NdCgzzOYS3FKY+R0pDTZNzLwZVMKUqpdRj1xUJlcSm3jFCSuv01UJrbnd8Zkq0T2WBNM6VcDdexxtQGsaXoaMtlXsS9U8ziLcv+4tMcVKph7y4Mg3GnviUn0/0gFhL6FPOzzbXrnSxAJsfpkUJ7L4Uxb7BA9Kg77MbbP44wx2JkPt69j/pzLwn7YAdVuPop+mGyj/rNJtGesh7PKGQXy40QSz3WcqMhMKl7reVYibUQikUgkEolEIpFIJBKJ+lDyo41IJBKJRCKRSCQSiUQiUR9q3fSod3/yYZVNI6SHb91PRvmWb4RTxg0EGSa2xIgeFdVuh+b0pXB7SyPOhP8OxaH7pnQczT7ClAq6bdtQv+n2aRPZwUSb4tQqvgmcw7BZJhqUicrBIdwcVm0ZiFo6vSucrqXV7+sZd9wmW4U/g+lGbxMNiskWPJ84NY7V8RBi6Hjo3zbRo9p8o3cN4aTLZdRz88v7nx6VSqI/Crlnp0fFyWc9CkPly+x1GhT62PW472HPt/oz3clEFGLClOY7hrUizuQ4GvO10KlMc4rnP6cn2D6RBQxrhVYP+R3flr8W3zT5Mqc6mtpvkqnNnJLJdTqKKCT0t11Kk0xEEKbLf+uqcL80rbemm/Y5nLvthlPdlNoYZLeniYtKKTWAaHo1mMW8SsdRLiaJgkFpoKZ1UadHhacGs33MJ2qGYW5rpAamsayBHmUiLWr7jsEX1jK3uQ0sE9Fpvfam9nua/bPTpngfZ5mekSkbJhqOyd5EweDnMlE2THOG0467Hvsj7ZlEj1qsIU1muaKvOf1Kdpu6cI//oc887ZtMj4KPZGIoc3ovp5uxeLw4nUGnnsGGU2MsSjuyHaQh8GYcMcxnq420oF6mEJQ5FSLdorQ+B+k8ThJpRJyeY/J3E/WM289i8hE/C9OgFJ+B2Z5kql+ZztjU/9xvPUqn4r/lPmHalG+oX29DOPGKyV+8tjgxpN6shUbEdTqUtuPSGYP3dKZHLXWRPjNbQ6qOUkq96gp7Q/nmYBrjko6iXIjjOos4nU88w5mT/Zf7n9dtbd800Jq0fY3mSbTHZ7bw9zuWts4b6FFroUGZ2mOaY5x+ZaJl8XcxRdTUVyy+msNEW9bs6fxpokFp7Vfh77M8B3iP6ypqP51RTRRa3gfXYs/vmmZSMaV1V1F/CduLUkqpt98g9CiRSCQSiUQikUgkEolEog0j+dFGJBKJRCKRSCQSiUQikagPtS56VDyq1OSIp1ZqCO/ZSvSoWaJHcUqUS2FFwzEiznRxS3aMfj5yKP2FiUhlIv/UOog1H4wjriitiDijEPZZdgZC7RMKYXJthbDD6RrICFNZ3FDNVA4OtTrVxE3mW9O4odpiogqF6h2p4Fb5i/JnyN4LtT9Qwm38zx8ClcA33AZ/sDwVlC8exM3eNoXhcSjayTrCaLdl0X79eTEu3D9bs7j5POFTWK/SSRVnGviOyQxu0+YxaPgI36y7GI9sFPUy2WLFxxzyad5wSsygjZvWZ13c/D4QR53NLuYH3+jtbiB6VLFgpkedKcFfxjJEBmmhvzdnQLQ52wAxpJhA6GmZ+mlTEvazbaI4se9TiGDR4PspSvHg8EIet1IPIb4tD+HNSRthkDwvqn4hKJvSAdIR9E/LR//c9QD8+v1vQsj0nZ/DfPztX8M686abcWP8X94HYgvTpj573xQ+v+Xs+uzfic9NRB4TtcpEofrTT4BG8eu3HA3Kn7r3kqD8/eMYo6vOB7FrqYU2jKcxB9I++qTiY7w4xZVTXwtWOSjP91BnJkbEQFq3mVCj1MYgu8WiSo0VV+dcvYV5OJVHvy20QDPhMGMmGw56GOuVCGgXJlpitlcOyg0b9TPJcSxOa3AP87xjwxcWHPj1eBTzyqRHSyBB7C6ABmVK0zvcAnnh4hSIDBzqz2lcf7eI+fniMdBYOBWRQ83/pfy8oLy3eDgoOzbRmij98NEqyBGX5tF+FoeFn3GwL2+Jw085HJ2/63Qbe+DWJMgUCRf934xizs85GOvRBHww6WLtqtuFoFztYeyyNmwGXKylKzbq1NOfidzoY37O+UQxi6POZgPf23Voz3T73y+VUipm+2pTYXWc6h2M6Y7EdFCe69GzO+iTZgxny+HKiaC8nAcxJEXkFJfSChpEzmSi5mtuQ/nrd+LcxFSpL/8+9utXvRvr7d/cDSLJZw/vCsq/fCn2puLp/xWUp5/3iqA8uQiq1NzI84PyrR+DX3zyVrShSOSXTrIQlBcyePbR5nRQjrXwXO0M1pNKGmtRvklnbKYjERlnJYO9stg4G2rvpLDW/dXsi4PyjWPfC8p/9MS1QfmmS7GGvJb6+Vvvw5rDtKlvfhDz/2Ufxhh99S7Mn5ffgfXnS/dgnujEPfhppol55RCRiulFTO3JVvDsK0Wst7wmdCj9qktnsF54VkrfKW77anxwdf5VW2j/NgM9Kqr4fRN7wVALfbWUwllIu4aCcvsH2lhja0nM1TJRMose3neYEtUg6hMTjQdd2Mdpne/E4MszFvaR8R7OafEufLyZhC80bcyrrIs2JGnNaRCtiduT9+jMRimT1Qz8kWmJvBdk2kRtTmPNMaUyFZoYr8U0njGuiJ5MdMtiC+vVfHIKz6XQb0yAZfrhXAL2fJ0CE5CHOthz5+JoT8bHOw7TOUe7qP9cDPVznzDtetzD2E37O2CfwDjONbCetDrrJxVLpI1IJBKJRCKRSCQSiUQiUR9KfrQRiUQikUgkEolEIpFIJOpDrYseteX8Pf4t9z6sBjIUTpbG3yeiiL0rpBBamYzS7dwGwgsTavhmZlNYddxAj2J7nVxEFIw1EGe4DSb6iUbBMNCj1mbP7TfQoAy3Z5vsuQ3a7eUUcm9KG9HrR50me1NIv1JrozuxDROGOMRNI9wY6FEstufwUO1Gb4cIGT3Us1SFzUoF9dz6y/1JqFFKqc079vhvu+uHKpUietQAxi5GiZD5NOZSMkY34XsGXyPCFNOjPJO9TQQNi+lR4fZcp5buYbQnmhX56b+FHqXVbyDyRAw+wvOUxe03kddMt+izNIKPH742crgvl5nMxjftO0SE4fb3qA9Nfav1D/Ut+67zDIpcmNgXdaob2tahm/ZX6jpVZBlR98ab9n/aepq4qJTSqIuFDPo2Hadw4gTC4Dn1zzPsg7HI+vZNTnc1kYZYPD9Nc0+3X8O+aaAjmag0/xbymrYPGupnfzHWb/A103qihd8b2qPbU3t4DzRSHcP3cZZGduM9cw3/VueQb/L+2TZQMDTiIvmlUv3rm1MX7vHf/+lVQg1TUEey8Ds+u+ZiSD9JWnoa+NNikgun3ZloLDqdjXyZ6DNOjLBzBkWZlMRkGSLd8Jx3KfWGyVD1WCEoJzw8I89hTuUztd9IRGUKlRe+r+kEVcNawRQt09pFdCqL+t+0FnGfR5gexaQ8JkNRClKPKDwu0amYtsMEIhMdci3idEuuvxvB57zXL3cKQXm2ijYrpdRr9/YpPeo5e/z3ffppehR8qpjBOCaiGN98nH2T6VHha12MCKRMCzXtazxG2j5o2Ec4Pdbyw/dZfV8z0ISt8HOd5uMarfjZ9x1uP6chm/ZB/i5OQ+Z3Pe1djdZATn3S7Lk9tMfxPsX2bMNnTs2exjpmOKOa7JlMzfamd03tXMGpWEQ+5TMtv2sydXdRo0fpZwMTrVgibUQikUgkEolEIpFIJBKJ+lDyo41IJBKJRCKRSCQSiUQiUR9qXfQo215NuehQNN+2Qdy6fK6K27C3pHEb/Lk2iD1jSdw+Pd/G7daTNohFCz3Y56Kov+Lgxuyiwi3TyxHYJy0iEXkIKx3yUH/JplvHKYyqS7dMF1zcIl6hm8O1UDQKl8r18Fy1KG75NoUiM4mgSjQBkz3fEM71m9KJCg7IIFy/FuZN7c/T85Zj6B8OS+Pv4hvRV6Lof+5PpfQwzaKDMViK4ubxRAThjEwP2uRhjOcim4PygI2buEtOISiP27A/14P9YAw3qs+2cIv6aBpx3CdLmIs8vzcKCSMaVWpo0FaNFtq7YxThzWdWEBa7o4C5MV1Ff2zLYU6eqaI/tqQx1qcbGOsJIgfNNDHHJhIYh5kObqQfToBgstTBHB6zaJyJ1pGncWPfH1Jo/5IPEkrGQtg2+z7f9l+28LwcIsu+n+lhXtRstJPTndjXMj20s2VhDeQ6+bsW2nTbfAI+8dEvFoLy7a8rB+U33Ybn/fw98E2mRN1/H2h0b74ZtLg/u++8oPyWm48F5U/eC0rIwycw1numMEaWFR4yWnSf3Y+7RHAY9UEQmPVBAOG1fbGDNoyk0P88P7sbkB4VtZUqPjV1XYro31Eg3yEKz4QF+sCchzVsKAr7lR76atzFWC/F4DtMRmMi33AXc6mcgC8zoYlDmgc68J16YjDUxqY1P00kl1aciHxEfGByRNLBWt4mmkYzgnJSYR1LdTBnWjHUz37HBMNMt4w646A2cHs4ZSzdgX2DnzcSnk6Ya6E/mTbCYfCc7jTYAr2inMLaaKI6DrXh48tJzAcTcXGsi/mwEActJaPQbyUf82fCBYnynD0VlAt2OSgzcXE0ifXhRBVrLxMXnY2yZ9pKjeZX+71N9KvtKfjgjIP1bbIK0tBcHpSxkcZ0UGbC0WAZlKVSAWQl3rOYNvLXx0F9+tWpfwrKv/EZzMO734H2Mw3wC/diT3n9rVgrvvYR2L/8fVjDH7wH5zKmVv3xJ7CG/Gh+KihfvQlkN04j4rSgzDIoWo0RkFNiXSLmJOCzAyvTsB/Gd0Ud+G83jrmdWcLcbg6inzkti9uznMb8H6lhLO76wRVB+Y4rvh+Ub/xzjNEDN2GvfNmdaMPX78Tc/qX3B0X14D04X73udqxp938M55aTXdBqdsTQHiYKMWVsYAFUx8rYRUE53cRZvZTDvj/UxHw4mwSVj1OM3V54+k+/ybaVGhxYna9MjWSy7UwT6+3mLuYeU4SGXZw9+KwyUcN8XhzAuA84eI+rxFD/cA31r+QwjimHqEPxQlAerGOulgcwVzlFjve74RLmWzmPMWVqGO93xSrmT5nmAKcucntGSphLywX4ZppoU9UE1pAhqn8hD0JZ1ikH5VIM69hE+UhQ5rWx0MX5YTGG/Wuy/nhQPpvF3ObxmrPRb5tbGK9z6eeE2s9a8Pfx9vGgfDqJ9ox6sJ9RsJ9y0J7TcdQ/prBfn/PQz9s9kCWnbdjzO+jJHubJZBY+e6yM/bSJbVw7H/5rkkgbkUgkEolEIpFIJBKJRKI+lPxoIxKJRCKRSCQSiUQikUjUh/o306MySfx9PIbyUBphYHzLN9+ozErZSB+wiThjsk8TWYOpGXzbM6cCxSk9wXSbNKc/xK1wyoZrqN9EnOH0IK6f0yUimj3CsLX6lZ529Gz1c3s0ioTB3kTLcnxDe0z1P4MawylVpu/oUBqJZ7gBnNUl8o2rUW3CSRvtHup3iBLVdtHWjovPV2pErCmjztte1Z837Sul1Obz9vi/cdcPVTJJKXtZms80LEyuYTIU32rOSpKNzb5jsE/Hwn2ZaUGshB3umybfZ3smHLk013RfDifNPXOuPq2YwZ7nMss0rz0D2Y19mUlSJtqUrcJ9jW/XZ3sTjY59mZ+d288ykRRM9o7ml3TzPxPBqM5Oj2/UJ1+kcO6uG06oUUqp5TL64pZX9CehZttz9vh3/OH/ScHIJtEn7IPFJMKh4zalIRjmHpMybM0XDL5GKWw8r0z7jkabYupERB+LwN4nAouBOmEip2hzO0L7FBE6NHtD/SaKh7ZPETVDo0xSmhjXr9lT6pPtGfZl6h8mPTGpRNtnKSVqLVRH9mVPWytoLWKqhcE3owZfbveISqPRo4gqRXsm++ZSWT9T9it1cerCPf6HPrPqm/kM+jlP5NMU0aMKMaRCJCgNv0e+xmMa88nXaF6Z5ienNnCKEKf8eOxHNA+ZHtWjuRrtoZ3dWCYoM3WoYyG1p+UjbXDERWqApVGoDIQdA8HKJdqR5js9g++bfK0Xvhax7ytT/dx+pkHR+4/tcvuJZkV9xTQf/i5uQ5doX7yOJR2krGr1W+FrtU7rg691qH7HQtt4Def1YbFdCMqzFYyFUkq94Zr+9c0P/vHT+ybmUjYRfnYtJpGSxnsir3ssvkaD03tdw/tO0odvsi9z//Nc5TQotu/a8DXt/bQHf2eSFPsprxumfZDJYkwk5PZoZF2253c1w5mzo9ie39XC32e7PtrP51XT+2OXrsfo0Zw3vb+3Peofag+f+bX2e4Z3Te3MH26vvS9b4Wd+7V2T3l86vG+ugVSslHnflEgbkUgkEolEIpFIJBKJRKI+lPxoIxKJRCKRSCQSiUQikUjUh1o3PWowp9OjthYRNnamhLC9TAxGDQchQ2Mp0AfONnA7dyZKBCEKmx+Ow362DfsehR5xukQhWg7KSw4oCU0PYV2ZGELRBmyEvK6Q/WIbt76PJHHDdobIRdUebBZaBdgT/YQpHhUf9IpTNVBgtgzgtv8UEXBqPdwWfo6oR5vS6BNT/dy34xmyt2Bf9dD+Shuhs0P8vBEiNfVAMZjvFIKyqX+UUqrk4G+6HkIDeczyNvproUtjHAlPCSjEYM9zIk7j2nQx3kOJclCeJuJFJk5ztIu2lWsUVr5BSBi2pdRA1lIOReufR/SoU8t4vvEBzPn5Bm6wnxzAPGGa1kQWY7rUwpycyOCmfab8FFNErnEQvsjkkXN08386SiHcFIpfpHGeI+IS/9LMc8Tk+5xawmGQ7Ps8T8td+MJgAs/OvsO+2XZhPxCF/6YiKNc92M8RNY/XQw6557DPKj3LYBy+xgSZpo/xnWviWZjwlYxgPjQUxr3ioJyL4Rl5bWHfb7tEDCGfy1lo24JDfmlR+LFhfM81sR4OxLAXzNNY1NGdq3VtAN+M2UqNFlZDaRsdzNzJXDkon6vlyZ6IZhRqOxwDfWCuizWMU0h5nucjRGrz0LfVHvqT0z0GfLSnHIGvrThoWzFO+5qHv61GMDdONkCfYdJHyoMfNSwiqrRBlNiWBtkh2aM1xEYbDlangvJzC6ClJDzMw04EvnCiDQKFqX4mxPG6tDUT3v66hfas0FgwHY8JdEysW6J1hn0568G+pGDvamsXxjrvE4XTGycbzB8O5x6MwH7WBbUqTqmsTRf9NhTHujFNY5qLY82Z62LdqDYoLXQDUN2UUipqIVWYUxW2p0EAOdNG3+Y8IoTSnB9rgCwzmwZpJU+ktloSa/hQZTooL+Rgf8IBxeb8JOgnn/pH0EluvWpfUH7g6OVB+U0XPByUf+U9mNtfuge+9urbMN8+e99UUP7GYVBRrrsIbWYq6HAXqVLpBmwqOfhXLY5nZMpMpj4fas80nKTbCLVnkk6XaG6ZLq1FDRBqagOYqx7ReZjCw+2v5rD+tGzaBzu0b7ZQbiXRJy6lrSUcbE65KuaP1j80B7j9pudlcQpMvob6Z/Mg7/Cas0RE3XqXUiM3CD0qais1nFv1zWYX++bWAeyDZ+rYp9IWnf3pPWPMI/qP2kr2mG8dejcccoguFAX9h1ONorQOD3ZA91uMY6y7lDYVp5Rkpg0uJkAvahD9kNvG9kwP7FhoM6fc5ttEa6L6OxHYcypToY25Nx8nChVNE40A3MXznrWxXvG5pU1n0SGX7CNTqCcWfpZmutNpH/2fo71Ssycy6WmiNQ3a2Iv57DoaQXtOOrAvprC287vAJgvzh+lvk3Qe47PuRAztOdaEfTaOObDUwO8kNdo313qelUgbkUgkEolEIpFIJBKJRKI+lPxoIxKJRCKRSCQSiUQikUjUh1oXPWrzjt3+W3/3hyqTRshuOkk32DOhJotwvmQMZc8LD89LxohQYxEVwkCoYSIVU4N6GoGFbvOm25759mlOs9Ju86YQOLbnG6eZ68Bt0Oqn8GZu23rbwzbaTfuG+rk9TJHg+rn9NtnoNCh6XgOpiet/JlGI28f16mQL2PDfa21ie6LLeH74fNJuDCd7Dg9tO/Rs1BmVOmxWyhin9//HaF/etK+UUhPbd/v/+be/r1IpPGs2QxQSC8+UQ4aESsaJ8mAInY1F0ZdRi8fa5MtExrF5bpNv0rITj8ImSr7Pc0G3x5iYfF9rP/masf41rBU8/1kaPYrmKdubbp63mU5l+A2dbTRf9sPbb7I30bVM4lSmnkaaC/fLbi/c3iS257nU6oavaeW63j/LJTzne1/Tn2S3Lefv8W/+2GrqAtPcmLoYtVHOpbDvpGJEnDH4mmkfdA1zlfc1noemucqh4Bo5zjCXOIWHSUYmkpqJdqTvs7zvhFMnPIMvmPYc3pf4b9nfNXKc4jnJe1T4vuxq+3I4QZEpFUy9NK0zLN4zTe3X6FRkz2cqBgFpvkzUNp24yPXgb9k3l1Z0ItUdr+vPfXPrBXv893zqKXpUFs/OdEXeL/IJpIYlo0itNq2la/EFVjyCOpnaxjLR0FhMLNLmQITJLLxW85kQbePU+BhRqJikppGwiJKjkebWSWrTSXBMjiPCC9OjDKQ522RvINmZ2s/PaFpbWNye9fYPP69JDtFWmRLIxDde/0stpGPMV3Sa0k3XRfrWN2/9eNi+SWdFuj0hl8RYM/HNdA6J2xiLmIFWzH7N1zmwX5v2QabyWYZ9U6cXha8VPL6eCq8/soZ9xNQeJvGa9h3TGY/ttTPtGs6EvK5q7THUz/a8h/J1CnxG4n3NRKTlfZB/c+DvMr1rWvSMfAbQ3jWp/laXz1doW6VB1GIiFStlPtNKpI1IJBKJRCKRSCQSiUQiUR9KfrQRiUQikUgkEolEIpFIJOpDrYse5XQ9NXO2rnJ5hOFdcB5RdyoI7xnOIQZoroSvGc0jtGmhglCibcMID1usof5CGmFpSzWEcm0t4vPFBtqQiaOeUhP2m/O43X2FwgU5BL3UwvduyeO26nIH9hw6VW0jTJGJPBWytyidpNaB/UQWN71Xu7Bnsf1YhqhVXbo53NSeLNrD7efQNVP7Tc9bbsF+c47s26lQe6WUWm6iT8cHMAZ8gzaPwVKd+qiAG+EX60T/imMO8ZwYL+CG7rkK6smnYb9Ic47DKytEjKo10J52Sw/17lc5jqcW5hoqm0N/D+bRx6UKnmOkgDC/+RWUx4rog4USfs/dMoIxnS+j00bIl+dL5Muj6L95GoehbLgvTwxi3BY030c9y3Xy/UGiGrUxLzRfbtI8ysGe5yqnWZl8p0ZUMQ4TbXTQnmIa85rJShyW2XZhP5LG2lInYguHU3ZcrJmDSdSvhXdSqC2HZQ4l0f6Wg/7hv2061P4k/IzXlpiN/qnQ2riJaGKlNq0t5Pvc/+z3vFanyY8Xq7DndKFyDfOz1tDXlmaz/32z2/XU6VOr/TU8ime/YBvGYqWKcR+itOKFGsZikPdBWiO3DhLZrYmxyCaQXrHSRD1b8kQ1ImJgnMaafWpThtZ5mkscXl7tYG5szoLawFQyTitoEk1ylEiLTRf1sFoG+mSjh+fldAC2H07B1xrUflad5jyTGbn9rBrZj6bR/rrD+yz5Tgf2E5lyUGZKHe/LKy1qD/naYgP2mQSdf2hv3JwLnw/pePj5aoLORfM1zM+BJOwXqlgr2Dc5jbhaw/O2Nsie2e166tSp1bVvdJQohzn4IO87o2n4wjJRFItJ9PlCE59PZkEkWeqAOMZEwqUW6E5b0iCbrPRAGkpa2B9LDuzHEiCY1D3MjVQEqUxVB+0Zi6L+tsJY81ytO3SWjqGdTEDjFMWaCx9h0goT5TjNkH1qLAYyTl0VgnKMaDjVLto/boOaxPVz+/l5R6Mg49Qj+VD7OtH0xhTaX7fRHl676kSKLEYxvkyH5DQ3U/9XIhhfi1LDyvS8o3GMb8nF86ZsjO88UWs5zadMa0ilib2GaTX9rE7HU9OnVs9txSE8y3N3YJ1f5n2TUhpnqlj3RgfQV7yfbinAl2dq8KmhNM5CC3XUs62AfWGhhbnEpEtebzdlse8sN2HPKZZsvzUHQhmvFZzqtUzvraa1JU1pm0tNzNXJAaIN0pzJUPt5f+EzMPdPMYX2z9ao/fkafY45XCB73l+2Uf/P0/fmk9SeOtbkyTzWorka+WCGSKM0vpOFcKr1aI7eNar8ewLsZyqwHxkge3qX2VLEPJkp47mGs+j/uSrO8DaFx1Tq9B7RhO+v9TwrkTYikUgkEolEIpFIJBKJRH0o+dFGJBKJRCKRSCQSiUQikagPta70KMuOqHQmplwXIT0nTyF8KB7Hb0AnZlB1iqKeT8zQjc0UantqCUactjJdQ0gS3wh9lkKemG5zroR6+JbmMz6FgpP9SoNunqfboWctCnekNIoSpfswbWcugrDPGBFz6k2+3RrtmY/kQu1rbdh3XL5xGvUzwWeFUqiYzjMXGSB71L9C9TsuPa8y2FMaCD8vh8CxPYfuP/M7zlAoqk3PsEzh2kykOL2cDrUvUWpNjyLKph3UQ7AkNT1HN4B7RJXqhoeKUrSqcrpeqE2/ybIiKvUM35w+jdBE9s3jZ9AfiQQ66iSij7XUnpOzTKFCn7Ev823q0/OYA3GCFZycj5E9Pj/dC/f9U41w3z9H4YsxTqVpoB5P84UM2XMKD9+cD/sFky93yHfIF3p+eP2tru4LT8si3+QUJE6HZL/xVXgaS7NrojWF+ybXz+S0LoW4cwrYSoP8jPpzhtYi9staC/Zdg9/zPFmhtb2LKGDlIPpe81fX1f3VcfrfNy0rorIDq8/Ja8nJs0QqJN88uYAQ33QCz3t6KTx16HQJY8H7WrkZnnLLoc48V5cN+9qMF26/QvY0RGreKpA95iqnE3Z7/G9F+VD7ZpfmHs3tJQv2nKJVoxQkJhx5VD/7AreH0xLnI9R+SjfgFLCuG95+W6sf7WEy2gyngVB/LlHqccdh30H/MyVkmUL3+ZxzqgffZ99cqibD7Sndg31/ucLnCtg75KceVcRnm2f6ab/KtiMqO7A6D1odPMATZzE3krQ/nighRSVNtNPjK/icdbKHlCLdd/A574NnI5uCMs/tlRbGiOdqzx9B/TRXV9zwtD6lUD9T4WqUcsW0FN8fDa2/4cKe99n5+HhQZppMrYP0AZ0OMxZa/zK1h+fqXGQivP0dar9GR0X9TM1ruvAFXlsiMbQ/7lOKloP+57TlTg/18/Mut+GDTPzxqP/1tQX9w2nO3R7s+TzGaSy8ljo9onRRv7UJRNbpbBzfHHhq33QdtPnoKZQTtD8encN6mIzj8+Pz+JzPkMdojvG+eayOseOz7qkyfJyJqCsN2PMZqU3pbHzmWW7kQj8/XR0Kytq+QOnk2ruRF27P9bP9KR/2nIq7TM/L+36jUwht59Fa+NrC/ckptMcplYl1wgu3P7EIe57DxynNkN8ReHz5HHK0E/69R2fg+9p8mKczKm3vx2bDU6r5e3X78HNRm/zOp//R6/H5dm3nWYm0EYlEIpFIJBKJRCKRSCTqQ8mPNiKRSCQSiUQikUgkEolEfah1pUf1ep6qVzuqvISbn3dePhmUjxxYCMq7LkNo37EToLds3YKwooMHcCP3i65GONnhJxHPNzGOkL8jh0FquPLyAuo/jlDD0WH8DnXwEOyvvQrhVQeehP3EJoTCHjqCG6qv2IVwqSdPI45qaBD17z8E+6v24LmOTMNmdIjacwQ3VO95IcLeZnCJvhomss++Q+i3K3fB/sRZ2Ov1w/6ynWjP2Tm6ZZ3av+9gePtPnrND7U39c2oGbS4WOE1Dqf0HcYv65bsQEvfEaYSrDtMzHDmCMduzC6HnR08iXHV0hMaMxnjXpQXUfxy3e0+MI8Tt4AHcou5R/GA0RjSXedRp2Rvjd81ez1PVUktVVzBGu/ZuDcqH9oGk8IJd8M0TxzE+O87D+Bw+iNvsr7gC4dwHD8H3t29HqOSRw/DlSy8FGeGJYxiHyc0YhwMHy0H56r3w/YOPw37rFsx5nhdXXoZ2crjs2Ajm3oGDaOc1V2CuHjkBm4kxmtuPwzcv34l2npkn8l0Rf/vYQfja3t1o58HjsNk8hjl1+Emkqu1+Pta0mUUi6aDb1GOHYH/FToRcnpwhWhqGRR2iNXPnxVw/2jNCUfyPHEA/X7Ubz3voOPpzM/XPgcOYV3t3Y604fgZ1DlP/sN9fsRtr7/FTWHvZ7w/SfLD0JSTQ4mxZ+297A/hmr+epSnl1LJs1pBJfshOpDUcOYU3aeyXCmB8/jjVvM+2DBw7CF372mvB9bfN4+L529WUYuydOhe9Tjx6A/XVXYm4/+iRsJjfxvoO5dOUuzNUz888+t6/ZjXYenCZKFLpBHXwCc3v3JWjP/AraMFzAWv7oIfTb3p3w36Nn4Y/sOwceR/2XPR/tObuIZxkuwP7RA2j/VbvR5uPniDREvnDgcHj/TM/Chvd97n/2tcdPwDfHkZmh+drePZgPT5zAfBgbCT8XXb47T/bot/Exmm/7sbb3DHvm8lw5KG8Ev1TqKeLi/Oo6Xi1h/b/6RUiT4b79+Wuwj+w7hmec2oyx+/E+1PPSqzEfHj6CvrpgG+wfOYi59/NX0ucnsbduHUWf/2Afzk0vvRLP8qOjsN8xAfufHEb5ul0Y06NzGPfNRGL9l/2YY79wGdr8yDT23G1jaMNPDsP+Wto3TyzATzcVUP8PDsD+JXtozZnGvN1K9MlHjnD9QVEdmy+Etv/71P6f24P+f+wUnnfrCOx/fAR9/jMvpFTxRbR/fBBj9P39sLluF9rz4+OYG9vHn73/981Q/UX4qT6+eJYfHyNy0Ch9vg97ytOpfkop1emgzjMnsb9EObekj+W6niqVVtfZ6gq9N12BhW//PjzX1VeF75s7tqLPf/Io1r2fuwb+8uOD6PPzt2N9fmQ/znjXXoHxYt/nM9Ij+7Fu/+xe2PMc2L4V/X/gMJ7r2svhO4enYbNphPcF2F93Jdr56DE6E9I6v+8Q7K/ZA/tDtO+zPbef3+/2P4n+4f58dH/4Ge8g2U9tCbfnferwSfTP5Lj17PZHMb5bJ1H/Y/swvs+/BP5+/AT23wvOx7g89lg5KO/cWQjKTx7H/n7e9mSo/Z7dsH/8KOy3b4P9vkfD902LDrilRTzjWvfNjbG7ikQikUgkEolEIpFIJBL9O1PE59t+ns04EllUSp36f9cckaivtc336fa/PpL4pujfufrSN8UvRSLxTZGoTyW+KRL1p0J9c10/2ohEIpFIJBKJRCKRSCQSif7/SNKjRCKRSCQSiUQikUgkEon6UPKjjUgkEolEIpFIJBKJRCJRH0p+tBGJRCKRSCQSiUQikUgk6kPJjzYikUgkEolEIpFIJBKJRH0o+dFGJBKJRCKRSCQSiUQikagPJT/aiEQikUgkEolEIpFIJBL1oeRHG5FIJBKJRCKRSCQSiUSiPpT8aCMSiUQikUgkEolEIpFI1IeSH21EIpFIJBKJRCKRSCQSifpQ/xteci4Jj84SPwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17:57:25 prod-0001 SmartSim[61617] INFO fd_simulation_0(61776): Completed\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17:57:58 prod-0001 SmartSim[61617] INFO fd_simulation_1(61784): Completed\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# connect a SmartRedis client to retrieve data while the\n", + "# simulation is producing it and storing it within the\n", + "# orchestrator database\n", + "\n", + "client = Client(address=db.get_address()[0], cluster=False)\n", + "\n", + "num_tests = 5\n", + "rng = default_rng()\n", + "# Choose some random samples from the simulation\n", + "sample_indices = rng.choice(steps//5, size=num_tests, replace=False)\n", + "sample_indices.sort()\n", + "\n", + "samples = []\n", + "for sample_idx in sample_indices:\n", + " u_steady_name = ensemble.entities[0].name + \".{sim_data_\" + str(sample_idx)+ \"}.u_steady\"\n", + " client.poll_key(u_steady_name, 300, 1000)\n", + " samples.append(client.get_tensor(u_steady_name).squeeze())\n", + " \n", + "pcolor_list(samples, \"Simulation\")\n", + "\n", + "for i in range(0, epochs//10):\n", + " nn_name = f\"DiffusionResNet_{nn_depth}_{i}\"\n", + " client.poll_key(nn_name, 300, 1000)\n", + " ml_steady = []\n", + " for sample_idx in sample_indices:\n", + " u_init_name = ensemble.entities[0].name + \".{sim_data_\" + str(sample_idx)+ \"}.u_init\"\n", + " client.run_model(nn_name, inputs=[u_init_name], outputs=[f\"ml_steady_{sample_idx}\"])\n", + " ml_steady.append(client.get_tensor(f\"ml_steady_{sample_idx}\").squeeze())\n", + "\n", + " pcolor_list(ml_steady, f\"Model at training epoch {(i+1)*10}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7bbce88c-6f63-407a-8912-5787139f015b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Optionally clear the database\n", + "client.flush_db(db.get_address())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7d9f2669-4efb-4f38-97e9-869a070ab79c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17:58:00 prod-0001 SmartSim[61617] INFO tf_training(61792): Completed\n", + "17:58:04 prod-0001 SmartSim[61617] INFO Stopping model orchestrator_0 with job name orchestrator_0-CIP2C9QSETQV\n" + ] + } + ], + "source": [ + "# Use the Experiment API to wait until the model\n", + "# is finished and then terminate the database and\n", + "# release it's resources\n", + "while not all([exp.finished(ensemble), exp.finished(ml_model)]):\n", + " time.sleep(5)\n", + " \n", + "exp.stop(db)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2bca8a25-6e1b-4540-9d1e-932eb52d7b1e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Completed', 'Completed', 'Completed']" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exp.get_status(ensemble, ml_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "50b42065-6356-4a5a-b742-daca17b8bd6e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Name Entity-Type JobID RunID TimeStatus Returncode
0fd_simulation_0Model 61776 0124.276Completed 0
1fd_simulation_1Model 61784 0157.534Completed 0
2tf_training Model 61792 0159.324Completed 0
3orchestrator_0 DBNode 61701 0183.885Cancelled -9
" + ], + "text/plain": [ + "'\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n
Name Entity-Type JobID RunID TimeStatus Returncode
0fd_simulation_0Model 61776 0124.276Completed 0
1fd_simulation_1Model 61784 0157.534Completed 0
2tf_training Model 61792 0159.324Completed 0
3orchestrator_0 DBNode 61701 0183.885Cancelled -9
'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exp.summary(format=\"html\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2260d2f7-f986-4651-821a-aa5d0b25968d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "smartsim", + "language": "python", + "name": "smartsim" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/ml_training/surrogate/vishelpers.py b/tutorials/ml_training/surrogate/vishelpers.py new file mode 100644 index 000000000..8a0fe1d29 --- /dev/null +++ b/tutorials/ml_training/surrogate/vishelpers.py @@ -0,0 +1,32 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib import cm + + +def pcolor_list(list_of_images, title=""): + try: + fig, axes = plt.subplots(1, len(list_of_images)) + + fig.set_size_inches(4*len(list_of_images),4) + for (ax, mat) in zip(axes, list_of_images): + ax.pcolor(mat, cmap=cm.coolwarm, clim=[0,1]) + ax.get_xaxis().set_visible(False) + ax.get_yaxis().set_visible(False) + ax.set_aspect('equal') + except: + fig = plt.figure(figsize=(4,4)) + plt.pcolor(list_of_images) + plt.axis("off", cmap=cm.coolwarm, clim=[0,1]) + ax = plt.gca() + ax.get_xaxis().set_visible(False) + ax.get_yaxis().set_visible(False) + ax.set_aspect('equal') + + plt.suptitle(title, y=0.92, fontsize=14) + plt.show() + + fig = plt.figure(figsize=(0.00001, 0.00001)) + dummy = plt.plot(0,0) + gca = plt.gca() + gca.set_visible(False) + plt.show(dummy) \ No newline at end of file diff --git a/tutorials/ml_training/tf/data_uploader.py b/tutorials/ml_training/tf/data_uploader.py deleted file mode 100644 index e05ed87a0..000000000 --- a/tutorials/ml_training/tf/data_uploader.py +++ /dev/null @@ -1,30 +0,0 @@ -from smartsim.ml import TrainingDataUploader -from os import environ -from time import sleep -import numpy as np -from mpi4py import MPI - -comm = MPI.COMM_WORLD -mpi_rank = comm.Get_rank() -mpi_size = comm.Get_size() - -batches_per_loop = 10 - -data_uploader = TrainingDataUploader(num_classes=mpi_size, - smartredis_cluster=False, - producer_prefixes="uploader", - num_ranks=mpi_size, - rank=mpi_rank) - -if environ["SSKEYOUT"] == "uploader_0" and mpi_rank==0: - data_uploader.publish_info() - - -# Start "simulation", produce data every two minutes, for thirty minutes -for _ in range(15): - new_batch = np.random.normal(loc=float(mpi_rank), scale=5.0, size=(32*batches_per_loop, 224, 224, 3)).astype(float) - new_labels = np.ones(shape=(32*batches_per_loop,)).astype(int) * mpi_rank - - data_uploader.put_batch(new_batch, new_labels) - print(f"{mpi_rank}: New data pushed to DB") - sleep(120) diff --git a/tutorials/ml_training/tf/training_service.py b/tutorials/ml_training/tf/training_service.py deleted file mode 100644 index 4d5a96953..000000000 --- a/tutorials/ml_training/tf/training_service.py +++ /dev/null @@ -1,16 +0,0 @@ -import tensorflow.keras as keras - -from smartsim.ml.tf import DynamicDataGenerator - - -training_generator = DynamicDataGenerator(cluster=False, verbose=True) -model = keras.applications.MobileNetV2(weights=None, classes=training_generator.num_classes) -model.compile(optimizer="Adam", loss="mse", metrics=["mae"]) - -print("Starting training") - -for epoch in range(100): - print(f"Epoch {epoch}") - model.fit(training_generator, steps_per_epoch=None, - epochs=epoch+1, initial_epoch=epoch, batch_size=training_generator.batch_size, - verbose=2) diff --git a/tutorials/ml_training/tf/training_service_hvd.py b/tutorials/ml_training/tf/training_service_hvd.py deleted file mode 100644 index dbe7720b1..000000000 --- a/tutorials/ml_training/tf/training_service_hvd.py +++ /dev/null @@ -1,39 +0,0 @@ -import tensorflow.keras as keras -import tensorflow as tf - -from smartsim.ml.tf import DynamicDataGenerator - -import horovod.tensorflow.keras as hvd - -# HVD initialization -hvd.init() -hvd_rank = hvd.rank() -hvd_size = hvd.size() - -gpus = tf.config.experimental.list_physical_devices('GPU') -for gpu in gpus: - tf.config.experimental.set_memory_growth(gpu, True) -if gpus: - tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], 'GPU') - - -training_generator = DynamicDataGenerator(cluster=False, init_samples=True, replica_rank=hvd_rank, num_replicas=hvd_size) -model = keras.applications.MobileNetV2(weights=None, classes=training_generator.num_classes) - -opt = keras.optimizers.Adam(0.001 * hvd.size()) -# Horovod: add Horovod Distributed Optimizer. -opt = hvd.DistributedOptimizer(opt) -model.compile(optimizer=opt, loss="mse", metrics=["mae"]) -callbacks = [ - # Horovod: broadcast initial variable states from rank 0 to all other processes. - # This is necessary to ensure consistent initialization of all workers when - # training is started with random weights or restored from a checkpoint. - hvd.callbacks.BroadcastGlobalVariablesCallback(0), -] - -print("Starting training") - -for epoch in range(100): - model.fit(training_generator, steps_per_epoch=None, callbacks=callbacks, - epochs=epoch+1, initial_epoch=epoch, batch_size=training_generator.batch_size, - verbose=2 if hvd_rank==0 else 0) diff --git a/tutorials/ml_training/torch/data_uploader.py b/tutorials/ml_training/torch/data_uploader.py deleted file mode 100644 index 30b4a43d3..000000000 --- a/tutorials/ml_training/torch/data_uploader.py +++ /dev/null @@ -1,30 +0,0 @@ -from smartsim.ml import TrainingDataUploader -from os import environ -from time import sleep -import numpy as np -from mpi4py import MPI - -comm = MPI.COMM_WORLD -mpi_rank = comm.Get_rank() -mpi_size = comm.Get_size() - -batches_per_loop = 10 - -data_uploader = TrainingDataUploader(num_classes=mpi_size, - cluster=False, - producer_prefixes="uploader", - num_ranks=mpi_size, - ranks=mpi_rank) - -if environ["SSKEYOUT"] == "uploader_0" and mpi_rank==0: - data_uploader.publish_info() - - -# Start "simulation", produce data every two minutes, for thirty minutes -for _ in range(15): - new_batch = np.random.normal(loc=float(mpi_rank), scale=5.0, size=(32*batches_per_loop, 3, 224, 224)).astype(float) - new_labels = np.ones(shape=(32*batches_per_loop,)).astype(int) * mpi_rank - - data_uploader.put_batch(new_batch, new_labels) - print(f"{mpi_rank}: New data pushed to DB") - sleep(120) diff --git a/tutorials/ml_training/torch/training_service.py b/tutorials/ml_training/torch/training_service.py deleted file mode 100644 index cd8cc1794..000000000 --- a/tutorials/ml_training/torch/training_service.py +++ /dev/null @@ -1,56 +0,0 @@ -import torchvision.models as models - -from smartsim.ml.torch import DynamicDataGenerator, DataLoader - -import torch -import torch.nn as nn -import torch.optim as optim - - -if __name__ == '__main__': - torch.multiprocessing.set_start_method('spawn') - training_set = DynamicDataGenerator(cluster=False, - shuffle=True, - batch_size=32, - init_samples=False) - trainloader = DataLoader(training_set, - batch_size=None, - num_workers=2) - model = models.mobilenet_v2().double().to('cuda') - criterion = nn.CrossEntropyLoss() - optimizer = optim.Adam(model.parameters(), lr=0.0001) - print("Started training") - - for epoch in range(50): # loop over the dataset multiple times - - running_loss = 0.0 - epoch_running_loss = 0.0 - output_period = 100 - print(f"Epoch {epoch}") - for i, data in enumerate(trainloader): - # get the inputs; data is a list of [inputs, labels] - inputs, labels = data[0].double().to('cuda'), data[1].to('cuda') - # zero the parameter gradients - optimizer.zero_grad() - - # forward + backward + optimize - outputs = model(inputs) - loss = criterion(outputs, labels) - loss.backward() - optimizer.step() - - # print statistics - running_loss += loss.item() - epoch_running_loss += loss.item() - - if i % output_period == (output_period-1): # print every "output_period" mini-batches - print('[%d, %5d] loss: %.3f' % - (epoch + 1, i + 1, running_loss / output_period)) - running_loss = 0.0 - - - print('[%d, %5d] loss: %.3f' % - (epoch + 1, i + 1, epoch_running_loss / (i+1))) - epoch_running_loss = 0.0 - - print('Finished Training') \ No newline at end of file diff --git a/tutorials/ml_training/torch/training_service_hvd.py b/tutorials/ml_training/torch/training_service_hvd.py deleted file mode 100644 index 1654311cc..000000000 --- a/tutorials/ml_training/torch/training_service_hvd.py +++ /dev/null @@ -1,75 +0,0 @@ -import torchvision.models as models - -from smartsim.ml.torch import DynamicDataGenerator, DataLoader - -import torch -import torch.nn as nn -import torch.optim as optim - -import horovod.torch as hvd - -if __name__ == '__main__': - - # Initialize Horovod - hvd.init() - - hvd_rank = hvd.rank() - hvd_size = hvd.size() - - # Pin GPU to be used to process local rank (one GPU per process) - torch.cuda.set_device(hvd.local_rank()) - - torch.multiprocessing.set_start_method('spawn') - training_set = DynamicDataGenerator(cluster=False, - verbose=True, - init_samples=False, - num_replicas=hvd_size, - replica_rank=hvd_rank) - - trainloader = DataLoader(training_set, - batch_size=None, - num_workers=2) - - model = models.mobilenet_v2().double().to('cuda') - criterion = nn.CrossEntropyLoss() - optimizer = optim.Adam(model.parameters(), lr=0.0001*hvd_size) - optimizer = hvd.DistributedOptimizer(optimizer, named_parameters=model.named_parameters()) - hvd.broadcast_parameters(model.state_dict(), root_rank=0) - print(f"Rank {hvd_rank}: Started training") - - for epoch in range(100): # loop over the dataset multiple times - - running_loss = 0.0 - epoch_running_loss = 0.0 - if hvd_rank == 0: - print(f"Epoch {epoch}") - output_period = 100 - - for i, data in enumerate(trainloader): - # get the inputs; data is a list of [inputs, labels] - inputs, labels = data[0].double().to('cuda'), data[1].to('cuda') - # zero the parameter gradients - optimizer.zero_grad() - - # forward + backward + optimize - outputs = model(inputs) - loss = criterion(outputs, labels) - loss.backward() - optimizer.step() - - # print statistics - running_loss += loss.item() - epoch_running_loss += loss.item() - - if hvd_rank == 0: - if i % output_period == (output_period-1): # print every "output_period" mini-batches - print('[%d, %5d] loss: %.3f' % - (epoch + 1, i + 1, running_loss / output_period)) - running_loss = 0.0 - - if hvd_rank == 0: - print('[%d, %5d] loss: %.3f' % - (epoch + 1, i + 1, epoch_running_loss / (i+1))) - epoch_running_loss = 0.0 - - print('Finished Training') \ No newline at end of file diff --git a/tutorials/ml_training/train_tf.ipynb b/tutorials/ml_training/train_tf.ipynb deleted file mode 100644 index c31f8a417..000000000 --- a/tutorials/ml_training/train_tf.ipynb +++ /dev/null @@ -1,494 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Train a Neural Network loading data from and to SmartSim\n", - "\n", - "In this tutorial, we will see how one can set up a workflow in which one or multiple processes produce data (e.g. in a simulation) and one or multiple processes consume the data to train a neural network. The key to achieve this behavior is to use SmartSim to load data from and to the database.\n", - "\n", - "This tutorial works on Slurm, but can easily be adapted to any supported Workload Manager (PBS, Cobalt, or LSF), with an only difference: in Slurm, we are allocating the resources *from* this Notebook, whereas with other WLMs, this Notebook has to be started *within* an existing allocation.\n", - "\n", - "Note: this tutorial requires the python packages `tensorflow`, `mpi4py` and `horovod`.\n", - "\n", - "## 1. First scenario: an ensemble of parallel producers and a single trainer\n", - "\n", - "The first use case is similar to a common workflow:\n", - "- several copies of a simulation (possibly with different initializations) are running, each one consisting of multiple MPI ranks. Each rank produces samples (e.g. data points computed by the simulation) at regular intervals (e.g. each time iteration)\n", - "- a neural network has to be trained on the data produced by the simulation, and as new data is produced, the neural network needs to add it to its training data set.\n", - "\n", - "\n", - "### 1.1 Workflow components\n", - "We will use SmartSim to allow the exchange of data between the data-producing processes and the training service. Thus, the first component which we will need to launch is the `Orchestrator`. This is a fairly small example, thus we will run a single-node DB." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from smartsim import Experiment\n", - "from smartsim.database import SlurmOrchestrator\n", - "from smartsim.settings import SrunSettings\n", - "from smartsim import slurm\n", - "\n", - "def launch_cluster_orc(experiment, port, alloc):\n", - " \"\"\"Spin up a cluster\"\"\"\n", - " db = SlurmOrchestrator(port=port,\n", - " db_nodes=1,\n", - " batch=False,\n", - " alloc=alloc,\n", - " interface=\"ib0\")\n", - " \n", - "\n", - " # generate directories for output files\n", - " # pass in objects to make dirs for\n", - " experiment.generate(db, overwrite=True)\n", - "\n", - " # start the database on interactive allocation\n", - " experiment.start(db, block=True)\n", - "\n", - " return db\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Our data will be very simple: each rank will produce random samples, drawing values from a Gaussian distribution centered at the rank id, and each sample will be labeled with the rank id. The neural network will be trained to infer which rank produced a data sample. Thus, our data set will have a total number of labels equal to the number of ranks in each replicas.\n", - "\n", - "The data-producing processes will be started as part of an ensemble of two replicas (this mimics the execution of two copies of the simulation). The actual script producing the data is called `data_uploader.py` and is contained in the `tf` directory. Its content is\n", - "\n", - "```python\n", - "\n", - "from smartsim.ml import TrainingDataUploader\n", - "from os import environ\n", - "from time import sleep\n", - "import numpy as np\n", - "from mpi4py import MPI\n", - "\n", - "comm = MPI.COMM_WORLD\n", - "mpi_rank = comm.Get_rank()\n", - "mpi_size = comm.Get_size()\n", - "\n", - "batches_per_loop = 10\n", - "\n", - "data_uploader = TrainingDataUploader(num_classes=mpi_size,\n", - " cluster=False, \n", - " producer_prefixes=\"uploader\",\n", - " num_ranks=mpi_size,\n", - " rank=mpi_rank)\n", - " \n", - "if environ[\"SSKEYOUT\"] == \"uploader_0\":\n", - " data_uploader.publish_info()\n", - "\n", - "# Start \"simulation\", produce data every two minutes, for thirty minutes\n", - "for _ in range(15):\n", - " new_batch = np.random.normal(loc=float(mpi_rank), scale=5.0, size=(32*batches_per_loop, 224, 224, 3)).astype(float)\n", - " new_labels = np.ones(shape=(32*batches_per_loop,)).astype(int) * mpi_rank\n", - "\n", - " data_uploader.put_batch(new_batch, new_labels)\n", - " print(f\"{mpi_rank}: New data pushed to DB\")\n", - " sleep(120)\n", - "\n", - "\n", - "```\n", - "\n", - "as the script is running in python, we can use the `TrainingDataUploader` class, which streamlines uploading of the data samples from the simulation. Here is an explanation of the arguments:\n", - "- `num_classes` is the number of classes of our training data set\n", - "- `smartredis_cluster=False` specifies that the DB is not a cluster (it is a single shard)\n", - "- `producer_prefixes` is used to identify the SmartSim entity names of the processes producing data: this is useful in the case the training service has several incoming entities (as defined in SmartSim, through the environment variable `SSKEYIN`), but it should expect data only from a subset of them. \n", - "- `num_ranks` is the number of concurrent data loaders withing this application, in this case it is simply the number of MPI ranks, as each process will upload its own data.\n", - "\n", - "At each iteration, each rank of \"simulation\" calls `put_batch` to upload a batch of samples and the corresponding labels. The batch will be uploaded on the DB and stored under a key composed by a prefix (defaulting to `samples`), the sub-index, and the iteration number, which increases monotonically every time a batch is uploaded.\n", - "\n", - "Now that we know the content of `data_uploader.py`, we can create an entity representing the uploader ensemble." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def create_uploader(experiment, alloc, nodes=1, tasks_per_node=1):\n", - " \"\"\"Start an ensemble of two processes producing sample batches at\n", - " regular intervals.\n", - " \"\"\"\n", - " srun = SrunSettings(exe=\"python\",\n", - " exe_args=\"data_uploader.py\",\n", - " env_vars={\"PYTHONUNBUFFERED\": \"1\"},\n", - " alloc=alloc)\n", - " srun.set_nodes(nodes)\n", - " srun.set_tasks_per_node(tasks_per_node)\n", - "\n", - " uploader = experiment.create_ensemble(\"uploader\", replicas=2, run_settings=srun)\n", - "\n", - " # create directories for the output files and copy\n", - " # scripts to execution location inside newly created dir\n", - " # only necessary if its not an executable (python is executable here)\n", - " uploader.attach_generator_files(to_copy=[\"./tf/data_uploader.py\"])\n", - " experiment.generate(uploader, overwrite=True)\n", - " return uploader" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The last component of our workflow is the trainer. This process will keep downloading samples as they are produced, and use them to train a neural network.\n", - "\n", - "Here is the content of the `training_service.py` script, stored in the `tf` directory\n", - "\n", - "```python\n", - "import tensorflow.keras as keras\n", - "\n", - "from smartsim.ml.tf import DynamicDataGenerator\n", - "\n", - "training_generator = DynamicDataGenerator(cluster=False, verbose=True)\n", - "model = keras.applications.MobileNetV2(weights=None, classes=training_generator.num_classes)\n", - "model.compile(optimizer=\"Adam\", loss=\"mse\", metrics=[\"mae\"])\n", - "\n", - "print(\"Starting training\")\n", - "\n", - "for epoch in range(100):\n", - " print(f\"Epoch {epoch}\")\n", - " model.fit(training_generator, steps_per_epoch=None, \n", - " epochs=epoch+1, initial_epoch=epoch, batch_size=training_generator.batch_size,\n", - " verbose=2)\n", - "```\n", - "\n", - "The key component is the `DynamicDataGenerator` object. Since the DB contains the metadata of the `TrainingDataUploader`, and these are stored under a default key, the `DynamicDataGenerator` will retrieve them and use them to know the key of the uploaded batches of samples and labels. We create a SmartSim entity representing the trainer and we are ready to go!\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def create_trainer(experiment, alloc):\n", - " \"\"\"Start a process running a training service which will\n", - " download batches from the DB.\n", - " \"\"\"\n", - " srun = SrunSettings(exe=\"python\",\n", - " exe_args=\"training_service.py\",\n", - " env_vars={\"PYTHONUNBUFFERED\": \"1\"},\n", - " alloc=alloc)\n", - " srun.set_tasks(1)\n", - "\n", - " trainer = experiment.create_model(\"trainer\", srun)\n", - "\n", - " # create directories for the output files and copy\n", - " # scripts to execution location inside newly created dir\n", - " # only necessary if its not an executable (python is executable here)\n", - " trainer.attach_generator_files(to_copy=\"./tf/training_service.py\")\n", - " experiment.generate(trainer, overwrite=True)\n", - " return trainer" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### 1.2 Request an allocation\n", - "\n", - "We need one node for the DB, two for the producer ensemble, and one for the trainer, thus we request 4 nodes to be allocated." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "tags": [] - }, - "outputs": [], - "source": [ - "alloc = slurm.get_allocation(nodes=4, time=\"03:00:00\", options={\"constraint\": \"V100\", \"partition\": \"spider\"})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.3 Run the workflow\n", - "\n", - "Now that all components are available, we create the SmartSim experiment representing our workflow. \n", - "Notice that the line\n", - "```python\n", - "uploader_model.enable_key_prefixing()\n", - "```\n", - "sets the ``uploader`` process so that tensor keys produced within it will be prefixed with its\n", - "SmartSim entity name, and the lines\n", - "```python\n", - "for uploader in uploader_model.entities:\n", - " trainer_model.register_incoming_entity(uploader)\n", - "```\n", - "make sure that each uploader replica (within the ensemble) is set as an incoming entity of the `trainer_model`. This will allow the `trainer_model` to know which processes are producing batches it will need to download.\n", - "\n", - "We call `exp.start` and the workflow is launched! As the trainer was started with `verbose=True`, we can look at its output in `launch_streaming`: we will see that it keeps downloading batches at the end of each epoch, as expected. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp = Experiment(\"launch_streaming\", launcher=\"slurm\")\n", - "\n", - "db_port = 6780\n", - "\n", - "# start the database\n", - "db = launch_cluster_orc(exp, db_port, alloc)\n", - "uploader_model = create_uploader(exp, alloc, 1, 2)\n", - "uploader_model.enable_key_prefixing()\n", - "exp.start(uploader_model, block=False, summary=False)\n", - "trainer_model = create_trainer(exp, alloc)\n", - "for uploader in uploader_model.entities:\n", - " trainer_model.register_incoming_entity(uploader)\n", - "\n", - "exp.start(trainer_model, block=True, summary=False)\n", - "\n", - "print(exp.summary())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "exp.stop(db, uploader_model, trainer_model)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "Finally, we release the allocation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "slurm.release_allocation(alloc)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2 Second scenario: an ensemble of parallel producers and a distributed trainer\n", - "\n", - "In the second scenario, we use Horovod to distribute the training and use multiple ranks. Each rank will download only a portion of the dataset, thus speeding up the download and training process.\n", - "\n", - "\n", - "### 2.1 Workflow components\n", - "The only component we change with respect to the previous example, is the training service, which is now defined in `training_service_hvd.py`:\n", - "\n", - "```python\n", - "import numpy as np\n", - "import tensorflow.keras as keras\n", - "import tensorflow as tf\n", - "\n", - "from smartsim.ml.tf import DynamicDataGenerator\n", - "\n", - "import horovod.tensorflow.keras as hvd\n", - "\n", - "# HVD initialization\n", - "hvd.init()\n", - "hvd_rank = hvd.rank()\n", - "hvd_size = hvd.size()\n", - "\n", - "gpus = tf.config.experimental.list_physical_devices('GPU')\n", - "for gpu in gpus:\n", - " tf.config.experimental.set_memory_growth(gpu, True)\n", - "if gpus:\n", - " tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], 'GPU')\n", - "\n", - "\n", - "training_generator = DynamicDataGenerator(cluster=False,\n", - " replica_rank=hvd_rank, \n", - " num_replicas=hvd_size,\n", - " verbose=True)\n", - "model = keras.applications.MobileNetV2(weights=None, classes=training_generator.num_classes)\n", - "\n", - "opt = keras.optimizers.Adam(0.0001*hvd_size)\n", - "# Horovod: add Horovod Distributed Optimizer.\n", - "opt = hvd.DistributedOptimizer(opt)\n", - "model.compile(optimizer=opt, loss=\"mse\", metrics=[\"mae\"])\n", - "callbacks = [\n", - " # Horovod: broadcast initial variable states from rank 0 to all other processes.\n", - " # This is necessary to ensure consistent initialization of all workers when\n", - " # training is started with random weights or restored from a checkpoint.\n", - " hvd.callbacks.BroadcastGlobalVariablesCallback(0),\n", - "]\n", - "\n", - "print(\"Starting training\")\n", - "\n", - "for epoch in range(100):\n", - " model.fit(training_generator, steps_per_epoch=None, callbacks=callbacks,\n", - " epochs=epoch+1, initial_epoch=epoch, batch_size=training_generator.batch_size,\n", - " verbose=2 if hvd_rank==0 else 0)\n", - "\n", - "```\n", - "\n", - "Compared to the previous training service, we notice that the only thing changing for the `DataGenerator` is that we need to specify the total number of replicas, which is equal to the total number of Horovod ranks, and the rank of each replica, which corresponds to the Horovod rank. The rest of the training service script is modified according to the standard Horovod distributed training rules.\n", - "\n", - "Let's define the SmartSim entity representing the training service." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def create_trainer_hvd(experiment, alloc, nodes=1, tasks_per_node=1):\n", - " \"\"\"Start a process running a distributed training service which will\n", - " download batches from the DB and use Horovod to distribute\n", - " data and compute global weight updates.\n", - " \"\"\"\n", - " srun = SrunSettings(exe=\"python\",\n", - " exe_args=\"training_service_hvd.py\",\n", - " env_vars={\"PYTHONUNBUFFERED\": \"1\"},\n", - " alloc=alloc)\n", - " srun.set_nodes(nodes)\n", - " srun.set_tasks_per_node(tasks_per_node)\n", - "\n", - " trainer = experiment.create_model(\"trainer\", srun)\n", - "\n", - " # create directories for the output files and copy\n", - " # scripts to execution location inside newly created dir\n", - " # only necessary if its not an executable (python is executable here)\n", - " trainer.attach_generator_files(to_copy=\"./tf/training_service_hvd.py\")\n", - " experiment.generate(trainer, overwrite=True)\n", - " return trainer" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### 2.2 Request an allocation\n", - "\n", - "We need one node for the DB, two for the producer ensemble, and one for the trainer, thus we request 4 nodes to be allocated." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "alloc = slurm.get_allocation(nodes=4, time=\"03:00:00\", options={\"constraint\": \"V100\", \"partition\": \"spider\"})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.3 Run the workflow\n", - "\n", - "Now that all components are available, we create the SmartSim experiment representing our workflow. The setup is completely identical to the previous example, thus we can start the experiment and look at the output files to see that now each replica has a smaller portion of the dataset, and the training proceeds much faster!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp = Experiment(\"launch_streaming_hvd\", launcher=\"slurm\")\n", - "\n", - "db_port = 6780\n", - "\n", - "# start the database\n", - "db = launch_cluster_orc(exp, db_port, alloc)\n", - "uploader_model = create_uploader(exp, alloc, 1, 8)\n", - "uploader_model.enable_key_prefixing()\n", - "exp.start(uploader_model, block=False, summary=False)\n", - "trainer_model = create_trainer_hvd(exp, alloc, 1, 8)\n", - "for uploader in uploader_model.entities:\n", - " trainer_model.register_incoming_entity(uploader)\n", - "\n", - "exp.start(trainer_model, block=True, summary=False)\n", - "\n", - "print(exp.summary())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.4 Stop the workflow (optional) and release the allocation\n", - "If we did not wait until completion of the previous cell, but we stopped it, we need to stop the SmartSim entities. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp.stop(db, uploader_model, trainer_model)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we release the allocation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "slurm.release_allocation(alloc)" - ] - } - ], - "metadata": { - "language_info": { - "name": "python" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorials/ml_training/train_torch.ipynb b/tutorials/ml_training/train_torch.ipynb deleted file mode 100644 index 718976a69..000000000 --- a/tutorials/ml_training/train_torch.ipynb +++ /dev/null @@ -1,575 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Train a Neural Network loading data from and to SmartSim\n", - "\n", - "In this tutorial, we will see how one can set up a workflow in which one or multiple processes produce data (e.g. in a simulation) and one or multiple processes consume the data to train a neural network. The key to achieve this behavior is to use SmartSim to load data from and to the database.\n", - "\n", - "This tutorial works on Slurm, but can easily be adapted to any supported Workload Manager (PBS, Cobalt, or LSF), with an only difference: in Slurm, we are allocating the resources *from* this Notebook, whereas with other WLMs, this Notebook has to be started *within* an existing allocation.\n", - "\n", - "Note: this tutorial requires the python packages `torch`, `mpi4py` and `horovod`.\n", - "\n", - "## 1. First scenario: an ensemble of parallel producers and a single trainer\n", - "\n", - "The first use case is similar to a common workflow:\n", - "- several copies of a simulation (possibly with different initializations) are running, each one consisting of multiple MPI ranks. Each rank produces samples (e.g. data points computed by the simulation) at regular intervals (e.g. each time iteration)\n", - "- a neural network has to be trained on the data produced by the simulation, and as new data is produced, the neural network needs to add it to its training data set.\n", - "\n", - "\n", - "### 1.1 Workflow components\n", - "We will use SmartSim to allow the exchange of data between the data-producing processes and the training service. Thus, the first component which we will need to launch is the `Orchestrator`. This is a fairly small example, thus we will run a single-node DB." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from smartsim import Experiment\n", - "from smartsim.database import SlurmOrchestrator\n", - "from smartsim.settings import SrunSettings\n", - "from smartsim import slurm\n", - "\n", - "def launch_cluster_orc(experiment, port, alloc):\n", - " \"\"\"Just spin up a database cluster\"\"\"\n", - "\n", - " db = SlurmOrchestrator(port=port,\n", - " db_nodes=1,\n", - " batch=False,\n", - " alloc=alloc,\n", - " interface=\"ib0\")\n", - " \n", - "\n", - " # generate directories for output files\n", - " # pass in objects to make dirs for\n", - " experiment.generate(db, overwrite=True)\n", - "\n", - " # start the database on interactive allocation\n", - " experiment.start(db, block=True)\n", - "\n", - " return db\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Our data will be very simple: each rank will produce random samples, drawing values from a Gaussian distribution centered at the rank id, and each sample will be labeled with the rank id. The neural network will be trained to infer which rank produced a data sample. Thus, our data set will have a total number of labels equal to the number of ranks in each replicas.\n", - "\n", - "The data-producing processes will be started as part of an ensemble of two replicas (this mimics the execution of two copies of the simulation). The actual script producing the data is called `data_uploader.py` and is contained in the `torch` directory. Its content is\n", - "\n", - "```python\n", - "\n", - "from smartsim.ml import TrainingDataUploader\n", - "from os import environ\n", - "from time import sleep\n", - "import numpy as np\n", - "from mpi4py import MPI\n", - "\n", - "comm = MPI.COMM_WORLD\n", - "mpi_rank = comm.Get_rank()\n", - "mpi_size = comm.Get_size()\n", - "\n", - "batches_per_loop = 10\n", - "\n", - "data_uploader = TrainingDataUploader(num_classes=mpi_size,\n", - " cluster=False, \n", - " producer_prefixes=\"uploader\",\n", - " num_ranks=mpi_size)\n", - " \n", - "if environ[\"SSKEYOUT\"] == \"uploader_0\":\n", - " data_uploader.publish_info()\n", - "\n", - "\n", - "# Start \"simulation\", produce data every two minutes, for thirty minutes\n", - "for _ in range(15):\n", - " new_batch = np.random.normal(loc=float(mpi_rank), scale=5.0, size=(32*batches_per_loop, 224, 224, 3)).astype(float)\n", - " new_labels = np.ones(shape=(32*batches_per_loop,)).astype(int) * mpi_rank\n", - "\n", - " data_uploader.put_batch(new_batch, new_labels)\n", - " print(f\"{mpi_rank}: New data pushed to DB\")\n", - " sleep(120)\n", - "\n", - "```\n", - "\n", - "as the script is running in python, we can use the `TrainingDataUploader` class, which streamlines uploading of the data samples from the simulation. Here is an explanation of the arguments:\n", - "- `num_classes` is the number of classes of our training data set\n", - "- `smartredis_cluster=False` specifies that the DB is not a cluster (it is a single shard)\n", - "- `producer_prefixes` is used to identify the SmartSim entity names of the processes producing data: this is useful in the case the training service has several incoming entities (as defined in SmartSim, through the environment variable `SSKEYIN`), but it should expect data only from a subset of them. \n", - "- `num_ranks` is the number of concurrent data loaders withing this application, in this case it is simply the number of MPI ranks, as each process will upload its own data.\n", - "\n", - "\n", - "At each iteration, each rank of \"simulation\" calls `put_batch` to upload a batch of samples and the corresponding labels. The batch will be uploaded on the DB and stored under a key composed by a prefix (defaulting to `samples`), the sub-index, and the iteration number, which increases monotonically every time a batch is uploaded.\n", - "\n", - "Now that we know the content of `data_uploader.py`, we can create an entity representing the uploader ensemble." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def create_uploader(experiment, alloc, nodes=1, tasks_per_node=1):\n", - " \"\"\"Start an ensemble of two processes producing sample batches at\n", - " regular intervals.\n", - " \"\"\"\n", - " srun = SrunSettings(exe=\"python\",\n", - " exe_args=\"data_uploader.py\",\n", - " env_vars={\"PYTHONUNBUFFERED\": \"1\"},\n", - " alloc=alloc)\n", - " srun.set_nodes(nodes)\n", - " srun.set_tasks_per_node(tasks_per_node)\n", - "\n", - " uploader = experiment.create_ensemble(\"uploader\", replicas=2, run_settings=srun)\n", - "\n", - " # create directories for the output files and copy\n", - " # scripts to execution location inside newly created dir\n", - " # only necessary if its not an executable (python is executable here)\n", - " uploader.attach_generator_files(to_copy=[\"./torch/data_uploader.py\"])\n", - " experiment.generate(uploader, overwrite=True)\n", - " return uploader\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The last component of our workflow is the trainer. This process will keep downloading samples as they are produced, and use them to train a neural network.\n", - "\n", - "Here is the content of the `training_service.py` script, stored in the `torch` directory\n", - "\n", - "```python\n", - "\n", - "import numpy as np\n", - "import torchvision.models as models\n", - "from smartsim.ml.torch import DynamicDataGenerator, DataLoader\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "\n", - "if __name__ == '__main__':\n", - " torch.multiprocessing.set_start_method('spawn')\n", - " training_set = DynamicDataGenerator(cluster=False,\n", - " init_samples=False,\n", - " verbose=True)\n", - " trainloader = DataLoader(training_set, batch_size=None,\n", - " num_workers=2)\n", - " model = models.mobilenet_v2().double().to('cuda')\n", - " criterion = nn.CrossEntropyLoss()\n", - " optimizer = optim.Adam(model.parameters(), lr=0.0001)\n", - " print(\"Started training\")\n", - "\n", - " for epoch in range(50): # loop over the dataset multiple times\n", - "\n", - " running_loss = 0.0\n", - " epoch_running_loss = 0.0\n", - " output_period = 100\n", - " print(f\"Epoch {epoch}\")\n", - " for i, data in enumerate(trainloader):\n", - " # get the inputs; data is a list of [inputs, labels]\n", - " inputs, labels = data[0].double().to('cuda'), data[1].to('cuda')\n", - " # zero the parameter gradients\n", - " optimizer.zero_grad()\n", - "\n", - " # forward + backward + optimize\n", - " outputs = model(inputs)\n", - " loss = criterion(outputs, labels)\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " # print statistics\n", - " running_loss += loss.item()\n", - " epoch_running_loss += loss.item()\n", - "\n", - " if i % output_period == (output_period-1): # print every \"output_period\" mini-batches\n", - " print('[%d, %5d] loss: %.3f' %\n", - " (epoch + 1, i + 1, running_loss / output_period))\n", - " running_loss = 0.0\n", - "\n", - " \n", - " print('[%d, %5d] loss: %.3f' %\n", - " (epoch + 1, i + 1, epoch_running_loss / (i+1)))\n", - " epoch_running_loss = 0.0\n", - " \n", - " print('Finished Training')\n", - " \n", - "```\n", - "\n", - "The key component is the `DataGenerator` object. Since the DB contains the metadata of the `TrainingDataUploader`, and these are stored under a default key, the `DataGenerator` will retrieve them and use them to know the key of the uploaded batches of samples and labels. We need to specify `init_samples=False`, because initialization of the data set will be performed by the `DataLoader` workers: notice that the `DataLoader` is imported from `smartsim.ml.torch`: it is our custom implementation of a data loader, which will also triger a data update at the beginning of each epoch, to check if there are new samples available.\n", - "\n", - "We create a SmartSim entity representing the trainer and we are ready to go!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def create_trainer(experiment, alloc):\n", - " \"\"\"Start a process running a training service which will\n", - " download batches from the DB.\n", - " \"\"\"\n", - " srun = SrunSettings(exe=\"python\",\n", - " exe_args=\"training_service.py\",\n", - " env_vars={\"PYTHONUNBUFFERED\": \"1\"},\n", - " alloc=alloc)\n", - " srun.set_tasks(1)\n", - "\n", - " trainer = experiment.create_model(\"trainer\", srun)\n", - "\n", - " # create directories for the output files and copy\n", - " # scripts to execution location inside newly created dir\n", - " # only necessary if its not an executable (python is executable here)\n", - " trainer.attach_generator_files(to_copy=\"./torch/training_service.py\")\n", - " experiment.generate(trainer, overwrite=True)\n", - " return trainer\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.2 Request an allocation\n", - "\n", - "We need one node for the DB, two for the producer ensemble, and one for the trainer, thus we request 4 nodes to be allocated." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "alloc = slurm.get_allocation(nodes=4, time=\"03:00:00\", options={\"constraint\": \"V100\", \"partition\": \"spider\"})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.3 Run the workflow\n", - "\n", - "Now that all components are available, we create the SmartSim experiment representing our workflow. \n", - "Notice that the line\n", - "```python\n", - "uploader_model.enable_key_prefixing()\n", - "```\n", - "sets the ``uploader`` process so that tensor keys produced within it will be prefixed with its\n", - "SmartSim entity name, and the lines\n", - "```python\n", - "for uploader in uploader_model.entities:\n", - " trainer_model.register_incoming_entity(uploader)\n", - "```\n", - "make sure that each uploader replica (within the ensemble) is set as an incoming entity of the `trainer_model`. This will allow the `trainer_model` to know which processes are producing batches it will need to download.\n", - "\n", - "We call `exp.start` and the workflow is launched! As the trainer was started with `verbose=True`, we can look at its output in `launch_streaming`: we will see that it keeps downloading batches at the end of each epoch, as expected. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp = Experiment(\"launch_streaming\", launcher=\"slurm\")\n", - "\n", - "db_port = 6780\n", - "\n", - "# start the database\n", - "db = launch_cluster_orc(exp, db_port, alloc)\n", - "uploader_model = create_uploader(exp, alloc, 1, 2)\n", - "uploader_model.enable_key_prefixing()\n", - "exp.start(uploader_model, block=False, summary=False)\n", - "trainer_model = create_trainer(exp, alloc)\n", - "for uploader in uploader_model.entities:\n", - " trainer_model.register_incoming_entity(uploader)\n", - "\n", - "exp.start(trainer_model, block=True, summary=False)\n", - "\n", - "# shutdown the database because we don't need it anymore\n", - "exp.stop(db)\n", - "\n", - "print(exp.summary())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.4 Stop the workflow (optional) and release the allocation\n", - "If we did not wait until completion of the previous cell, but we stopped it, we need to stop the SmartSim entities. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp.stop(db, uploader_model, trainer_model)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "Finally, we release the allocation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "slurm.release_allocation(alloc)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2 Second scenario: an ensemble of parallel producers and a distributed trainer\n", - "\n", - "In the second scenario, we use Horovod to distribute the training and use multiple ranks. Each rank will download only a portion of the dataset, thus speeding up the download and training process.\n", - "\n", - "\n", - "### 2.1 Workflow components\n", - "The only component we change with respect to the previous example, is the training service, which is now defined in `training_service_hvd.py`:\n", - "\n", - "```python\n", - "\n", - "import numpy as np\n", - "import torchvision.models as models\n", - "\n", - "from smartsim.ml.torch import DynamicDataGenerator, DataLoader\n", - "\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "\n", - "import horovod.torch as hvd\n", - "\n", - "if __name__ == '__main__':\n", - "\n", - " # Initialize Horovod\n", - " hvd.init()\n", - "\n", - " hvd_rank = hvd.rank()\n", - " hvd_size = hvd.size()\n", - "\n", - " # Pin GPU to be used to process local rank (one GPU per process)\n", - " torch.cuda.set_device(hvd.local_rank())\n", - "\n", - " torch.multiprocessing.set_start_method('spawn')\n", - " training_set = DynamicDataGenerator(cluster=False,\n", - " verbose=True,\n", - " init_samples=False,\n", - " num_replicas=hvd_size,\n", - " replica_rank=hvd_rank)\n", - "\n", - " trainloader = DataLoader(training_set, batch_size=None,\n", - " num_workers=2)\n", - "\n", - " model = models.mobilenet_v2().double().to('cuda')\n", - " criterion = nn.CrossEntropyLoss()\n", - " optimizer = optim.Adam(model.parameters(), lr=0.0001*hvd_size)\n", - " optimizer = hvd.DistributedOptimizer(optimizer, named_parameters=model.named_parameters())\n", - " hvd.broadcast_parameters(model.state_dict(), root_rank=0)\n", - " print(f\"Rank {hvd_rank}: Started training\")\n", - "\n", - " for epoch in range(100): # loop over the dataset multiple times\n", - "\n", - " running_loss = 0.0\n", - " epoch_running_loss = 0.0\n", - " if hvd_rank == 0:\n", - " print(f\"Epoch {epoch}\")\n", - " output_period = 100\n", - "\n", - " for i, data in enumerate(trainloader):\n", - " # get the inputs; data is a list of [inputs, labels]\n", - " inputs, labels = data[0].double().to('cuda'), data[1].to('cuda')\n", - " # zero the parameter gradients\n", - " optimizer.zero_grad()\n", - "\n", - " # forward + backward + optimize\n", - " outputs = model(inputs)\n", - " loss = criterion(outputs, labels)\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " # print statistics\n", - " running_loss += loss.item()\n", - " epoch_running_loss += loss.item()\n", - "\n", - " if hvd_rank == 0:\n", - " if i % output_period == (output_period-1): # print every \"output_period\" mini-batches\n", - " print('[%d, %5d] loss: %.3f' %\n", - " (epoch + 1, i + 1, running_loss / output_period))\n", - " running_loss = 0.0\n", - "\n", - " if hvd_rank == 0: \n", - " print('[%d, %5d] loss: %.3f' %\n", - " (epoch + 1, i + 1, epoch_running_loss / (i+1)))\n", - " epoch_running_loss = 0.0\n", - " \n", - " print('Finished Training')\n", - " \n", - "```\n", - "\n", - "Compared to the previous training service, we notice that the only thing changing for the `DataGenerator` is that we need to specify the total number of replicas, which is equal to the total number of Horovod ranks, and the rank of each replica, which corresponds to the Horovod rank. The rest of the training service script is modified according to the standard Horovod distributed training rules.\n", - "\n", - "Let's define the SmartSim entity representing the training service." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def create_trainer_hvd(experiment, alloc, nodes=1, tasks_per_node=1):\n", - " \"\"\"Start a process running a distributed training service which will\n", - " download batches from the DB and use Horovod to distribute\n", - " data and compute global weight updates.\n", - " \"\"\"\n", - " srun = SrunSettings(exe=\"python\",\n", - " exe_args=\"training_service_hvd.py\",\n", - " env_vars={\"PYTHONUNBUFFERED\": \"1\"},\n", - " alloc=alloc)\n", - " srun.set_nodes(nodes)\n", - " srun.set_tasks_per_node(tasks_per_node)\n", - "\n", - " trainer = experiment.create_model(\"trainer\", srun)\n", - "\n", - " # create directories for the output files and copy\n", - " # scripts to execution location inside newly created dir\n", - " # only necessary if its not an executable (python is executable here)\n", - " trainer.attach_generator_files(to_copy=\"./torch/training_service_hvd.py\")\n", - " experiment.generate(trainer, overwrite=True)\n", - " return trainer\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.2 Request an allocation\n", - "\n", - "As before, we need one node for the DB, two for the producer ensemble, and one for the trainer, thus we request 4 nodes to be allocated." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "alloc = slurm.get_allocation(nodes=4, time=\"03:00:00\", options={\"constraint\": \"V100\", \"partition\": \"spider\"})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.3 Run the workflow\n", - "\n", - "Now that all components are available, we create the SmartSim experiment representing our workflow. The setup is completely identical to the previous example, thus we can start the experiment and look at the output files to see that now each replica has a smaller portion of the dataset, and the training proceeds much faster!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp = Experiment(\"launch_streaming_hvd\", launcher=\"slurm\")\n", - "\n", - "db_port = 6780\n", - "\n", - "# start the database\n", - "db = launch_cluster_orc(exp, db_port, alloc)\n", - "uploader_model = create_uploader(exp, alloc, 1, 16)\n", - "uploader_model.enable_key_prefixing()\n", - "exp.start(uploader_model, block=False, summary=False)\n", - "trainer_model = create_trainer_hvd(exp, alloc, 1, 8)\n", - "for uploader in uploader_model.entities:\n", - " trainer_model.register_incoming_entity(uploader)\n", - "\n", - "exp.start(trainer_model, block=True, summary=False)\n", - "\n", - "# shutdown the database because we don't need it anymore\n", - "exp.stop(db)\n", - "\n", - "print(exp.summary())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2.4 Stop the workflow (optional) and release the allocation\n", - "If we did not wait until completion of the previous cell, but we stopped it, we need to stop the SmartSim entities. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exp.stop(db, uploader_model, trainer_model)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "Finally, we release the allocation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "slurm.release_allocation(alloc)" - ] - } - ], - "metadata": { - "language_info": { - "name": "python" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 4 -} From 6a3d0b57f51b2d1fd016808351ca938bf8723ae8 Mon Sep 17 00:00:00 2001 From: Al Rigazzi Date: Mon, 21 Mar 2022 16:45:20 +0100 Subject: [PATCH 2/5] Fix online training doc --- doc/tutorials/training.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/tutorials/training.rst b/doc/tutorials/training.rst index fb6413cf1..495ebbc09 100644 --- a/doc/tutorials/training.rst +++ b/doc/tutorials/training.rst @@ -7,7 +7,7 @@ Online training provides the ability to use dynamic processes as your training data set. In SmartSim, training data can be any process using the SmartRedis clients to store data inside of a deployed `Orchestrator` database. -SmartSim includes utilizes to help with online training workflows in PyTorch and TensorFlow +SmartSim includes utilities to help with online training workflows in PyTorch and TensorFlow In this example, we show how to use ``smartsim.ml.tf`` to train a Neural Network implemented in TensorFlow and Keras. @@ -21,7 +21,7 @@ and one application (the ``training_service``) downloading the samples to train A richer example, entirely implemented in Python, is available as a Jupyter Notebook in the ``tutorials`` section of the SmartSim repository. An equivalent example using PyTorch -instead of TensorFlow is available in the same directory. +instead of TensorFlow will soon be available in the same directory. Producing and uploading the samples From 8e8198f5ddb5b8c80806acdd98c7ae9d874f78e8 Mon Sep 17 00:00:00 2001 From: Al Rigazzi Date: Mon, 21 Mar 2022 18:03:17 +0100 Subject: [PATCH 3/5] Change ml notebook and dockerfiles related --- doc/index.rst | 2 +- docker/prod/Dockerfile | 2 +- .../surrogate/train_surrogate.ipynb | 35 +++++++++---------- 3 files changed, 19 insertions(+), 20 deletions(-) diff --git a/doc/index.rst b/doc/index.rst index f8f27329e..c84b69871 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -16,7 +16,7 @@ tutorials/getting_started/getting_started tutorials/online_analysis/lattice/online_analysis tutorials/ml_inference/Inference-in-SmartSim - tutorials/training + tutorials/ml_training/surrogate/train_surrogate tutorials/ray/starting_ray diff --git a/docker/prod/Dockerfile b/docker/prod/Dockerfile index ff758f168..b868c1579 100644 --- a/docker/prod/Dockerfile +++ b/docker/prod/Dockerfile @@ -26,5 +26,5 @@ RUN python -m pip install smartsim[ml]==0.4.0 jupyter jupyterlab matplotlib && \ rm -rf ~/.cache/pip # remove non-jupyter notebook tutorials -RUN rm -rf /home/craylabs/tutorials/ml_training /home/craylabs/tutorials/ray +RUN rm -rf /home/craylabs/tutorials/ray CMD ["/bin/bash", "-c", "PATH=/home/craylabs/.local/bin:$PATH /home/craylabs/.local/bin/jupyter lab --port 8888 --no-browser --ip=0.0.0.0"] diff --git a/tutorials/ml_training/surrogate/train_surrogate.ipynb b/tutorials/ml_training/surrogate/train_surrogate.ipynb index 8d895cd5f..ff2fad069 100644 --- a/tutorials/ml_training/surrogate/train_surrogate.ipynb +++ b/tutorials/ml_training/surrogate/train_surrogate.ipynb @@ -5,8 +5,7 @@ "id": "4061d9f5-cdfc-4396-bc7d-eaecb9472558", "metadata": {}, "source": [ - "# Training a surrogate model on the fly\n", - "\n", + "# Online Training\n", "Simulating a complex phenomenon can be computationally intensive and expensive. In some cases\n", "the computational model is too expensive or too slow to be used in production, for example when\n", "results are needed in real time. In other cases, a correct computational model, capable of\n", @@ -43,7 +42,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -55,7 +54,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -67,7 +66,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -79,7 +78,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -91,7 +90,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -103,7 +102,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -455,7 +454,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -467,7 +466,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -479,7 +478,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -491,7 +490,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -503,7 +502,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -515,7 +514,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -534,7 +533,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -546,7 +545,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -565,7 +564,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -577,7 +576,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] From b6ec9bb6ac5840ab33f74d8f697d0c3e7d01d099 Mon Sep 17 00:00:00 2001 From: Al Rigazzi Date: Mon, 21 Mar 2022 18:07:02 +0100 Subject: [PATCH 4/5] Fix typo in surrogate training notebook --- tutorials/ml_training/surrogate/train_surrogate.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/ml_training/surrogate/train_surrogate.ipynb b/tutorials/ml_training/surrogate/train_surrogate.ipynb index ff2fad069..22fc5365c 100644 --- a/tutorials/ml_training/surrogate/train_surrogate.ipynb +++ b/tutorials/ml_training/surrogate/train_surrogate.ipynb @@ -443,7 +443,7 @@ "\n", "Notice that the inference happens on the database\n", "through a call to `Client.run_model()`, and only\n", - "the result is downloaded displayed." + "the result is downloaded, to be displayed." ] }, { From b78c03e98891e5466805d1193c270812768c66f2 Mon Sep 17 00:00:00 2001 From: Al Rigazzi Date: Tue, 29 Mar 2022 17:26:41 -0500 Subject: [PATCH 5/5] Add tests for new serialize_model function --- tests/backends/run_tf.py | 27 +++++++++++++++++++++------ tests/backends/test_tf.py | 12 ++++++++++-- 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/tests/backends/run_tf.py b/tests/backends/run_tf.py index 599e0d1b7..2cbd3c323 100644 --- a/tests/backends/run_tf.py +++ b/tests/backends/run_tf.py @@ -4,7 +4,7 @@ from smartredis import Client from tensorflow import keras -from smartsim.ml.tf import freeze_model +from smartsim.ml.tf import freeze_model, serialize_model def create_tf_mnist_model(): @@ -29,21 +29,36 @@ def create_tf_mnist_model(): def run(device): model = create_tf_mnist_model() - model_path, inputs, outputs = freeze_model(model, os.getcwd(), "mnist.pb") client = Client(cluster=False) - client.set_model_from_file( - "tf_mnist", model_path, "TF", device=device, inputs=inputs, outputs=outputs - ) + + model_path, inputs, outputs = freeze_model(model, os.getcwd(), "mnist.pb") mnist_image = np.random.rand(1, 28, 28).astype(np.float32) client.put_tensor("mnist_input", mnist_image) - client.run_model("tf_mnist", "mnist_input", "mnist_output") + + model_key = "tf_mnist" + client.set_model_from_file( + model_key, model_path, "TF", device=device, inputs=inputs, outputs=outputs + ) + client.run_model(model_key, "mnist_input", "mnist_output") pred = client.get_tensor("mnist_output") print(pred) assert len(pred[0]) == 10 + serialized_model, inputs, outputs = serialize_model(model) + model_key = "tf_mnist_serialized" + client.set_model( + model_key, serialized_model, "TF", device=device, inputs=inputs, outputs=outputs + ) + + client.run_model(model_key, "mnist_input", "mnist_output_serialized") + + pred = client.get_tensor("mnist_output_serialized") + print(pred) + assert len(pred[0]) == 10 + if __name__ == "__main__": import argparse diff --git a/tests/backends/test_tf.py b/tests/backends/test_tf.py index 0132060af..ccfa3615f 100644 --- a/tests/backends/test_tf.py +++ b/tests/backends/test_tf.py @@ -12,7 +12,7 @@ try: from tensorflow import keras - from smartsim.ml.tf import freeze_model + from smartsim.ml.tf import freeze_model, serialize_model except (ImportError, SmartSimError) as e: print(e) tf_available = False @@ -85,7 +85,6 @@ def create_tf_model(): @pytest.mark.skipif(not tf_available, reason="Requires Tensorflow and Keras") def test_freeze_model(fileutils): - test_name = "test_tf_freeze_model" test_dir = fileutils.make_test_dir() model = create_tf_model() @@ -93,3 +92,12 @@ def test_freeze_model(fileutils): assert len(inputs) == 1 assert len(outputs) == 1 assert Path(model_path).is_file() + + +@pytest.mark.skipif(not tf_available, reason="Requires Tensorflow and Keras") +def test_serialize_model(): + model = create_tf_model() + model_serialized, inputs, outputs = serialize_model(model) + assert len(inputs) == 1 + assert len(outputs) == 1 + assert len(model_serialized) > 0 \ No newline at end of file