diff --git a/doc/changelog.rst b/doc/changelog.rst index 030e0d727..34f1f9edf 100644 --- a/doc/changelog.rst +++ b/doc/changelog.rst @@ -22,6 +22,7 @@ This section details changes made in the development branch that have not yet be Description +- Update ML data loaders to make use of SmartRedis's aggregation lists - Drop support for Ray - Allow for models to be launched independently as batch jobs - Update to current version of Redis @@ -31,6 +32,7 @@ Description Detailed Notes +- The PyTorch and TensorFlow data loaders were update to make use of aggregation lists. This breaks their API, but makes them easier to use. (PR264_) - The support for Ray was dropped, as its most recent versions caused problems when deployed through SmartSim. We plan to release a separate add-on library to accomplish the same results. If you are interested in getting the Ray launch functionality back in your workflow, please get in touch with us! (PR263_) @@ -49,6 +51,7 @@ Detailed Notes - The release of RedisAI 1.2.7 allows us to update support for recent versions of PyTorch, Tensorflow, and ONNX (PR234_) - Make installation of correct Torch backend more reliable according to instruction from PyTorch +.. _PR264: https://github.com/CrayLabs/SmartSim/pull/264 .. _PR263: https://github.com/CrayLabs/SmartSim/pull/263 .. _PR258: https://github.com/CrayLabs/SmartSim/pull/258 .. _PR256: https://github.com/CrayLabs/SmartSim/pull/256 diff --git a/smartsim/_core/control/controller.py b/smartsim/_core/control/controller.py index c70585271..80dfc68ca 100644 --- a/smartsim/_core/control/controller.py +++ b/smartsim/_core/control/controller.py @@ -290,7 +290,6 @@ def _launch(self, manifest): raise SmartSimError(msg) self._launch_orchestrator(orchestrator) - if self.orchestrator_active: self._set_dbobjects(manifest) diff --git a/smartsim/_core/control/manifest.py b/smartsim/_core/control/manifest.py index 90f27d565..4ae3363a1 100644 --- a/smartsim/_core/control/manifest.py +++ b/smartsim/_core/control/manifest.py @@ -50,7 +50,6 @@ def __init__(self, *args): self._check_names(self._deployables) self._check_entity_lists_nonempty() - @property def db(self): """Return Orchestrator instances in Manifest @@ -69,7 +68,6 @@ def db(self): _db = deployable return _db - @property def models(self): """Return Model instances in Manifest @@ -83,7 +81,6 @@ def models(self): _models.append(deployable) return _models - @property def ensembles(self): """Return Ensemble instances in Manifest @@ -103,7 +100,6 @@ def ensembles(self): return _ensembles - @property def all_entity_lists(self): """All entity lists, including ensembles and @@ -119,7 +115,6 @@ def all_entity_lists(self): return _all_entity_lists - def _check_names(self, deployables): used = [] for deployable in deployables: @@ -130,7 +125,6 @@ def _check_names(self, deployables): raise SmartSimError("User provided two entities with the same name") used.append(name) - def _check_types(self, deployables): for deployable in deployables: if not ( @@ -141,7 +135,6 @@ def _check_types(self, deployables): f"Entity has type {type(deployable)}, not SmartSimEntity or EntityList" ) - def _check_entity_lists_nonempty(self): """Check deployables for sanity before launching""" @@ -149,7 +142,6 @@ def _check_entity_lists_nonempty(self): if len(entity_list) < 1: raise ValueError(f"{entity_list.name} is empty. Nothing to launch.") - def __str__(self): s = "" e_header = "=== Ensembles ===\n" diff --git a/smartsim/experiment.py b/smartsim/experiment.py index d177cee4c..850562153 100644 --- a/smartsim/experiment.py +++ b/smartsim/experiment.py @@ -774,7 +774,12 @@ def summary(self, format="github"): ) else: return tabulate( - values, headers, showindex=True, tablefmt=format, missingval="None", disable_numparse=True + values, + headers, + showindex=True, + tablefmt=format, + missingval="None", + disable_numparse=True, ) def _launch_summary(self, manifest): diff --git a/smartsim/ml/__init__.py b/smartsim/ml/__init__.py index 513d48244..84fd06b57 100644 --- a/smartsim/ml/__init__.py +++ b/smartsim/ml/__init__.py @@ -24,9 +24,4 @@ # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -from .data import ( - DynamicDataDownloader, - StaticDataDownloader, - TrainingDataUploader, - form_name, -) +from .data import DataDownloader, DataInfo, TrainingDataUploader, form_name diff --git a/smartsim/ml/data.py b/smartsim/ml/data.py index 4862a1f38..f9adc7dae 100644 --- a/smartsim/ml/data.py +++ b/smartsim/ml/data.py @@ -29,8 +29,9 @@ import numpy as np from smartredis import Client, Dataset +from smartredis.error import RedisReplyError -from ..error import SmartSimError +from ..error import SSInternalError from ..log import get_logger logger = get_logger(__name__) @@ -40,6 +41,89 @@ def form_name(*args): return "_".join(str(arg) for arg in args if arg is not None) +class DataInfo: + """A class holding all relevant information to download datasets from aggregation lists + + This class can be passed as argument to SmartSim's ML data loaders, as it wraps the + information about the aggregation list holding the training datasets. + + Each training dataset will store batches of samples and (optionally) labels or targets in the + form of tensors. The tensors must always have the same names, which can be accessed + in ``DataInfo.sample_name`` and ``DataInfo.target_name``. + + :param list_name: Name of the aggregation list used for sample datasets + :type list_name: str + :param sample_name: Name of tensor holding training samples in stored datasets. + :type sample_name: str + :param target_name: Name of tensor holding targets or labels in stored datasets. + :type target_name: str + :num_classes: Number of classes (for categorical data). + :type num_classes: int | None + """ + + def __init__( + self, list_name, sample_name="samples", target_name="targets", num_classes=None + ): + self.list_name = list_name + self.sample_name = sample_name + self.target_name = target_name + self.num_classes = num_classes + self._ds_name = form_name(self.list_name, "info") + + def publish(self, client: Client): + """Upload DataInfo information to Orchestrator + + The information is put on the DB as a DataSet, with strings + stored as metastrings and integers stored as metascalars. + + :param client: Client to connect to Database + :type client: SmartRedis.Client + """ + info_ds = Dataset(self._ds_name) + info_ds.add_meta_string("sample_name", self.sample_name) + if self.target_name: + info_ds.add_meta_string("target_name", self.target_name) + if self.num_classes: + info_ds.add_meta_scalar("num_classes", self.num_classes) + client.put_dataset(info_ds) + + def download(self, client: Client): + """Download DataInfo information from Orchestrator + + The information retrieved from the DB is used to populate + this object's members. If the information is not available + on the DB, the object members are not modified. + + :param client: Client to connect to Database + :type client: SmartRedis.Client + """ + try: + info_ds = client.get_dataset(self._ds_name) + except RedisReplyError: + # If the info was not published, proceed with default parameters + logger.warning( + f"Could not retrieve data for DataInfo object, the following values will be kept." + ) + logger.warning(str(self)) + return + self.sample_name = info_ds.get_meta_strings("sample_name")[0] + field_names = info_ds.get_metadata_field_names() + if "target_name" in field_names: + self.target_name = info_ds.get_meta_strings("target_name")[0] + if "num_classes" in field_names: + self.num_classes = info_ds.get_meta_scalars("num_classes")[0] + + def __repr__(self): + strings = ["DataInfo object"] + strings += [f"Aggregation list name: {self.list_name}"] + strings += [f"Sample tensor name: {self.sample_name}"] + if self.target_name: + strings += [f"Target tensor name: {self.target_name}"] + if self.num_classes: + strings += [f"Number of classes: {self.num_classes}"] + return "\n".join(strings) + + class TrainingDataUploader: """A class to simplify uploading batches of samples to train a model. @@ -53,25 +137,18 @@ class TrainingDataUploader: and the data will be stored following the naming convention specified by the attributes of this class. - :param name: Name of the dataset as stored on the Orchestrator - :type name: str - :param sample_prefix: Prefix of samples batches - :type sample_prefix: str - :param target_prefix: Prefix of target batches (if needed) - :type target_prefix: str + :param list_name: Name of the dataset as stored on the Orchestrator + :type list_name: str + :param sample_name: Name of samples tensor in uploaded Datasets + :type sample_name: str + :param target_name: Name of targets tensor (if needed) in uploaded Datasets + :type target_name: str :param num_classes: Number of classes of targets, if categorical :type num_classes: int - :param producer_prefixes: Prefixes of processes which will be producing batches. - This can be useful in case the consumer processes also - have other incoming entities. - :type producer_prefixes: str or list[str] :param cluster: Whether the SmartSim Orchestrator is being run as a cluster :type cluster: bool :param address: Address of Redis DB as : :type address: str - :param num_ranks: Number of processes (e.g. MPI ranks) of application using - DataUploader. - :type num_ranks: int :param rank: Rank of DataUploader in multi-process application (e.g. MPI rank). :type rank: int :param verbose: If output should be logged to screen. @@ -81,141 +158,110 @@ class TrainingDataUploader: def __init__( self, - name="training_data", - sample_prefix="samples", - target_prefix="targets", + list_name="training_data", + sample_name="samples", + target_name="targets", num_classes=None, - producer_prefixes=None, cluster=True, address=None, - num_ranks=None, rank=None, verbose=False, ): - if not name: + if not list_name: raise ValueError("Name can not be empty") - if not sample_prefix: - raise ValueError("Sample prefix can not be empty") - - self.name = name - self.sample_prefix = sample_prefix - self.target_prefix = target_prefix - if isinstance(producer_prefixes, str): - producer_prefixes = [producer_prefixes] - self.producer_prefixes = producer_prefixes - self.num_classes = num_classes - if num_ranks is None: - self.num_ranks = None - else: - self.num_ranks = int(num_ranks) - self.rank = rank + if not sample_name: + raise ValueError("Sample name can not be empty") self.client = Client(address=address, cluster=cluster) - self.batch_idx = 0 self.verbose = verbose + self.batch_idx = 0 + self.rank = rank + self._info = DataInfo(list_name, sample_name, target_name, num_classes) + + @property + def list_name(self): + return self._info.list_name + + @property + def sample_name(self): + return self._info.sample_name + + @property + def target_name(self): + return self._info.target_name + + @property + def num_classes(self): + return self._info.num_classes def publish_info(self): - info_ds = Dataset(form_name(self.name, "info")) - info_ds.add_meta_string("sample_prefix", self.sample_prefix) - if self.target_prefix: - info_ds.add_meta_string("target_prefix", self.target_prefix) - if self.producer_prefixes: - for producer_prefix in self.producer_prefixes: - info_ds.add_meta_string("producer_prefixes", producer_prefix) - if self.num_classes: - info_ds.add_meta_scalar("num_classes", self.num_classes) - if self.num_ranks: - info_ds.add_meta_scalar("num_ranks", self.num_ranks) - self.client.put_dataset(info_ds) + self._info.publish(self.client) def put_batch(self, samples, targets=None): - batch_key = form_name(self.sample_prefix, self.batch_idx, self.rank) - self.client.put_tensor(batch_key, samples) - if self.verbose: - logger.info(f"Put batch {batch_key}") - + batch_ds_name = form_name("training_samples", self.rank, self.batch_idx) + batch_ds = Dataset(batch_ds_name) + batch_ds.add_tensor(self.sample_name, samples) if ( targets is not None - and self.target_prefix - and (self.target_prefix != self.sample_prefix) + and self.target_name + and (self.target_name != self.sample_name) ): - labels_key = form_name(self.target_prefix, self.batch_idx, self.rank) - self.client.put_tensor(labels_key, targets) + batch_ds.add_tensor(self.target_name, targets) + if self.verbose: + logger.info(f"Putting dataset {batch_ds_name} with samples and targets") + else: + if self.verbose: + logger.info(f"Putting dataset {batch_ds_name} with samples") + + self.client.put_dataset(batch_ds) + self.client.append_to_list(self.list_name, batch_ds) + if self.verbose: + logger.info(f"Added dataset to list {self.list_name}") + logger.info(f"List length {self.client.get_list_length(self.list_name)}") self.batch_idx += 1 -class StaticDataDownloader: +class DataDownloader: """A class to download a dataset from the DB. - By default, the StaticDataDownloader has to be created in a process + By default, the DataDownloader has to be created in a process launched through SmartSim, with sample producers listed as incoming entities. - All details about the batches must be defined in - the constructor; two mechanisms are available, `manual` and - `auto`. - - - When specifying `auto`, the user must also specify - `uploader_name`. StaticDataDownloader will get all needed information - from the database (this expects a Dataset like the one created - by TrainingDataUploader to be available and stored as `uploader_name` - on the DB). - - - When specifying `manual`, the user must also specify details - of batch naming. Specifically, for each incoming entity with - a name starting with an element of `producer_prefixes`, - StaticDataDownloader will query the DB - for all batches named _ for all indices - in `sub_indexes` if supplied, and, if - `target_prefix` is supplied, it will also query for all targets - named .. If `producer_prefixes` is - None, then all incoming entities will be treated as producers, - and for each one, the corresponding batches will be downloaded. - - The flag `init_samples` defines whether sources (the list of batches - to be fetched) and samples (the actual data) should automatically - be set up in the costructor. + Information about the uploaded datasets can be defined in two ways: - If the user needs to modify the list of sources, then `init_samples=False` - has to be set. In that case, to set up a `BatchDownlaoder`, the user has to call - `init_sources()` (which initializes the list of sources and the SmartRedis client) - and `init_samples()`. After `init_sources()` is called, - a list of data sources is populated, representing the batches which - will be downloaded. + - By supplying a DataInfo object as value of ``data_info_or_list_name`` + + - By supplying a string as value of ``data_info_or_list_name``. + in this case, an attempt is made to download information from the + DB, where a Dataset called ``_info`` should be available + and have the information normally stored by DataInfo.publish() + + The flag `init_samples` defines whether samples should automatically + be set up in the costructor. - Each source is represented as a tuple `(producer_name, sub_index)`. - Before `init_samples()` is called, the user can modify the list. - Once `init_samples()` is called, all data is downloaded and batches - can be obtained with iter(). + If the user needs to modify the `DataDownloader` object before starting + the training, then `init_samples=False` has to be set. + In that case, to set up a `DataDownloader`, the user has to call + `init_samples()`. - After initialization, samples and targets will not be updated. The data can - be shuffled by calling `update_data()`, if `shuffle` is set to ``True`` at - initialization. + Calling `update_data()` + - check if new batches are available and download them, if `dynamic` is set to `True` + - shuffle the dataset if `shuffle` is set to ``True``. :param batch_size: Size of batches obtained with __iter__ :type batch_size: int + :param dynamic: Whether new batches should be donwnloaded when ``update_data`` is called. + :type dtnamic: bool :param shuffle: whether order of samples has to be shuffled when calling `update_data` :type shuffle: bool - :param uploader_info: Set to `auto` uploader information has to be downloaded from DB, - or to `manual` if it is provided by the user - :type uploader_info: str - :param uploader_name: Name of uploader info dataset, only used if `uploader_info` is `auto` - :type uploader_name: str - :param sample_prefix: prefix of keys representing batches - :type sample_prefix: str - :param target_prefix: prefix of keys representing targets - :type target_prefix: str - :param uploader_ranks: Number of processes every uploader runs on (e.g, if each - rank in an MPI simulation is uploading its own batches, - this will be the MPI comm world size of the simulation). - :type uploader_ranks: int - :param num_classes: Number of classes of targets, if categorical - :type num_classes: int - :param producer_prefixes: Prefixes of names of which will be producing batches. - These can be e.g. prefixes of SmartSim entity names in - an ensemble. - :type producer_prefixes: str + :param data_info_or_list_name: DataInfo object with details about dataset to download, if a string is passed, + it is used to download DataInfo data from DB, assuming it was stored with + ``list_name=data_info_or_list_name`` + :type data_info_or_list_name: DataInfo | str + :param list_name: Name of aggregation list used to upload data + :type list_name: str :param cluster: Whether the Orchestrator will be run as a cluster :type cluster: bool :param address: Address of Redis client as : @@ -230,140 +276,79 @@ class StaticDataDownloader: :type verbose: bool :param init_samples: whether samples should be initialized in the constructor :type init_samples: bool + :param max_fetch_trials: maximum number of attempts to initialize data + :type max_fetch_trials: int """ def __init__( self, + data_info_or_list_name, batch_size=32, + dynamic=True, shuffle=True, - uploader_info="auto", - uploader_name="training_data", - sample_prefix="samples", - target_prefix="targets", - uploader_ranks=None, - num_classes=None, - producer_prefixes=None, cluster=True, address=None, replica_rank=0, num_replicas=1, verbose=False, init_samples=True, - **kwargs, + max_fetch_trials=-1, ): - self.replica_rank = replica_rank - self.num_replicas = num_replicas self.address = address self.cluster = cluster - self.uploader_info = uploader_info - self.uploader_name = uploader_name self.verbose = verbose self.samples = None self.targets = None self.num_samples = 0 self.indices = np.arange(0) self.shuffle = shuffle + self.dynamic = dynamic self.batch_size = batch_size - if uploader_info == "manual": - self.sample_prefix = sample_prefix - self.target_prefix = target_prefix - if uploader_ranks is not None: - self.sub_indices = [str(rank) for rank in range(uploader_ranks)] - else: - self.sub_indices = None - if producer_prefixes: - self.producer_prefixes = list(producer_prefixes) - else: - producer_prefixes = [""] - self.num_classes = num_classes - elif self.uploader_info == "auto": - pass + if isinstance(data_info_or_list_name, DataInfo): + self._info = data_info_or_list_name + elif isinstance(data_info_or_list_name, str): + self._info = DataInfo(list_name=data_info_or_list_name) + client = Client(self.address, self.cluster) + self._info.download(client) else: - raise ValueError( - f"uploader_info must be one of 'auto' or 'manual', but was {self.uploader_info}" - ) + raise TypeError("data_info_or_list_name must be either DataInfo or str") + self.client = None + sskeyin = environ.get("SSKEYIN", "") + self.uploader_keys = sskeyin.split(",") + + self.set_replica_parameters(replica_rank, num_replicas) if init_samples: - self.init_sources() - self.init_samples() - else: - self.client = Client(self.address, self.cluster) - if self.uploader_info == "auto": - if not self.uploader_name: - raise ValueError( - "uploader_name can not be empty if uploader_info is 'auto'" - ) - self._get_uploader_info(self.uploader_name) - # This avoids problems with Pytorch - self.client = None + self.init_samples(max_fetch_trials) def log(self, message): if self.verbose: logger.info(message) - def _list_all_sources(self): - uploaders = environ["SSKEYIN"].split(",") - sources = [] - for uploader in uploaders: - if any( - [ - uploader.startswith(producer_prefix) - for producer_prefix in self.producer_prefixes - ] - ): - if self.sub_indices: - sources.extend( - [[uploader, sub_index] for sub_index in self.sub_indices] - ) - else: - sources.append([uploader, None]) - - per_replica = len(sources) // self.num_replicas - if per_replica > 0: - if self.replica_rank < self.num_replicas - 1: - sources = sources[ - self.replica_rank - * per_replica : (self.replica_rank + 1) - * per_replica - ] - else: - sources = sources[self.replica_rank * per_replica :] - else: - self.log( - "Number of loader replicas is higher than number of sources, automatic split cannot be performed, " - "all replicas will have the same dataset. If this is not intended, then implement a distribution strategy " - "and modify `sources`." - ) - - return sources + def set_replica_parameters(self, replica_rank, num_replicas): + self.replica_rank = replica_rank + self.num_replicas = num_replicas + self.next_indices = [self.replica_rank] * max(1, len(self.uploader_keys)) - def init_sources(self): - """Initalize list of data sources based on incoming entitites and self.sub_indices. + @property + def autoencoding(self): + return self.sample_name == self.target_name + @property + def list_name(self): + return self._info.list_name - Each source is represented as a tuple `(producer_name, sub_index)`. - Before `init_samples()` is called, the user can modify the list. - Once `init_samples()` is called, all data is downloaded and batches - can be obtained with iter(). The list of all sources is stored as `self.sources`. + @property + def sample_name(self): + return self._info.sample_name - :raises ValueError: If self.uploader_info is set to `auto` but no `uploader_name` is specified. - :raises ValueError: If self.uploader_info is not set to `auto` or `manual`. - """ - self.client = Client(self.address, self.cluster) - if self.uploader_info == "auto": - if not self.uploader_name: - raise ValueError( - "uploader_name can not be empty if uploader_info is 'auto'" - ) - self._get_uploader_info(self.uploader_name) - elif self.uploader_info == "manual": - pass - else: - raise ValueError( - f"uploader_info must be one of 'auto' or 'manual', but was {self.uploader_info}" - ) + @property + def target_name(self): + return self._info.target_name - self.sources = self._list_all_sources() + @property + def num_classes(self): + return self._info.num_classes @property def need_targets(self): @@ -372,7 +357,7 @@ def need_targets(self): :return: Whether targets (or labels) should be downloaded :rtype: bool """ - return self.target_prefix and not self.autoencoding + return self.target_name and not self.autoencoding def __len__(self): length = int(np.floor(self.num_samples / self.batch_size)) @@ -380,48 +365,44 @@ def __len__(self): def __iter__(self): - if self.sources: - self.update_data() - # Generate data - if len(self) < 1: - msg = "Not enough samples in generator for one batch. " - msg += "Please run init_samples() or initialize generator with init_samples=True" - raise ValueError(msg) - - for index in range(len(self)): - indices = self.indices[ - index * self.batch_size : (index + 1) * self.batch_size - ] - - x, y = self.__data_generation(indices) - - if y is not None: - yield x, y - else: - yield x - - def init_samples(self, sources=None): + self.update_data() + # Generate data + if len(self) < 1: + msg = "Not enough samples in generator for one batch. " + msg += "Please run init_samples() or initialize generator with init_samples=True" + raise ValueError(msg) + + _calc_indices = lambda index: self.indices[ + index * self.batch_size : (index + 1) * self.batch_size + ] + yield from ( + self._data_generation(_calc_indices(idx)) for idx in range(len(self)) + ) + + def init_samples(self, init_trials=-1): """Initialize samples (and targets, if needed). - This function will not return until samples have been downloaded - from all sources. - - :param sources: List of sources as defined in `init_sources`, defaults to None, - in which case sources will be initialized, unless `self.sources` - is already set - :type sources: list[tuple], optional + A new attempt to download samples will be made every ten seconds, for ``init_trials`` + times. + :param init_trials: maximum number of attempts to fetch data + :type init_trials: int """ - self.autoencoding = self.sample_prefix == self.target_prefix - - if sources is not None: - self.sources = sources - - if self.sources is None: - self.sources = self._list_all_sources() + self.client = Client(self.address, self.cluster) - self.log("Generator initialization complete") + num_trials = 0 + max_trials = init_trials or -1 + while not len(self) and num_trials != max_trials: + self._update_samples_and_targets() + self.log( + "DataLoader could not download samples, will try again in 10 seconds" + ) + time.sleep(10) + num_trials += 1 - self._update_samples_and_targets() + if not len(self): + raise SSInternalError( + "Could not download samples in given number of trials" + ) if self.shuffle: np.random.shuffle(self.indices) @@ -434,300 +415,79 @@ def _data_exists(self, batch_name, target_name): else: return self.client.tensor_exists(batch_name) - def _add_samples(self, batch_name, target_name): + def _add_samples(self, indices): + + if self.num_replicas == 1: + datasets: list[Dataset] = self.client.get_dataset_list_range( + self.list_name, start_index=indices[0], end_index=indices[-1] + ) + else: + datasets: list[Dataset] = [] + for idx in indices: + datasets += self.client.get_dataset_list_range( + self.list_name, start_index=idx, end_index=idx + ) + if self.samples is None: - self.samples = self.client.get_tensor(batch_name) + self.samples = datasets[0].get_tensor(self.sample_name) if self.need_targets: - self.targets = self.client.get_tensor(target_name) - else: + self.targets = datasets[0].get_tensor(self.target_name) + + if len(datasets) > 1: + datasets = datasets[1:] + + for dataset in datasets: self.samples = np.concatenate( - (self.samples, self.client.get_tensor(batch_name)) + (self.samples, dataset.get_tensor(self.sample_name)) ) if self.need_targets: self.targets = np.concatenate( - (self.targets, self.client.get_tensor(target_name)) + (self.targets, dataset.get_tensor(self.target_name)) ) self.num_samples = self.samples.shape[0] self.indices = np.arange(self.num_samples) - self.log("Success!") self.log(f"New dataset size: {self.num_samples}, batches: {len(self)}") - def _get_uploader_info(self, uploader_name): - dataset_name = form_name(uploader_name, "info") - self.log(f"Uploader dataset name: {dataset_name}") - - ds_exists = False - try: - ds_exists = self.client.dataset_exists(dataset_name) - # As long as required SmartRedis version is not 0.3 we - # need a workaround for the missing function - except AttributeError: - try: - uploaders = environ["SSKEYIN"].split(",") - for uploader in uploaders: - if self.client.key_exists(uploader + "." + dataset_name): - ds_exists = True - except KeyError: - msg = "Uploader must be launched with SmartSim and added to incoming entity, " - msg += "when setting uploader_info to 'auto'" - raise SmartSimError(msg) - - trials = 6 - while not ds_exists: - trials -= 1 - if trials == 0: - raise SmartSimError("Could not find uploader dataset") - time.sleep(5) - try: - ds_exists = self.client.dataset_exists(dataset_name) - except AttributeError: - try: - uploaders = environ["SSKEYIN"].split(",") - for uploader in uploaders: - if self.client.key_exists(uploader + "." + dataset_name): - ds_exists = True - except KeyError: - msg = "Uploader must be launched with SmartSim and added to incoming entity, " - msg += "when setting uploader_info to 'auto'" - raise SmartSimError(msg) - - uploader_info = self.client.get_dataset(dataset_name) - self.sample_prefix = uploader_info.get_meta_strings("sample_prefix")[0] - self.log(f"Uploader sample prefix: {self.sample_prefix}") - - try: - self.target_prefix = uploader_info.get_meta_strings("target_prefix")[0] - except: - self.target_prefix = None - self.log(f"Uploader target prefix: {self.target_prefix}") - - try: - self.producer_prefixes = uploader_info.get_meta_strings("producer_prefixes") - except: - self.producer_prefixes = [""] - self.log(f"Uploader producer prefixes: {self.producer_prefixes}") - - try: - self.num_classes = uploader_info.get_meta_scalars("num_classes")[0] - except: - self.num_classes = None - self.log(f"Uploader num classes: {self.num_classes}") - - try: - num_ranks = uploader_info.get_meta_scalars("num_ranks")[0] - self.sub_indices = [str(rank) for rank in range(num_ranks)] - except: - self.sub_indices = None - self.log(f"Uploader sub-indices: {self.sub_indices}") - def _update_samples_and_targets(self): - for source in self.sources: - entity = source[0] - sub_index = source[1] - self.client.set_data_source(entity) - batch_name = form_name(self.sample_prefix, sub_index) - if self.need_targets: - target_name = form_name(self.target_prefix, sub_index) - else: - target_name = None - - self.log(f"Retrieving {batch_name} from {entity}") - trials = 6 - while not self._data_exists(batch_name, target_name): - trials -= 1 - if trials == 0: - raise SmartSimError( - f"Could not retrieve batch {batch_name} from entity {entity}" + if not self.client: + self.client = Client(self.address, self.cluster) + + self.log(f"Rank {self.replica_rank} out of {self.num_replicas} replicas") + + for uploader_idx, uploader_key in enumerate(self.uploader_keys): + if uploader_key: + self.client.use_list_ensemble_prefix(True) + self.client.set_data_source(uploader_key) + + list_length = self.client.get_list_length(self.list_name) + + # Strictly greater, because next_index is 0-based + if list_length > self.next_indices[uploader_idx]: + indices = [ + idx + for idx in range( + self.next_indices[uploader_idx], list_length, self.num_replicas ) - time.sleep(5) - - self._add_samples(batch_name, target_name) + ] + self._add_samples(indices) + self.next_indices[uploader_idx] = indices[-1] + self.num_replicas def update_data(self): - self._update_samples_and_targets() + if self.dynamic: + self._update_samples_and_targets() + if self.shuffle: + np.random.shuffle(self.indices) - def __data_generation(self, indices): + def _data_generation(self, indices): # Initialization x = self.samples[indices] if self.need_targets: y = self.targets[indices] - elif self.autoencoding: y = x else: - y = None + return x return x, y - - def __len__(self): - length = int(np.floor(self.num_samples / self.batch_size)) - return length - - -class DynamicDataDownloader(StaticDataDownloader): - """A class to download batches from the DB as they are produced. - - By default, the DynamicDataDownloader has to be created in a process - launched through SmartSim, with sample producers listed as incoming - entities. - - All details about the batches must be defined in - the constructor; two mechanisms are available, `manual` and - `auto`. - - - When specifying `auto`, the user must also specify - `uploader_name`. DynamicDataDownloader will get all needed information - from the database (this expects a Dataset like the one created - by TrainingDataUploader to be available and stored as `uploader_name` - on the DB). - - - When specifying `manual`, the user must also specify details - of batch naming. Specifically, for each incoming entity with - a name starting with an element of `producer_prefixes`, - DynamicDataDownloader will query the DB - for all batches named __ for all indices - in `sub_indices` if supplied, and, if - `target_prefix` is supplied, it will also query for all targets - named ... If `producer_prefixes` is - None, then all incoming entities will be treated as producers, - and for each one, the corresponding batches will be downloaded. - - The flag `init_samples` defines whether sources (the list of batches - to be fetched) and samples (the actual data) should automatically - be set up in the costructor. - - If the user needs to modify the list of sources, then `init_samples=False` - has to be set. In that case, to set up a `DynamicDataDownloader`, the user has to call - `init_sources()` (which initializes the list of sources and the SmartRedis client) - and `init_samples()`. After `init_sources()` is called, - a list of data sources is populated, representing the batches which - will be downloaded. See `init_sources()` - - Each source is represented as a tuple `(producer_name, sub_index, iteration)`. - Before `init_samples()` is called, the user can modify the list. - Once `init_samples()` is called, all data is downloaded and batches - can be obtained with iter(). - - After initialization, samples and targets can be updated calling `update_data()`, - which shuffles the available samples, if `shuffle` is set to ``True`` at initialization. - - :param batch_size: Size of batches obtained with __iter__ - :type batch_size: int - :param shuffle: whether order of samples has to be shuffled when calling `update_data` - :type shuffle: bool - :param uploader_info: Set to `auto` uploader information has to be downloaded from DB, - or to `manual` if it is provided by the user - :type uploader_info: str - :param uploader_name: Name of uploader info dataset, only used if `uploader_info` is `auto` - :type uploader_name: str - :param sample_prefix: prefix of keys representing batches - :type sample_prefix: str - :param target_prefix: prefix of keys representing targets - :type target_prefix: str - :param uploader_ranks: Number of processes every uploader runs on (e.g, if each - rank in an MPI simulation is uploading its own batches, - this will be the MPI comm world size of the simulation). - :type uploader_ranks: int - :param num_classes: Number of classes of targets, if categorical - :type num_classes: int - :param producer_prefixes: Prefixes of processes which will be producing batches. - This can be useful in case the consumer processes also - have other incoming entities. - :type producer_prefixes: str - :param cluster: Whether the Orchestrator is being run as a cluster - :type cluster: bool - :param address: Address of Redis DB as : - :type address: str - :param replica_rank: When StaticDataDownloader is used in a distributed setting, indicates - the rank of this replica - :type replica_rank: int - :param num_replicas: When ContinuousBatchDownlaoder is used in a distributed setting, - indicates the total number of replicas (ranks) - :type num_replicas: int - :param verbose: Whether log messages should be printed - :type verbose: bool - :param init_samples: whether samples should be initialized in the constructor - :type init_samples: bool - """ - - def __init__(self, **kwargs): - super().__init__(**kwargs) - - def _list_all_sources(self): - sources = super()._list_all_sources() - # Append the batch index to each source - for source in sources: - source.append(0) - return sources - - def _update_samples_and_targets(self): - for source in self.sources: - entity = source[0] - sub_index = source[1] - index = source[2] - self.client.set_data_source(entity) - batch_name = form_name(self.sample_prefix, index, sub_index) - if self.need_targets: - target_name = form_name(self.target_prefix, index, sub_index) - else: - target_name = None - - self.log(f"Retrieving {batch_name} from {entity}") - # Poll next batch based on index, if available: retrieve it, update index and loop - while self._data_exists(batch_name, target_name): - self._add_samples(batch_name, target_name) - source[2] += 1 - index = source[2] - batch_name = form_name(self.sample_prefix, index, sub_index) - if self.need_targets: - target_name = form_name(self.target_prefix, index, sub_index) - - self.log(f"Retrieving {batch_name}...") - - def update_data(self): - """Update data. - - Fetch new batches (if available) from the DB. Also shuffle - list of samples if `self.shuffle` is set to ``True``. - """ - self._update_samples_and_targets() - if self.shuffle: - np.random.shuffle(self.indices) - - def init_samples(self, sources=None): - """Initialize samples (and targets, if needed). - - This function will not return until at least one batch worth of data - has been downloaded. - - :param sources: List of sources as defined in `init_sources`, defaults to None, - in which case sources will be initialized, unless `self.sources` - is already set - :type sources: list[tuple], optional - """ - self.autoencoding = self.sample_prefix == self.target_prefix - - if sources is not None: - self.sources = sources - - if self.sources is None: - self.sources = self._list_all_sources() - - if self.sources: - - while len(self) < 1: - self._update_samples_and_targets() - trials = 6 - if len(self) < 1: - trials -= 1 - if trials == 0: - raise SmartSimError("Could not find samples") - time.sleep(5) - self.log("Generator initialization complete") - else: - self.log( - "Generator has no associated sources, this can happen if the number of " - "loader workers is larger than the number of available sources." - ) diff --git a/smartsim/ml/tf/data.py b/smartsim/ml/tf/data.py index 236df3098..263c6baea 100644 --- a/smartsim/ml/tf/data.py +++ b/smartsim/ml/tf/data.py @@ -25,22 +25,12 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import numpy as np -import tensorflow.keras as keras +from tensorflow import keras -from smartsim.ml import DynamicDataDownloader, StaticDataDownloader +from smartsim.ml import DataDownloader -class StaticDataGenerator(StaticDataDownloader, keras.utils.Sequence): - """A class to download a dataset from the DB. - - Details about parameters and features of this class can be found - in the documentation of ``StaticDataDownloader``, of which it is just - a TensorFlow-specialized sub-class. - """ - - def __init__(self, **kwargs): - StaticDataDownloader.__init__(self, **kwargs) - +class _TFDataGenerationCommon(DataDownloader, keras.utils.Sequence): def __getitem__(self, index): if len(self) < 1: msg = "Not enough samples in generator for one batch. " @@ -50,7 +40,7 @@ def __getitem__(self, index): indices = self.indices[index * self.batch_size : (index + 1) * self.batch_size] # Generate data - x, y = self.__data_generation(indices) + x, y = self._data_generation(indices) if y is not None: return x, y @@ -65,7 +55,7 @@ def on_epoch_end(self): if self.shuffle: np.random.shuffle(self.indices) - def __data_generation(self, indices): + def _data_generation(self, indices): # Initialization x = self.samples[indices] @@ -76,21 +66,45 @@ def __data_generation(self, indices): elif self.autoencoding: y = x else: - y = None + return x return x, y -class DynamicDataGenerator(DynamicDataDownloader, StaticDataGenerator): +class StaticDataGenerator(_TFDataGenerationCommon): + """A class to download a dataset from the DB. + + Details about parameters and features of this class can be found + in the documentation of ``DataDownloader``, of which it is just + a TensorFlow-specialized sub-class with dynamic=False. + """ + + def __init__(self, **kwargs): + dynamic = kwargs.pop("dynamic", False) + kwargs["dynamic"] = False + super().__init__(**kwargs) + if dynamic: + self.log( + "Static data generator cannot be started with dynamic=True, setting it to False" + ) + + +class DynamicDataGenerator(_TFDataGenerationCommon): """A class to download batches from the DB. Details about parameters and features of this class can be found - in the documentation of ``DynamicDataDownloader``, of which it is just - a TensorFlow-specialized sub-class. + in the documentation of ``DataDownloader``, of which it is just + a TensorFlow-specialized sub-class with dynamic=True. """ def __init__(self, **kwargs): - StaticDataGenerator.__init__(self, **kwargs) + dynamic = kwargs.pop("dynamic", True) + kwargs["dynamic"] = True + super().__init__(**kwargs) + if not dynamic: + self.log( + "Dynamic data generator cannot be started with dynamic=False, setting it to True" + ) def on_epoch_end(self): """Callback called at the end of each training epoch @@ -99,4 +113,3 @@ def on_epoch_end(self): if `self.shuffle` is set to `True`, data is also shuffled. """ self.update_data() - super().on_epoch_end() diff --git a/smartsim/ml/torch/data.py b/smartsim/ml/torch/data.py index d7e1484ba..d07364990 100644 --- a/smartsim/ml/torch/data.py +++ b/smartsim/ml/torch/data.py @@ -26,77 +26,103 @@ import numpy as np import torch +from smartredis import Client, Dataset -from smartsim.ml.data import DynamicDataDownloader, StaticDataDownloader +from smartsim.ml.data import DataDownloader -class StaticDataGenerator(StaticDataDownloader, torch.utils.data.IterableDataset): - """A class to download a dataset from the DB. - - Details about parameters and features of this class can be found - in the documentation of ``StaticDataDownloader``, of which it is just - a PyTorch-specialized sub-class. +class _TorchDataGenerationCommon(DataDownloader, torch.utils.data.IterableDataset): + def __init__(self, **kwargs): + init_samples = kwargs.pop("init_samples", False) + kwargs["init_samples"] = False + super().__init__(**kwargs) + if init_samples: + self.log( + "PyTorch Data Generator has to be created with init_samples=False. Setting it to False automatically." + ) - Note that if the ``StaticDataGenerator`` has to be used through a ``DataLoader``, - `init_samples` must be set to `False`, as sources and samples will be initialized - by the ``DataLoader`` workers. - """ + def _add_samples(self, indices): + if self.client is None: + client = Client(self.address, self.cluster) + else: + client = self.client - def __init__(self, **kwargs): - StaticDataDownloader.__init__(self, **kwargs) + if self.num_replicas == 1: + datasets: list[Dataset] = client.get_dataset_list_range( + self.list_name, start_index=indices[0], end_index=indices[-1] + ) + else: + datasets: list[Dataset] = [] + for idx in indices: + datasets += client.get_dataset_list_range( + self.list_name, start_index=idx, end_index=idx + ) - def _add_samples(self, batch_name, target_name): if self.samples is None: - self.samples = torch.tensor(self.client.get_tensor(batch_name)) + self.samples = torch.tensor(datasets[0].get_tensor(self.sample_name)) if self.need_targets: - self.targets = torch.tensor(self.client.get_tensor(target_name)) - else: + self.targets = torch.tensor(datasets[0].get_tensor(self.target_name)) + + if len(datasets) > 1: + datasets = datasets[1:] + + for dataset in datasets: self.samples = torch.cat( - (self.samples, torch.tensor(self.client.get_tensor(batch_name))) + (self.samples, torch.tensor(dataset.get_tensor(self.sample_name))) ) if self.need_targets: self.targets = torch.cat( - (self.targets, torch.tensor(self.client.get_tensor(target_name))) + (self.targets, torch.tensor(dataset.get_tensor(self.target_name))) ) self.num_samples = self.samples.shape[0] self.indices = np.arange(self.num_samples) - self.log("Success!") - self.log(f"New dataset size: {self.num_samples}") - - def update_data(self): - self._update_samples_and_targets() - if self.shuffle: - np.random.shuffle(self.indices) + self.log(f"New dataset size: {self.num_samples}, batches: {len(self)}") -class DynamicDataGenerator(DynamicDataDownloader, StaticDataGenerator): - """A class to download batches from the DB. +class StaticDataGenerator(_TorchDataGenerationCommon): + """A class to download a dataset from the DB. Details about parameters and features of this class can be found - in the documentation of ``DynamicDataDownloader``, of which it is just - a PyTorch-specialized sub-class. + in the documentation of ``DataDownloader``, of which it is just + a PyTorch-specialized sub-class with dynamic=False and init_samples=False. + + When used in the DataLoader defined in this class, samples are initialized + automatically before training. Other data loaders using this generator + should implement the same behavior. - Note that if the ``DynamicDataGenerator`` has to be used through a ``DataLoader``, - `init_samples` must be set to `False`, as sources and samples will be initialized - by the ``DataLoader`` workers. """ def __init__(self, **kwargs): - StaticDataGenerator.__init__(self, **kwargs) + dynamic = kwargs.pop("dynamic", False) + kwargs["dynamic"] = False + super().__init__(**kwargs) + if dynamic: + self.log( + "Static data generator cannot be started with dynamic=True, setting it to False" + ) - def __iter__(self): - if self.sources: - self.update_data() - return super().__iter__() - def _add_samples(self, batch_name, target_name): - StaticDataGenerator._add_samples(self, batch_name, target_name) +class DynamicDataGenerator(_TorchDataGenerationCommon): + """A class to download batches from the DB. - def __iter__(self): - if self.sources: - self.update_data() - return super().__iter__() + Details about parameters and features of this class can be found + in the documentation of ``DataDownloader``, of which it is just + a PyTorch-specialized sub-class with dynamic=True and init_samples=False. + + When used in the DataLoader defined in this class, samples are initialized + automatically before training. Other data loaders using this generator + should implement the same behavior. + """ + + def __init__(self, **kwargs): + dynamic = kwargs.pop("dynamic", True) + kwargs["dynamic"] = True + super().__init__(**kwargs) + if not dynamic: + self.log( + "Dynamic data generator cannot be started with dynamic=False, setting it to True" + ) class DataLoader(torch.utils.data.DataLoader): # pragma: no cover @@ -108,7 +134,7 @@ class DataLoader(torch.utils.data.DataLoader): # pragma: no cover be set to None. """ - def __init__(self, dataset: StaticDataGenerator, **kwargs): + def __init__(self, dataset: _TorchDataGenerationCommon, **kwargs): super().__init__( dataset, worker_init_fn=self.worker_init_fn, @@ -120,25 +146,16 @@ def __init__(self, dataset: StaticDataGenerator, **kwargs): def worker_init_fn(worker_id): worker_info = torch.utils.data.get_worker_info() dataset = worker_info.dataset # the dataset copy in this worker process - dataset.init_sources() - overall_sources = dataset.sources worker_id = worker_info.id + num_workers = worker_info.num_workers - # configure the dataset to only process the split workload - per_worker = int((len(overall_sources)) // worker_info.num_workers) - - if per_worker > 0: - if worker_id < worker_info.num_workers - 1: - sources = overall_sources[ - worker_id * per_worker : (worker_id + 1) * per_worker - ] - else: - sources = overall_sources[worker_id * per_worker :] - else: - if worker_id < len(overall_sources): - sources = overall_sources[worker_id] - else: - sources = [] + dataset.set_replica_parameters( + replica_rank=dataset.replica_rank * num_workers + worker_id, + num_replicas=dataset.num_replicas * num_workers, + ) + dataset.log( + f"Worker {worker_id+1}/{num_workers}: dataset replica {dataset.replica_rank+1}/{dataset.num_replicas}" + ) - dataset.init_samples(sources) + dataset.init_samples() diff --git a/tests/backends/test_dataloader.py b/tests/backends/test_dataloader.py index 8e68bb110..3bde965e0 100644 --- a/tests/backends/test_dataloader.py +++ b/tests/backends/test_dataloader.py @@ -24,15 +24,17 @@ # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import os.path as osp -import time +from os import path as osp +import os +import numpy as np import pytest -from smartsim import status from smartsim.database import Orchestrator -from smartsim.error.errors import SmartSimError +from smartsim.error.errors import SSInternalError from smartsim.experiment import Experiment +from smartsim.status import STATUS_COMPLETED +from smartsim.ml.data import DataInfo, TrainingDataUploader shouldrun_tf = True if shouldrun_tf: @@ -40,6 +42,7 @@ from tensorflow import keras from smartsim.ml.tf import DynamicDataGenerator as TFDataGenerator + from smartsim.ml.tf import StaticDataGenerator as TFStaticDataGenerator except: shouldrun_tf = False @@ -48,45 +51,156 @@ try: import torch + from smartsim.ml.torch import DataLoader from smartsim.ml.torch import DynamicDataGenerator as TorchDataGenerator + from smartsim.ml.torch import StaticDataGenerator as TorchStaticDataGenerator except: shouldrun_torch = False -def create_uploader(experiment: Experiment, filedir, format): - """Start an ensemble of two processes producing sample batches at - regular intervals. - """ - run_settings = experiment.create_run_settings( - exe="python", - exe_args=["data_uploader.py", f"--format={format}"], - env_vars={"PYTHONUNBUFFERED": "1"}, +def check_dataloader(dl, rank, dynamic): + assert dl.list_name == "test_data_list" + assert dl.sample_name == "test_samples" + assert dl.target_name == "test_targets" + assert dl.num_classes == 2 + assert dl.verbose == True + assert dl.replica_rank == rank + assert dl.num_replicas == 2 + assert dl.address == None + assert dl.cluster == False + assert dl.shuffle == True + assert dl.batch_size == 4 + assert dl.autoencoding == False + assert dl.need_targets == True + assert dl.dynamic == dynamic + + +def run_local_uploaders(mpi_size, format="torch"): + batch_size = 4 + for rank in range(mpi_size): + os.environ["SSKEYOUT"] = f"test_uploader_{rank}" + + data_uploader = TrainingDataUploader( + list_name="test_data_list", + sample_name="test_samples", + target_name="test_targets", + num_classes=mpi_size, + cluster=False, + address=None, + rank=rank, + verbose=True, + ) + + assert data_uploader._info.list_name == "test_data_list" + assert data_uploader._info.sample_name == "test_samples" + assert data_uploader._info.target_name == "test_targets" + assert data_uploader._info.num_classes == mpi_size + assert data_uploader._info._ds_name == "test_data_list_info" + + if rank == 0: + data_uploader.publish_info() + + batches_per_loop = 1 + shape = ( + (batch_size * batches_per_loop, 32, 32, 1) + if format == "tf" + else (batch_size * batches_per_loop, 1, 32, 32) + ) + + for _ in range(2): + for mpi_rank in range(mpi_size): + new_batch = np.random.normal( + loc=float(mpi_rank), scale=5.0, size=shape + ).astype(float) + new_labels = ( + np.ones(shape=(batch_size * batches_per_loop,)).astype(int) + * mpi_rank + ) + + data_uploader.put_batch(new_batch, new_labels) + + return data_uploader._info + + +def train_tf(generator): + if not shouldrun_tf: + return + + model = keras.models.Sequential( + [ + keras.layers.Conv2D( + filters=4, + kernel_size=(3, 3), + activation="relu", + input_shape=(32, 32, 1), + ), + keras.layers.Flatten(), + keras.layers.Dense(generator.num_classes, activation="softmax"), + ] ) - uploader = experiment.create_ensemble( - "test_uploader", replicas=2, run_settings=run_settings - ) + model.compile(optimizer="Adam", loss="mse", metrics=["mae"]) - uploader.attach_generator_files(to_copy=[osp.join(filedir, "data_uploader.py")]) - uploader.enable_key_prefixing() - experiment.generate(uploader, overwrite=True) - return uploader + for epoch in range(2): + model.fit( + generator, + steps_per_epoch=None, + epochs=epoch + 1, + initial_epoch=epoch, + batch_size=generator.batch_size, + verbose=2, + ) -def create_trainer_tf(experiment: Experiment, filedir): - run_settings = experiment.create_run_settings( - exe="python", - exe_args=["training_service_tf.py"], - env_vars={"PYTHONUNBUFFERED": "1"}, - ) +@pytest.mark.skipif(not shouldrun_tf, reason="Test needs TensorFlow to run") +def test_tf_dataloaders(fileutils, wlmutils): + test_dir = fileutils.make_test_dir() + exp = Experiment("test_tf_dataloaders", test_dir) + orc: Orchestrator = wlmutils.get_orchestrator() + exp.generate(orc) + exp.start(orc) - trainer = experiment.create_model("trainer", run_settings=run_settings) + try: + os.environ["SSDB"] = orc.get_address()[0] + data_info = run_local_uploaders(mpi_size=2, format="tf") + + os.environ["SSKEYIN"] = "test_uploader_0,test_uploader_1" + for rank in range(2): + tf_dynamic = TFDataGenerator( + data_info_or_list_name="test_data_list", + cluster=False, + verbose=True, + num_replicas=2, + replica_rank=rank, + batch_size=4, + max_fetch_trials=5, + dynamic=False, # catch wrong arg + ) + train_tf(tf_dynamic) + assert len(tf_dynamic) == 4 + check_dataloader(tf_dynamic, rank, dynamic=True) + for rank in range(2): + tf_static = TFStaticDataGenerator( + data_info_or_list_name=data_info, + cluster=False, + verbose=True, + num_replicas=2, + replica_rank=rank, + batch_size=4, + max_fetch_trials=5, + dynamic=True, # catch wrong arg + ) + train_tf(tf_static) + assert len(tf_static) == 4 + check_dataloader(tf_static, rank, dynamic=False) - trainer.attach_generator_files( - to_copy=[osp.join(filedir, "training_service_tf.py")] - ) - experiment.generate(trainer, overwrite=True) - return trainer + except Exception as e: + raise e + finally: + exp.stop(orc) + os.environ.pop("SSDB", "") + os.environ.pop("SSKEYIN", "") + os.environ.pop("SSKEYOUT", "") def create_trainer_torch(experiment: Experiment, filedir): @@ -105,70 +219,98 @@ def create_trainer_torch(experiment: Experiment, filedir): return trainer -def test_batch_dataloader_tf(fileutils, wlmutils): - if not shouldrun_tf: - pytest.skip("Test needs TensorFlow to run.") - +@pytest.mark.skipif(not shouldrun_torch, reason="Test needs Torch to run") +def test_torch_dataloaders(fileutils, wlmutils): test_dir = fileutils.make_test_dir() - exp = Experiment("test-batch-dataloader-tf", exp_path=test_dir) - config_path = fileutils.get_test_conf_path("ml") - dataloader = create_uploader(exp, config_path, "tf") - trainer_tf = create_trainer_tf(exp, config_path) - - orc = Orchestrator(port=wlmutils.get_test_port()) + exp = Experiment("test_tf_dataloaders", test_dir, launcher=wlmutils.get_test_launcher()) + orc: Orchestrator = wlmutils.get_orchestrator() + config_dir = fileutils.get_test_dir_path("ml") exp.generate(orc) exp.start(orc) - exp.start(dataloader, block=False) - for entity in dataloader: - trainer_tf.register_incoming_entity(entity) - - exp.start(trainer_tf, block=True) - if exp.get_status(trainer_tf)[0] != status.STATUS_COMPLETED: + try: + os.environ["SSDB"] = orc.get_address()[0] + data_info = run_local_uploaders(mpi_size=2) + + os.environ["SSKEYIN"] = "test_uploader_0,test_uploader_1" + for rank in range(2): + torch_dynamic = TorchDataGenerator( + data_info_or_list_name="test_data_list", + cluster=False, + verbose=True, + num_replicas=2, + replica_rank=rank, + batch_size=4, + max_fetch_trials=5, + dynamic=False, # catch wrong arg + init_samples=True, # catch wrong arg + ) + check_dataloader(torch_dynamic, rank, dynamic=True) + + torch_dynamic.init_samples(5) + for _ in range(2): + for _ in torch_dynamic: + continue + + for rank in range(2): + torch_static = TorchStaticDataGenerator( + data_info_or_list_name=data_info, + cluster=False, + verbose=True, + num_replicas=2, + replica_rank=rank, + batch_size=4, + max_fetch_trials=5, + dynamic=True, # catch wrong arg + init_samples=True, # catch wrong arg + ) + check_dataloader(torch_static, rank, dynamic=False) + + torch_static.init_samples(5) + for _ in range(2): + for _ in torch_static: + continue + + trainer = create_trainer_torch(exp, config_dir) + exp.start(trainer, block=True) + + assert exp.get_status(trainer)[0] == STATUS_COMPLETED + + except Exception as e: + raise e + finally: exp.stop(orc) - assert False - - exp.stop(orc) - - trials = 5 - if exp.get_status(dataloader)[0] != status.STATUS_COMPLETED: - time.sleep(5) - trials -= 1 - if trials == 0: - assert False - + os.environ.pop("SSDB", "") + os.environ.pop("SSKEYIN", "") + os.environ.pop("SSKEYOUT", "") -def test_batch_dataloader_torch(fileutils, wlmutils): - if not shouldrun_torch: - pytest.skip("Test needs PyTorch to run.") - test_dir = fileutils.make_test_dir() - exp = Experiment("test-batch-dataloader-tf", exp_path=test_dir) - config_path = fileutils.get_test_conf_path("ml") - dataloader = create_uploader(exp, config_path, "torch") - trainer_torch = create_trainer_torch(exp, config_path) +def test_data_info_repr(): + data_info = DataInfo( + list_name="a_list", sample_name="the_samples", target_name=None + ) + data_info_repr = "DataInfo object\n" + data_info_repr += "Aggregation list name: a_list\n" + data_info_repr += "Sample tensor name: the_samples" + assert repr(data_info) == data_info_repr - orc = Orchestrator(wlmutils.get_test_port()) - exp.generate(orc) - exp.start(orc) - exp.start(dataloader, block=False) + data_info = DataInfo( + list_name="a_list", sample_name="the_samples", target_name="the_targets" + ) - for entity in dataloader: - trainer_torch.register_incoming_entity(entity) + data_info_repr += "\nTarget tensor name: the_targets" - exp.start(trainer_torch, block=True) - if exp.get_status(trainer_torch)[0] != status.STATUS_COMPLETED: - exp.stop(orc) - assert False + assert repr(data_info) == data_info_repr - exp.stop(orc) + data_info = DataInfo( + list_name="a_list", + sample_name="the_samples", + target_name="the_targets", + num_classes=23, + ) + data_info_repr += "\nNumber of classes: 23" - trials = 5 - if exp.get_status(dataloader)[0] != status.STATUS_COMPLETED: - time.sleep(5) - trials -= 1 - if trials == 0: - assert False + assert repr(data_info) == data_info_repr @pytest.mark.skipif( @@ -177,19 +319,33 @@ def test_batch_dataloader_torch(fileutils, wlmutils): def test_wrong_dataloaders(fileutils, wlmutils): test_dir = fileutils.make_test_dir() exp = Experiment("test-wrong-dataloaders", exp_path=test_dir) - orc = Orchestrator(wlmutils.get_test_port()) + orc = wlmutils.get_orchestrator() exp.generate(orc) exp.start(orc) if shouldrun_tf: - with pytest.raises(SmartSimError): - _ = TFDataGenerator(address=orc.get_address()[0], cluster=False) + with pytest.raises(SSInternalError): + _ = TFDataGenerator( + data_info_or_list_name="test_data_list", + address=orc.get_address()[0], + cluster=False, + max_fetch_trials=1, + ) + with pytest.raises(TypeError): + _ = TFStaticDataGenerator( + test_data_info_repr=1, + address=orc.get_address()[0], + cluster=False, + max_fetch_trials=1, + ) if shouldrun_torch: - with pytest.raises(SmartSimError): + with pytest.raises(SSInternalError): torch_data_gen = TorchDataGenerator( - address=orc.get_address()[0], cluster=False + data_info_or_list_name="test_data_list", + address=orc.get_address()[0], + cluster=False, ) - torch_data_gen.init_samples() + torch_data_gen.init_samples(init_trials=1) exp.stop(orc) diff --git a/tests/backends/test_dbmodel.py b/tests/backends/test_dbmodel.py index a1ec78190..bb223b4a2 100644 --- a/tests/backends/test_dbmodel.py +++ b/tests/backends/test_dbmodel.py @@ -122,6 +122,7 @@ def forward(self, x): output = F.log_softmax(x, dim=1) return output + except Exception: should_run_pt = False diff --git a/tests/test_configs/ml/data_uploader.py b/tests/test_configs/ml/data_uploader.py deleted file mode 100644 index 7e9b3f89a..000000000 --- a/tests/test_configs/ml/data_uploader.py +++ /dev/null @@ -1,85 +0,0 @@ -# BSD 2-Clause License -# -# Copyright (c) 2021-2023, Hewlett Packard Enterprise -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright notice, this -# list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright notice, -# this list of conditions and the following disclaimer in the documentation -# and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -from argparse import ArgumentParser -from os import environ - -import numpy as np - -from smartsim.ml import TrainingDataUploader - -# simulate multi-rank without requesting mpi4py as dep -mpi_size = 2 - - -def create_data_uploader(rank): - return TrainingDataUploader( - name="test_data", - sample_prefix="test_samples", - target_prefix="test_targets", - num_classes=mpi_size, - producer_prefixes="test_uploader", - cluster=False, - address=None, - num_ranks=mpi_size, - rank=rank, - verbose=True, - ) - - -if __name__ == "__main__": - - parser = ArgumentParser() - parser.add_argument("--format", default="tf", type=str) - args = parser.parse_args() - format = args.format - - batch_size = 4 - data_uploaders = [create_data_uploader(rank) for rank in range(mpi_size)] - - print(environ["SSKEYOUT"]) - if environ["SSKEYOUT"] == "test_uploader_0": - data_uploaders[0].publish_info() - - batches_per_loop = 1 - shape = ( - (batch_size * batches_per_loop, 32, 32, 1) - if format == "tf" - else (batch_size * batches_per_loop, 1, 32, 32) - ) - - # Start "simulation", produce data every two minutes, for thirty minutes - for _ in range(2): - for mpi_rank in range(mpi_size): - new_batch = np.random.normal( - loc=float(mpi_rank), scale=5.0, size=shape - ).astype(float) - new_labels = ( - np.ones(shape=(batch_size * batches_per_loop,)).astype(int) * mpi_rank - ) - - data_uploaders[mpi_rank].put_batch(new_batch, new_labels) - print(f"{mpi_rank}: New data pushed to DB") diff --git a/tests/test_configs/ml/training_service_tf.py b/tests/test_configs/ml/training_service_tf.py deleted file mode 100644 index 854b77e5d..000000000 --- a/tests/test_configs/ml/training_service_tf.py +++ /dev/null @@ -1,101 +0,0 @@ -# BSD 2-Clause License -# -# Copyright (c) 2021-2023, Hewlett Packard Enterprise -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# 1. Redistributions of source code must retain the above copyright notice, this -# list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright notice, -# this list of conditions and the following disclaimer in the documentation -# and/or other materials provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -import tensorflow.keras as keras - -from smartsim.ml.tf import DynamicDataGenerator - - -def check_dataloader(dl, rank): - assert dl.uploader_name == "test_data" - assert dl.sample_prefix == "test_samples" - assert dl.target_prefix == "test_targets" - assert dl.uploader_info == "auto" - assert dl.num_classes == 2 - assert dl.producer_prefixes == ["test_uploader"] - assert dl.sub_indices == ["0", "1"] - assert dl.verbose == True - assert dl.replica_rank == rank - assert dl.num_replicas == 2 - assert dl.address == None - assert dl.cluster == False - assert dl.shuffle == True - assert dl.batch_size == 4 - assert len(dl.sources) == 2 - for i in range(2): - assert dl.sources[i][0:2] == [f"test_uploader_{rank}", str(i)] - assert type(dl.sources[i][2]) == int - - -# Pretend we are running distributed without requiring Horovod -hvd_size = 2 - - -def create_data_generator(rank): - return DynamicDataGenerator( - cluster=False, - uploader_name="test_data", - verbose=True, - num_replicas=2, - replica_rank=rank, - batch_size=4, - ) - - -training_generators = [create_data_generator(rank) for rank in range(hvd_size)] - -[ - check_dataloader(training_generator, rank) - for (rank, training_generator) in enumerate(training_generators) -] - -model = keras.models.Sequential( - [ - keras.layers.Conv2D( - filters=4, kernel_size=(3, 3), activation="relu", input_shape=(32, 32, 1) - ), - keras.layers.Flatten(), - keras.layers.Dense(training_generators[0].num_classes, activation="softmax"), - ] -) - -model.compile(optimizer="Adam", loss="mse", metrics=["mae"]) - -print("Starting training") - -for epoch in range(2): - print(f"Epoch {epoch}") - for rank in range(hvd_size): - model.fit( - training_generators[rank], - steps_per_epoch=None, - epochs=epoch + 1, - initial_epoch=epoch, - batch_size=training_generators[rank].batch_size, - verbose=2, - ) - -assert all([len(training_generators[rank]) == 4 for rank in range(hvd_size)]) diff --git a/tests/test_configs/ml/training_service_torch.py b/tests/test_configs/ml/training_service_torch.py index a103df574..8c1091820 100644 --- a/tests/test_configs/ml/training_service_torch.py +++ b/tests/test_configs/ml/training_service_torch.py @@ -47,40 +47,21 @@ def forward(self, x): return output -def check_dataloader(dl): - assert dl.uploader_name == "test_data" - assert dl.sample_prefix == "test_samples" - assert dl.target_prefix == "test_targets" - assert dl.uploader_info == "auto" - assert dl.num_classes == 2 - assert dl.producer_prefixes == ["test_uploader"] - assert dl.sub_indices == ["0", "1"] - assert dl.verbose == True - assert dl.replica_rank == 0 - assert dl.num_replicas == 1 - assert dl.address == None - assert dl.cluster == False - assert dl.shuffle == True - assert dl.batch_size == 4 - - # This test should run without error, but no explicit # assertion is performed if __name__ == "__main__": torch.multiprocessing.set_start_method("spawn") training_set = DynamicDataGenerator( + data_info_or_list_name="test_data_list", cluster=False, - shuffle=True, - batch_size=4, - init_samples=False, verbose=True, - uploader_name="test_data", + batch_size=4, + max_fetch_trials=5, ) trainloader = DataLoader(training_set, batch_size=None, num_workers=2) - check_dataloader(training_set) model = Net(num_classes=training_set.num_classes).double() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.0001) diff --git a/tests/test_run_settings.py b/tests/test_run_settings.py index d8d5830e0..a87cc2e5a 100644 --- a/tests/test_run_settings.py +++ b/tests/test_run_settings.py @@ -27,11 +27,12 @@ import contextlib import logging -from shutil import which import subprocess +from shutil import which import pytest +from smartsim.error.errors import SSUnsupportedError from smartsim.settings import ( MpiexecSettings, MpirunSettings, @@ -39,7 +40,6 @@ RunSettings, ) from smartsim.settings.settings import create_run_settings -from smartsim.error.errors import SSUnsupportedError def test_create_run_settings_local(): diff --git a/tutorials/ml_training/surrogate/steady_state.py b/tutorials/ml_training/surrogate/steady_state.py index 21e7fbf04..5e1fac5d6 100644 --- a/tutorials/ml_training/surrogate/steady_state.py +++ b/tutorials/ml_training/surrogate/steady_state.py @@ -267,7 +267,7 @@ def fd2d_heat_steady_test01 (nx, 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) + u_init = np.zeros_like(Xgrid).astype(bool) for center in source_centers: u_init |= (Xgrid-center[0])**2 + (Ygrid-center[1])**2 < 0.05**2 diff --git a/tutorials/ml_training/surrogate/tf_training.py b/tutorials/ml_training/surrogate/tf_training.py index fd2c16d83..932cb2df3 100644 --- a/tutorials/ml_training/surrogate/tf_training.py +++ b/tutorials/ml_training/surrogate/tf_training.py @@ -24,7 +24,7 @@ def store_model(model, idx): 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) + training_generator = DynamicDataGenerator(cluster=False, batch_size=50, shuffle=True, data_info_or_list_name="training_data") print("Compiling NN") initial_learning_rate = 0.01 diff --git a/tutorials/ml_training/surrogate/train_surrogate.ipynb b/tutorials/ml_training/surrogate/train_surrogate.ipynb index 408ecd71b..c811d1205 100644 --- a/tutorials/ml_training/surrogate/train_surrogate.ipynb +++ b/tutorials/ml_training/surrogate/train_surrogate.ipynb @@ -41,7 +41,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -53,7 +53,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -65,7 +65,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdAAAADvCAYAAABCBoXMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtaElEQVR4nO2de7QtSV3fv7/uvc+5594ZZniDs0QQWPhABXkoAjJETSTBJIxGjWHF8YEag9EkLJfmocRnsjJqkqXRgMEHZik+kogQNCJi1BDUgBJUQMULIwgMCOPcmXvP2bu78kf3PfWtOvXr3bvOOXPnznw/a511qrurqqsfe9eu7+9Xv7IQAoQQQgixHc2VboAQQghxNaIOVAghhKhAHagQQghRgTpQIYQQogJ1oEIIIUQF6kCFEEKICtSBniJm9mIze7+ZBTO7+Zh1BTP7gi3yP3Is8+QN+X7UzF51mm0R91zGd/StW5Z5vZl9/2m16Z6EmV047mdX3HtRB+pQ07Fk5R8P4FsBfA2AhwN4hZmdN7MXVVb5cAC/sEX+W8cyvzu258ax43tQlu/rATy/sk1FjnvvrjbuiT8o6Hlf/vuQmb3OzJ6eZb0FwLNO4fzHeden6r1Xdd61785p3V+xHepAT4/HjP//ewjhfSGEi8epbKxjf4v83VhmvSHf7SGEjxynbfdGzKwxs/ZuPufCzOyEq/1EDD+kbgRwG4BXm9lDLh8MIVwIIXzohM8pxH2DEIL+Cn8AfhTAqyaOfwKAVwO4A8AHAPwkgIeNx14MIGR/r8/3bdmeAOALxvQjx+3PB/DLAO4C8AcAPofyX87zZErz34+WrhPA5wL4dQAfBvAXAH4JwMd7bSm0s3TtN47HbgDwU2PdHx7v32Ozsm8F8KUAzgO4E8CPANgB8LUYRtUfAvC9ABoqd34s+xMALgB4H4AXZe26DsBLxmd1B4BfA/BkOn7zWPavj21YA3g8gKcA+J8APgjgLwH8BoCnZefmaz3P15K14WYAFwrXezOAPwHQAbhmU1tnvi83ju15EO37pHHf5+VtoO0FgO+jZ/R9AH4QwOspz+sB/EcA3zXelw9gGMk2dPw47/q3AHgXgP3xWf44vav5u/XITZ/H8fjkcxzzPGZs+yUAbwfw3PGduHk8/joA35+VuR+Gz99NzrVcB+DlY5suAXgngG/Y8O48GsDPj9d+J4A3AXhudv+L9xfAZ4zvy10A3jM+u/ud1vfkff1PI9AKzOzhAP4Xhi+/pwL4bAxffD9vZg2GL5MXjNkfPv7dBODPAHwb7btcXzCzF1c05TsB/AcAnwLgtwH8lJldU8h3K4bOFogjkq936jwH4N+N13UjgNsB/IKZ7cxs0y0AfhrAaxGv83+b2VkAv4rhS+RZAJ4G4M8BvHY8dplHAvhbGL68bgLwdwC8EsMX4F8F8JUAvg7A87Lz/hMAfwjgUzFI599lZjcBwDiqezWGDvy5AJ6I4fm9bnyWlzkD4F8C+GoMX8jvAnAthi/AZ4735HcB/A8ze+BY5inj/xeM1/oUbMejAHzJeJ2fgqHTmNPWrRjv8c3j5moi64vGfF8J4NMxqFRfUsj39zD8yPgMAC8E8A0Avmg8Vv2um9nnj234WgCPxXAPfms8/PUA3oDhR9Xlem+d8XkENjzHMd9/G6/3aQC+HMOPi11q3ksBfImZ8b6/i6GT9cwr34Hhh8tzATxurPc94zHv3bkGwGsAfA6Gd+LnAPxXM/u48Xjx/prZJ2H4kfDKsdxNAJ4A4GVO28RxudI9+D31DxMjUAwv7q9k++6P4dfgU8ftL0D2yxvDL84XFep7G4AXbmhPaQT61XT8hnHfM7I8Tx63b0Q2Itl0nePxcxhGRs8otWXuvcPwxfFHAIz2tRhGlF84br8YwEUA11Gen8UgPe7QvteDRgLjff3l7Hw/DOA3xvRfwfAlt5fl+V0A3zimbx6v60kbnoNh6PifP3U/MH8EugLwUNq3sa0z39/Lz/vC+NeP278NYOm1c7y2b8qu9+04OgJ9Q3a+Xwbww8d91zH8EHo7tzE7njz7uZ/HTc8Rw4+zDsAjKM8zxjpuHrd3MYxgv5jyvBHALRPX80oAL5s4PvlZonz/B8C/mLq/AH4cwH/O9j1hPMdD5r47+pv/t4Co4UkAPtPMLhSOPRrxF/MsQggftzlXkbdQ+r3j/4eUMs7FzB4N4NsBfBqAB2P4Rd4AeMRx6sVwzx4F4I7MzHcWwz27zLtDCLfT9vsBvCOEcJDty6/zDYXtm+jcZwHclp37THbuNUanq8uM9sJvB/BsAA/F0Onv4fj34zJ/FkJ4P23Pbetcno1BRXgigO8G8KUhhOII1MyuA/Aw0PsbQghm9lsAPjrL/pZs+72Y8e7NeNd/BsNI80/N7JcA/CKAV4Zp+//Gz+OM5/jxAN4TQng3lX0jhh8el9u+b2Yvx/Bj8KfM7BMxjGZvnmjbDwL4WTN7EoYfGb8QQvi1ifwws3MYVJTnYhhdLjE8//ye5zwJwGPM7Ito3+WX6NEYZGRxgqgDraPBILOVvODeX9h3Whx+EY5fdMDxHcNehUEe+moMUtMag311roTr0WDonL64cOwvKJ1/uQdn3zYOPg2G5/LMwrG/pPR+CKHLjv8Yhi/cf4zhV/8+gF/B5vvRI355XWZZyHdnZVvn8qchhA8CeIeZncEgBX7Khg5pDqVncmyTUAjhVjN7HIDPwiDFfg+AbzWzTwsh5PfqMnM+j7XPMeeHAbzFzB6BoSN9QwjhDyeu5zVm9jEAnjNe06vN7GdCCF82cY5bMPgivAiDanMXhtHlprY2Y/u+r3DsPYV94pioA63jTQC+EMC7vF/zDgfY7ov/JLk8gnPPP9qDPg7A14YQfnXc96nY/j0pXeebMNiLPhhOx+v30wvbl7/Y3oThy7MPIbxzy3qfAeAfhRBeDQBm9lCQTW9khaPXexuAh5qZhVFLwyCnbeI4bd3EyzE46PxDDI5YCSGE283sfRhsca8DDu3HT8Hg0LIN1e96COEShg7x1Wb2r8dzPx2Dfc97tzZ9Hjc9xz8EcIOZfXQI4dZx31OR/SgIIfy+mb0Rg93y+QD++Yzr+SCGe/9yM3sNgJ80s68Zf8SU3p1nYHCc+rmxrZfVh3dQHu8+fGII4Y83tUmcDHIimuZ+ZvaE7O+RAH4Ag3fdK8zs08zsY83ss83sJWZ27UR95wE808xu4PmYZvY2M3vhqV7J4BATAPwNM3uw42z0YQw2nheY2WPM7FkAfgjDKHQbzgN4vJk9zsweZGZLAP8Fw2jg583sWWb2KDP7TDP7HjN7bPVVRT7dzL7ZzB5rZi8A8PcRf4m/FsBvjud+znjup5nZvzKz0kiPeQeA55vZJ5jZUzB4ER9kec4D+Cwze5iZ3X/c93oADwDwz8zs0Wb2FRjs4pvY2Nbx/XmbmeWOVJOEEHoMDmLfNMqEJf49gG80s+eNI8HvwdDRBCe/x3lUvOtmdrOZfaWZfZKZPQrAl2HoZP6I6n2qDYFCHjQ6/8z5PG56jq/FYJ/98fFz/jQM70/p3X8pgG/E4B/wiqmbYGbfZmZ/e3wvPx6DWeGdpACcx9F35x0Anmdmn2qDY9BPYJBwmfM4en//zXhvfsjMnjh+hp9rZv+J2vNCM3vbVJvFfNSBTvNMAG/O/m4JIbwXwy/iHoON5vcxfIj3xz+Pb8FgS/oTDCOUyzwOQB7g4EQJIbwHg13lOzF0ZEcmo49fsF8E4JMxeDT+AAav1G3lvpdi+EX/Oxiu8+khhLsAfCYGN/6fwfBl9WMYnD0+vP0VHeF7x3a/GYPn47eEEH4WGD25hukprxvb9nYMnsKPQ7Qde3w5Bq/I/4vhS/dlGL68mH+KwbZ263h+jLLePwDwVRhsV5+DYdrHJDPbuhy3r9tUX4GXYVAUPC/sWzCMln4Eg+MKMHinXtryPLXv+kcAfAWGqVRvxeA9flMI4U+pfQcYzAq3YXD6mfN5nHyO47v/PAzfiW/EIJl+B8rv/ivGNvx0COGOqZswlv9OAL+H4YfRtQA+j44feXcwOFJ9YLwHr8HwHH49q/fI/Q0hvAXDZ+yRGKay/B4GuzeblR6E4RmIE8CiuiTE1YmZncfgmXnLlW7LvREzezMGj+avu9JtuSdgZh8F4N0AnhVC+M0r3R5x5ZANVAhxyOjw8tcwjGCWGGx9n4w4r/k+y2iKeCAGJeHN6jyFOlAhBNNjsB//Wwxy5h8AeE4I4XeuaKvuGTwdQzCQP8LgtCTu40jCFUIIISqQE5EQQghRgTpQIYQQogJ1oEIIIUQFWzkRLXeuC7tnH3ZabRHiXsOdt7/jgyGEB1/pdnjosyzEPKY+y1t1oLtnH4YnPPMlJ9MqIe7F/OarbnzXlW7DFPosCzGPqc+yJFwhhBCiAnWgQgghRAUKpCCE2Ig1835rW5Ov4FbIY8era6otjVfGOSefY6peztfMqsu/D3PaclxC78/vH8L+Tufj/f2M/MOxcj4+H9PPrMtrV7LfOcdkGecc26ARqBBCCFGBOlAhhBCiAkm4QohDPBlzriQ5R3b1ZNapurj8lJzqyahevQ23q/Xr4vM0C6rLuC5Kt+la1+k5uV3l9jY2T87tnVCsqYSa5unWffEYS5pdV5Zju65zz9NTmZ7q6qlM0q5MWvWk4jnScC4HJ2XMk5ObYv5t0AhUCCGEqEAdqBBCCFGBJFwhRBFPAj1yzJFn58ix+bHGk1pJEvUk2CFfuXxL5TlPu6B6M9m0Jal2QflYwm3bsgTctlldST4r70/kXMyCFUmWc1ma7bpMwmWpdd0X863XnZMnlTrXK8pHUq1/jrKcmx/zZF+vvK0zaZmePcu7/ZoyNceXczUCFUIIISpQByqEEEJUoA5UCCGEqEA2UCHu43hTRKamp3CZ1rFPevW2U1M82FbpTDFJ7JmLdAyQ2hpjPrZncl2LJeXJprEsFuV8i2VTzrPwbaBpPivm49OnzyGpCs7MlcSGyencpLcmm+RqTXbPVV/Oc9BRntTWyPn4GNtAUzsp72eDpG8r5TLN2rG5Zu9nn9hEKU22bLaHBqTXNReNQIUQQogK1IEKIYQQFUjCFUIUmZp64sm2DU/3cKL35FF6PEl2ztSTPHqQJ8kmEuwMaTbPt9yJ+XaWZTl2ZxnTy2UqKfKxBX3r0qUkEm7TRGl1KsY8zwTp+1gBK5iZUorVOuY7WNH+VaD9LOHG9MFBqgevSJ49SKReR9ql9HqZvgecj+VdTvNUo1y2nQdNg+H3O8T0RFz6I2gEKoQQQlSgDlQIIYSoQBKuEOKQ1PPWDwDvybap7MpesL7s6km4i+WiWGbSc9aRape7i+L+HZJml5mEu7ND5ZdlqXZ3h9NUdpm6yu4sekrHY4s2pnda8jalAOhmjtstgL4nSZNkyFXXFNMAsL+ycvogpg94/35DedK2HBy0lC/Ko6m0S22hupp12q4kihRHZWLZ1rb3lk0iFiXRj+o8bxmNQIUQQogK1IEKIYQQFUjCFUJs5Ggwec9bdrNsy9Ls1DEvmHubeM6mnpwsybJX7ZLyJdIspXd30mtM5dmyVHtmJ0qCuyTbnlmk8uDuMm6faaNX6Q6lFw2lSapskLqFBlCg9ECetyFe40Ef7+NBl97v/XXcvrSOZS6S1HqJ0hdZsl6lEu7FS+RdvCzLviyZ77cs52ZmAWcN1Km1aD1Ytm2dtUUTz/JOgRSEEEKIuw11oEIIIUQFknCFuI+TBkzgtTbL+wE/kMIc2fZo8APykHXkWU4vdyYk3CQfybO77G1LkuQuS7jpNe7tcr1RBjy7W5Zq95Zr2k8RCgCcWRzEdLMfz4lL8RzdxcP0oovlm96XF7sm3rtVGxt8sDxzmN5fnEnKXFrGfBfXMb27WB6m76LnuCQJ9mImuzZJjGOO60tyblP2qM0V2xqp9jJ9Fv2gJTmbY+Z6nuV9YqKYL+dqBCqEEEJUoA5UCCGEqEASrhCiiBdUYdguL0HGEp0Xyzb3wvWlWpZ2nbi0O6mEy8dSebYs1XL6DEm2QOphe3YnSoQs1SbpRZRmz7ZRjgWAM4jbe6s74vn3//Iwvdi/cJhuV1HaxTqVgxNIdu12zx2mV7vXHKYv7dwvKXLX4trD9E5zNlbVRKl32URX40Ubz9Fm70Gy5Fwizx5vbBb6cvAI3t/z0mRd7+ZL3k+Wc4/ZRkAjUCGEEKIKdaBCCCFEBepAhRBCiApkAxVCHMK2Tm96S76d2MEW5TRPb+EIQ8DU1JXNdk+enjLk22z3PLMb0zxV5cxOakfbS+ye0XZ2dhmnpJxdRFvl2SbaOc920bYJAHsHcXvnrg/H9t7xoZjp9rg/3BntpOEgni/HdslueW20dS7ud3/a/8CkzPLsA2K+nesP0w0FvG+TYPZJabct6XjMnP2REEK23VI67k/WPCVbJ5fv1unUE+ucqVlk9zx+KHmNQIUQQogq1IEKIYQQFUjCFUJspMmDyfMUF2fqCq/VmUxjWaSya3qsvO5nsm7nTjnaEHA82XYvk3DP7sQpKmcpkhBPVznX3BXzkGy7d+kjabsu3HaYbj/ywcN0f9v7DtP7743pu94Xpd1u35/G0u5GSfXcRz04nu+GjzpMLx98KSkDjmx0jvRRnsZDjyjQOqOZ6ooQ4vn7JJ8V9/ckrXZ9+uy6LpTTJOX3XUt5SHLO3imWeruGIxGVpd3aKEgagQohhBAVqAMVQgghKpCEey/im3/xq7Yu892f+5JTaIm4mmA5Ng0gX/bIzbfZ29aLUJTIuXO9cBdlaXdnWU4P25vX8OTA8GcozZ62ALBHAeE5GDx72+510Vt2b//2eL47ybsWmWz7gT8/TF88f+th+gP/712H6Xe+8t3Ylo/9m484TD/0ibHte1m+ZUNyJ6V7Ckzf7VKanuM6pPd7TTJs15NUS/vXHe/3JdzekXDX67IpwDMRAPl76L/Hx0UjUCGEEKICdaBCCCFEBZJwr3JqZFuvvORc4ZFLX2kQ8bJHbrJOqCO9Ddsst8W0J+EuFlZMA+lanzs0539nESXBXQoYcIZk2502et0CwG5LEi6v4RmihLu7ujOe+1L0wm0vfCSpi4MkrG6Lcu7t56PnbY1sy3D5vftTkPhrziX5ds7G7XY35ttZRrH3TBs17zUFk1+1aZexpufCcu6KZNtdeibrNT+7tP2pB3Z8XguScNdtWZo9+k5RmWQ9Un+BhBo0AhVCCCEqUAcqhBBCVCAJVwhRxBzpa9h2pNrFZs/b3GOS8y0X5Vi4i2VZtt3JQrPyfHpedpQ9b1nCXdIk+zO5hNtEz9sdIwl3FYMnLA+ihNtejOt54mLcDwDdheite3B7zHfp9nTd0JNi/44YPGF9IW3LkuLsNtdQ/Ny9mI/l3J02pneb9IavyEP3gOTdJT3TVRvvfSKxZ8FoWd5tE/m/bApoJmM13z1jQ41AhRBCiArUgQohhBAVSMIVQhySS7VuPi+mqCPt8v58LnvjeOEmMl5TlnCbrDKWdBckHS4akhHbKOHutB3lSSXcpUUv3GUXJdzFOsqj7SpKsM1+lHZzCbe/K+ZbX4x1rfdPYlGto3QH8Vr4fADQX6L2H8R0s6L9XZSvFz2l83tEEviyZY9mknDZa3rtP7uWnpEr2zpeuI1lEm7yvm1eoq9W8tUIVAghhKhAHagQQghRgTpQIYQQogLZQIUQRTzbUb7t2T3ZLtU4weeBPEqRN32B7aGxbLYMZHYslNMNrSPJNrzMvrdwbaAx3ZLdEKtoKwwHMQ0APW2zfTL06Rqkp0J2jtCR3XUdr9HWsV3NmuyeZA/l+wUArZEN2eJ5+H7zM/HSQGb/duziyXtEr+Tk+8llTnh6i0agQgghRAXqQIUQQogKJOFe5XAAeK0HKq40XnSYqSkHjRuAvizbUvCbJA34U1dS2bYciWhhqYTb9nGbp3I0JOcaybbTEi7VHWK7GtKgr3lMjPhz4Y+3j1B0/eOvie09Q/N5ctmyj+cHybnWRTm36SkdYp4W2T0i2bZJ0qGY9qaqDMfKTWZ1tnXWqJ1a5/Ok1wBlNAIVQgghKlAHKoQQQlQgCfdehORYUYMfncX3XmQP3WaWR275fMN2TLdJXXQ+N0JRei2N4+XpybmJ7IjUW7UN5JVKcq51nI5SJ3u0hnXqrdqTVMqet3xdy3NRdt27IebpLqbtMg7Ifn38Ct97QJSAl3txPU+zCQmTPXRDTBvLzCThchpI71nLUq2xZE51TXnhJhKu906B0uU8eXmPZmbUrck6jl2DEEIIcR9EHagQQghRgSRcIcSx8AJxe9JhvjsJ/N2U8yUScOKVmdaVeH+SdGi030BSI3wJl+VK68tpOEEJAqWH7Ziv53QXUIJlWltn3qp78aJ3SPZd7sV0sv5qHm3CkTdZtmU5l72G+d7l28k9dp5Xk+TJA8A7ZZxhnheoI6/bS58EGoEKIYQQFagDFUIIISqQhCuE2Bpvcvqc/bnc5nlcNo5HrpceylCapVorp9PJ/5mHKcu27KFKHrmgPBxj9ogX7ipKuutLMb26yPtjvex5G1apbBoWcZslYPbotcaJSpBDx0KFvOlJ47y/wWZpd9hmr+2y1HvSEuxx0QhUCCGEqEAdqBBCCFGBJNyrnG3j3yrYgqhhSjrzjnlxcae8L739niLJUuFU+XS/4/kaJjxMQzmdBCKgGLPJkmFIlzBj2fbiX8SYt3e8/a5ygydgj9xuNW9pNEujEWx9znsKpxnjdi5X790TQgghriDqQIUQQogK1IEKIYQQFcgGepVRs+bnVHnZRMU9iTkmuamZDJ5ZzLV7wrehHofQp/Vy9KGDO+NaoR9564VjnYfXDb3uo68t5jkSvJ8jE/GxJnYHoaE8dMMD0rpCuPJ2SODKTW/RCFQIIYSoQB2oEEIIUYEkXCFEkZppAk1NNBvnPF4A+ZOEJck8Eo93LLjza8rTdq4EybShNgsmz9sk1aayLUUoAkcrSsdcLOEm94v298n+GY2/itAIVAghhKhAHagQQghRgSRcIcQ9nmSpygoZMJEaZ8iOQCpXJmnyVmUJlKXSXDblNTlPS97lc7S7O8U0ANgirhsKSodFvK6+ifs7ut5+SsIN20m1JynnhiukDWsEKoQQQlSgDlQIIYSoQBKuEOKKkgcduIyzOy2bya49SXme7Msh1xNvUUtlV5Yrew4y0FKaZE9b7h6mmzNnkroWe/HYcm+J02DnXJRqF2f9tthuPIbdeCy0sV19y3JuvC99yO5RoGD2dC872t/3dI8nZF6WYftQ3p/kn/OCnDIagQohhBAVqAMVQgghKpCEe5WRx67VeqDitKiRyPpjekMGZ0nLZNlNSh+VASkfypP5E9mRxhB9Np7oyBOVvVL7NkqlYRklUJZGm7N7SV07111zmL7mYdcfpm94doxl+55f/QC25YZnPyTW+9DrDtO718e4uM25s2mhvbjdU/s53dE1rpuY7pBKuOvA8i7dS5bGNy+fCmBCck+e95WXbRmNQIUQQogK1IEKIYQQFUjCvcqRJCuuNubKcF62RN6bknDZ+7N3JNw+SpBd5oXbWfx65GAC3SJKte1OlD2bM1EatXPp0mLLB8QlzM7R0mYcVOHsA88dpteXVvBYnIly8rmHRNn27EMeEPNcH/c312TLnO3F8/S7UWpeL+K1sGy75qAKfXaPSMJdJ/e17HnL+7t4G4Z8iUzved5SHvbazfKHxBv79GRfjUCFEEKICtSBCiGEEBWoAxVCCCEqkA1UCHEsPBsT26WmpsQEJ+pMUt6JYJOfOrGxUfk0So5jD82i7Kwt2v5WbbR7LhbRntktow3R9qLdss0MfA0Z73ZpPVEO9H7mgdFu2R/4NtBmJ7ZreU20uy6uu1/Mc/39Y4Frr0/Kd3txSg23n227fL3rQPchpF3Gum+K6eR+O9OOjj47Lx9HKCq/U/Pt6idrD9UIVAghhKhAHagQQghRgSRcIcRGZktk7vQDf8pBnxzjc8Z050Sw6bLIRbzNMqInNa4bSucSLsmVLGm2YX2Yth2akhI4nV5jQ7JtQ2tw7lBUoMX+pcN0WPkSri1j+YaCwePsOUpHmbY/m05j6c7E7dVOLHOwiHLuQUNTWug+rPu0y1jxNCC+r505aWpH9uzS503ye7e9VOtNg0nyeGGvtkAjUCGEEKICdaBCCCFEBZJwhRBbMyfQvLuO48Q6kGm6fD6WebsuWw80iT4UivtZamQJcmHp1+GBxROxF23TUnpBsi2owZaOTVpaU7OhdUONogI1q/1YIA/Tk1RGUjPVFSgqEkcY6nZJ2gVwsBPl3YNlPLbfRjl5hegdfMBeuHkkIk+27cteuN1EtKFEqnWkfM+zO38fp46dJBqBCiGEEBWoAxVCCCEqkIQrhDgWgTRVN6iCI8cO2+V8LOl5QcgzRTGRCBNJsS3vb4wl3NQrsyFJd0XHzGK7bEHXTrJtnwWmX1JA9pbXEF3HoAxNR563MyXcvo31hgWt20mB4VfLdG3Sg2WUag9a8rwFBVLoSbbtYvpgwgv3oNvshcuXlV9i8rw7lt/Lsv7UO8Wk8v/xPW8ZjUCFEEKICtSBCiGEEBVIwhXiPo7nsTglfc2ZhO7Wlcm8ybqO7Im5KMt4XrxbIJULFy3LiDHfAUmtTUP7u1R2TaRaSifDDnICDguWcNOxSU/ribYUc7bpY1AGlnBt4v4Gqqsn796u3SmmOQgEAKyauM2y7UEfy+xTmmXbVXaPEtm2LwdMSNP8HJOqsiAazjvB7xFVkL9Tp7kGKKMRqBBCCFGBOlAhhBCiAnWgQgghRAWygQohjkXvBIr31ms8Mo3FWQM0ncqA4v48ElHn2N7ahqau0LBhRTa8Jq0KNjGTJBaKSbZ7dm0WmL6JNsV2Ee2eLdtAk2D0EzZQZ7pMR7ZRPt8acRoKAKwoslAaZYj2d7GufbJ7HqzTMddqbcV0Mo0lXmL6fNZ+JKLk2QfeT3bPyUhEbB/ti/nSdN30Fo1AhRBCiArUgQohhBAVSMIVQmzNHHm2d6TZXG5jua5tuHw5D0uwPKUFSKdJtCQjsoRLS3OiITnUMgl3Dn2I5Rc8pSSLRLQwikRE2nDTUnrm+pSB5s4EanRH63Z2iOfn9TwBYNWX1/fk6SqpbFuONgQAKyfi0IpkW34myXqg3TwJl2Vb973Lp0adYgB5RiNQIYQQogJ1oEIIIUQFknCFEEU878UpPDk38bTN1wP1ZF+W8UjabTnCUObJyVIte3+yPGtWlnPnjieSgOYted4GklMzCbclD9mFlWVbXk80iXx05Py05ilJyJxeB5KTQ+YR7KyHyp637J28T563q8zr+WDtyLZumiMRZRJuX372vSPtBsf7G5h6DxVMXgghhLjiqAMVQgghKpCEK4TYmjkT0l0Z7YgXbizTJGtHUvCDlveXPXKBbK3PhiVRXgOUS0y53sbKU9mW2p544XI6lQrbPsq2LcmzjbfOKMm5YaKNLNuytLtmObdPb1LXl4+xbMvetizb7q/StnDwhANazjTxvF2XJdj1KvOcTQLN91Sm/E553rk53rHa4AmMRqBCCCFEBepAhRBCiAok4QohDvG8FKe8Fz2JzAue0GULQbJXLUulSYAFxyM3W3YTzbos26Zre3qS6DyplIM37LTxWtakDS8ybbl11iBtHdl2CpZ0+dbzfpZm+zzYRCLhkhctr+1JAQ8OnHi3gC/bskfuau3IuflariuWbTe/O56X99Sxud7kc9EIVAghhKhAHagQQghRgSRcIUSRSc/GJDBCeYmpxpHemkXmFcpetR17pXIeJ5ZtJpWuE6mW8iWyLct7vmybBCwg1Zm9cHsKUrAgaXbdpPeOJVyO95sGT3CbkrWL0o6cy7Jtl11jstQY5VvPiGvL6WE7npTl3BV52KYeuSR5r1Ip3/O89eTcVJpN6zppqdZDI1AhhBCiAnWgQgghRAXqQIUQQogKZAMVQmwktyn1ZHNqae1Jb43GxGa6zuxVFJCdj/W81mXHtkKeLpG2yxwbaErZHppPY0lsihwonu2LPds9Y/4mDXeUTFehy3WDxk/ZQxMbaHBsoEl70/JdYvcEpZ39ztqeQDaNxZmuwhGHOidI/JFja88eWra358HkU7u8M/VlIjrWXDQCFUIIISpQByqEEEJUIAlXCHEs5gSW7zkyTsilO566QtNVKCA7B5nnKSl9Nl1kbaxXbh4fsNR5JJoNy6AkaS7pW5PlUF6LtM3axZJuMyMq0nwJN6bTa+E2puV7R8LlfJ5sm09jYak2mbrCEmxf3r/ik2Ni6ooTSah3gszn+U5zSotGoEIIIUQF6kCFEEKICiThCnEfJ7iRhPz1Fud4M3pRiSbrcuS6dea568Njgs1yrufRCqTtbzn6EEmgHAiJ87SZF64XFYn3ex65R9tc1nc92TZTN5NjXeKFG5z9lM68nlPPW5Zn2Qu3L+bJvXA9z1tvf2IiyD27k3eK8oW+uL8WjUCFEEKICtSBCiGEEBVIwhVCbE0IZQ9IlsgaWkOzJ02wy+XNxsrpxBXVCbDQpDKcJY6dm+XcxIs1l5YX5eAJ7GHLsi0HImizoUkaAL+8nwM58C2aciJN21/ef1TCLUu1LO32iedtOTD8ZD5Htu0SmTgLJp8EWfBk27KJoM/k2Nwrt1T+JNAIVAghhKhAHagQQghRgSRcIUSRMCGRNfTbm2ONNhQwISlPHqZNHre0c+TZRN+M9Vozz3sybTIHcogHluTR2rSptMwqYMvyJg07UtmWJMzMUdaTbb1ACvMl3PJBlmanvHD5GaXeueW4tl0m4XrybLLuZ7IGaEfpXMItS7WJRy5dWO/kB/z4tyeNRqBCCCFEBepAhRBCiAok4QohDuHJ6exiOhn8gOTZVHqLcht717IMlx9L4uI2ZXkz3T8h5y4pTctuNeRRG9i7NpNw+9bzwmVPYfbILXvR5m1OVVuStifi3ybtchTJxPM2kd/TfGmcWdqfxJkty7Y1Eq4X4/aIFy7Ju3M8b6fi3c6Lz1wOtrANGoEKIYQQFagDFUIIISpQByqEEEJUIBuoEGJrEpsTRePxgsF7U1oAwMje1Tj2UCZdkrLNjpbL9C3ZKgNHIuI1NNPxBF9iw1FyWrZnkm2XTn10dkooHmvmGj4dUjteOU93xD5I6bDZ1plGCMrWcu0dG2hizyxHGOqz59uHsn2UbeZe1Kuja7keP1D8HDQCFUIIISpQByqEEEJUIAlXCFEkCRjfZ1IjT3FJ1hMty5velJahbpIB8xA+G1hn28GJhNSEcgD5RMLNVD8OTN9SdHiWJPla2s5vexqJiPNxXW7xBE+dTORNR6YFUmk6nXZUXpd1aupJ7xzzZNu1M1Ulz5ekWf5fe9Nb/PVAE6lXweSFEEKIK486UCGEEKICSbhCiK1hWcw4sg9HJaLg6sGR4U6X8nqgqXcwSbNNKu9xZCGWJFvPC9eNNpTiRVg6diQixyP3yDqniac011uWY5NoRbnsOmOtT29tz9wLt+O61uWg8fzeTQWTZ7xjoT/+e6gRqBBCCFGBOlAhhBCiAkm4QtzH8QLDs/RnWfADN5h8s9kjt8/W82QJOA2ykAad35ZEqiQvXG4LX8dR7+CmeIxj4TdN+RqbCQ3X87b11gbN8dYA9bxz+yNBBsrPmD1qeycgRh5M3vWWnSHbduvcC7ccMMGT/5M1P4PvhZvsP+EACxqBCiGEEBWoAxVCCCEqkIQrhDgW23rkzvfC5d/38+Rclu44+EESVKEtx8LNJVTX87bZLNXmcrCnztbEws29akt4a4MCvjzrrSHqybTDecrPtXMk3OQc2bqwidSb1LVZ2j16jXzO0/P61ghUCCGEqEAdqBBCCFGBJFwhxEaOejmypElxcVlWa9jjMpZtF+kSZImXpyPVstSa7k+lu1SedWRblhGbsjQLZJ7DXVnqTeVcFPfnTB3bFj9IgC/zerFwPe9cT6Yd6nKWKnM8cpO4x5NBGUi2dWLehokYt6407eyvjZGrEagQQghRgTpQIYQQogJ1oEIIIUQFsoEKIYok7v+Nb7dMbYrlKS1wIhTlNPSbnu2hTV/+rW+TQcTJhsnTWJzoQbltsvECxXvRh6bsnjOjDB0HL0LR1LSXOdNCPDtnXrc3RWWuPdWze/L+3rONHrHR3z0LFmgEKoQQQlSgDlQIIYSoQBKuEOIQnhpgiLJtLgO2pOimchlNFzFHUpwZVSiRgPmbiqbEHAkATxIhy6Y8dSadgkMSbDZVJrDsSk32IhHxVd1d01iYuVNa8uDypXzulJaJSES8huccabjLIhF5x7zyc6ehhFOMSqQRqBBCCFGBOlAhhBCiAkm4Qogi6VqZ2TH2ekw8ZMnblqVOx4t2KFGW61h2ZY9NDkxvmezaOGt4etIue872TdpGz3M2kXAdOXau122NnDsnao7nkQv4XrmehMuy51Qwed+L1wsmn3v0bg4679frrwfqXu8JrA2qEagQQghRgTpQIYQQogJJuEKIjeQSWU+/vZumLOd6ARam5Fw4AehTb1mSabOgDJ6860m7feJdm16jGySByuSyb6nslWBKwvU8Ub2AB2lZP2i7J9X63r3ZOzXD83bOOYbzlK+xNmi8h0agQgghRAXqQIUQQogKJOEKIU4FL8BCvuanL7WW5djUOzjzwnXk3Z68g82JazvpKex52zbzPDnvbkl3WsLdbg1RTzadrMuRalM51/ecneXFmwRumIrRe3pxcTUCFUIIISpQByqEEEJUIAlXiPs4ntQKx7t23EGpOR65UW47Gjwg5vO8dVPZ1g+k4EmKnhdv4lFrvtTnBTyYGwihySNRnDL58l4ec+Tc6aAMvrwby8/znPU9bDdLwFNLtp0mGoEKIYQQFagDFUIIISpQByqEEEJUIBuoEGJrUvtV2R7KBsYkks+EPZVNd0lUIScSUD71hO2jyf7A0YfIHjthm3TP2ZRtqEnZbNoKT6O5O5iyWzJ5NKDD8hUB2Oeszzk1JSat63h2zznlPTvrNmgEKoQQQlSgDlQIIYSoQBKuEKJIIrEdCbRenmICR6p0p7oACBzQ3TZPfbFmXlQjxo8yVI5QNFZePMYSsMeUNHx3ULPW5bYRigB/uoxf10wJ2Kl3boShOXWdBBqBCiGEEBWoAxVCCCEqkIQrhNgalsV8OZehdT4zRc2azZ67icw7ISl6kYF6sBzsjBsyZdbzwvVIow3dvV63U8yNSsTMXTfTk1HnlJ+SVj0PW8+7dm7dWg9UCCGEuAegDlQIIYSoQBKuEOIQlshY6pyUvuasiTmx1qYnd7LU68m8R5rieOGmFc8LpDCHxDt3js57D+A4MuZcj9Y5wd3nBi+oCeowq/wJrBOqEagQQghRgTpQIYQQogJJuEKIIp6cezTfDElwQuYNbjzZclCFKcLM9Tkjfr1T1zyj+FXNceXN43q7zpFna85xErItoxGoEEIIUYE6UCGEEKICSbhCiI0cX/ra/rd6qNBHvVi4VcyIeSvKnHTAgvI5rnywCo1AhRBCiArUgQohhBAVqAMVQgghKpANVAhx6txd9qpTXPpRiCNoBCqEEEJUYCHM95Yys9sAvOv0miPEvYaPCSE8+Eo3wkOfZSFm436Wt+pAhRBCCDEgCVcIIYSoQB2oEEIIUYE6UCGEEKICdaBCCCFEBepAhRBCiArUgQohhBAVqAMVQgghKlAHKoQQQlSgDlQIIYSo4P8DSGel8wYZWKoAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -77,7 +77,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -89,7 +89,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -101,7 +101,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -115,8 +115,6 @@ "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", @@ -248,6 +246,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "12:21:18 C02YR4ANLVCJ SmartSim[68607] INFO Working in previously created experiment\n", "Database started at address: ['127.0.0.1:6780']\n" ] } @@ -290,7 +289,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "17:55:20 prod-0001 SmartSim[61617] INFO Working in previously created experiment\n" + "12:21:38 C02YR4ANLVCJ SmartSim[68607] INFO Working in previously created experiment\n" ] } ], @@ -385,7 +384,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "17:55:21 prod-0001 SmartSim[61617] INFO Working in previously created experiment\n" + "12:21:38 C02YR4ANLVCJ SmartSim[68607] INFO Working in previously created experiment\n" ] } ], @@ -454,7 +453,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -466,7 +465,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -478,7 +477,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -490,7 +489,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -502,7 +501,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -514,7 +513,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -528,12 +527,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "17:57:25 prod-0001 SmartSim[61617] INFO fd_simulation_0(61776): Completed\n" + "12:25:30 C02YR4ANLVCJ SmartSim[68607] INFO fd_simulation_0(68661): Completed\n", + "12:25:30 C02YR4ANLVCJ SmartSim[68607] INFO fd_simulation_1(68662): Completed\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -545,7 +545,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -555,16 +555,9 @@ }, "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -576,7 +569,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGUlEQVR4nGP8//8/AzmAiSxdoxpHNQ4hjQB59QMZfQJbWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -643,8 +636,8 @@ "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" + "12:26:24 C02YR4ANLVCJ SmartSim[68607] INFO tf_training(68664): Completed\n", + "12:26:28 C02YR4ANLVCJ SmartSim[68607] INFO Stopping model orchestrator_0 with job name orchestrator_0-CR7RNSKODOYG\n" ] } ], @@ -690,18 +683,18 @@ "text/html": [ "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", "\n", "
Name Entity-Type JobID RunID TimeStatus Returncode
Name Entity-Type JobID RunID Time Status 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
0 fd_simulation_0Model 68661 0 231.9948Completed0
1 fd_simulation_1Model 68662 0 231.7866Completed0
2 tf_training Model 68664 0 285.1160Completed0
3 orchestrator_0 DBNode 68629 0 309.7907Cancelled-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
'" + "'\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n
Name Entity-Type JobID RunID Time Status Returncode
0 fd_simulation_0Model 68661 0 231.9948Completed0
1 fd_simulation_1Model 68662 0 231.7866Completed0
2 tf_training Model 68664 0 285.1160Completed0
3 orchestrator_0 DBNode 68629 0 309.7907Cancelled-9
'" ] }, "execution_count": 11, @@ -712,14 +705,6 @@ "source": [ "exp.summary(format=\"html\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2260d2f7-f986-4651-821a-aa5d0b25968d", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -738,7 +723,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.8" } }, "nbformat": 4,