From b98bd5b1aeaafced5468041f0072d0ca7ab1f85c Mon Sep 17 00:00:00 2001 From: GokuMohandas Date: Mon, 18 Sep 2023 22:03:20 -0700 Subject: [PATCH] updated to Ray 2.7 --- README.md | 20 +- madewithml/config.py | 1 - madewithml/data.py | 14 +- madewithml/evaluate.py | 6 +- madewithml/models.py | 46 +- madewithml/predict.py | 52 +- madewithml/serve.py | 14 +- madewithml/train.py | 53 +- madewithml/tune.py | 8 +- notebooks/madewithml.ipynb | 5331 ++++++++++++++++++++++-------------- requirements.txt | 1 - tests/code/test_data.py | 4 +- tests/code/test_utils.py | 7 +- tests/model/conftest.py | 2 +- tests/model/utils.py | 11 +- 15 files changed, 3484 insertions(+), 2086 deletions(-) diff --git a/README.md b/README.md index f33f484..3e8b91c 100644 --- a/README.md +++ b/README.md @@ -108,6 +108,7 @@ touch .env ```bash # Inside .env GITHUB_USERNAME="CHANGE_THIS_TO_YOUR_USERNAME" # ← CHANGE THIS +``` ```bash source .env ``` @@ -120,8 +121,6 @@ Now we're ready to clone the repository that has all of our code: ```bash git clone https://github.com/GokuMohandas/Made-With-ML.git . -git remote set-url origin https://github.com/$GITHUB_USERNAME/Made-With-ML.git # <-- CHANGE THIS to your username -git checkout -b dev ``` ### Virtual environment @@ -289,7 +288,6 @@ python madewithml/evaluate.py \ ### Inference ```bash -# Get run ID export EXPERIMENT_NAME="llm" export RUN_ID=$(python madewithml/predict.py get-best-run-id --experiment-name $EXPERIMENT_NAME --metric val_loss --mode ASC) python madewithml/predict.py predict \ @@ -485,17 +483,23 @@ We're not going to manually deploy our application every time we make a change. -1. We'll start by adding the necessary credentials to the [`/settings/secrets/actions`](https://github.com/GokuMohandas/Made-With-ML/settings/secrets/actions) page of our GitHub repository. +1. Create a new github branch to save our changes to and execute CI/CD workloads: +```bash +git remote set-url origin https://github.com/$GITHUB_USERNAME/Made-With-ML.git # <-- CHANGE THIS to your username +git checkout -b dev +``` + +2. We'll start by adding the necessary credentials to the [`/settings/secrets/actions`](https://github.com/GokuMohandas/Made-With-ML/settings/secrets/actions) page of our GitHub repository. ``` bash export ANYSCALE_HOST=https://console.anyscale.com export ANYSCALE_CLI_TOKEN=$YOUR_CLI_TOKEN # retrieved from https://console.anyscale.com/o/madewithml/credentials ``` -2. Now we can make changes to our code (not on `main` branch) and push them to GitHub. But in order to push our code to GitHub, we'll need to first authenticate with our credentials before pushing to our repository: +3. Now we can make changes to our code (not on `main` branch) and push them to GitHub. But in order to push our code to GitHub, we'll need to first authenticate with our credentials before pushing to our repository: ```bash -git config --global user.name "Your Name" # <-- CHANGE THIS to your name +git config --global user.name $GITHUB_USERNAME # <-- CHANGE THIS to your username git config --global user.email you@example.com # <-- CHANGE THIS to your email git add . git commit -m "" # <-- CHANGE THIS to your message @@ -504,13 +508,13 @@ git push origin dev Now you will be prompted to enter your username and password (personal access token). Follow these steps to get personal access token: [New GitHub personal access token](https://github.com/settings/tokens/new) → Add a name → Toggle `repo` and `workflow` → Click `Generate token` (scroll down) → Copy the token and paste it when prompted for your password. -3. Now we can start a PR from this branch to our `main` branch and this will trigger the [workloads workflow](/.github/workflows/workloads.yaml). If the workflow (Anyscale Jobs) succeeds, this will produce comments with the training and evaluation results directly on the PR. +4. Now we can start a PR from this branch to our `main` branch and this will trigger the [workloads workflow](/.github/workflows/workloads.yaml). If the workflow (Anyscale Jobs) succeeds, this will produce comments with the training and evaluation results directly on the PR.
-4. If we like the results, we can merge the PR into the `main` branch. This will trigger the [serve workflow](/.github/workflows/serve.yaml) which will rollout our new service to production! +5. If we like the results, we can merge the PR into the `main` branch. This will trigger the [serve workflow](/.github/workflows/serve.yaml) which will rollout our new service to production! ### Continual learning diff --git a/madewithml/config.py b/madewithml/config.py index 93b1de9..4b1849e 100644 --- a/madewithml/config.py +++ b/madewithml/config.py @@ -5,7 +5,6 @@ import sys from pathlib import Path import mlflow -import pretty_errors # NOQA: F401 (imported but unused) # Directories ROOT_DIR = Path(__file__).parent.parent.absolute() diff --git a/madewithml/data.py b/madewithml/data.py index c0f253f..299dd74 100644 --- a/madewithml/data.py +++ b/madewithml/data.py @@ -5,7 +5,6 @@ import numpy as np import pandas as pd import ray from ray.data import Dataset -from ray.data.preprocessor import Preprocessor from sklearn.model_selection import train_test_split from transformers import BertTokenizer @@ -135,13 +134,18 @@ def preprocess(df: pd.DataFrame, class_to_index: Dict) -> Dict: return outputs -class CustomPreprocessor(Preprocessor): +class CustomPreprocessor: """Custom preprocessor class.""" - def _fit(self, ds): + def __init__(self, class_to_index={}): + self.class_to_index = class_to_index or {} # mutable defaults + self.index_to_class = {v: k for k, v in self.class_to_index.items()} + + def fit(self, ds): tags = ds.unique(column="tag") self.class_to_index = {tag: i for i, tag in enumerate(tags)} self.index_to_class = {v: k for k, v in self.class_to_index.items()} + return self - def _transform_pandas(self, batch): # could also do _transform_numpy - return preprocess(batch, class_to_index=self.class_to_index) + def transform(self, ds): + return ds.map_batches(preprocess, fn_kwargs={"class_to_index": self.class_to_index}, batch_format="pandas") diff --git a/madewithml/evaluate.py b/madewithml/evaluate.py index a61aca4..a450ba5 100644 --- a/madewithml/evaluate.py +++ b/madewithml/evaluate.py @@ -8,13 +8,13 @@ import ray import ray.train.torch # NOQA: F401 (imported but unused) import typer from ray.data import Dataset -from ray.train.torch.torch_predictor import TorchPredictor from sklearn.metrics import precision_recall_fscore_support from snorkel.slicing import PandasSFApplier, slicing_function from typing_extensions import Annotated from madewithml import predict, utils from madewithml.config import logger +from madewithml.predict import TorchPredictor # Initialize Typer CLI app app = typer.Typer() @@ -133,8 +133,8 @@ def evaluate( y_true = np.stack([item["targets"] for item in values]) # y_pred - z = predictor.predict(data=ds.to_pandas())["predictions"] - y_pred = np.stack(z).argmax(1) + predictions = preprocessed_ds.map_batches(predictor).take_all() + y_pred = np.array([d["output"] for d in predictions]) # Metrics metrics = { diff --git a/madewithml/models.py b/madewithml/models.py index 40ca441..6c43f1c 100644 --- a/madewithml/models.py +++ b/madewithml/models.py @@ -1,13 +1,20 @@ +import json +import os +from pathlib import Path + import torch import torch.nn as nn +import torch.nn.functional as F +from transformers import BertModel -class FinetunedLLM(nn.Module): # pragma: no cover, torch model - """Model architecture for a Large Language Model (LLM) that we will fine-tune.""" - +class FinetunedLLM(nn.Module): def __init__(self, llm, dropout_p, embedding_dim, num_classes): super(FinetunedLLM, self).__init__() self.llm = llm + self.dropout_p = dropout_p + self.embedding_dim = embedding_dim + self.num_classes = num_classes self.dropout = torch.nn.Dropout(dropout_p) self.fc1 = torch.nn.Linear(embedding_dim, num_classes) @@ -17,3 +24,36 @@ class FinetunedLLM(nn.Module): # pragma: no cover, torch model z = self.dropout(pool) z = self.fc1(z) return z + + @torch.inference_mode() + def predict(self, batch): + self.eval() + z = self(batch) + y_pred = torch.argmax(z, dim=1).cpu().numpy() + return y_pred + + @torch.inference_mode() + def predict_proba(self, batch): + self.eval() + z = self(batch) + y_probs = F.softmax(z, dim=1).cpu().numpy() + return y_probs + + def save(self, dp): + with open(Path(dp, "args.json"), "w") as fp: + contents = { + "dropout_p": self.dropout_p, + "embedding_dim": self.embedding_dim, + "num_classes": self.num_classes, + } + json.dump(contents, fp, indent=4, sort_keys=False) + torch.save(self.state_dict(), os.path.join(dp, "model.pt")) + + @classmethod + def load(cls, args_fp, state_dict_fp): + with open(args_fp, "r") as fp: + kwargs = json.load(fp=fp) + llm = BertModel.from_pretrained("allenai/scibert_scivocab_uncased", return_dict=False) + model = cls(llm=llm, **kwargs) + model.load_state_dict(torch.load(state_dict_fp, map_location=torch.device("cpu"))) + return model diff --git a/madewithml/predict.py b/madewithml/predict.py index 45f92a2..e90832d 100644 --- a/madewithml/predict.py +++ b/madewithml/predict.py @@ -1,19 +1,20 @@ import json +from pathlib import Path from typing import Any, Dict, Iterable, List from urllib.parse import urlparse import numpy as np -import pandas as pd import ray -import torch import typer from numpyencoder import NumpyEncoder from ray.air import Result -from ray.train.torch import TorchPredictor from ray.train.torch.torch_checkpoint import TorchCheckpoint from typing_extensions import Annotated from madewithml.config import logger, mlflow +from madewithml.data import CustomPreprocessor +from madewithml.models import FinetunedLLM +from madewithml.utils import collate_fn # Initialize Typer CLI app app = typer.Typer() @@ -48,25 +49,51 @@ def format_prob(prob: Iterable, index_to_class: Dict) -> Dict: return d -def predict_with_proba( - df: pd.DataFrame, - predictor: ray.train.torch.torch_predictor.TorchPredictor, +class TorchPredictor: + def __init__(self, preprocessor, model): + self.preprocessor = preprocessor + self.model = model + self.model.eval() + + def __call__(self, batch): + results = self.model.predict(collate_fn(batch)) + return {"output": results} + + def predict_proba(self, batch): + results = self.model.predict_proba(collate_fn(batch)) + return {"output": results} + + def get_preprocessor(self): + return self.preprocessor + + @classmethod + def from_checkpoint(cls, checkpoint): + metadata = checkpoint.get_metadata() + preprocessor = CustomPreprocessor(class_to_index=metadata["class_to_index"]) + model = FinetunedLLM.load(Path(checkpoint.path, "args.json"), Path(checkpoint.path, "model.pt")) + return cls(preprocessor=preprocessor, model=model) + + +def predict_proba( + ds: ray.data.dataset.Dataset, + predictor: TorchPredictor, ) -> List: # pragma: no cover, tested with inference workload """Predict tags (with probabilities) for input data from a dataframe. Args: df (pd.DataFrame): dataframe with input features. - predictor (ray.train.torch.torch_predictor.TorchPredictor): loaded predictor from a checkpoint. + predictor (TorchPredictor): loaded predictor from a checkpoint. Returns: List: list of predicted labels. """ preprocessor = predictor.get_preprocessor() - z = predictor.predict(data=df)["predictions"] - y_prob = torch.tensor(np.stack(z)).softmax(dim=1).numpy() + preprocessed_ds = preprocessor.transform(ds) + outputs = preprocessed_ds.map_batches(predictor.predict_proba) + y_prob = np.array([d["output"] for d in outputs.take_all()]) results = [] for i, prob in enumerate(y_prob): - tag = decode([z[i].argmax()], preprocessor.index_to_class)[0] + tag = preprocessor.index_to_class[prob.argmax()] results.append({"prediction": tag, "probabilities": format_prob(prob, preprocessor.index_to_class)}) return results @@ -125,11 +152,10 @@ def predict( # Load components best_checkpoint = get_best_checkpoint(run_id=run_id) predictor = TorchPredictor.from_checkpoint(best_checkpoint) - # preprocessor = predictor.get_preprocessor() # Predict - sample_df = pd.DataFrame([{"title": title, "description": description, "tag": "other"}]) - results = predict_with_proba(df=sample_df, predictor=predictor) + sample_ds = ray.data.from_items([{"title": title, "description": description, "tag": "other"}]) + results = predict_proba(ds=sample_ds, predictor=predictor) logger.info(json.dumps(results, cls=NumpyEncoder, indent=2)) return results diff --git a/madewithml/serve.py b/madewithml/serve.py index 331a74b..56135a8 100644 --- a/madewithml/serve.py +++ b/madewithml/serve.py @@ -3,11 +3,9 @@ import os from http import HTTPStatus from typing import Dict -import pandas as pd import ray from fastapi import FastAPI from ray import serve -from ray.train.torch import TorchPredictor from starlette.requests import Request from madewithml import evaluate, predict @@ -21,7 +19,7 @@ app = FastAPI( ) -@serve.deployment(route_prefix="/", num_replicas="1", ray_actor_options={"num_cpus": 8, "num_gpus": 0}) +@serve.deployment(num_replicas="1", ray_actor_options={"num_cpus": 8, "num_gpus": 0}) @serve.ingress(app) class ModelDeployment: def __init__(self, run_id: str, threshold: int = 0.9): @@ -30,8 +28,7 @@ class ModelDeployment: self.threshold = threshold mlflow.set_tracking_uri(MLFLOW_TRACKING_URI) # so workers have access to model registry best_checkpoint = predict.get_best_checkpoint(run_id=run_id) - self.predictor = TorchPredictor.from_checkpoint(best_checkpoint) - self.preprocessor = self.predictor.get_preprocessor() + self.predictor = predict.TorchPredictor.from_checkpoint(best_checkpoint) @app.get("/") def _index(self) -> Dict: @@ -55,11 +52,10 @@ class ModelDeployment: return {"results": results} @app.post("/predict/") - async def _predict(self, request: Request) -> Dict: - # Get prediction + async def _predict(self, request: Request): data = await request.json() - df = pd.DataFrame([{"title": data.get("title", ""), "description": data.get("description", ""), "tag": ""}]) - results = predict.predict_with_proba(df=df, predictor=self.predictor) + sample_ds = ray.data.from_items([{"title": data.get("title", ""), "description": data.get("description", ""), "tag": ""}]) + results = predict.predict_proba(ds=sample_ds, predictor=self.predictor) # Apply custom logic for i, result in enumerate(results): diff --git a/madewithml/train.py b/madewithml/train.py index 75a63f7..8565985 100644 --- a/madewithml/train.py +++ b/madewithml/train.py @@ -1,6 +1,7 @@ import datetime import json import os +import tempfile from typing import Tuple import numpy as np @@ -10,21 +11,23 @@ import torch import torch.nn as nn import torch.nn.functional as F import typer -from ray.air import session -from ray.air.config import ( +from ray.air.integrations.mlflow import MLflowLoggerCallback +from ray.data import Dataset +from ray.train import ( + Checkpoint, CheckpointConfig, - DatasetConfig, + DataConfig, RunConfig, ScalingConfig, ) -from ray.air.integrations.mlflow import MLflowLoggerCallback -from ray.data import Dataset -from ray.train.torch import TorchCheckpoint, TorchTrainer +from ray.train.torch import TorchTrainer +from torch.nn.parallel.distributed import DistributedDataParallel from transformers import BertModel from typing_extensions import Annotated -from madewithml import data, models, utils +from madewithml import data, utils from madewithml.config import EFS_DIR, MLFLOW_TRACKING_URI, logger +from madewithml.models import FinetunedLLM # Initialize Typer CLI app app = typer.Typer() @@ -106,18 +109,18 @@ def train_loop_per_worker(config: dict) -> None: # pragma: no cover, tested via lr = config["lr"] lr_factor = config["lr_factor"] lr_patience = config["lr_patience"] - batch_size = config["batch_size"] num_epochs = config["num_epochs"] + batch_size = config["batch_size"] num_classes = config["num_classes"] # Get datasets utils.set_seeds() - train_ds = session.get_dataset_shard("train") - val_ds = session.get_dataset_shard("val") + train_ds = train.get_dataset_shard("train") + val_ds = train.get_dataset_shard("val") # Model llm = BertModel.from_pretrained("allenai/scibert_scivocab_uncased", return_dict=False) - model = models.FinetunedLLM(llm=llm, dropout_p=dropout_p, embedding_dim=llm.config.hidden_size, num_classes=num_classes) + model = FinetunedLLM(llm=llm, dropout_p=dropout_p, embedding_dim=llm.config.hidden_size, num_classes=num_classes) model = train.torch.prepare_model(model) # Training components @@ -126,7 +129,8 @@ def train_loop_per_worker(config: dict) -> None: # pragma: no cover, tested via scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", factor=lr_factor, patience=lr_patience) # Training - batch_size_per_worker = batch_size // session.get_world_size() + num_workers = train.get_context().get_world_size() + batch_size_per_worker = batch_size // num_workers for epoch in range(num_epochs): # Step train_loss = train_step(train_ds, batch_size_per_worker, model, num_classes, loss_fn, optimizer) @@ -134,9 +138,14 @@ def train_loop_per_worker(config: dict) -> None: # pragma: no cover, tested via scheduler.step(val_loss) # Checkpoint - metrics = dict(epoch=epoch, lr=optimizer.param_groups[0]["lr"], train_loss=train_loss, val_loss=val_loss) - checkpoint = TorchCheckpoint.from_model(model=model) - session.report(metrics, checkpoint=checkpoint) + with tempfile.TemporaryDirectory() as dp: + if isinstance(model, DistributedDataParallel): # cpu + model.module.save(dp=dp) + else: + model.save(dp=dp) + metrics = dict(epoch=epoch, lr=optimizer.param_groups[0]["lr"], train_loss=train_loss, val_loss=val_loss) + checkpoint = Checkpoint.from_directory(dp) + train.report(metrics, checkpoint=checkpoint) @app.command() @@ -183,7 +192,6 @@ def train_model( num_workers=num_workers, use_gpu=bool(gpu_per_worker), resources_per_worker={"CPU": cpu_per_worker, "GPU": gpu_per_worker}, - _max_cpu_fraction_per_node=0.8, ) # Checkpoint config @@ -201,7 +209,7 @@ def train_model( ) # Run config - run_config = RunConfig(callbacks=[mlflow_callback], checkpoint_config=checkpoint_config, storage_path=EFS_DIR) + run_config = RunConfig(callbacks=[mlflow_callback], checkpoint_config=checkpoint_config, storage_path=EFS_DIR, local_dir=EFS_DIR) # Dataset ds = data.load_data(dataset_loc=dataset_loc, num_samples=train_loop_config["num_samples"]) @@ -210,14 +218,13 @@ def train_model( train_loop_config["num_classes"] = len(tags) # Dataset config - dataset_config = { - "train": DatasetConfig(fit=False, transform=False, randomize_block_order=False), - "val": DatasetConfig(fit=False, transform=False, randomize_block_order=False), - } + options = ray.data.ExecutionOptions(preserve_order=True) + dataset_config = DataConfig(datasets_to_split=["train"], execution_options=options) # Preprocess preprocessor = data.CustomPreprocessor() - train_ds = preprocessor.fit_transform(train_ds) + preprocessor = preprocessor.fit(train_ds) + train_ds = preprocessor.transform(train_ds) val_ds = preprocessor.transform(val_ds) train_ds = train_ds.materialize() val_ds = val_ds.materialize() @@ -230,7 +237,7 @@ def train_model( run_config=run_config, datasets={"train": train_ds, "val": val_ds}, dataset_config=dataset_config, - preprocessor=preprocessor, + metadata={"class_to_index": preprocessor.class_to_index}, ) # Train diff --git a/madewithml/tune.py b/madewithml/tune.py index 13d0d43..b5ac181 100644 --- a/madewithml/tune.py +++ b/madewithml/tune.py @@ -73,7 +73,6 @@ def tune_models( num_workers=num_workers, use_gpu=bool(gpu_per_worker), resources_per_worker={"CPU": cpu_per_worker, "GPU": gpu_per_worker}, - _max_cpu_fraction_per_node=0.8, ) # Dataset @@ -90,7 +89,8 @@ def tune_models( # Preprocess preprocessor = data.CustomPreprocessor() - train_ds = preprocessor.fit_transform(train_ds) + preprocessor = preprocessor.fit(train_ds) + train_ds = preprocessor.transform(train_ds) val_ds = preprocessor.transform(val_ds) train_ds = train_ds.materialize() val_ds = val_ds.materialize() @@ -102,7 +102,7 @@ def tune_models( scaling_config=scaling_config, datasets={"train": train_ds, "val": val_ds}, dataset_config=dataset_config, - preprocessor=preprocessor, + metadata={"class_to_index": preprocessor.class_to_index}, ) # Checkpoint configuration @@ -118,7 +118,7 @@ def tune_models( experiment_name=experiment_name, save_artifact=True, ) - run_config = RunConfig(callbacks=[mlflow_callback], checkpoint_config=checkpoint_config, storage_path=EFS_DIR) + run_config = RunConfig(callbacks=[mlflow_callback], checkpoint_config=checkpoint_config, storage_path=EFS_DIR, local_dir=EFS_DIR) # Hyperparameters to start with initial_params = json.loads(initial_params) diff --git a/notebooks/madewithml.ipynb b/notebooks/madewithml.ipynb index 04ab696..cad9d15 100644 --- a/notebooks/madewithml.ipynb +++ b/notebooks/madewithml.ipynb @@ -55,7 +55,7 @@ "tags": [] }, "source": [ - "# 🛠️  Setup" + "# 🛠️ Setup" ] }, { @@ -67,12 +67,13 @@ }, { "cell_type": "code", - "execution_count": 163, + "execution_count": 1, "metadata": { "tags": [] }, "outputs": [], "source": [ + "import os\n", "import ray\n", "from dotenv import load_dotenv; load_dotenv()\n", "import warnings; warnings.filterwarnings(\"ignore\")" @@ -89,16 +90,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:00:03,106\tINFO worker.py:1431 -- Connecting to existing Ray cluster at address: 10.0.41.50:6379...\n", - "2023-09-14 15:00:03,149\tINFO worker.py:1612 -- Connected to Ray cluster. View the dashboard at \u001b[1m\u001b[32mhttps://session-59p8a57mrjelmhz1ec7m8c7yke.i.anyscaleuserdata.com \u001b[39m\u001b[22m\n", - "2023-09-14 15:00:03,155\tINFO packaging.py:346 -- Pushing file package 'gcs://_ray_pkg_b89128278b4b23728836e7ef293f2994.zip' (1.46MiB) to Ray cluster...\n", - "2023-09-14 15:00:03,159\tINFO packaging.py:359 -- Successfully pushed file package 'gcs://_ray_pkg_b89128278b4b23728836e7ef293f2994.zip'.\n" + "2023-09-17 22:40:03,729\tINFO worker.py:1471 -- Connecting to existing Ray cluster at address: 10.0.35.174:6379...\n", + "2023-09-17 22:40:03,738\tINFO worker.py:1646 -- Connected to Ray cluster. View the dashboard at \u001b[1m\u001b[32mhttps://session-klxewghyvu1191sq8t885l6ynr.i.anyscaleuserdata.com \u001b[39m\u001b[22m\n", + "2023-09-17 22:40:03,753\tINFO packaging.py:346 -- Pushing file package 'gcs://_ray_pkg_33f9aafa2eafc632d810a161969b543f.zip' (5.14MiB) to Ray cluster...\n", + "2023-09-17 22:40:03,766\tINFO packaging.py:359 -- Successfully pushed file package 'gcs://_ray_pkg_33f9aafa2eafc632d810a161969b543f.zip'.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0600f97bbc1944ac9a46fc1edce91293", + "model_id": "a78e1d2dc86847b1a21dded4c84a12c9", "version_major": 2, "version_minor": 0 }, @@ -126,11 +127,11 @@ " \n", " \n", " Ray version:\n", - " 2.6.0\n", + " 3.0.0.dev0\n", " \n", " \n", " Dashboard:\n", - " http://session-59p8a57mrjelmhz1ec7m8c7yke.i.anyscaleuserdata.com\n", + " http://session-klxewghyvu1191sq8t885l6ynr.i.anyscaleuserdata.com\n", "\n", "\n", "\n", @@ -139,7 +140,7 @@ "\n" ], "text/plain": [ - "RayContext(dashboard_url='session-59p8a57mrjelmhz1ec7m8c7yke.i.anyscaleuserdata.com', python_version='3.10.8', ray_version='2.6.0', ray_commit='0db82e31e249eac614f7c8e7da1c4f8f05c9064a', protocol_version=None)" + "RayContext(dashboard_url='session-klxewghyvu1191sq8t885l6ynr.i.anyscaleuserdata.com', python_version='3.10.8', ray_version='3.0.0.dev0', ray_commit='6aa4ad9fbe0241a88e580e3c1a01e96ac3cce75a', protocol_version=None)" ] }, "execution_count": 2, @@ -164,13 +165,14 @@ { "data": { "text/plain": [ - "{'node:10.0.41.50': 1.0,\n", - " 'CPU': 24.0,\n", + "{'GPU': 2.0,\n", + " 'memory': 137438953472.0,\n", " 'node:__internal_head__': 1.0,\n", - " 'object_store_memory': 28764595813.0,\n", - " 'memory': 103079215104.0,\n", - " 'GPU': 1.0,\n", - " 'node:10.0.50.151': 1.0}" + " 'CPU': 32.0,\n", + " 'accelerator_type:A10G': 2.0,\n", + " 'object_store_memory': 38456435097.0,\n", + " 'node:10.0.35.174': 1.0,\n", + " 'node:10.0.34.101': 1.0}" ] }, "execution_count": 3, @@ -216,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": 165, + "execution_count": 5, "metadata": { "tags": [] }, @@ -248,7 +250,7 @@ "tags": [] }, "source": [ - "## 🔢  Data ingestion" + "## 🔢 Data ingestion" ] }, { @@ -343,8 +345,8 @@ "" ], "text/plain": [ - " id created_on title \n", - "0 6 2020-02-20 06:43:18 Comparison between YOLO and RCNN on real world... \\\n", + " id created_on title \\\n", + "0 6 2020-02-20 06:43:18 Comparison between YOLO and RCNN on real world... \n", "1 7 2020-02-20 06:47:21 Show, Infer & Tell: Contextual Inference for C... \n", "2 9 2020-02-24 16:24:45 Awesome Graph Classification \n", "3 15 2020-02-28 23:55:26 Awesome Monte Carlo Tree Search \n", @@ -376,7 +378,7 @@ "tags": [] }, "source": [ - "## ✂️  Data splitting" + "## ✂️ Data splitting" ] }, { @@ -493,7 +495,7 @@ "id": "WuCrsbxbNkSV" }, "source": [ - "## 🔍  Exploratory Data Analysis (EDA)" + "## 🔍 Exploratory Data Analysis (EDA)" ] }, { @@ -562,7 +564,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -616,7 +618,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -625,7 +627,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAD7CAYAAACi0gmlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d5gk2Xneif5O2PSZlVnedVV7O94PBjMACIBwFEGQFElRFGUvJWpluBJXq9Vd3XtFrfRIK+3dR5e6olYURSNSAmgAwrvBGIztcT3d0766y/v0Jnyc+0dUZ1V2VXVXdfeAlG6/eDCdlRlx4sSJE+c7n3s/IaWU3MVd3MVd3MVd3AEof9IduIu7uIu7uIv/fnBXqNzFXdzFXdzFHcNdoXIXd3EXd3EXdwx3hcpd3MVd3MVd3DHcFSp3cRd3cRd3ccdwV6jcxV3cxV3cxR3DXaFyF3dxF3dxF3cMd4XKXdzFXdzFXdwx3BUqd3EXd3EXd3HHoO30QCFE9G8shppNIzQN6fn4xRIEwY3PjcXQclm8ldWbHnsXd3E9jLhC95CJZihUV1yqK94P7NqKKlB1gWeH7e+EAt1DMVZm7B9YPxAKqhFDKAq+1djxaWosiZZIAQKvUSV0rfevjzuEUFQkEsL1MVV0E6FqBHbzttrWU1mEquM1KsjA33mfEFGfbnSMomLmehCKilsvETgbx1Jgmhl0LQ5CEAQejlMlDN+/uWoYaXQ9AYDv2zhODcNIoarm+3btnRCw7FpTUdMp4ocPkvv0x4kd2IvQby6X1HSK7Cc+gppJ7/Zyd/H/7xDw5Gd7eerH+7j3mTyjR1I/0Mt3D5kceiiDqov2d6om2HMs+QPthx5PkegewswUdnyOlkhTOP4YmbGjpIb2oaey72MPdw4z30+sq6/jOy2exEh33Xbb8d4RCiee3NW9asIgrfegK7EbHpceOcS+T/3f2Pcjf4Oee58BsT4nhFBIJvsYHHyYsT0fIpsZRdNu3N7tYqDvfvr77qcrt5dksg9FUUkl+xkeeox4PP++XvtG2LGmcg3+yirNt2yUZILmybeQYUj66ScRMRPr7AW8mTn0wX5iRw4C0HjlJP7KKt5q6Y53/i7++0e2W+eep/P8xj+8RL3soWrRi5wp6Dz5Y71kunUuvVnnyjs1nv6z/YSBJJ3Xef6/LjF3qUU6r/PEj/aQ6zO48k6Dd75b5MEf7kYIGD2aZPpsk1e+tMLQgQSPfaYHI65w+e06b32rSLZH54f/yhA9IyZHn8zx5reKlBcdHv5EN9kegze+UQQizeWep7s4+mSOesnje7+7yPg9KfYcSZHq0lidc3jpD5exm5u19NTwQXrveRqA1uosiye/AdftBoWikugbQzMT+FZ9x2MX7x5CSlg99eLarl0Q7x0hM3YUGQZUJ94l9D1yhx5EUVVkGFI8/TKJgTHcygpOZYXsgfuwlmZQzTiZ8WOEvkv18im8RpXCPU8Sei5GuoulN76DnsiQ3XcPqhGjuXCF+tR5cgcfINY9QGC3KJ9/AzWWoOf+D4JQsFfnWXnre5hdfeQO3oe1PIu1Mhs99wP3Ee8Zwq2VqVx8i3j3IMmhfSiajlMtUj77GqnRQyQH90b3cukdnPIyrYVJjF0IXgBVaOTMfnzLwWN77TM9ehgtmUEIQXbsOEtvfAspo2cqZUCpdBEpQ5KJXhaX3orOSY/Q030Y33dYXjmNouj09hxDERp+4DA98yKJRIGe7mOoqkGlMkmpfInuwhGymVEct8bS0ikQgr7eewDQtDhT088DsLJ6llptut3Ham2aRKKn/bdhpOnrvQdDT1GqXCYMA3zPIp0exHXrKKpBrTqN6+1c+70ZbtunEjuwj9BxaL5ykuSD96KkkphjozgXJ7DPXyL9+CObzhGatiMNZ9dQ1TvepNB0tEQaLZFGqO9Dn/8koYg7+hy0fB5hGOj9/Xeszd7ROOUlB00X/PT/spe//WtHUVTBB368l8WrFm98o8i++9KMHEly30cKvPHNIu8+X+aJz/aiqILHfqSH0oLLya+tMnosyfDhJMOHEnT1GXz5V2d469uRYKiuurz8pWVe+8oKI4cSdA+blJdc3vp2kfOv1fjav59l8nSD8pLLa19ZZfjguqbSPWjy0Me6+er/d5b5yxYf+4uDjB1LgYBv/sd5YkmV8Xu21rCMZJbMniNk9hwh0TOy5TEyDGgtTRF6DqoZ3+HICbRkusMMpMaTZMaOUr74FvWZi6T3HEFPZkn0DrPy9vOReSdbgDAg0TeKasZJDx8g9Fy6Dj9EdeI0XqNKavggimZgdvVjLc+y/MZ3kZ5LLN9PGHiUL7xBc2ESgObCFUrvvYaiGRjZbpzKCo3Zy9Qnz7H67ksAOJUVrJU59FSkqZhdfST7x1g++Z1IAxjci5EtEPoey28+S3JgDC2RwV6dp3zudbxamcTA+A7HZTO80GHVnsYNb2wadGslZBgggwCnsnxTU5CmxRnsf4Cl5dN4XpOu3F5MM41pZpmaeYFYLEc8nieV7Mf3HRaX3qZamyYeL9DVtY/J6efwfYdc115U1SAeL1AqX2Zm9vttYbZn9IMcPfwT9PfdjxCdy7kQCl1d+3CcOlPTL9BdOEwq2YdppslmRkmnBokZGYRyZ13rt72iKIk4YbNF0GyhmCZCVUBRCG0b6fkoic6XQEkmMEdHCG0Hd2YWCSiGgXRdhK4T2nYkdDSN0HURhg6eh5QgFAW55pMRhgGBjwxldL7vYQwP4S0tE9pOh732ViEUlczYUcyuXkLXpj51AaeyfNvt/kAgBErcJHTcaNKoKtL3UUwD6UWLjDHaj9AUnKlFpO2CotzU55VKCh5/JEbcFLzyhs3K6ga7eCyGmkyiplJ4i4trX6po8QSBbSHDADWeRAYBiq4jw5DAbiFUFekHIDc/M88N0U2F0qLLl391mr/yLw4SSyr0jMTI9Zo0Kx7Nqk+rFlBecliYsAgDycOf0DATCr0jMfrH49RW49iNgGbFx3clU+81aNWCa13kwAMZRo4m8R1JrtdENxVkCK4d4rshTjMg8KNFxLXDDvt771iclVmbWtHjwutVnvmpfk6/WGbpqkW95FEvesSSt7fhEaqKZ9UxUl0YmQJuvbzleK1D4jfrxHuHEaqGDHwUVUfKkNC1EQiEoiBUFbdaJHRtAsdCaDpOeQWzq5f8kUeoT51HKAI9mYk0nMDHKs4DktC1cOtlQs8BoDF7keTQPrL778GtFqlPX6Bw/Encegmz0E9z4QqEITIICAMf6btrXQ07/B+qGSdwLELPIXBaqGaC0HcJGx6haxN6Dlo8SXr0EGHgY3b13tZ7qSsxCuYIFXeBure67XGl8ydRdQOh6pQunLzJ+IOqGhhmmu7CYaQMqDcWkDLEtksEgUPg2yiKTrF0ka7cXnp7TtBsrWBba78HDr5voetJBALPa+I4NYLAbV9javp5arWZ7fug6NhuBT+wCQIP33dIJvtwvSaKauAHbkd7dwK3LVScq9Okn3wUvbcbd2qGsGURVKok7jsBgH3+Eub4GMbgAPETR/EXl1ELeeTCEsIwiO8bJ7Rt/GIJc3wM+/IE8aOHQQj8YhmhqxBKgmYTvacbf2UVJZFABgFqKklQayBiJvbEVdRcDiUex5meIWzcnsMPAEVBS6Rpzl+hOTeBaiZIjRygtTiFns6jaDrW8iz5448ROjaB5yDDEK9WxKmu0nXkEcpnX8Ps6m3vpFpL02hmnNbSNEa6CzWWoLU41XHZdErw9/9Wju68wjeftfjS11rbdvHIIZ1f+PkMpgn//jfrvHUqmiDGSB9aIYN9eZbYwVEIJWHLRvo+en837uwSSiKGO7eEsWcA6bgE9RbBauWGQ/LYwzH+j3+aJ5dV+Mf/vMyv//a62hy2WsQPHcKZXp/kydF9ANjL85jd/aimSei66F3dOCsL2EtzpMYO4TVq2AvTm663NGmRzGoM7I3TrEYLj+eEtKoBZ1+p8N73K2iGINOtE3idO0fPCWlWfSbfa/DOsyU0TRCGEqRkow9XNxX2HE9x5sUy5UWXz/ziusYQhhJFFQhVwDaO3PKiQ+5jBTRDMLg/QXHORgYSGa4dLzrM77eE0Hcx0nm0WGK7bmyCtTpHvG+Uvkc+TuDa1KfO4dXL5I89hhAKVnGewLE2OajdRhmkJDm0l+J7ryJ9j9rU+cjhLwSB1USG1zYf6+ea+X5ihUGEoqHGUoi198e36oSe0xYcvt0kM3YMLZ6kdOYVEv17yIwfQ40lcSrLWKvzpJXD9D74ERQzRvn8G8Ty/bBxDBUFNZ5COBbS96INqKbTdfghEgPjKLpJ6czLOwpqUNZ2+OImhpvAabL4xrduPvDXxtFtUCxeWHOmCzyvgaqam55fKtm/5hPR0PUkpdJFwtBnz+gzqKrBysoZJOFNNSMhFPr77ieXG8cwkszNv06jsUh34TDp9BC+71CuTLB/7w+zsPQ26VQ/Qog/HUIlbDSpP/d9pOsRlMrUnn0RFIG0HaTnY5+/hDMZLRBhy0LoGqX/+odIz0dNJVFzOQLLAlVBSom7uExs3xjGnhHcuXnUVAq/XEbv60GoCkGtHu28Ewlihw4S1Go4M3MoySRoKt7SMngeWjaL9D3sK5Ob+qxqMUAS+M6O71P6Ho2Zi+SPPkJiYIz61bOYXb2Rqp7MopoxrJVZ0iMHWXjpK/h2CyPTRXrsKGL2EqoRQzFMkgPjOLUiqmaSGhxHqBpOdZVYYQC3Udl03XhM8LnPJBgb1VgtBjcUKgN9Kj/5o0kSScE3n7XaQiVoWsSP78VbraD15LDPTmKM9iF0DWO4F2+pSGg7hE0bCiHxE/tovPjOTcekK6eQTisk4gr5rs7dt5rNIsMQNZuBhfn291oygwxnifUPUTt3CrNnAEXVcMurCEVBMUwSI+NbChWrHvC9313kc//jHoyYysyFJp4j+f4fLvGhn+nnic/2snjF4u3vFrFb0UIXBuBYAb4refXLKzzzU/08/Mlulqdsnvu9BVw7bGsdAIqU1OYsPvOXBykVfcqLLtfWzNUZh/s/ovPn/x/7eOHzS0gpeewzPeT7TX7s747yypdXWJ6ymT7X5C/+bwdwWwHf+88LHHwog792Dd8N8b3bK1ukqDqh7+K1AtxGaZPfZSv4rTqrp15A0U1AEtgtnMoKqhE5kAPHAilZeeNZAEpnX4sW/jCkdO51KpfeIXQjH0PlwluoZgwQBG60kC+/8Z2OCCinuIjXqICUhK5D6LssvvyVSKJefLt9bHNuAnt1vr1I2sUFlk5+G4Eg8BxC12blredQdAMZBAROC69Wbl9n6fVvEboOK7VnEaoaXc93kb5P+fwbVC69jQxDfGf792YjAulRtGfw5e0vrtXqZFtzkDJgcemdtsPe921A0mwsATA18yJB4KIoKpZdbh8Thh4zsy+jqgZShgShhaopLCy91iEA5hZeJ9iwO5IyZHnlNKvFs0gZ4nkWrlvHsksIoRAELkHgcHni63i+taGf12tcAlNPYRoZhFDwfIuWvb0Gdz1uSahkuscJA4+mvYAMfcJmp1YgfR/Z8Iln+9ELfTQrCwSVatRdVcGbn8dbWESYJkGlinRdZCjxl1cIHQdveYWgXkcur6L1dhMUy4SOQ2jb6IU81qUJjKFBhKYS1OqELQsZhjiTkwhdR00k8O11h5tmpjj69F8jcC0uvvo7ePbOnZ1OeZmFl75CZu9xcgfux2vVQAiErrePCTwHtxbZ5t2aRKgambGj1CbPIhQNI9eD0dWL36rTWpxEi6cxc91oiQy1ybObLyqiEG5xG9tbxdQJak0IJQiBPtILiiBoWrjzq7jTS8Tv3U/ixH6CRougXCNs3TxE9rnvW/zm79ZJJhX+4Eudzz1oNDCHh3Hr6+PrrCygmnFiPQNIz0dPZ0FKZOAjwwAj34vQDRTDRI0nCazNGubpF8qcfqHc8d3ChMXv/pOrHd/9+i9fAmBlxm7/tnjV4r/8s87jvvbv59qfVRX++s9neOJhlZn5IqtnHL72R3W8tWjMyrLLF/7FZMf5l9/aPH+e+71Fnvu9RYSAxx6MsXqqxLnT0QLw8hdXNh2/W/iuhVWcx0jldiRQgHYYsp7IRCG7ioIMfHy71eFrCdYW32sCJPrsELrrGzAZeAQu6IksRiq31p4KMiQMfAK7hdes4Ddrnf3eUlMQGOk8qpnAb1axivOEngsItESKWK4H1YhCc8PAJ3RtvGYV3476GVz712mBEMS7h9HjKXyrQWslWiiFqmGmC2iJNIqmg4y0Pc+q49XLGzQtiKlpDDVB06tsGDqVeM8wmpnYcmjdZgW7uLDp+zD0AX/D3x5KqhsjlSNwLVrLM/iBjVBUlHgcM9kf9U8IQt9DWA28RpnAj8xfAKP3ZMh0GxRnLRYurj/7SEgBQkFPZqLnvBZ2LhDcKPYsWJq8LiR6HaaeYv/ID2G5ZWQY0rKL779Q2XPPpwlDj8uv/xecZnnb44YOf5hEtp/Lr/8XWpXoBoJaPdI8AGnbuLPRC269e6Z9XqtcaX92pzvthc5EtEBYG45p/za5ead7OxCqRnJwL3o6h2rEaC1PY2QKZPeeQEtkcMrRjmOjOhv6Ll6jQnJwL36rTujatJam0BNpfKuF16jilJYo3POBaLe2i1j63cCbX8VbKIKU6L15Wu9cjBajDVac1slzoKqYYwPYF2eQzs3j2ldWQ/7Xf1bZ8jfpOLhLS2jZLO5c9FwVw8Rv1XErRbxaGSOXxy0t49crSM/Db9WpXziFULU77jDcKWr1kF//zzVefNXin/7DAu+cdghCyWMPxrAdyfMvW4yN6AwNaGgaxEzBC6/YOI7kmSdjJBMKJ99xePOUw9FDBkcP6bxyMloQxkY1nno0hm4Imk3J57/U2LFM2AhVMxFCobk0dfODiRb/rkMPkho6EC3SsRSKqhJ6Lm6jTGt5hsrld2gsTNx0DmrxFKmhA6QG9xLLD2CkIrOtokZ+sdCzcRsVrOI81SvvUps+f0N/g55IM/jYp0kO7KV65V0mv/WbIBS69t9Hbt+9xAqD6Ilolxz4Dr7VoLk4ycq7z29ayBVNp/+hj5EdO0ZzaYpLf/RvMNJ58ocfJj10ADPbjdLWzFo41VUa8xOsnvk+fitah6ygjhO2cIP1RVbRTYYe/xGS2wQAlM6/zvRzn7+pXwWg58RTFI4+hl1e4vKXfhWEQv7gQ6RHDxHr6lsXoK6DU1uluXiV4nuv4FRXSHcbDBxIUp63ca3N11LNOPnDj5IePkgs14sWTyE0/YYbUikll7/0/8FamSTVGyfTl2D2ndX1dUwI6q1Fphdfuem9bYVbEip2Y5V4th9VjwPbCxUjnokk7p+ChKtbgQwD7NISXr2ClAFevRK9TLoZvUyuDVKyfPLb6yeFIfXJczQXruJbTZAhjemLaPEo+iewW8jAQ0ukacxdfp9vIJol1ntX1ne31y9oYYA7t4x0bz9RSonFEJqOu7TU/s4tr+KW13c5XrUztNyvVW77uncKjabk3CWXhx8wGezT+M4LLXq7VT72oQTdeZVaLaS/T2V5NeAjT8X5vT9q8Oa7Lpm04C/+TJo3TzksLPlk0wn2j+ucveiyZ1jng4/H+T/+XYW/9ddyvPS6zez87jcSUoYY6TxGKkdt9sINtZVYfoDBxz9DamAvQtMB2T5e0U1i+QFiXf2khw+y/PazrJ59ZdvFUag6haOP03PiKdTYtYi3a+1JhCJQYwnisSTx7kEyI4eYf+XLlC+9ddN7EoBixFB0k+5jT9Bz7zNr74lsz1PViKMacWQY3tSXZGZ7MHM9DD3xI6QG97dNY9eupsXT6IkMid5RYvk+Zp//fXyrgRAq/fGDFJ0ZGmuOehkGtFZmEJoWJZCaiTWNQrllC4KRzqPF0/Q9+FEye46gaMaGcY/GMRnfQ6JnmGT/GJPf+i3sRo3Zs3V0UyWZ0ynOrK+laizB0JOfJTt+vN2Wb7cIWzW0WDIye65ZPKSUbaHq1kp4zRpSQrIQi/yFHWMr6crsIR7LEwQ2TWuVhdVTO77PWxIqVmOVdPc4urG1angNZjyH1VjBc++A0/xPAlLiN6tsXAKi3U2n+eOa6esaAqfVNikAhJ6DuxYhoyWzdB18nPrVsx3mhfcT0vVIxAU93QqplIKxlsjneZKWJSlXfGqeZKu4L02LdtvZjNIx8YIQZud8VkvRS6HEYmhdXQTVSuQTK0Zjks0o7B/XKFdCJmd8FAGFvEo+rxAzBKGElhWyvBJSrd1412cY0Nutks0oGIZA2fhub9DAHFdy4bLXNmHtFKYpGBnUeO+CSyjh/CWPej1k7x6dmCk4Ne1F9z3vcd9xk4fvN/nIU3FcD4YHNISAciVktbQ+kkEguXDF4+xFj1I5JJdVmJ2/QSe2gVA1hKoSOC7Z0WPUZs51mHCuIdbVx/BTP0ZyIMrfaC1PU5s6S2t5Ghn4GOk8mbFjpIcOoKdyDD35Z/CdJpXL72x5XRl42KVFAs8hcG2cygrNpUms4gKB00LRTZJ9e+jafz9Gths9mWXgsU/TXJzCrRe3bHP9pgSqEaf33qfpPv4UYeBRnzpLc2kKr1VDqBqxXC+J3lHs6gp2eemGzalmjNEP/TTx7kHcWpHKlXdpLU0ReA5GMkd27z2kh/ajGDEyo0foPv4Ui29GuSaWX+kQ1KHnMPfyl6JFGQEI8kceZvipH7/Jk7rB7aoaI0//BIneEdxGhdrUWRqzl/BdCy2WJLvnGJk9R9HiSRK9oww88glmnv8CsZRO14DJwqX1dVQoKr33PENu7z0IRaW1NMniG9+mMX8ZZGSCz44do/+RT2Jm8iAlsy/+IZUrp6L3RIaohkLghtSXOn1Pntfi6tyLqKpBGAY43s7dBXCrmkp9FVWPRWrbNlD1GIpm4LsWob/uXFJUnURukESmD0UzCDybVnWBZjkKU9yIZG6IZH6E0txpZBiQyo8SS3UjhMCzG1RXLuM7zeuuGyddGMVMdYMMsGor2I3VG+7sFFTy2iCq0PCkTcVfJtxyib19+M0qK28/F92fksOXLo7cmUPxVnHvcZ2f+rEUjz9isndMJ5uOzEz1Rsj8QsCZcy7f/J7Fl7/eomV1jlMuq/Av/195Pv7hzg1EtRbyP/8/S/yn34ts5sI08SsVlHgcvVDAmYrMNE89bvL53+jjm99t8Qu/VOSHPhTns59KcN8Jg0JexfclC4sBL7xi81v/pc4bb7tbRoMPDaj8+J9J8qmPJTh8QCebUdA0sWVU1eS0x0d+dJGFxZ09w3hM4eknDEaHNZqtkG99r8VPfy7Nj3w8QSqlMLcYMDwQTaFofw6aGgmgai1kctpj755IqDzygMn9J0zqjZCzF12EoO30vy1XfRgghIqRKeA1ylGY8HVCRagahaNPkOyPTDbVK++y8PrXr9v0TFC+/Da99z5D7/0fRtFN+h78KK3lWdza1nbzxvwEC699DaeyjF1aiLSGDahPn6M+e5GRp3+CWFcfWizKh1k9/eJNbyuW68FIR2HHK5dfo3blDKHrIJ31DZeim2iJNKgK+NtvPIRQSPQMU5+7xMIrX14LfY7QBKpT79H/4MfoPv4EimaQGtyLcSGH0nSRsPmdl5FGdu25hf7tafNCCBJ9e7BWZ5l/+Y9pLFzt0BBrU2fpPv4B+h/8KKoZX9OoBliaWKQ0Z3VEfxmZAqnhAyiajtuosHjyW9RnL6x3PQwoX34boagMPfU5FE0nf+hhqlfebee4BF5I4Aak+xI0ljf6UwWGniQRKyAJKVZ2pxTcovmriKqbaGuaimYk6T/wAZK5ASZOfgHfbaKbkbnHs9Ydd6oeZ+DgU3SP3IeRyAICKUOcZpnlK6+ydOU1ZLiuF2R69jJ4+EP4TpN0YQ+FkXvRY+korNGzOPvcv+sQKnoszdCRj5AfOo5uppChj+c0Kc+fJbyB3VgVGnm9n5K3QErtwpcetWDnjqlbgUAhoxWwwjqO//4JleNHdP7VrxR49CGTIIi0i4krPqYJw4MaRw/rHDui07IkX/vW5n40mpL/+DsNTr7tkM+pHNir8+Rj5qbjgnod0mn8SmU9lHYDxvbo/OWfTfMLfylNOqVwddpnbsFlZFBl75jG+J4Uhw/o/I//qMSpM51ROLmswi//7Sw/87kUui549kWLS1d80knBB5+IMb4nmsavnHT4xncsLl72KJd3lqcUhvD177YYHtSwnZBzFz2qtZDPf7HBnhEN34crkx65rEKjFXLhsodlh0xc9Wk0Q/YMaziu5My/qSAlFEshf/CVBmEIjWbI2QsBcwvR3Pvtz9fan3eLMPDbARx2ebmdG7IRRqqLroMPIhQFr1XbQqBEkIFP6cJJkv3jpEcPY6YLZMePsXLq+S2vHTgtKpffvmH/WsvTVK68S98DP4RQ1SgEeAdQzThBvczC619DjPVi7hkltCxQFIJKBSWZRDoOwjRIDPXgLi2jptN4i4uEdmdgiZQSr1Vj5dRzHQLlGkLXpnzpTTJjxyJhlimgJ7O0apN4ocNtiv0dQfoey6eeozF/ZdP1ZOBTvXqa7NgxUoP70OIpCmODxEWDZF7HaQVUFqLnriczGOl8dM+NCs3Fq1tcTNJamcWtFYkXBjAyefRkFrcemaAVVaCZKslCrEPT17U46cQAK+Xz6Fqc3vxRJudvvkG4hlsSKq5dJQx8jFgGoagYiSzdI/cSSxXI9u6nOHsqWvyROK1rPhdB/77HGTz0NOX5s1x4+bfw7BqxVDcjxz/G8NGPEgQeK5NvdEhvRdUZOPRBAs/m6tt/RKuygGamSBdGserrC78QCr1jD9O391HKC+eZPv01fNcilR9m7N7PEEt2Uy9ObntPoQxwpU2aiDNn2DhMQkljyQYL7gQCwd7YfYBk0b2KL10GjP2oQmPevUw9KNKv7yWjFvDxmHHOMR67FztsIQlYcifp0UdJqTmaYYVF9yqaMBk0+hk0DjDvTFAJFm/lcWwLRYGf/ckUDz9gcnXK5+/9oxKvv+Xg+xIhQNMExw4bfPzDMZ5/yabe2PxS2bbkq99q8Y3vRO09/YE4xw4XSCavc6qHIVouR6AoaNkM7mznz/vHNX7pb2Z4+TWHf/Ivy1y4HCW0JhMKf/Xn0vydv5Hh0YdMPvvpBBcuedjOel+efDTGz/1UGiHgf/jlIn/w5Sa+L1GEYHRY5X//JwU+8nQM0xD8u9+o0WzJHTvDpYTLVz0uX+3chS6tBCytrO9cK23TXPTvSjH6d3G5c3d76YrHpSudbRXXBNz5S7e+01V0E8JwLay4uuUxuX33tDPuKxOn2ovHVvCaVZpLk6RHDiI0nUTPCIpubimsdgIZ+DiVFULfRdGMtaip7XN72udJSfXqGZpLkyTHetAHB8D3o7y0vt5IU3Ac7MnJiNFCVdEKebyVrSPq7NLCDX2VdmmRwG4gZTeqGUfVTWJaiozeR8sv3zD58U7AbZSpXjnNduPi1stR5v7AXhTdwHUNKrNNgnMh5oYEWkUzUI1ocxc4rQ5r0EaEvts2xQtFjebHBmuWmTGI54zOk4RAEuJ4dYLQo0vZnZi4JaEigwDXqmLEMyiKRixZIAw87GaJ3MChNaESaSqOFb0AeizFwMGnaJRmmD79dZxmNOEbpWkmTn6B4x/+RXr2PEh16SJuq9K+lqJqCAST7/wxdj2aSE6rTLPcGRWmaCY94w9jN4pMn/5a+9jKwnmmFZ2DT/zcDe9JF3EGjf140iWQPmmti2V3mozaTUxJ4oQWvnQp+0u0whq9+h486VALivTqe6gHRepBCVs26VL7iCtpYkqSq/YpPOlgijhpNc95K4qoECiEMmDJnaIVVhg2Dt9xoWKagsF+DU2Fq5Mez33fotMfL/n+qzbff/XGocRhuE5Q4LrbL9h+qUTy+PEOR/01qKpgds7nb/7yKtOz6wtxvRHwz//PCk8/GeOJR2M89pBJOiXaQkUI+OgzkcB4/U2HL3+jRat1rQOSixM+f/yNFo8/YjI0qHJwv97O1fnvCYFrYZUW0BPpbU25ycH97c/Nhas3DT32mjVCz0U14+iJDFo82fb93Qpk4CGDAKGvZXsqIgppvwFCz8FanSN0Hbz5BZRYjKDZiPxHjUbkn6vVCG0HmfTA8/CLRRTT3JTKgJQ0F69u6WtqHxIGBF40PxRVQygaCgqWX13TVt5fNBau3DjaTobtXDohVFLdCZSmjmYoCAGVRad9HzIIEKq+Ft6tdVh5rkFR9Xb0mwxDgg1h40ZCI/RD6sudgVS+b+P5LYb7HkERCivlC+wGtyZUZIDbqqCbKRTNIN0zjt1YxXOapAqjqHp8TVMBd02opPIjqEaCRmm2Q2gAeE6T6vIEheETGGa643cZBtSLU9j1G+8gjFiaWKrA6tRbeHZnbHyjPIPv3tjE5Mgmi+4VBo0DxJQkgoieu+wvYAcNfHwW3Svk9QF0YUZ5JCh40mHJvYIpEnTrIzSCEqrQEQhCArx2QtVm439IQIBHKEOEuPO8Za4rWVoJCAI4fNDgx34kyZe+2sKy3x81X02ncWZnEbGtI+T/4I+bHQLlGjwPXnrN5olHY/T1aujGBvZXoLc3GpuFJR8/2Nz3ciXAsiSaKijkTQaG7sMw0wSBS3HlLFbrJg7jG0BRDRSh4vvrL14snseMZamWtzA5bIN4oodCz2Fq1WlqlZ2FBW+EqpsRg8MWZh0AhOhgMM4ffpj0yKEbtmlmu9eiw0DRDRTVuOHxCIGeyhHr6osimcxEm7I+cqr3oOg3aeM6hJ6Dv/a+2hMTm373ltbpV5xGdJxf3i7iVOLWdkBcuyEiLMoHU5HcPq3TTrCVOXIT1iLrEGDENRxdIJTOPYLXquPWS8S7h9BTOeI9w7SWJq9rSBDr6sPMFCIzWbOK11zXcn03JN5lYqb064JwXBZWTmEYKcLQX8u92TluLaM+DHCsKrFUAUXVyXTvpbxwlkZxmtzAYZJdQ+jmmlBZExBmogspA3ynsTmDU4Y4rTKKZm5KNpIyXBNMN14I9VgGEHhOY5PEloG/yaHf8TuR+eua5qEJk1qwSrc2hB02aYU14pgMmYdQ0VgIrtDwSgwY++jWhiiFc7hBC13odGn9yLX/BdJv99sTFi1Z4VD8UZpBlUXvCqEMkDLikQrlnc9XCQL4vd9v8LEPxRkf0/jXv5Ln5386xW/+XoPvvmBTrQY4d2pTLwQyCDAGBtp5SNfjhVe214hKlWhOxMzOqC4JLC5Fgqi/T8M0BI0Nc0EIKHSpxOOCWj2kUoVEsoelxXeIxXIUuo8wP/tau7VrmcUg2lpwGAZrzkuBouoIoiQ2KSXpzCCGmaG4cp5w7TzftwmaGwZOKKhrJoIg8ACJouhroZwhYejj2GV83yKe6L4loSLDIOL9SuepTp7Z9LuirS3ua5ELmdEju7uAokb2zS0gVI1k/xg993yQePcQimasXUvZRP++Wz4aGQaEwZ2r+xE4u6txI5H4octg4jCrzhR2sLtIp91iu4TD7VBesEnEVYQQaKZC92ic1WkLp7JMbfYiZlcfRqqLgUd+mIXXv45dWlzLRxMkB/Yy8OgnUXWTMPApvvdSh5YUeCHFiRoDJ/JtS6UQSnt9dt0GqmrQXzjB7PLJHff51jSV0MdtlUnnRzCTeYx4mlZ1gdpqlA+Ryo9ixDPIIMBzot2FlGFEYie2mbhrO/kt+W12kGCEWN99bNnnGwglXzpMOqcBWPYmtz3uovV6x9+X7SgWf/+9KfoTMWYunqZe8jDiCqEmOW+9jLKmgPSPmSwvXcSzQ1RNEBBSFJOEgFDhsv3mxs62x+Fm76ho/2dra8db77r8ub+2zD/4uzkevt/kiUdifOCxGEvLAV/9dos/+OMWp864VKq3t1NTkklio3sissjk1rVG5m8QjbXd05MSvvyNFj/z4ykevt/gZ38yxZe+1qJWD9E0wdFDOj/52SSJuODFV1zOnPcYGApxnTqKohGP51EUlf2HPkOzsYRuJJiefAFdT9Dbfw+ansB1asxMvkB37xGyuXEkIStLZ/DcJn0DD2AYaRKJbqavPocZyzE0+jie22L66vcA6Bu4j1R6EClDFmdP4npNBocfQdeTgGTi4tcIQ5/Ad1BUnVuDQNHNNcqVLX/eMGYSu7y0lqW+MzjVlXWCxw1QzTh993+EwrEnovyswI92vK16O3Q+8Fyk72Jmu0mPHtkdm/e1cLo7hM2UIzeHF1pUnHmC97GgVhu7JLqVoUQzFHL9JlJCfdWJtJbAZ+Wd5zBSucixP3SAAz+6D6cWkYNq8RR6MgdC4FkNVt97mcqVd69rXOI0PeY2JD525w5Sby4wOvAYnm+hCC0qPLYL3KJQCXFbVVQjQbZ3P57TwqotE/oejdIMydwgmhHHsavtlc6uryCEgh5Lb7b/CQUzVSDwrJuaqbaD24q0Gd1MRTxJG3Y/QlHRzWRbzb6TEAL2HEugaQK7FZDr0dpVCi++Uad7yGTuskXfqInTCskfiJHvN7jwZoO9x5M0Kj6KAhfeXM+0lsAakTCGIW7o7lRVga5FB7ju1kedOefxC393lUcfMvnAYzE+/FScE0cN/sqfz/Cjn0zyB3/c5Fd/vcblK7euLYWNBs7sLGoyuW0Jgu36dzO88Y7Dr/92nb/y59P841/u4pMfTbC0HGAagmNHdMZGNd58x+VX/mUF1xFoWoz+wQcIw4B6fZ4g8AjDgOLqeVrNyJyiqgat5moU7993gjnlFbp7jjFx8at43vocXFk6TSyWY2Eu2qnZVoni8jnSmWEAFEWnu+co507/13alPU2LY7WKWJQY3vMBduKw3gm8Vh09pWzZ3jXCRrlmOll87Wu0Vme3amZLXOPY6oQgt+8+CsefjML/7SarZ75PffYSdmV5jS5lvR9dBx4gNXQA/hsrEaEIDVNLYTnvr5Zyq6iXXAojcZplj/qq295j+1Y9yqWRIbn9D3CN/kYIhdD3cKortJZnqE29R23q3KZdp6Iq9B3OoRoqlZnIklNrzCEBy65Qql1FVXS6uw7sqr+3+PQlntNECIVMzziuVcFuFAFJZfE8g4c/hKJoHdFWjfIsTrNMunsPsVQBq7buzDUTOXJ9B2iUZnbFy7URntPAqi2RKuzBiGU6hFO6MNYOf34/IAQEvsRphdzzVBYZwsq8w8EHUySzGldON9BNhWxB58gjGcIQ5i7b9I6YDB+MszTV6SAMQ2g0opnT36dtuyYJERE8xmKCIOCG2kajKfnu8zbff9Xht/5Lg3uOGfzFn0nxzFNxfv7PpdENwT/6lfJtaSzeyjJBI96m1r9TqNcl//rfVkkmBH/hZ9I8dJ+BROA4IZeuePzOf23wxa+3uHDJQ1FMgtCjVpnBsoq4Tj0yMcqoOBFEDtCu/F6klFhWKbKpyzAiLVV18K8ZsNe0RUXtMAsgrtEOiw3naYQyACnJ5EYxYzkqpcsbsq/FWiLd1kLhhhAKZrYHoao05i5tfa6UONVVjEwBIRSEqkXkjrcBoSgUjj6OqptIKVk5/SLL7zyH3MZcdeeodu6MEN4pFKGhiRtTm/xJIttjcuGlIlYjwK53vlvx/ACJvj2EnsPyqeepz5wHWKPPiShuNm8WIiiaIPAluZF4e8gdr45AML/6zhr3mNh18uMtzwDfbREGHoncELWVq23No16cRtNimIkc9oaM2sCzmX7vm5jJPOMPfJZc/2ESuUHywyc4+PjPEgY+y1dfx7Vq213yhgh8l8XLL2PEUow/+GNk+w6QzA3RM/YQw8c/1hH1cKdRXHC5cqaJYQouvFnHtgLmr1gk0hpTZ1uYcZV0l0b/uMnUuRb1skd11WN5xqFZ9Zk+3+rYRLiu5Mpk9OI+fL9BMrH1ZDcNwSMPmiiKwHEllyZurr47juTqlM8ff73FT/6lZf6v36xj6PDZTyXo6729YAHp+wT1OqF9Z2l5VAWeeTLGp384wTvvujz04XmGjk6z974ZPvrZRf7Fv6ly/qK3lpwYYlslms1F3LCFMKLFwrYr0aJPZCKxrSrp7Ahd+f1UK1dBVZid/j4jY0+z/9Cnyeb2AGC3SsTjBcb2fRSEIJPbQ0/fCVLpAfoG7kNRVGauPs/4/o9z4NCnSab6sK0y8USBQu9RqpUphBDkuw+RLxwg1zVOoefwrgIzhKqi6EaU130DLaA2c679OTN2dFsfyc6vq3Xkm5QunNxeoCgqRqoLccvmvQhmtpfc+D0ke8fQExFJolB1VDPx/hXJk5Kqu4zt33lLxu1C1RVcK+DwBwr07+3cGBvpPINP/BmMVJ7yxTdZOfUcraUpWktTWCszOJXlbQUKQOCGLJ0tMfnyYqcMFwJVrI/1bk2Kt/yU/DVTlWYkqK2sR20EbotmdZ6uxBGcZmekQ3nuPVRVo2fsYQ489ucQikoYeLSqi8xfeIHS3Hvc8g5FhhRn3kU3U3SP3sfhD/wlwsDHbhZZnniVZH4EM5691dvd/rIS3n620vHdxLtNkDB/eV2Qfff3NsTVr+0K3rruvGuwbMkb77j86Kckg/0aP/W5FP/pP9fxr3NJHD6o85mPRxPt9TedtrN7I7bb80kJrgtf/VaLv/GX06SSCu9HMc47gVxO4Sc/m2KwX+OX/3GJq1Pba0Jh4DE3/TIoCol9B/HrNaTnstQ8hzRV9GwP0nVpyCLN5ZcIbAstmSY2MoofSq7OPkvQWF9cLKvIxMWvtv+uVaY2Odpr1Wlq1U4y00vnvtjxd2n1PKXV87d0/zII8Ft11FgCPZnbNoKoNnmWvvs+jJ7Mkh07TmpwP43Zi7d0TWCzQ+8GIcpGpkBmz5Hb3u2rZpzQ9zAz3YSBiwxDzEw3ejJHa3UWp3rni+T50iGh5NAUEzd8f9ktdovCcIyZ79sIReDane93on8PeiIdrXOVrRNibwQpoWs0TSJnUJpcn/OGnqI3f4SZxdfQVIORvkeYmH12x+3e8jJiN4pcfeuLqLpJs7Ie5ui7LaZPf52liVdplDpftDBwWZl8k9rKVcxkF4qiEQQebrOM3dz8opTm38Oqr2DVdzaRfLfJ/MXnqSyeZ999n2N17hSlxXPY9RXiy72ouol/i+SWmpFkYPxxlmfe3JDQuQ1uJhdv8rvvw8uv21y+4nHogM4v/Y0Muga//6UmK8WQWEzw5KMm/+BvZxkaVGlZIb/+O/VNRRuHBlU+95kkVyY9XnrNoXyd0BnoU/m5n4ryia5O+zSauxToPyBrgaELCnkFKeGxB01eetVhpRjc2OcpJUGzjppIouWGcObnSB49HuVNhAFC0wk9D8IAa/IKmppD+jax4VGa57coR/AnCRliFeduepjXqLB69hX6H/hoxLL7xI+w9Oa3qU6e3VLDUDSDePcQyYExyhff6gg3hSj722tUMLPdAGTHT7B65vub2tGTWQYe+QTx7iGklLclWIRQiGUKBL6HFku1aeuFohJ474+1QRE6mjDQFB33BxNZvCuM3Zch3W2yNNEZwXqNk0xRNdLDhyINpbiwrTZ5PRRNkMib6PF1rTlmdrGn/zEyqSHS8T6EotFo7S5/7paFSug71FevbPpeypBWZZ5WZet4eilD7MZqxMd1EzjNUjtJcksIhUx+jL49DxNP9RIGLqXFsyxPv0HgWDTLc1jVaEBa1c21D7aDpicifrENRJiKqpHO76G08B63kiKlm+kotNnfmVB7+12Xf/cbdf7nX8qxZ0Tjn/6jLv7hL+Wo1iKhkk4pJBOCRlPyH36rznef39xuKqHwZz6Z4MRRg2YzZHrOZ34hwPclfX0a+8c0CnmVai3kP/5OnfnFTg1A0+D4EYM9IxGhZDajcOKoQSYdETp+6mMJurIKlVpIrR5SKoe8etK543kwlWrIi6/YPHSfyV/9+Qw/8xMp2qS1Eiw7ZGom4I+/3uQLX2qyshoihUCNJ1CTKbRkmjBfIGy1QFHwK2W0TJbAiupxmINDSM/Hq5RRk1vUkhegxE207hzxY3sx9w2i9xdQsymEoUVVNW2XoNbEX63gTi3hXJnDnV0hqNZ3rHybuV4GH/sMNzsh9FwqV09jX5ezIsOA4tlXMNJ5uvbfTyw/wMiHfpre6jLNxck21btqxjFzvW2eLt+qU7363qbrSBlSvvgGfQ9+FIRC/8Mfx0jnqc+cI3AstHia5OBecnvvRU9msIoLkckqmdnZDW+B5vLUWoCBbIfG5vYcx2uU0eNp/NatmcdvBE0YxLU0VrDW9lodGqEobVZiIRT0xPp9KUYcM5Mn9H2QYTtAInCdHS/qO8HqlMXqmWLEIed3zovm4mREwdIzTGb0EKnBvWvl1jcQYwY+XquGtTxD6eIbWKvz7f4pmsBpeKR7N/hUnCozS6+Tt8ZZKkWbq91WhvxTavDYGTL5Pew58sOszp9i5vx3UPUYQohdJ+tcj57hewkDn6Xpncdm3wxD+56iWrxCeWlnJpAggP/w23UqtZC/8FMp9u/VKXQp5LIangflasDp93z+4MtNfvf3G9TqWycFvvyaQyIuGOjTOH7Y4IF7ol2k40hKlZCXX7f5/BebfP6PmrjXzZ1sRuEf/0+5TWSS1/CpjyX41MfWf6tUQ5765DwTV++so76QV6hUQlaKAX09KuqG0r6KAqmUysiQxuOPmHzkg3H+/v9aYmLSpzURFe2K7RnHnp68aYY5QPN85+IqTJ340XHSzzxA4oGDKMYNfAaD3cAe+ABRdvcb51n61T9AWjvbhpiZPL33PXPT43yrgV1Z3iRUIGLRXnj1K/h2g65996OnciS6h0l0D2/ZlpQSv7S4dZa3lBTPv06sMEhm9AhaLEnvfc9s6mPgOZQvvsnq2VcZeuIztyVUonr1nepCZfJdFCNOYL8/bOdJLdtRSthIdzH05I9iZruj6q26GeXmbPBR5faeIDt+nND3CD2H0HMIPIeVU89FtP+3UjRnC4ShxHe2Vp8Cx6J8+W1i+ajQl2ps7aczUjmSvSN0HXyAlVMvsHL6BQLHIvQk5akG5alGWw5JQiynzGKxiR/cmmb437RQ6R97jHp5mqXJ1zoEybUkrGRmkGxhHKFoVJYuUClOgJQk0r109R3FjGfx3Aar82ew6ksoqs7Q/mfI9x9BhgHp/B6s5irL029E7SLI9uynd/QhfLfFytwp7GakcRnxLN0DJ4glu7EayxQXTuPadYxYlv7xxygMniCZHaQwcIxmdYGl6ZM3TfoKQ/j8HzX5/is2hw7o9BRU4rHIKV+qhFy+4nF1yt92/i6vhvyz/3eFz39RY3hQI5NWMM1IabYcSbEYcOmKt2WWO0SEiP/21+v88dd3Zmd2XcnKamdb777n8ot/PxqjYmn7PJXvPm/xi39/lUZTdpjpRodV/vU/LfDEwyavvenwz77ZolwO26Y+oUAiLjhyyOCv/8U0H3oqzqc/nuDf/sdam/renp2+tZdcU8l85CGyn3oCrZDdnVlHCNzZ5fXY8B8gfKvB4slv0pi9THr4IIm+UcxsD6oZj5I9fRe3UcGprmAtz9BYvLrJ9HUNXqPC/CtfprU0FRExdvWhGrGoUqtVwyouUJt6j8rEuwSujVuv3LSW+m4hw/B9EygAdtCkFdRwg2ieK7oRETCm8zc8TwiBqhuougFEyd6RNvP+R6/FuvroueeDpIYPApLWygxuvdy5ORAKqmFipAuYmQKqEaf7xFM41RXKl99GSkl2MAECmqvrAkQRGn2FY6TivSAUKrVJlkqbNdntIOQOZ8DGFyp+7wG6f/4TO77InUD1m69T+/ZJ1h0Hggc+8veYOvdNivOdST1CKNz3ob+Da1VZmn4D3UiQHzjG5Htfo1mdJ5UbJt01itVcJZPfg5koMHnmK3hek0Sql5FDH8GxqqzMvkPgOzhWGd1MceLJX6Cycony0nmy3ftRVJ2pc18HKRk98nFkGFBZuUyu5wBCCKbOfwsZ+MRSBfbf9+Oszp2iujqB79lrfhmJECrKWoaklHJNOG73SN6Pybq5zXaI7Q8wrHM7/Kt/kuev/oU0z79k80v/qMjlK1sL0XhM8H/9n9382GeSfP6PGvytf1DcUnvbDRIPHabvFz+HkuiknZHXOPDDkHY1TTbwXQHSdln+1T+gefLcpnY3QjFiEZ/XLhAt6PUdOWaFpq+VodDXdtpRGLQM/PYu+0ZcWe12FBXVTERRaEIBJGEQEPpOu9Y9RFUiVSNO4Dnbm6qUyJSkaFHlSK9VQ94yrbxAT2YiehgZCdTAc2CN+mireawns+3jvVZ1U5KoUFT0VO6WwqN9q7kp4kqLpyOBLhS8ZuWmkajXxhDAt6P2FEUjDCPTlmomGfv4z5Ea2EvgOsy88AWaC1cjgbLx5RCAUFBUna5DDzHw8McRikrl6mmmv/OfCQMXPa6h6gp2dX0MYkaWwd4HkGFIvTVPIt7D9MLLwDbJ6df3f2dD1QklbmAM9tzKqbcMNZ3ocAxfyx0IvK19FGHgsTr/Lqtzp9D0OOmuPZiJLprVeVr1ZcLQR9PjWI1VUrkRNDOJ5zZo1Zfx3BauVaNZ7XSOek6Dldl3qBWvYDVWGT/+Gcx4DoB4ssDEu1/Ebhaxm6vsPfGjmPEcrdoCrfoSYeBiN4s0q50mi5HBx8h37cf1Grhuk9mF17DtrQMBCl0HqDcXcN07l6TVWzhCqXp1g69HUOjaT8sq0rLeX8bWmyGbETz8QJRB/s4Zh0sT2+/6LVu2GYMN81p1vlsXKkomSf6nP4qId2awh66Hv1jCmV7CnVsmbNpRCGbCREnG0XpyaPkMQbmOO3/z8QtdG2dtkVHjCcyegWhn3mpEFTNvc9cvfQ//NuuAQOSv8a06bHjdtFQmSnTd0EffarTr0gvdgDDcZFpT40nCwL3tPJq1nm3QsgQDww9jt8qUS5cY3vMktcpMFDK+AdtpZe0Ww2BnHF07hG/VEYEkkxmm7N+83Y1jGEEwvu/jzM2+gm2VyO2/N6psKWDprW9TnbhxVcYAWDn1HD0nnkJPpIkXBhGqiqaq5IaTZPoTTLy4sMEEJvG8FpLIV6Sp27A4bIP/Zs1fMox2SdeIK69HEHi4a4mUUsqIJkZEgmhg7DFiqW6cVhlVM9scUDdDELhr/E+sma7CaAenmW0aDgDfs5HSR9O2Jla8HrMLr7FaXPe1GHqKbGaE1dJF0qkBFEUnDD2GBx+lVp+l0VyiXL1KELh0ZcdQFB3TzFCrzeL6TfK5fSiKTqu1Qrl6FZDEY3m6sntRVZ1KbYpGc5lcdpThwceJx/NrbU6STg0Qi3XRaC519KeQP4gQCtXaDI5bozt/GIgm3ErxHI67oW5OIYdi6HgrJa7FQSvJOKFl35S1diMUZb0Il6IIFGV7lotcNsrZAZia8W45e/8akg8eQu/uNHmFjkv9xVPUvvFaZNraZsFXcymUmIFf3J1TOTY4Stf9T9CcvIiR76by9qs4K3eWufqOQQiS4weQUlI7s3Xp4MToPvx6FWe5cyOlxhNRTpN158N3BWLD5lOgqga5/H4MI4WiaNSq07Say3Tl92HGutZIR8+RSPYQBC5Wq0i++yDNxhLJVB+aFgckldIVXK9BLreXWLwL16lRKl4ikezBNLPoRgLPa2G1iphmhmplklg8j2EkaTSWyGSGEcoa9QURKWk2OwpCoV6bo9VcIp0ZIZnqw/dalIqXUBSNrsJ+FEXrWEtSg/sACIOAxtxmEs6t0C5/nkivaZqCMAgxEhqpns51yvctyrWrCEWjKzNGtb5zZgb4b1iogKRWmiJX2Edp4b32gr7+s9wyaUcoGt3D9zF9/ltUli8RT/eSzo9tOlesZUxv3O2qmomqmWufDUCJIrrCEEXRUbUYntNA0yNV199A9xGFWm6tTo8MPk5/z700rRXm5l8nlD7JZB+KopPP7WNy5vk1gebRaC7SaC4RBh6KUOntPk69MU+1NoPrNpCENJpLqKpBV3Yc2ynjuHWGBx6lWp+m3pjD9ZpIGdCyikgZUG8stD87To3e7mPEzBy2U0EIlcGBh9rX7Ckcply9ysjgY1y++k3UeIH+3nuZml0r4qMomOODOBOzqKkExmg/3twKWn8BZ2IWfaAbYeigKAhVwV+tRDv7Sh0RMxGainNlFvyAai3k8lWP++8x+KGn43z92y1efcPpECyKAgf26vzSL2a555jBymrAy6/ZHfVYdg1VIX5kDGGsM+5KKXGnlij//vcIyjfWFINK45brhlpzk5TffIn8I09j9g3irCwS6x8me+8jgKTy9ms4q0uk9h4itf9o9N2p17EXZogPj5G95xFCx6byzqskhsfQu7rxaxX0rm7shRm8Wpn44ChaOoffqKIl0yw/93VU0yRz/EHM7j6c5QXqF8+Qu+9REAItlaV+7hTNyYuoiRRd9z+GlkoTBgH2wgzJ/UdIHzoBQUD1zJtY89MkhsYoPPp05GdZWaR6+k3c0gqp/UdJHzpB9fQbeJUiSixO9vhDmL0DOEtzVE69hqIbFB7/MDIIUFNpKm+9gr0wc7Oh2xKKqtNdOMrK0hk0zSTXtRfbKtM/+BCL82/iODVAkkz147kNbKtMV/4AvmfR23cvczMvkUoPkusap16fp6twgJXFU/QPPYjVKpJIdJPKDLGydBrftwkDl/7xD1OrztDVtQ/HqSJDH9936CqMUC5dhtAnXzgYCeTqFJ7bQNcT9A3cx+LcGxR6juB6TTTVxIxlKRcv09N7on1P6hqVPVJuSXe/FbR4MqqeSaQJRSwTEPoh5elGh1IfhB5NazVy2tulXTM43xpLccvGmbwWoivQFB1FqHih2y5V2XGRrjRKJtne9Ukpka6Ht7BzFTOo1DftDOcmXmD/vZ9j7OgnqaxeRlF1XLtG/br8mA7IEM9tksxGBIC9w/fTSVgpsRordPUdpNVYwXcbNGvRblHTY3QP3YtmJMh278NpldbqxUisxjKDe5+gunqVbPdemrVFHKuy1qSkWZ2nMHiCMPRx7Tqt2kJb6M0tvM5q6WKbTgSgVL7Mwb2fYmr2RSw7Cqv2ApuWtdr+WxUGnm9Rrc/SaEbPI5sepaf7KEIomEYaTYvh+TaJeIFLV7/BxtnjOFX8wKbZWmlrGo5b6+C+MowkqmJSq83g+RZd2TF0PYnj1ihXr+C6DUaGn1gfvjDEm18ldmQvwtCxTl0gbFoY44MoqTixw+OEjRZKIk7z5BkSDx3FuTBFaDkk7zlI2LJwZxaRfpSH8q9/tcqD95ocOajzR7/Tx9vvukxMegQ+pNMKB/ZpHNgb1ZBfWQ35979Z57vP27dlNdK60mg9uc7cPylpvHpmXaCoKkJRkP4GO7amQhDelslKTaaID42hdxVoTl5C6DqFJ3+I4ivPome6yD/yFKWT3yc5doDVl79D0IoWBDWRJP/YMyx+7QsYXd10PfQBAquJW1wmue8IxVeeJXvsAeRajo6zuoRiGKixBFoiSWL8IEhJ5Z3XSB88TnL8EKl9R1j42ucRikr2xENYc5Ok9h7Cb7UovfkSPR/8YQDclUVKlTKx3n6SYwewl+ZpzV6lOTWBvTBDa+pSO6KrefUCeq4LNZFsazsIWP7Ol8je8zDpQ/fQmrxEcu8h5v7gN9HSWbLHH9yxUAlltMGLHocZkd+6DZqNRXQjRS6WRQiF2emX6ek7hue2mJ9bI4pde+DKGuO0H9g0m8uoqkki2UMi2UMuH2n7QqhtctBWY5lWc7n9Pjfqc/T234uqGbTKKxHTulvrCMxZWT5Db98J+gcfZHnxXULpk8mOwhrprqro6EYK2yrTbCx1mLyv0fsLVSM1uA+7vHzdGnbdnDIT9D34URTdQMqQxtyltv+lOFnHiHdGNMbNPAf3fIyJ2e9hO1VG+h59/ys/Wu9OMPvuv41uDEEhNkoofWruCr7cHNOc/9mPk/vUEx0Zuu7UEnP/939/K5dvw24WuXzqD8n3HSbdNUoQuDitMlIGFOdPt5MUZehTXrmI3VwlDH2mz32TfP8RMvkxlmfeQlH1jpyUlbl3kGFAtjBOq75Iq75C4LvMXvwevtci3bUHp1WmuHCmrY3MXvwe+YFjpPOjtOqLFBfPdmhPcxMv0Dv8AJnCOI3yDK36OjVCKIM2GSFEgQbxWJ5ma4lUsp/V0gWkDKIFQXQ+ssi0t2ZiUnS6cvsoli/RbC4xPvqh9jGhDND1BJ7X7OCxkjIy4W2HMPARa84+VQYgBFIGG6LtrltAhQBVwV8pIR0PrbsLn2gjIlQV+8Ik0vEQMZ3QsnEmZhCmjtA17ItTSNtFOutjcfqsx1/9O6v8xZ9Jcf89JscO6zz6kIkiwPMklVrIxcseFy57fOlrLb7+Heu2TV9KKoGSjHdmlIcS+9xk+09z7x4U08RbWsZfLaIkEmi93YSNFkG1GuULSNrOXmHohLaNkkigZtJ4yytsokgAzJ4B9HQWZ2UJZ2kOvasbPZMlMRqZPKzZqagEr2Pj1yrt8/RMH369RtBqYnse3V0FrEYNr1bBb0SsAlKGCFXFb9Twmw20RILQc1BicYxsF1qmC6Hp+FYLr1oiaDVxVpbQUmmEqkZ0MWYMr1omdGycpXkUTSdz7AFCz0VLpFDMa6VpZRQevFZM6hpkGK7XuBcKWiKFVykRug7O8jyJPftpTV7Cr9dwy6tIJIq5U5u+xGquUOg+jKbFUDWTVmuVVOa6cGohiMWyNGrz5AoHono5Xot0ZhhF0dHWrBG6lqDQfZh4vECzsUSjPk+lNEG9FvlardYK8Xg+8j1seA9Wl9/jwJHPUlw5h2PXUFWDbG48Ekpde6mULmOaGVynHhXiSvezvPjuWtuRqalenyMpQ7q69oIMUTeYv6pXT9N16CFU3aTvgR9ChiHNxUm8ZpUw8KL3VTfQ4iliXf1kx4+T2XMsoiuqrFC9egYZ+GgxlfxYhkx/nIvfWfcfh9LHcirk0qPYZg1ll7We7oD5S6ArMQLpRZrIDzhgyG6uMn9lc5bvwtWX25/D0Gd19p32343KLI3K9nZC322xOPXapu+XZyJ6+tLi5oge16mzOPnqtm16dp25y1vXAB/se4juroO4XpP5xTdRVYNMeojJmefpKRyjr+cEi8vvRGanocep1edYXj2zKSQ5DANsu0xv4Sh+bm9bbQ1Dl2L5EuOjH4oS5MqXKFWikquV6jTjI89Qrl5ltXiOwf6H6crtJR7Lo2lxVkvnqVSvMDL4GCBoWavYzg18BVLizWz2AwTlrc9xJzY8h+WtE11fe8Ph/EWPPSMa3QWFRDwqruT7kkZTUiwHzM1H5rI7ASVmoJib81H81XUHr97XA0IhdBzUTBolEUcf6MNfKSLGRvAWlghtG62QRwYhQtdwJibRuvMYI0P4pTJyC6HSmrxE9cyb9H740+i5AkGrQWBZ1N57C79eRdFNjO5eFNNEjSciv4Si4NVraMk0QjcwcgX8Zn09Sm0DOSas/S3XK3hGNDBN/GaDyqnXAIGWSHVGhQkRCQTfQ02kogipXJ7AtogPjDD3x79LcuwAyfH1wmAyCG5ctEuGBFYrcvgrKka+B79ea5+74eI3eFqdqNfmCMMAVTOoTU9h2xVWlk7h+RZB6LXr4rhu5Aifm3450vYrU3ieBUimJ18gDD08t4nrNrDtCq3mCoHvsDj/FoYRlTSQUlKrzUT9kxstAHWmJ5/DsSvRZlAqtJrLOHYF37eQMsT3bVy3gePUsFpFgsBhcel19t43TLpg8M53oF6bJQxchFCYmXwed41Fubk4Sen86xSOPo6WyDD4+GdwqqsEdosw9BFrxKiKGcdI5VDXalS5zRqLb3yrzV5tpnQUNSrWdd2DoWUXWS6doy9/lJi5O3qr2xYqEknTK9P0KwTyB1CP4L8zzC68zsLS20A0lhEzKFyZepYgcJidf7Xti1kpnqVUmUDKcC3LVTI18/wGrSFkafU0q+ULbZ9SKH2kDFlYeht1rbLfRq1obvEkmmoQhgFB6DG/eJKFpbeiwmFr4c3F0iUqtSki555HKAPOX/oiAC1rlUtXvv6+j1O1FvLuez+YMsFCUzfT90tJsDGJUYD0faTrYowMY1++gt7Xg18so/f3ouQyUFdRu3L4q0WMoQHc2XnCepOgVke6m98V6fuEroNfr1I7/y7pQyconXyB4qvfo+dDn0YoCo3LZ6lfOI2zvEDfR38UGQRU3nkVa26KyqnXGPjkTyB9j8pbrxDrG0IGPoFjtR21QpEgg4gm33MJbAsZ+DQuniF3/+MMfuZn8Bs1amffJmg1iTLbQwK7Fe2IJy/R9dAH6PvYZ/FrFbxKCUsI+n/4cwStJn6j2pZfzasXyD/6DInRvVTefhW3tEL3Bz5KfHBPtFNOpKhdOE3XfY8y+Jmfwi0uU3rj+xEli7VmOQjDNYr9nSEMPeq1TlNZqxnx7gWhT+BHkXbVymTHMb5vUauuc7oZRhrXbVCvznTkwFmtFazWOo+fuyVdvuzghwtDbxM3nG2VsK3OTZQfVPFCwekX69itiOL+mubScY++y+LJb+I2ynQffSLSSPL97ZDxqAsy0hLDAL9VozF3maW3voNdWWmbyjRDId0bR092bqAct8H8ytuEoc/cytvouywnfEt5Kh3fo9Ad24MTNGn6pbVqh524Zv66ZgqQUuJcmu0wfwlVQ81kIAzxq5XtO6IoCFVFencF2F28P4if2EfvL/woWneu/Z10Pa78/K9EPhPAPLCXoFpD6DpIid7XC6qCdF2EquJcmcIYHUbJpHGnptEH+rHPXohoYfaN41y+Qtj8wZIXGoUkqb3dyEBizVWQQUjg+GhJA69iEdh336k/SegxhUNPFAgDyaXXS3jWzTVvLZ4iPXQAs6sPLZFG0YwoMtZz8Vs17MoyreWZtfDt3ZuRhFDJJAepNiJB/b7lqWxEVDg3JKFlaflV4BYziAUYff0EtSogUJMJAstCTaWRnhvVolBUglYTxTAi1TqeIGg0UOORvdGZvznp3l3cxZ2Ac6mT986b32zys06vE1N6s+vcc9apzeWAfxDQMzHcskXmcB9GPoFbbBLrz0RBCFeL1C8s3byRu3hf0Sx7LE408O2dmXJ9q0H58tt37Prp5CCWXSKfGQeioIV0cqAtVHaC2xYqAoGhJBAIVKHi36JPRfo+oW3jNxpouS6MQsSMGqntDophElpWJFRiMbRMDntuhvjefVHMe3MtWUiIiORvg2YlHW9zRI4AoWkYo33E79mHuacfNZ9FiRlR5FHDwltcxZlawr4wjb9SRrr+5nZ2NEgCoakoyTjm+ADGnn6MkT7UbBIlGUNoGtLzCZsWfrGGO7eMfWEab3aF0HZ3XYK0DU2NTDnXEISbC2ipCmomSfzIGOahUYyhbtRUAoQgbNoEtQbu9BLW2UmcyYWtx/J2IARCV9F6u4gd2oM52ofe24WSjCNMfY2s0SFsWngrFbz5VZyrC3jzq0jXi6KKbqU/imgX2xJi/bMSN9B6uyI2zetPiZtb+kE2YS268bb8i6qCkowT2zdE7MhY9FyyKRRTJ/R8gmoTb76IdfYq9sVpwpbd1qK2Q+j4ZA51E9g+geXhWx4ykMggxK9tyPLeNG8CpLfFfasKajZF/Ng4sUOjEclmKh75miyboFTDnV/FPj+FM7VIaDlbBidcg9C1qHgORFY3Z93cqSRjJB44ROrRY2g9uSgCdWKe2vNv4c2tbM5/UhViB0ZJP30fxkgvAN5KBevUZVpvXSCo3QHaF01F60oTO7yH2MFR9IECajIeaayOi1+q484sYb13FefqfDQnbpCnJSXE0hr7H8lz4aUirrXNWKlKNFbXEMotzakoIppDB0eIHd6DMdqHmk4iNJXQcQnLDdzFVZyJOewLM4SNFqoSlQ/O5/ZRrc+iKNq2qRDb4bbNXyDoMgcwlRRFZwov3EwdsRPzF4DRN4BfrxEfHYuiPgwToWsE9TpqOoNfrRC2WmiZbFQuc3aGxIGDCMPEKxWxr05gjPbR90s/hd63ztsz949+DWdiPQFLJEwSJ/aR+dijxI+Mtak1toWUOJdnKf7et7HPTu5kuKLrxAyMwW7MAyMk7j1A/Nh4tFDuBFLiL5epf/9dGi+9i7dUuumi0QFVIfuJxyn8uY+1v2qePMfqr3+FoNoAVUHvL5D5yIOkn7oPJX2TypihxJ1ZovadkzRPniOo3H5BI62ni8S9+0l94B5iB0bWF5SbQUqCSgP74gzNN87hXJnHXy5tvfBdBxE3iR/fi96dRe1Ko+bSaPm1f3NplGSsvSHZOOflmnN7J/CXy8z/b7+Jv3STEglb9U/X0Id7SX/wPlKPHUPtugmFi5QElTqNl05Tf+ld3OmlG8+TrYgGNnwnNJX8T36E7GeebP9cf/ZNVn/r6+tReUKgD/eQ+chDpJ44gZpJ3qSPENQa1L77JuU/+N7W/VMEfX/nz5J8+AgQ5frM/i+/RlCqofV20f3znyRx/8FNNV7ClkP589+l9txbSDsSQmo2SfbTT5L7xONRmPd1cCcXWf3Nr2Kfn7olwS/iJubeQbIffYTEvfs3sS5sQijx5leoPfcWzZPn8Ze2DkjRDIX9j3aRyOi899wKTnPr+Zz6wD30/uLnNtzPAgv/7LcIamvmVAFaPkvyiRNkP/YIWk/upvckbZfGK2coff67UHVIxPLUW4tRuezcQZbXuL9+IOYvXTGJqSm80Olg+rwVuEuRieAaU6zR1x+FMRom7tICQig487M48+vOK2vyKlom2zHZhBAdAkwrZNtCRUnF6fqxZ0g/de/NX4b1BiMhtdNFXQhih0dJPX6CxL370fryu68xIQR6f4GuH3uGxP0HqHzxBZpvXbzhTm+LJjr4i/TePErCJGhaJO8/SO6zT2OOD+yM40gVmGMDFP7CJ4kfHaf0hWfxdkBDsl3H4vfuJ/fpJ4kd2oNi7HIaCoGWz5B67BjJhw5jnbnCyn/8yrYv60bofXl6//pnox3lri4pNi1oN+rfbiKWrkFJJ8g88wCZjzyI1l/Y2ZwRAi2fJfeZD5B44BDVr79C4+XTEX3MVtiyYtv1bXbOGyWVQDENAscDTSVx/0G6Pvs05t7BHfYRtFwaod84NHXjeysMHWOwG8fzKPzMR0k8cGjLa6nJGLkfe5qwZVN/6V2EoZP95BNkP/Zo525+A4yxfrr/widZ/rUv4l7deUkMAK03R/bjj5F+6t6O3LsbQhUYI30U/tzHSd5/iMpXXqL17uVN64lQIh+60wpuPH0E6xo20Vgp6UQkVITA3D9E12efJnHvgU6N80ZNxs2ICktKgtCl0YpqWIWh1xYoO8VtC5VA+jhBC8uv4Ye7j84xCr1o2RzW7CTyOu51d3kJoWrIwI+c81ss6kG9Fg1Ea3un5zWHq5KIUfi5T5B+4kTnhJNy83t13S7VrzZwdjoBpcQcHyL99P0osa1DKm8k8TdeWygCc+8QhZ/5OEHDxj57ddvzbgatN4eSiJE4Nk7h5z6xluC3npB6s74AKLpG8rFjiJjOyq996ZY0lsSDhyn8uY+hDxQ2awM3QMTbeN3bpiqELTsy//w3DCVuUvjzP0zq4SMocbPTfLvDuaIPdpP/6Y+i9+Upf/EFwsadKeusptZMkYogufbstN6u9Wvf5P0BCF0/yvPZ4cZM6Cr6cA/6YDeJ+w6uXWb9KhvbVzNJ0h95COvsVYyRPjIfeQhh6luOm1hbjI3RPjLPPEBx/lsdeVE3glbI0vPXfpTYodFNJRB28oyEohA7Nk53d5bSF56l8cqZjvGQoUQzBLkBc0e0Ue32DR01ncRjFWO0l56//BmM0X7EBs1/u7Fo/x6EOFOLBLVWRMuU2ctC8d1N5+wEt5+nIiV+GMVSC6HAFhn1N4Key+OsLJI58RBepYgMAqTnoeg6CIE9P0Pq4FGUeILQcQisZmQWQ0QUKc0GscERrKkJnOWtF32tpwslYdL1kx8m9fiJSCWWktD1CBsWoeUQWi5h04p8H6k4StxEScRQEiYoCq13Lm9tt9wGrbcvkPnoQxEtiRBRkuKarya0HPxiFW9+lbBpIV0fJRlDH+hGH+xGy2c6hJEQAq0/T+HP/zAL/+Q3EIZJ4sjhyN/UatE6vbOdhJKIET+xj8wPPYy2xmslpSSstfDLNdyZJfxiDel4KAkTY7QffbAbNZdCaOr6JBSCxIn95D71JKUvPLurcTH29JP/3NMdAuUaw0JQrrf9JkGtifSDKGckncQYLEScWokYSiKG0LWodk7LpvXuZcL6ziKppO/jr1RuuOAKQ0fNJBAbworlmjlyJ/BXq2wqw3kDKIkY3X/lM6QeP96hIUgpCVsOQaWOO7uMv1IhaFqoa8SVxmA3alcm8sutLZZqIkb2k08gDJ3i736rbRICIhYAIaKql/bOBY6SiqPEDGKH9tD9859A7cpEFrMgJGxakVC3XcKGFT2zZAwlGZ2jJGMIQ8ebXcbbhTlQ6BrJB48gDA2ha7hTi9gXpgkaFvHDezD3DbXfESEEsYOjxE/sJ/PhB1FScaTt4kwuYl+cRgDx43sxxvrboeJCUYgdHUcf6MadvPlmUevO0fc//DjmodHOxdgPouJspSrO5CJhtYEMJGomgT7Yg96fR+tKtzexQgi0vjzdP/cJQsuh9eZ6uG4iqyMlnP72Mo6184CnSKgk0Lpz9P7i5yKBcu3dbtmETRtpuwRNay3x2EBNxVFiZvR8YgZBrYlzZQ7CEKGKiJJK0SOWD7amvNp2rHZ85DZQFYOM0YMdNPBCe9e5KkJV0bNd7YQsLZUFAfbcFEZ3X6TJZHKErotiGGiJVCRYYnHqZ9/B7B3Er1VuGMuu93WRfPwE6Q/ci2JohK6HPTFH6+2L2OcmcWeWIydi+wQVvZDFHB/EPDCMuXeI1hs3pjC/Ht5CkeYb58l9+kn8ch3nyjz2xCzOxRnc6aVtHYVad47UE8fJ/NDDHX4hIQTm+ADJhw5Tf+Ed3PkFUKIFYqcQQpD/8Q9FjlghCF2P1tsXqT//Nvb5qc0mEyEwRnpJP30/6Q89EC3m19RuXSPx4CEar5zGubJ1lc9NUBUSDxzEGBvoeDGDYo3qt16n8eoZ/JXy1s5MAUo6iTnWj7l3KAp4GBtAtmysM5srkG4Hb7HE4v/+uzf0o8UO7aHwMx9F69pQbMrzWfjnv31dUt42CEL8m/CDXUNkrnmc5ENHOgWKH2BfnqX+/Du03r6wJd+Ymk0Rv3c/mWcewDw4gqJHASpCFWR+6CG8pRLVb7wKQYjQdIzevig4pdBN7Z03d+wjUlNx9KEeuv7MU2j5KBHOW6nQevsC1pkrkU9rpXJd35Logz1RoMGhUdy5lW0TYLccF0UhfmwckDRefY/ib3+jPQbVRIz8n/0I6Y88FN0zkUbf9Wc+gNZXIGxYVL7yEtWvv9LWQtRcit6/8TkS9+5fu4BA78+j93XdVKgo6QRdn3sGc/9wx0YobFg0Xj5N4+XT2JdnN5umFQV9sEDmg/eT+sA9aIXs2qUFajZF4Wc/jju70jbb5vpjxJIa+x/Nc/a5VezGzgSLYmjoQ90kHzmKMdKHEIKg1sR67yrNt87jTMzjLZY6NjpKwkQf6G6vcYqht6m3pAxJmHmG+x7GDxxsp0KxujPiSrgDQsULbZpeGU2JcSteL3thFqHruOVitDMsrrQnu70wg6JqNC+djTQYWEvqCRGKQmjbOMvzCFUjdLevLRE7MIIx1IOaTiD9gOo3XqX+3TfwlrdZwLwAb7GEt1iicfIcencWb0M29U5R+9ZJ5Jra784sRw7ym8BfrVD56sv45TqFn/5oeyJeQ+qJE9RfeIfQsojt34czObVNS1vj2o4pdD1q33qdylde2p4gUUrc6SVKX3iWoNEi/2d/qONnvT9P7NAenMnFHUWoCUMncd/BjsUztF3KX3qR2ndP3tg0IiGsNbHencB6dwIlFY+0HUPHX63c9Npt+MGmBfB6BL1b+892HSyxA8QOjERm0g0BHFJKWmeuUPztr0d+q20ihoJqg8aLp3Auz5L/yY+QfOTIunalKGQ//iju1QWss1dBStREktCJIiw3QusuoCSTePMLW3JIqZkk+c99CH2oB6TEvjRL6fefjRzdQpB58jgAtedPYYz04swsE1SbBNUm9rlJlBfeRqgqYWt3hbiFquDOrVD+w+c75mjYsqk/9zaxo+OYo33t7/WB7ihB883z1L59ssOsFVQa1L5zktjhPe2xVgwdvb8QBYhs91wVQeL+g9HYbvBPSNej+DvfxH9zmqDZIKP34NIirmex/ToxNUXdXcabXaH0hWdxF1bJ/8SHO95nvb+b3KefZPU3vgKhZPZcHVVXiCVVfG/n80yYOpkPPYiSjnw83mKR8hdfoPnG+W01+LDl4EzM4UzMIb5/CjWbJChFY+yHDsvl9U20t8MS6NdwR0KKY1qKKA1ydxwxAH79xov1zfaF7VDibSCIdhrKmkAp//6zVL76chQevAUUoZJJDqEoOo5bRVNjVBfnUBQVKZTI7LZWOxsAGZKId9O0Vilk9+L5NpZTRiDwVqvUvvQyoech1ojidqRGBiHNV9/D3DdE9mOPdJhh9IECaj6DmkkjgxAltUVN9ZtAhlH75S++sCOzkbRdat96ncSJfcSP7W1/L1SV2OFRas++gdym5OlGCFXBGO6sw+POLkeaxi4X67Bh4VzanG0sNDXKdt9BJNifNETcJPX0fZuic9zZFVZ+7YsEpR3s7KXEm19l9Te+ilbIYh4YbmuTWk8X6Q89gDO1iHR8QsfBXVlun3cN5vgY3tIyaleOoLQ52EHoGvpaWK51borV//RV3OmIuy7zwXsQhkb8wDDVZ98i/cQxvC91mhfD2q0leUopab19cUuzozO9hDu9iDHS26n11po0T54jbG5eCL3FIv5KGWO4t/2d3p/f1l8LkTaY/aGHIy64a/0KAsp/+Dz175+iSx/ASORJmz3U7CWK1jT9qYOUrTlSRjcVex7p+TRePIXeX4iiYK/5cwUk7jtA7OAI9vlp9j/SRWE4gaoJrr5d3baM8PUQioK2ZtXwizVWfv3LWGeu7jgVQdou/gYzaRgGNFrLKIqOEFEZkd3g9sK1AFVoOEELO2gQ3jLh9/uIa+YaCY3X3qO6pj1sh5iZQyIp1SbwAgehqMSMLL1dR+hK76GQO0gi3k0uNUIuNYKuJ0jFe1EVnUSsQBA4mEYGQ0+RS++hN3OYQnYv+exeYsbOOXSk59N68zzBhpdTCIEwdPSeHF6xBIEfseTuAlJK/DVz0079EBDtbOovvrtOBrgGc3wQsUVOx5YQAsXoDFyQjrvre9i2eUMjeWIPsdEetK5U5OztzmAM5tF7shj9Xeh9OdRkDL07g5qJo/dkUDMJlLiBmt5dRNjtQu8vkHrkaMeiGNoOlT96rm0qSqcFmhb9eyME1QalL3y3Y3cuFBHlYI0PRCHk3d3Ex/YSGx3rOFcoCkrM3N4ctta/oNqg/EfP4U6tk6EqcRPr0iySKO9LMbT1yCVdQy1kETEz0gZ2GQEp/QB3emlrn10Q4M6udOYNSUlQbeJMbJ0EHbbsTWZJNZu6YSh7/Og45sGRjmdkn5+m/uI74Ad4gU3G7MPxWwihoCsmINDVWAfJpPQDat85iV+pt53mYi2KMXHPAVAUrr5ZobJoUZxtEe5mk3VtjQtDyn/0PNa7E7ee2wYYepIDox/lxIGf4PDYpxkdeHxX59+2ppIxepGEOEFryxyVPy0IKnUa3z+15Q6m47jQI6klSCX6UISKaaRRRWSrNvU0Qehh6hGhnKrGUBWDmBnRaVtOBdutkU4OoKkm+lqBH0XRaVlFLGd3eQvuzHLkaN0oi1QFETdR4nECy9p9qDLgXJrBmdi8y78hpMRbWCWot9Cy69qRVsjsLr+kZaMZG87v6ULNJnfsBL9Z+6HlgqaSPDpM6/wc6Qf2IXSV0PFQdA0ZBNhTKxj9OaQf4ldbeKU6WiaOEjdonJq8/X7sEMmHDkeRXhvgTMxhn59uL9rHj+t4vqRUDBkZFdi2xPeh1ZRYlqTZXF+47Isz2OenSNx3oP2dlk0RP74X5/I87uICzsLmBdeZmkYr5G+6EFnvTmzyXzlTSyTvO4A50kPhpz5E0LDbmzZ9sBfF0PH9EtreYcJ6E2k7KMmoSJeIGfgrZcJtzMJhw7phkqJfrEZ+jLWdv2Stls02EYnS8zeZ4K75Cbcz3Kefvr9T6Hs+rXcutq9h+3WWG5fwQw9JiCI0KvY8MS2NF3SuNf5KBefSbAf9j9BUjLF+1EwS4bQwExrNqndL+bzO1XkaL99axNZGKEKlZZeoNxcp1a7Qmz+yq/PvSJGuhJojpeXxQwc3vL0wxkx6BFU1qNVnCAOf64MV4/EuLKu0nhMjroXL3ShTVeJMLWJvYS65Hq5bpxy47TYtpxwV2GqKtb7IdptCKITSZ2H1FEHoUq5NEoQe9dYCAgVJdIwMA8JdRsUBBNUm0vPXrrUelqjEDKTnETZbhNYux3utLshuKjBeQ9hyCGtN2CBUUNUoy3snl/YD3JkltNwGodKdJfvJJ1j9D1++qcC/OQRKMoaWTUAYkjg6gjC0SNAAoReADDGHuwGJ0DW8iUXclSrxvX24y9VbGpdb7CrJhw53fCXDEOv8FP6GRTaTEYyMapw86XLPCQPHlSwuBoQBnD3ndwgV6Xo03zhH/N79nZF69x2g+o3XMYdHMXr7kGFI4/Q77fO8xSX8YinyVd5gj1L79uubxse6NItfbkQ+w6YdbYTWtKVgpYR2cAy1JwrEkX5A/L7DhLaLMA3s9y5hjA9hv7M1YWFoOTcMFQ9bdmeorCTyk26zIssg3MQZKPQNmtV1UPMZzH1DHd8FlbXUgjVNwg8dqs4WFD1eha0ati5MkXz8eMd3el8eNZfEn2lw+fUyuf7dle+FaD2qP38qYuC4TYQywPUaCKEw3PfwGnntznHbQqXk7HLHexPEYl1Ua1P09twTFdjxmoRrtUQsu0QyEb0UmcwI0QIv8AOHSuVKB5toB4IQd3ppZ/4DJH6wPpF3ooW6a9cN1mrJ7PYhbN+ZKOy5AwKEHtUiIQhQUjtM4LzWZBBGDtZb6Y7vE24R068kdlY2Wbo+rTcvRFUVtfXQztTjx9G6MlS+/CLOxHwU0HALWzXp+TTeWotSueb3upFJ55oZwtDwinXcxcqur3mr0Hpy6L1dHd+FDSvKiN9g0imWQt5+2+P+B3Rm53wW5kNUDcb2aJRL103OUEaLe6WBtiET3xjtR0nGsKeuErQaCHVzxGB7sd0mWc5freLMLG/6Xk3F0fKpKAxdVzHHB7DOXEX6ASIRQ64JIdmyUXQNb255LSE5hz7QQ1Da3qcqHe+Gi+Rm2qSIXWBbhHJzwqG6gdn3OsQPjUaUTxsQVBp4CzdP+t1uE+luMYZaIYuaSpAfT9C7N0m216Q0Z+PtkP8LIKy3cKcW7simyPWaFKsTaFoMP3Cot3ZX0vpPXTlhRdWIxwsoioIUOmqgI4OoSI0QalTcxm2gqiaOU4G1mtRCqGxHZik9P6opThRY0K+OYRDZPC1ZZyWMTAIaOhmlQCn8U1QXfKukJVVFy3chNG3brOHtEBSrt54oKOXWJpKb0dxcQxjSeucSyceOEdsQ7y+EIH54FGP0c9jnp2i9cwnr9EQUbbXbl6Rj53qDczf8Jv0A6/LiZl609xHGUO8ms2HQ3Gzzf+NktNh/8xuR2UYIGN+r8uab7pa3FzYsgnK9Q6igCIyhbpwL86TvuZ/Asqi//cau+utOLW6Ze5N88CBaPhOZojZcDyBYrRAUq1s+h3Cod41aZ/sxl75/42ciw04DheQmc1tuwR6w/dzVR3o7Eggj86q9TodyC9iK6UCYBiJu0ljwaL5VoTCawHN2Z9nwVisEu/CR3gi6lmCo50FcPzI9Jsx8u9rsTvCnTqiUSlHxqGZzEUVo+IEbFZ0RalRkp3QR08zgeU00LU6pHB1/I+1ABmHbNitQyCv9FIN5LNnEZ0PUAyGWvANEczeCECipOEZ/Aa23a41UMkoUE0ZUAVFZ+xdDxRjo3tRE6LoRxbqm7jqk2C/W7igfJOyOkMRbKlL54xfp/sufQctnOsw0ajJO8sHDxI+O4y2VsC/N0Hz1PaxdZGLfEsKd1/q+U9C6c5vocULLvilDgZQwMx2wXeWHsGVvGbqu9+dxzs8Ret6mYImdIKg2thTw/kqVxOFR1GSsveFoKMr62r3NZPMWtiCBvA4yCLeNytoOmzT724De2xVxp2yAOT7IwP/0s7fMFbpV8TehCJSYwcjxLJUFi77xBMuXG7vTVJr2DQOQdgMhBKqqI70wqkq7S9P9HRUqEZtlFImwrSnqJnDdG4dRBoGD49QwjBSe19zZdcIQuSG5USLxcPFw8NZMVinRxYh6EAg5558kTpLD+iNYso4pkkz556jIZdKii0F1HzoGVbnKfHCF4EZ0/4pATSfQB7tJPnCY+Im9ERfYtQz1jZxS11bn63ZPWznj/VIZM5Ui9cB91F95/eZjsIagZW+t/WgKakwncPz3Nxw3lLTeushS5ffo/vlPYYz2ReWEN9yjEjcjJufRPtJP3483t0rtuTex3p3AX63s+OURCsTiSpSoFoCmC3xPtv8NguizY/2A/CgboGaTm56z9IIOZt7tcKNSQqHnE27RhlbIIoOAsNXaXIBsBwib9pbywRjIY1+ew7o8155X4U40vp1ooFuYq26K4A49SyVKUOzYMYnoXY4f37vtabcKoWmU5yziaY3Jd6p4OwwnvoaIsXuL91YRUTBIGLZ9izfDtQClll26BQa7OyxU4uk+dCNB4Ds3LNd7u5AywHF2l4y4ccB1DHqVEVwcKuEyxXCBhiwzHZxjTD0aHSQEmtCY8N4lKXL0qSPU/CJD6j5askEDj5zSSylcpCm3FoRKKk7y4aOknjgeESfulKF4B9C6C4SWRf21k7s6b7tFKzXaRfZwL42pMpX3dmf+2/VrLCXOxByL/+p3ST99P8mHj0TkhBsWu2sCVxgK5vgA3WOfwl8q0Xj1PZonz+FO3dxclSuoPPCBFI4dsrLg0T9isLrg0TOgMzPhICVkCxpvf/991k63gGIam1W8IGjfk5JKoRgGfnWN8kVR0HI5glrtxiHYW5U3AETMQGgaQaOOktidHw5ABlEV0OvhrVSJHxohcVht+0/cueKuNYxtrrrlNX8QEJqGUNUtN3TvzwVh8VLzlnyJQCR8tzBNK4ZO+t4x/EoTZ7GC0NYIO3UNv9IgbG6O2A2lj+1UuNWxv+OailBUAv/2QotV1WyX1X0/4GAxHVygtY0wAECCI622RqOiRf8XGp50cKXNQnAVW24dsaT1F8h/7pkobPQmjmwpJdJ2CW0X6XqEjod0PKTnRRxH5mZzhaLrUeVBTdsV99Z2O8TQD1HjBnpy95Ent4qg0qDylZdovnGexIl9pD54L+bYQIdwuQaxxtqc+5EPkHzoMM3Xz1L9xms3ZCnQNIEZE7QaMLTHwIgrxBMKQoCqC0b2mkxd/BMKg1e2YDKWsr0wx8bGcBcXUDMZtFwWv1hC7+0ldF3UeBzpOAjTRMtk8JaXCer1tSbW29gIoSj4jXq0WbqDpkT7ynwH20TiyOjOfWx/mqGITZrkf4sIbRe/2sRZqpA4MIBft4jt6aF1fo743n6apzebz4PQx/VbpBK9QFQcsVzbOZHtHRUqYejTrM4jlJ03K4SComhoWoxsdoxsdgzXrTM19b072bWbQkFFQ0cRChqROSa8TlL7uDjSJpQBtbCEQGyZ8KkPFCj8/CdJnNjf8YJdI04May2sizPYF6bw5lbwV6tRlIsMo43KhtodQ7/y17b2qzgu5tgofrmCMzW96ffdQjU17KU6gR+QO9pH5dzSjjcqN3/1Ip9YREwXdH4XBHhzq1QXitRfPk3swDCZZx4gdmQsIgzUOneLQlEwhnrQP/MB4if2s/xrX8Sb3bqvq0s+z36pSuCDujYlo88CXYdcXmVp9gdT9/56REl713VaURCaigTcxUXM4WGEYWBfuYoxOAisceUVCsgwxOjrI3RsZBi2hYpQla3pzoVK+p77QUr0XB579tYiADu6GzfW5u36fWiFDEJV/oT0izuIUG7SGqSUuJOLtE5duuOXixJK359Rk37Y3kxq6TiKqWMMdOGXt96Q6WqMhFmgWL0c3bO/O03+jgkVRdXJ5Pfguy0cu4prVXZ0Xj5/gO7uowShh6JozM+9RqOxuxoHu4FEUg/LBHTu7vNKHzmlh0CGDKjjlMJFamERAF961GQJiWTKP8eQuo9xrYeWrLIYTOFvyNIQhk72U09EtQyuoy93Ls9Sf/bNqMjVTiI1hNhWsxCagjBjdywbHSRqTEPPxqhPrKLoKqG7M9/KzV4FXY3Rk95P0y3ScsqRMJEhhfQ4dWuZQHp4gY1fa9J68wKtNy+gD/eSfOQo8WPjUVXOjUXEhEDoGub+Ifr+5udY/nd/tGVdDBmC3Yp6522QHZ4rCQzBO6+0cO0/meUvbFqbFhGhqSi6Rggo8RihZSHrdbRshqBRR8tmURJxvJUVtHwX9uXLKKkk3sp6mKpQ1S0jAoNqHevqBH69hhq7feYAoWuknzyBEjeIH9mDtCONz9zTT/mrr912+3/SkH7EVrExRwwZ0QqVfu/bf7Kd2yVaF6Lo1tprFwFIHBrCurK4re80lAGSgHisizDcYvNzE9wxoRIGHvXSFKoex27svHiT79vUG/MIBJnsKMlkH7Zdxvffn/oYkpC54PKm71fDeVbDTrbdZhCZxxxazAbR7sTDYTI4u+n8azCGe0k/ec8mW6x15grF3/5GtCPZKRSxvRogQTFNlMRNKjbuEF7DRdFUAsvDKbZ2LFB21HZg4QYWTadEKtZDXM+wWr8aVfdUVLLxIYr1Kx35Qd7sMpXZZerPvUX8yBjJR46QuPdARwa6WGNRzn78UYq/881d1Q/x3FsTJpmCRvdwjPKSS3mxU8vJ9epYjQCndXPzkl+uI0PZ6Qc29MhUWqrhzmz2Sbqz69nwfrG4ZbvC1Lc0twa1Jom9Bwgcm6BRvyln3s0gPZ/q994hcWKc5hsX8YrRu9L16cd3xuT8px2hjEKHo1S4CIL1yqA3q/0jFAwjTRh6eN76BlLXU6iagevUQCjEzCxBGHEDel4LKUNMMwNC4NiVWw54uhGsicUblsW+FnDluHXCMPjBE0puhJnIoZtpkCH18s5MMtXqFI3GIpoWp1qdJpXqZ2j4caYm181fQhWRnfjacxS0P1+L+NsJT+PQiMrefRpXr/jMzQS0C/RJSCQFjzxu8uy3bK5FepqmIJkWlFajTOMw7DSz7tmrsbocUK+tT7DkY8c2vdTeSpnyHz63O4FC5Mzdripj5EcJuVOOTCMbp3xmAbdm49XuvECXhAgUEnoXiqKQiGVJxvJ4oY0XNogbOWxvs48rKNVovPwurXcvEz86TuFnP95RXEyoKskHD1N/7u1bTurcDfIDJpohOPpYlqXpKJLOtSXpLg3dVFidcwgCycLEjV9Eb6G4SQtVEmZUPnh2c4LcTqEkYh2MBdfgTi3gzZRBKASt2y8FDUAQYJ2djBaotXupfvuNXbMR/2mFt1RcW1jWEnVFxNigZpI3ZRzX9STZ7CixRJ65mVcQioaqGnR3H8G2y8QTBZASVTWRMlpf4oluFubeIJPbg+c2cJ0applBKBq2tfM8kZvhRgIFIkLJMPRIxrtBQsvWqDW35lPbCrcmVLaR1HazTCIzQLOy8w6kUgMUCodx3Tr1+nz04JR1x7QeVzn+2b0sninitgJqc00KezNYVScqhmOqpLpjzL9bJHBvLFn2jGksLga4juSBRwxkCP2DKvVayLkzHqmUIJkUPPBwFJkzNx2QzgoOHNQxzMiEkssrNOohYQgDgyovfM/uECpRDYjrxuXc1K4FCoCaSWwb/qlmM1gXJ9B7uhGxGNK+PUEQegE9j+2hOVth5dU7vzgX6xFn1HzlNAB9x/P4mQn8mTr5I3muvjCPmV6PjlM0BbfpRc9URhnDzdfew1su0//3fhp9A3+Skk5ETK8XZ26LSG8nMGIKwwcThIEkldWQSIZ7DSZONTj8SIb+vXFe/uLKTdtxZ5cJLbujGJuaSuyonviNoOZSqPlMx3fS9XCmFsGLoppC5w4s+orAGOzGne281zuVgPenAc7EPDIIOwJHtGwKfaBwU6EihIKqmShCQ9Vi5HLjqKpBLJZDygDbLiNUnXg8TxA4BIGLECq+b+O7TVrNVaSUmLEcvb3Hmbj8zQ3+yPcXYehRa0brlaroON7OagNdwy2xFKcfPbzl93oshec0drV37uraT7l8GYlkYPAhXLfF1OSz6wcIgWYqdI2kOfiRIYQCRlJj8L5u/n/s/XeUHdl53o3+dsWTU+cANHIYxMmZQ04gOSSHWaQokcrJQbItS7J813W29X0OsmxLlpVoZVFM4pCcGZKT82AGg0HOqdE5nT65TuV9/6hGNxrdDXQDGJJa6z5cJNHnVNhVp2q/+03Pk2yNoaiCdGeCWGYZDV0Cbtpu0NKq0N2tEosJcnmBDKG9Q6XQqtLRrRJPCnpXa+hG9HlLq8KRgx4bNmmk04JEQpDNKdSql3X0KhHr6KWQYYg3Pr20ZvgVoPe2LylHHLou8S2bULMZ1ET8+itVBPgNF79xA5rHNBW9px2jr3uRcUVloqn2OM2yQ3PaIfRDNFOhc0cLHdtb6Luni62PrSXTvbD01R0cp/bi/vlDFwK9u+37UnU0PeoyeNxi6JRFcdRhetTlzIE6QsDpd2rs/c4UifTV+0Ck7UbEkZdAxAzMtV2IJX7zq0JViG3oRb3MU3bODhM2nSjJ39qO2dWzxAGWD8U0KHzivus+zg8z7DND8/rbANRcGnNN17KetSBw8dw6qmoAklD6Ea+W20BRDYRQcJwKvtec/a+q6rNTiqbFSKW70I2Vl4BfF4RAEQqKUDD0JLl034p2vyZPJXHTamp7FiohBp6DbiRRF+EWWnIAepyWlq1oehxdT5BMtqPrCcbG9gHg2wEnvzuIlJLhAwpe02fiZBn1fJXQC/HsAKto41pXjz0ePeQSi0VMr+NjIUKBjk6FUyc8mk1JvRFSKYU06iECQbMZUimHBAFUKyHfezIKaTSbEjMm0DQxn39JiIUPWxAuWwN7HlQl0sKOL17i641PEFoWemsr/vT1M/wGTQ8taaDGrz8iqiTiKKkESjIBQ+OLS+tKsCsOqqmQ6U5SHU2iJ/SIaLEtTnPaxlxsoTBDSnlRqG32nHHjimyzNwpTww5TwzcmvFN/4wjJu7bNo6uJbVmDVshE4lwrhGIaJG+bzygrpcQ6cDpi6FVc1EQCNZHEGbrOikEBsQ09tP/chxZ8NfXXz81XUv17irDawDp6nvTd22cXR4qpE9+5nvqeI1dkP/C8BtPF0yiKRhA4lH0HVTOoVgZBhvhBVDWnaTGkDPE8C00zCcOAWnVwliFkeuoklVL/iuR8rxdB4DBWjCIKmhqjr/veFe1/TTOIV6ySfd8uvIkyMghpnhgEiISswgBFW/5Ka3LiMCBmYu4zusrh3CQsQ0l1dL5LbVfmJ0h9e3luYaUsqcxOO9H/P/+MTaUc/btWDWa3u3Sfixgfu+SHrSwyfQXhQgI8VYlWnpfkgZYDc10Pid2bFqWVF4qCls9h9q3CL16/QRGagld3GH3hDLGW61wVKQJzw2q0tsJMiHTxiz738jBypvv54JdPIwNJ8XSZi1xu83Jo8wYrUOKxBR5Q2LzILP3uQVFFVLKriHnPnFDF7LVEH0Tbhv6Vx2OfvIB7bmQeE67R207q/l2UvvbCyrrJhSD1wG6Mvs55H/sTJZpHz0MQohgxvKlJ1Ex2+cddCjKSZq68cGDBVzeSKuUHjeozb5G8dfNcr5gQJHZtJHnXdqpPv7VkuDUM/XlJ9iBwYZHqdc9rXLKNM/PZ3Hxn2+Xrv4gVwtCTrO1+DwCqalCuDa5o/2syKmHDRokbmH3tERnfRaOimah6DN9bfrVALr+OqcnjuO6lVv/7Z5UvNRo3Av74NEZny+zfF/sq1HTyitoQl0LNpcg9ejdGb9uiHb1qNoN0BmZDGtcLIxcns6EVGUj0tEHl1LUnigklzql+hGlE3fuX3F41l4oaO5vOvEk4nJFOjRZjV/49lLhJ8pZNC+6LNzz5rudTEnmTtg1pzJTO8MEiqq7g1n3at2QZP17GSGgEXkgYSBIFk/Jgg0xnnGbVRTc13KY/b0EU1CyqL+2npbt11iMViiD7yB04p4ew9p9aXu+CEMS2rCb3oXvmVQtKP6DxzslZMtXQaaIXCijK9T8zMgxpnhnGOTty9Y3/HsPtH6Px5jFS9+2c9YyFplL41HsJpqtY75y8auJ7KQhdQ82mViaH/a5D4PlNLoztQVOisF29ubL54JqMSvn5gxgdOfyqFYlIAbqZxq5P4lglwhVQvxtGmp7eu+Z10LtunZHhNzHVFF7YRFfiOMENqli5QRCqRqJ1Fb7dwKnM3fTmsX4SuzbO2za2tQ9z0yqsfSeu6q1obTkKn32I5J03LVn5RRiid3fiTxcR+jXG3y+BM20xtXcAGUriXZmr73A1SIlQFZR0ct4kl7prO+amVTQPn8U6cHqe7vhyIAyN7AfvIr5rw7zPg5qFc27k3ddCEYK2jVkEEMsY+E7A5Kky+dUpSgN18qtTFM/VUATEcwZmSseuumiGSudNOaYv1OZ72UGI9fYJkjdvIr57rq9JScVp+fwHEIaGte/kleloFIX49nUUPvsQWmt29hhSSrzJErWXDsy+o0LTUQxzjm/uOjw76fpUnn3nmvf/+4LQsqm+sA9zQy9G91wTspJO0PKTj6J3t1J78Z2rEoFeCrWQJr5lDfFdG5Cux9QXn3g3hn5N6G7bzXjxKEHg0FHYiq4lmSydoFJfvrdyTUal8NidxNZ0UnnpEMnta5j4q+eIJfLE0+3RCqY+iWsvQ18b8NwaxenTeO7cKv5ilUPW6KDhTZOP9TLV7CeuZYhp0aRX96ZIaFm80EFXTOygQcV595omL4dmJkBKYrl2vEaZ0I9e3MZbx8g9dh9qaq7BTM2maP3pD1PUNJqHzkRNVTMToBACVAUlESN52xayj9yO3hNRbks/UqpT0onLdLhr2Kei47CU4VkB4m0pCrujEIwa1xh4/Mi1H0wItK62SFo2neRSq6IWMqTu3kHy1i2ETRvn3AjWwTM4Z4bwJ8tIP4hCWBcnOyEQikDEDOJb15J+3y3ENvbOo62RoYzKjUclSX0VFX8CTRjYYYOLTQaa0MnrnUy4F1BQkYREIgiLMyIshcAN8Jo+oR/i1n18N6A2buM7AUZCx656NIo2bRuy5HuTlIYatK7PUDxfw236pDuTTJ2rzVtY+MUK0197gY7uVrT2/Ky+vN7dStvPfwzrlhNUX9gX6XAEYXR/hEAoCnpHnvQDN5O6dwdKMj5vESIdj+mvPI/bf8k7EQQEzZnQyjUZlIiyI7rvwZKLAjETBl/6MNdn0L7fsE8MUH7iVVo+936UVHz2N9JasuQ/9V7S79lNY+9xrENn8UZmJI4v6vkIgZpNYnS3YvS2E9uyBmNVVIAjTJ3mseXTn3w/kEn2MF48SjbVi+s1mCydpLvt5nffqBjdLZRfOBDRtCejShOnWcZ16oS+E91IzVwWB9j09BnsZmleHuUiFEUjrmcx1DhxLUPSaInyLoTEtQxCaGTNPJPWOdJG2w03KnpCw1uiACDwHBRVRygq6Z5NVC5EE7E/Wab63NvkPnT3bGfzxQew41c+jTswjn12eEZMKKp71zsKxNb3omSiRkZBRMNSe2k/9ukh2v/hJ+edW0o5J6p0AxrN7GKDidfPo6XN6+f+kpKwUkOs7SWYKi1sIBLMvlCJWzaTuGVztJvl4E2WCBs2oe3MNHfqKNkUensesQgZp5QSd2CM6vfeJFtXKftFCno3ofTxpENKzWEqSaa9ERQ04kqKhJKN8jIoqEJn0hsgkMvLATQrLvu/fG7B54e/eWGeoRg/UWb8RHn2epEwdba6pJfqnBli6k+fpPVnPoLeluOi5riSjJF6z25S9+/Cn6rgT1dmQs8xtEI6kqWdybnNW3TULMrffpXGG0fmT96qihKLXbNHp6ga6RnWDNeq4LsWmpmMFFB9F81MIsOAVGEV1al+Qt9F1aN5QIgZQyPAiGdw6tOoRhzfsb7vsgMrRhhSe34fSswk/7H7I/ZionsuDB29u5Xcx+4n97H7IZSETQfpelEjqqkvaAsQ0c7veg7wWuAHNrlMH8l4G8XKWVyvgbIC2i24RqPiF6ukb9+M0NRZUSHXrpJr34w6k6Rv1iawahNcLd5jGGlsuwKX0Ka0tGyhWDxBxRnDCRo4QQMpQ2ruBEEYsaUKEVGaW940dlBHLpMqWghIdyXxbR8tppEomDRLDkZKx617CCX6sZ2aR+uGLBMny+R6kzg1j1jOwG8GlC7UCD2H2tgZhFBIdc5RYUvPp/rc2xi97SR2b5wV+Yk8EhVzbTfm2u4rjlF6PrWXD1J6/JWIubbpIJaprngtkH5IrCNNZn0rfsOlevrqfRaXYkHRcCixT5yPVPOW+Pkvz4mIZAwz2bWi87pDExS/9Az2qUHy+npSWh5fOphKkriSIqak0IRBTEkSUxLYShIpJDElGSl8hs6Nqaq50iMul7ENYB08TfEvvkP+U+/F6OuKPLRLtGb09vwCpcgFp5KSYLpK+YnXqD6/bxEaGC0ifLWvlZVZEvpu1MSa68azayTzPdi1SVQjHnkvno0WSxJL5jFTLVHvhduIwnHNCp5dQ4+lCXyXTOtaymOn8J0frtD2opBQ/d6bhJZN7iP3ovfM5TvnPcuqmIlSXD8Vzg8Co1MHyaf7qFvjWM1JFEWnUl8Z4/w1GZXS0/uIb+xBKGKWVwbAc2roZmfU5i+WV+6USnfRaIwTzFJ0CPKF9RSLJ2j6Eftpzb36JOeHyyxhVAQta9P4XkjLugxe00cGkspwg9qoRfvWPGEQ0iyVSBZiZHuShIFk9R0dNMsOvu1TG7fwXZVUx1q0WHLBisMfn2bqz5+ixX2Y5O03RRVgV+kjicI+IG2H0uMvU33ubcJ6E6FrOOdG3hUNh0vh1RyskSpmYeUvw+W/clAsExTLC88xPElo2Sgxc7b0ekXU4lJG1YFNl8ZbR6k89QbuYEQmOeUNAoJQ+qhCIyDADi0EEEgfN7TxcVFQaYgKLXo3ilBRhLpiEaJ3BaGMkupj0+Q/dh/JO7chdG12VbskpIzufxDinB2i+KVncc4OLao5Iz0PJRZboNO+fAgUPYYeS1Gf6iffsx2rNIzdmCYdX4NrNxCqRuDaeHaNeKYDKUN8x0LRDPR4VHUWS7XiO5EWkpnI/v0wKkSFD7WXD+CcGyH34btJ3r0jIu8UYtnP8Wx4N5R440Xqrx2+4ePMtmqs25ZgtN9hfMCZXfVlCxqVoj/HIpJWEQrUKwGKiN7jRnMS251GyhApJOkWhY4NQ4y/vvzzX5NRUUyD+t6InExvy85GpYVQCAMfu1HEqs51kPsTpajb+ZL7flGr2XMtMtnV1GvDSCmJxfIEwfyHXi1k0FpySNeLdJgvv4i2PGomiTc6hXQ8nHMj+Jd0vIYNe1agRgZRiXK6K8HYkWniOYNmycWuuriWh111iWcNUm1xjIyOogpiBZPahBUlWeVcREcoKqoZX5TryB+fZvz3vk76nlOk7tuF3llAScVRDH0mZBHxvkjPJ7RdgmoD5+wwlaffmqc1LYOA2uuHQZ+JZTcdwuVUkUmJP12leXJ+d7w3Wlw0nq2aKmY+jldb2jhL18cZGF9gROUVdMQvRe3lAzSPnY94vHZsiBLLcTNSujT06AW9SDkuie5PEEbMzpZD2Ghin7hA7bVDOOdH5pXcenJu3IGMJtRLSUPnPvNBOky40X3x5cKxh40m9rkR1Eslcr3gRjHiLI0gxBscZ+L3/474C/tJP3gLZl8XSiYRhQw1Lbo/oYzyco5HULfwRqaov3qYxr4TV5RBELqOUBTUTGbJvEaU4C8veG78yQqh71EZOwmAmSxQnx6g0RhFhgHTg4e5eIPqmob0fex6MeJRklEOCwBF0GxOEdoOVmV87mWS4I2XaJ68gKLrkQT4wMQVBePCho1zZggRn8mxhfKKne4ykHhjxXnX5o1OI1dSNRiEuBfGmPiDxzG/+ybpB27G3NCLmk2hxE2Eoc0amkhRNIQZ4bTQ9ghrDewzQ1j7T2OfvLAy2YqLQ6ha2Kfm9xm5w5MRGzGR8Qh8yabdCXrXm+iGYPSCyy0PpNn/Uo2Wbp3xAXdWrK5nrUlnn0mtHDBwqknv+hiuG5JMaRx/u048ubIHX8hlBvYutcQdP/tBxr/4XQA6f+FDjP3RUwDk2zfj+w5us4LTXF7/hKbFaO/YharoyJmw1uTEEWx7Zn9VJfuR+yl85hH86Sqj/+6P8KfmH7vlJz9C6r6bmfhfX6J5eCFZ5LsBRTNIda3HSOWxpoaxJpegNhFKRL/RkYso29tbEaZO6Ebyn2GjiT9dxR2cRDZcpOcRut/fxjEtodN6+2r8hos9Wad+YfHfTkUnJ1qpyojMMC5SVOVCTiIxmwS/wsuqKGitWbTWHFouhZJOoMRMFF2nVe9m0h9GejMTZ6WON1XGG5tenkH9PkFP6fTc0Y2e1JF+yOTxIpX+lYnHLYaO3e1Uh2o0Sw56ex5jVQdaSwYlEYuo8f2A0LLxS3W84Qnc0SJcraxVUdAyWdRkKvJqxpZPpbTo4TSTUPrEtqzFn65EjadSIps2xtpenHODKInYrMckNBXpemgtOZRMCvvYWZRkHMIQYehIx8Xo68E+cwGjux33wghqNh2dTFOj3qBiZZYN+YcJajaJ3tMWLW7TMwsAVUF6QaTE2WgSlGr4pRreWHHZi7CVIpMVPPBwnKExQUtPjHLRo63HoF4OOPRajdsezHD+WBMpYeBUkw07k8TigpYugyCQFMc82nsNhs7YtHToZAoaR96ss+32FC89Po1jy2XlgVbkqaiZBJn37CC5cx1dv/JxhKLMky6tlQfRjRSKuvzDxuOtTIwfxDAyaJpJvT5GNts3Z1RmIKVEzaZIv+9WSl99diXDflcgwwC/WcdI5jAzBazJCxhtnWipDH6tghqLEzg2immiJdI4k6OEgYUzNIASS+BOjkX6GUIhdB2MVB4SEdlfGPh4xZXlNa4HWsLAnqzjVmxibSlYwqjo6HSqqyGQNGmQFa2LGpWESKPNyC0viTDEnyjhT8w/l4JKh3oLpWBlipbvNoSAez7dxaa7crzx9TFO7ilhpg3atrcy+vYYRkpn1T09WBMWnnV9zX/dd3QTuIM0p5p4o8XIu7ze8Ws6ifUbCe1If+V6jUo4U4QjPR9pO5g3bcAfnyJUBGoujRIzUXNZ/NEJjHWrCBtNtM5W3HODGO0F1OFxjLW9hLaDe24QQomaS4HnR9WOho7W1QqhRO9oxT51Hr29gDuwvGKc3bcZ/NQvptENQRhKyqWQ11+yefEZm6Z1Y13OoNIgqDSA/ht63JUil1f49OeT/PffqvLaUyUSKZVzR5oEvqRW9jn0Rh2rFhB4kbz22AUHVYX+kzaqKqiVfYpjHsVRl+nx6Blu1kMOvV5bUT3QioxKULMoP70PNW5SeuqtiMVppoZeN1KkC6vRjAS+26RZX96kmM314ThlFFXDNLNUq0MUWjZRKs33OGTTIWw6JG67icaeI7iDKydovJGQMzoD9bFzeM2oWMEotGKPDJLesp3myBCxjm6aQ/0oqk68dw0oCopu4owOEuteTdBsELouse5VWP1nSK7fjNB0KgfnT6jJnEYiG1U/VSYc3OYNbvJTBVKCb7noqSv3vVRlibzSgRP2oyDoVPpIiRw+LiPBeTR01qhbUVAYD2NkRIGKLBIXSVzpYskqMZEgI1oICRgJztGlrp3RcJAUw1GEgKTIUhDtjIdRrmSNthWQjAb91OT1swisFIoq+Mg/XUs6H4VEz70TeSSBF9IsNtFiGnIm3LHrp3aQ7k7h2T7v/OEBEm0Jtn5qE6qhMXFkgtNPnKXvPavovqObMAw5+51zVC5U2f0zO1FNlXR3isFXV9bFPAshUI04imEiFAUZhoSuHYWlhwbxpiaRNyCOJzQDKULUbCoKTzYswkaT0PWQno8wDMJag6BuQRCgxE1kw0JvLyAbNnpXVFYrbQejuwPn/BAyCFHSSdRMGq01H5VIKxA2GoS1BkpmIfvyUmhpVblpp8Ff/HEN25Ks26jxy7+RZVWfzp/9YQ3X+eGrvLpeDA4E/IMfn8K2JWEYGYRLMXmZIF2luDDvNno+WixMjcwtjBrVleUcV5ZTkVFcvfT0PoLLCBI9t45Vm0SGHqpmoupxgmV01mtajHxhI7qeiPQHZIBhLP7wVJ9+g9zH30vi9ptwRyev7vIDamsOo7cDNRVHhpKgXMM9PzzLTaQkYiRu3YpzfgRvOEr6irhJYsdGUBXsE/0EpajnRmvPE9uyluah0wTlGoHnkundhFOZojp0Aq9UJHRsnInI4LnTU4SuQ+i7OBOjKIZJ6HmosThucXy2V8UeG0KNx7HHhgkaNbRUmqARGSpVF3z819Zzz6e7kKHkS//2FK99ZWWl09vf20IYSo6/Mr1oe4A92UBPmmQ3tVM9u3BVvGZnmrbVcY5+p0EgPVwESZHFFAlMkWA6HCch0iRFhpKcYCIcQiKZCkfIqAUUVEzimCJBTZYwiTMQnCQukrQq3ZgizoXgOE0aMwqcJt3KGkbDflxsTOJ40qESFrHkyhomARBwywfbKI06nD+4dGnvlSCB4pCNGVcpDtuEM79dohBj7UNrQIHy+QpCVRg7MM74oQm2fe4m9LiGaijUxxtU+qtMHS8SL8RZ82Af/S8OkOlJ07atDc3UCP2Qvb+3j3t/866VD3DmQhMdq2nZeS9aPIWYiRjUh04zue8F3PEbU3KvmnEKO+5h8u3nsPYu7GlqvDq/KbJ58OSyjntxv/qLby36fVSGv3zYzZBnn2oyNhKgalAuSW672+BbX1MYGwno6FTpW6dx7LDL9l0Gre0qlhXyxsvOrDeTTAl23mzQ0qZiNyXHjriMDM7NO7G4YOMWnd4+FU0VVCshh95xZzkBhYCbduqsXqMhBAyc9zl22JslfxACOrpVNm/VyWQVbFsyMuhz8pjHRf09XYftuw06e1QUIaiUAk4e85icCGfHePvdJrmCgmNL3nzVYboYfZfOCLbtNOg/57Nhs04ur1CthBx426F6CdVUa7vCTTsNcjmFi4QLngvPfbeJ3VzZC3NNifrk7vVUXzoEQObebVRfOxrd4GQBVbvY5yCwPJurvcHT02cw9CRh4OI4VQQwMX5owXbC1LGPn8fZvZnEzVtovHEIb/QK4RVFIb5zA5n33425phslGY9KLss1modOU3nyFfzxaZR0gvyPPEL9tQOU/+55pOdjrOqg8PlHEYZB8S+eoPH6QRCC+I6NFH78Q4z86/9DUK6hqFqU/5iZqZ2J6KW1LpydN5TAuvY8gBFX2XpfYeYmwK6HW3n9a6PL0o8BiKdVPv5r66hOupx8vUSwGB9VKKmdK1I7t9Cg6DGFBz7fy7b3FDjx7EFwYUqOsEa9CU86KFJBEi6Y8MVMYtaRTWIijodLjAS+9C4p2Jjp/ibEu4wYyZkxJnUquNiMh4MURAcqKpNyZaGbdEHnx/79ZvZ+e5wLh6tcqS9vKYS+5Mv/7hQtPTEuHKnhz4h81cYanPy7Uxhpg/UfXEvr1hZW3dfLwMuDaGaUCyifqxC4Idm+DDd9dgvH/vZ41KcQSIqnp7Emmxgpffa+XGv7glA1CtvvJvRcRt95gtD30OJJpO9duRlxhYi19ZDu28rk28/dsGOuFGpCR1GVKxaWXAoZRtx+ihCzxXQbtuj82E+nOHHEpbVdxfeh0Kqw9/XomLoO/+jXMmzaajA04JPNKnz4kwn+4HeqnDzmEU8IPv3jSR75UJzhwYCmFVJoURm84M8alUc+HOezX0gxPOSjKvCZL2j8zZ/WefqJaMHd1qHyj389g6FH5LS5vMLkeMBAf3VWUuMjn0rw4U8k6T8btTwUWhQe/3KDl56NFvaRFotg63aDBx6O8Rv/aJrpYvQ+tXeq/NwvZ6hWQhxb4tiSDVt09r/l8N//UwUpI8P4T/5FFkWBgf6AO+416ehS+fpfX9u8tTKjIkTUtLZ1FfV9pwBB8uYNs0bFc2poRhxFaDOJ/au/HdXKwgT3Ys02QlGikr6n36D1Fz9FfPemSERniUYuc10PLT/5GEJTKX3jBeyTF1BMnfT7biN1/80ITWX6S98ltF3c4Qn0njbQVPB8jFWdoAhC28HobqUxI1+rd7fhT04T1qOuZN9uIFQdeUkRg6JEBTpXcqIMHTx/eZPHxjtyZNsN6iUPI6bQtSFJ98YkwyeX94P3bk2TyutUJ68tOVjojtG2Oj474YWEeNKhHpaQQuJKh4LowBUOTtDEw8GRFj3qBkBQl1VyopWGrCKFxKGJjcVqdTMhPsPBOWIiMS8kY8sGY8EFOtTVWEENIRR6lfWoQqUarDy/sOG2HEb8+pkHBo/VGTw2V10kQ0m6M8ld//wOpB8y+MYwlQsVNn98I6vu6cGtuYR+SGFjns2f2IQAJo9O0SzZnP3uOVbd14tQBOe+d57iyWnWvLePu/75Hai6QrgSMsmLEALViGGN9WNPj0EY4pYnZ7/Lbb6VRFcf4298h8CJJrV4Ww+d9z7G8Atfw61MkehaQ+uu+9HTeaTvUxs8RfHQq4SujWrG6bj7UVKrNmGkcmz83D8HoHruCONvPQMyREtmaLvlfSQ7+wg9l+njeymf3o8WT9F170doDJ8jt/kWSsfewix0EG/vZfKdF6kPXNmbUQwV1dRmvXs9HUOGktALSfRmaY5V8evzn3GhRBIVAFu263zis0leecGmVJy7t2vWaxw/4vLb/6mC70l0Q8xO5g9+MM7d98f41/+8xLnTHomk4Fd+M8snP5fkd/9LhXUbND7940n+4H9UefV5myAAwxCRJAawZp3GF34+zZf+tMbLz0UG4Ec+n+KzP5HiyMHI4+nsVlmzVue//Ycyp455aHr0W9Xr0RgUBd7/4QQH3nb48z+qEfiReGDzEu+hXpN879tNLpzzueeBhf1sqZRgalLyX/9dGceRvOehGL/0zzJ89a8aDPT7rN+osWW7wb/99WlOnfB45QWdf/X/5Nm/11mxlwIrTdSn4mTu30Z8Uy8dP/l+UAT26blVo26kCHyHEO86msoEXV23MTy857KPxcz5BrCPnSfz8F003ji0OOeOIsh+5H7UVIKpLz5O4825zmK3fwS1kCF5x3bqrx/COT2ANzxB4pYtCF1Duj5GbzveyBRhzULrbI2qVACjpz2iXXc9hKqjqBq1kVPoqdzsqXfvMMhkBKfP+gyPBKSSAtuRxGICbyZB9vCDMfYfchkdvfI9EgJufbQNJBx6boreLSk61iXYdFd+eUZFwLpbMsSS104g2N4Xp3VV9KDa0qIWRvd7IDw1u80488sbq7JE1Z/LC5WC8XnfT4bDTDL33JwJ5jzTkIBTQaSXMhjMnEMy+9mKIWDrvXnEu6C10hi3ePU/vbHg8xf/v6/M+7s5bTN1fP52Q68PM/T6fI/rrf/19nWNRwYe1XNHIm8lCGgMn8WtFAm9yJt2psdp2X4XRraF5kTU0JbbfCt+s45bmUJoOr3v+zSVM4eY3P8iWiyFnsogZyiIAtdh8u3n8Wplcptu4cJTfwZSErhOZFDiKbof+CShazP6+pPoqRzttz2EDAOs0X7MfDtutURt4AQdd32QqYOvYo32k9u4G2t8gNBZOlyupUzS61tJdGYYe/kMRi6OGtNwUwa57d2YLUmm3py/QM0XFH7rfxZwXYnVkDz/vSZf+csGtj03USoKfPOrDarlmXexMffdPQ/EOH/W4/CBGQqmhuS57zb5hV/JUGhVue3uGAP9Pvv2uLOGyLpk/y3bdNo7VIIAbr0ziuD4vqSzW6V3lcbIYMD0VIBlhXzqc0m++22LMyd9JseD2UhEGMI7bzm87/1xpiYDDu5zOX/GXzDZhyGz4bIFEPD0t5uzIbFjhz0URdDWoTDQH32vKBBPKGiaIJ1W8FyJc415pxUn6ktP7cWbqlLfe3KBIxL4DrFYCwIlqk9fKd/7DOKJlkU/F0IQlOs09h2nsKmP1N27qHzntQUrfiUeI3bTOtzhiajn45INZBBgHz5LYsdGzLXd2MfP4Y0VUbPpqGRTVdHaCzjnRwirDZJ3bkfNJAhtF72rFfvFtwndKG+kJTLIwJ9lEQDYvk2fpeNKpwVrVmtMT4c4rmRtn8bjTzSxHYmuX32Sy3ea9G1P06z7nN5bxndDeramWLMzQzyt0awtfIrMhErXhgTtaxO09sbY9UgbmqnQ1hfn47+2bgGR78k9JY69PFfBpeqCznXR/m2r4my8I0cyrxN4ko/96jqCYP7NHjlV5+0nJwi8JTzGhMr6W7N0bUiQzOl4bsj0sM3ZtytMDS0uXNa+Js69n+li6Hidg89GIc6Nt+fo2pAkkdPwmiHFYZtTb5Yojy/0wBIZje7NSdr74rT0xNh6XwEhYN3NGT7+a+vnPS8ylBx8dorzBxZy1fXelOL2j3Qs+PzM3jJHXy4uL4wmoKUnxrpbsrT0xDDiCs2qz9hZi1NvlXEaix9kzc40N3+wnVNvljn+6jTxtMqG23N0rE0QS6k4jYDJgSYnXi9hVWaeAympnD0cdauv3UZ23Tbs4jjTR/dgF0exS+PY0+NkN+yiOTGEnsqR7F7L+FtPzw42cG3UeAok1AdPzQ+byRCvXsZvRo2LbmW+1xhv78XMtnDhyT/FrUbPVKJrDbnNN2ONRVQ21XOHEapOZu12KqcPYObbKWy7E0VVr8hN7pWbCEWgxvRI+ydlEu9MEw9CYm1JnMmF+ZZKOeS//vsyE2MB1UrI1GS4YDpyHLDqiz+7maxCpTx/VE1LYpgCXY+qrax6FFJaDImUgqbBAw/H5703LzzdZHomPDY6HPA/fqvCgx+M89P/IE2jLvnmVxu8/JyNP5Mr/9Kf1ZkcD7jngRgffCzBoXdc/uqLNSbGlr9wn56e+x0vVnIpMwutsyc93nnL4Rf/aYYL53zSWcGz32ly4fy10edcU07FOtJPbG0nXrFGaLuzIlRShmhaDKdZwW5MsRyD0tV1G9ncmtm/BQJVuwIliZQ0D5zEe+AWUg/cQn3PYZDhvPppNZ9GMQ2M3nbaf+Vz86mpBajpJEiJmovq4P2pclSF0tuBXyyjtReovxQVI2Q+fC9KJoUwHJRkPAq5+QGB38SaHIgkP7059tKLWva1uuTeu00MXdBSCPEDuHmXweNPNFEEqMtYOW+4PUcyb1Aedxg8VqdR8rj7U110b0rSujrG4NGFXtqqbSk+9qvraOuLY8ZVdDPq5s93mTzw+YWKf54TzjMq2TaDj/yTtfTtSBNLRrrriiIQBrznxxfSyxx4Zor935tcaFQEdG9M8vFfW0fv1hSxpIamC0IJXjOgMuHyzBcH2fvtccLLDFWhO8ZDP72K46+WGD1r8cjPrWLjbTliKQ3NiJQ6nWZAccjm6791hjP75veGbL4nz4f/8RrSLQZmQkEzonvQvTlF18b5ejGBL5kcaC5qVDrWJnjv53suSrygaFHntACOvzq9YNyXQ1Hhnk93894v9JBpMzBiCooqCDyJ3QgYPFbjyd/t58KR2oJXpXtziod/ZhWpgk5lwuGjv7qW1TelMRMqqi4IA3Cs6Bjf+C/nGD4ZPQuh51A9c4jG4BmMXCutO++j4+5HGfzeXxF6LtXzx+i8+1Em33mBZPdaZODTGIn4zKTvMvzC1ynsuJue934Sr1ZmYt/zNCeWV4mmxpPoqSyrH/2J2YZCPZnBrZVm2wwC10GLqQS2NVtBGV37VRgnQkn5yCiVE+OEXkD15Dj1/iIykCj6IH5j4eIi8CX9Z33GRpa2/jJcuhZueiqktUOZtzZOZxTspsR1JNPFgHWbdGJxQaW8cP96LcT34Pd/uzLPOEnJbPgqCCLP4expj/ZOlQ9/PMHP/3KGowc9xkeDmeNIvvlVi5eetVmzXuM3/k0O25b8/m8vj7QX4Er0ar4Pti05cdTlu9+0qNckE+PBNZdeXxtL8cfuQW/NUHv9GKlbNjD2x98BoFmfwPebaHqCMFherf7k5DHGxw8AIurZCD10/cpCUUG5Ru2Ftyl8/kOk7tu9SF5lJgEchFHn8WUJDn86IucLiuXIfS+W8cu1iJNLShTTwB2ejMgRLQe9swWEQlCp4890WeuJNKmujZHbH0swOUN/PzoWMDgchb3eettl9w591o0cHglIJgVtbSqZtMLQsM9SjBm6qbDxjhyxpMrY2Qbj5xpMDTSpFh061sTp3Zxi6Hh9QcJ+8kKTZ784iB5XUFXBvZ/pZv0tWcbOWDzzxYEFnsbo6fkCaI2Kzyt/O8K+70R5sS1357nrE524zZCv/IfT+P78E5ZGnNmk9ezdF7D25gyf+3eb6FibYGrQ5vhrJaYGmiSyGmt3ZejdkuJT/3I9sZTKq18eWdTT6Vgb5/P/cTOF7hhDJ6J8hmP5dG9MseG2LKu2pviRf7WR//urxxg/N3cdQ8fqPPW/+1E0gaYpPPoP+2hdFefUnhJvfnN8tnILogTuwOHFq4oOPTvFfzq6l2ROJ92i88l/sSHKLy0DekzhoZ9exft/fjUAw6caXDhYxar4tKyK0bcjzdZ7CxS6Y3z1P57m1JvlRXNsq7el+cn/spVUQefCkRrDJ+qEoWTVTWnW3Zxly915Pvqra/nSvz45z2sLHIvm+AClE2/T/cAnEIoGuNQHT+Hvup/CTXdiZAtU+48RenP72cVRRl76BloiQ2H7nfQ+9BkuPPXnuJVLi2LkbCHGpQhdF69WZnzPdwnsud8j8BzCYM6buniMleJSw+HVHFhmkv5a8fz3LP75v8px7wMxThxxSWcUHv1onP1vORSnQva+7vDRTye5/30xXn6+iedBIikoFUOshuToQZehQZ/HPp3kG19q4LgS0xRoGlgzHmo2r5DNKTRqIfWa5NwZn4cejbaBqFigq1fDsSNDNjwYMDQQ0NI6lyMUAnQDzJhAEVHOxTCZ9XSuBkWJ8j9RTkeQyoCqqoyOXJthuSajouWSVF46FLHwzsR6VC1Gtm0D8WQrteklussXQUvrZqaLJ9G0BKaZplzup6NzN4MDr1xxv8beo2Q+cDeJmzdHE/0lb2RQriJdF7d/hMk//gbBVURw/OkqQaWO0ddFaNl4E9OElh016I1OzhD8KVEZ8QyBptesUxk4gpHIosXnSqCffm5+SOfIUW+WBfviEL/0lfkT+WJoXRWje1PEO3b05WnCAMIw5MgLRR748V423ZXjne9O4ljzDWZlwp0NGam6YMu9BdbfkqU65fL2ExHB5+oNJtOTPpXi3L65Vo1GNcBpBLOei1Agnta46xOd+F7Ivqcm8JZB3Jlq0XnfT/TSuT7J+f1VvvpbZxg6Xps1gLkOg8f+6Tru/FgH9322m7P7KgwdX+h1tfTGyTgh3/qdc7z+tVHsejRe3VS459NdfOSfrKG9L85N9xXmGZXJgSaTA1F8XjMV7v+xblpXxZnob/L2E+PLrv7ynJCJ/ibQRNEEH/hFb9lGZePtOe79kS4UTfDSXw3z3P8dpDo1Nyl2b0ryqX+5gS1353n/L6xm+GSDemnhLNC1IUGj7PO13zrDwWcnZ3uUYkmVh392Fe//hdWs3Z2hd2uaylSZzNpt+FYN37ZQdIN03xa8Wnk2jCUDn9LxvbTf+X7cSpHpo2/NPphqPEW8vRevVkIGPs3xIXIbdqNcptnjW3UUwyTR2YffrBN6Lr5Vw54awbNqmPkOagMnkGGInkwjfO/aS9p+gNjzisOT37D4yV9MUSmFxBMKlXLA419uYDUkZ0/7fOnP6nzgownue19sVmb8j3+3yvHDHsODAX/8u1U+/7NpNm/VaTYlmg7nz/h88feqOC5s22nw+Z9LYdUlritJZwTPf7c5Wz2WSiv81C+lKRQiD0nVwTThiT+NnnchYMdugwc/GKezWyWbV/jMF5Lc974Yr75gM128+sO+qk/DtiXbdhus2xSF701T8OIzTb7+pQbeCmt8rsmouGMlcg9FFVTNM1GyUYYBzdoEilCw6uNXOcIcDD2JECqaZs70pwhM8+pCUbLpUH36DVp+4jHUfGYe6V5o2TSPnCO2ZQ3mmm6sy4wOMG+WD60m/mSJ+I4NBDULb2iCsGlHXEyjUxhre0ER+KXqbK28asTI9W1Hi6cpnV1arOjiaVf6TrWvTdC5LoFrhxx/dSY8JeHQc0Xu/9EeNt+VJ57WFhiVq2HHHUkmRz0MU2HbbSbVUoCZEKzdEuP8cZtURuX8CZvK9MqOeyl6NqeiPAbw1O/3M3h0vidQHnf57h9c4OYPttG5LsGG23OMnGosGk468fo0r31lBMe6hOfLCdn7xDj3/Wh3lD/qi6ObyrIM3vcDZlJlx/tayHeajJ6xePqPL9AozY8/jJxq8OTvnqdvR5oNt+fYeEeO/d9bvGH4ne9OsO+piXn3x24EvPw3I7z3C70kMhptq+OoWo3U6s3ECh0IRSX0XdzqNONvPT2r9wNQGzhJ+53vjxL01bm8iKLpFLbejp7KzcgrOEwdeBmnNF/5zxo9T2PwNF3v+TjS9yif2s/00T3Rud78Hq077yWzfjsgCJp1iodfm6k2uzSZde33dzk48LbDv/sXJUpXmFSPHXL5D/+yRK2y+HMTBPBXf1Ln9ZdscjkFx5EM9PtMzfSH2E3Jt75q8c5bDq3tKkJAox6F3C5izysOQxd8Ors1dD0Ke40OB7gu0fv8jsMf/E5IMimQRHmgwfP+bMK/Ugn5iz+s0d6pomngujA64s/2ykgJkxMB+08lkIcdnn4niXM+mi/GRgOKkwH/778uM1BKAdHnUxMB//Y3pjlzwkcI+PlfyTDY7/PVv2rguRJFFTz4gTgPPBLnu99qUnZX9l6t2KgIXaX8vbcxV7ejxHSapyKjohlxkplOdDNFLNFC3b36ahxAVU3Wb3gURdFQFJ1CyyaEWN6wmgdP414YwdzUF0nXXkQoqXz7JfSeNlp/+mPU1nZjn+hH+gFqNoWxphutNUfpa8/ijxVBgjswRvLunZjreqk+s2eWn8cdnSJxxzaEpmEfOzdLABc4TcoXjpDqXEus0IVbv3Fd3npMYdMdOcykyqHni/PKgcfOWQydqLPqphSb787x5uPLN+AA6bzK2WM2Hb06zUbIttsTVEo+1VLALe9JMT3uU68G12xUFFWw8fYobDd5oTnbeX45pkdsxs9ZrN6WZv0tGV77ysgCoyKlZN9TEziLMAhYFZ/KuEPXhgSxtIb2Q2RUEhmN9bdkEYrg4LOTCwzKRYyfszj3ToVt72lh58OtSxqVNx8fW9Tg1ooutaJLPJ0gmdNA+oy8/HgkpDWzaJJBgLwsFC1Dn8Cq0xg6Oy9M5dVKDD33ZRDqjKhPSOh7XB5jDZwmI698c7a5UgZz9fHN8QGGXhidEfMSIC8eQ3LuG38wa+gGvveXhJ5LvdnAGr0wz+iZSpI7Wz+JrkQVUxKJFzo0vBKTzgUm7PM4ocWVLFNxKqQ4deUldmk6pPTWlbdxbMnxw0vHkRxHcvaUz9lTi//GimYwMRlnfCLAd5qzAoQXUa9JDr2z9BjCAPrP+fSfWzopMjocMH00gZJsRaed5pl61P6hqShrkxw6M4q5rhsxWsfo6yX0PPa9NQRh5Dl1r1I5vN+lUg4JQ4jFor6XwJfzQsXLxYqMitaWJblrHQQhYdPBXNWG0DXqe0/h2lWmRhY2LV4NFy68wNWSdEshqDaov3YQo29hAtnpH6H4p98i8/CdpO7bTfbD90cNZ65HUK1HBsKZe1jcwbEonxI38CfmEtcXjY4wdNyhSydwSeBYVC4cvaaxXwnxlMaWeyMVQN8NufMTnbPfGTEFzw4RQnDLo+28+c3xFa36Th9usnaLSaMWYsQE/SdtFBVicZUjb1pICWMD1054p6hRaEeI6KG8/bGORRsuFUWgGVHoNNduzlaiXArfCaMKsSWuz5tZQSnqDRHAvGEw4iotM2XYFxPoi8FzQiYHonDpqq2Ls0i4zZDiElVykkvugRZVE0jfQ7L4JKjoJmosTmr1ZqQMqQ+dXrBNuMxYhwz8yJgs9t0SYwi9izkQOXceGc4zKBehzRiUqjeJLz00YZDSC7TGVtOT2MqZ2lsUncEZFc8fTiiqTufGe6PCI0WhMnqC6sQ53g03LaxbxLZuJJguo7XkEYZOUKlFzMmKgppKouYyiJiJPzE1uwjwPfjmVyw+8Fic3j4N35PkCwotbSpf/es6jSUq466EFRmVxObeqAkxCIlvWU31tSMUPnTnLA3+teCq/SxhiPXOcYLpCt5l5IOEIda+4wS1BkLTIm2N2e8k9vHzuMMTGD3tkVqbokRGpVLHGy8S1uZ6PdyBcYp/+i2k5+OcH77k8zGm//JJhKHjnOi/5utcCXo2J2nvi1Qgb320nVsfbV90u75taVq6YxSHF590FsPYgMfYwPURHl4RQpDMRo9V14YkP/bvN191Fz2mLCoZ4trhkqXKP8xQNYERj3qDZst9F0EYgF2Pvk/mFn8V7YZ/TQwACyAEqdWbKGy7E6FoTL7zAl7t+8+hthJYfpVT1T1YfhlV0Ymradpj61id3MnmzD0cq7xIyf3+SYivFPFMO5qRYOjI0yQLvSQLq/A9m3TrGhRVw7UqFAcOYCRy5Lq2oOom1fGzOFaJfM82VN0EBMULB/CuIs/uF0tYbx9COpFqqtA1goaFXyojPQ/n/CCh1cQbneDyRfy3vtrgzEmPji4VTRdYjZCB8z4D/f41CcuuLPylqrhj03gTZYyeVpyBd4dJt6PnVto6d2IYKVynTqV0nsFXXmIxCx+Ua1hvLe0thNUGdvX8ot9l82vo7L2DenWY4Quv0dizUDAnbDSx3jlBJtcHl3XsKopG75r7GTz/0o1REJzBzR9oRyiC0rhDadReUOGlaoL2NXHMlMrW+wu8+rcjN+zc1w3JbKhmoj/qxbjarSmN2viLGA8Zyr+XCV4ZSsJAoigCVVvahRIi+i1hzuNYeCxYycpWMxJk8qtxmuUZ5VUxIykhaAydxSmOEfoevlWPxPRm6qWljCq6pAxn2DDEvFDNqo0xPv3LXeimwIwr+J7k//nZs0sN44ZAIvGliycdvMDBDupUvUmklKxN7aYvuYuaV1xEE0dEAmzM9cqFMiDkyjOkQiTadqV9BAJVGITSJyRAEdrseSQhofRn2SE0M4lr15BhgGc3UDUTM5knnmln+NhzrNr+fhqlYTJt6/DsOlZ5lHzvdkpDRyj07OD821+nsGo7iXw3ldErGxXZtPEGl54HwtqMx1xb2DTteXBw342j41+RUZF+QPrOLUjHQ2vL0frJ+2Z12G8kxof3MT15krWbPsi5k0/he1HcNzbTFGkYKXyvSbM5TSLZhqaZBIFPozYCCBKp9kjjWzWwrWlct048nkc30yAl9dooYeBSKfUjhEI2P6eqqKgGiWQbiqoTeE2aVhEznqd3zf2MD7+NZRWxrSIIQSxeoFK6MNsjo2omiWQHQkDTmsZz6+hGEjOWQwgVCKnXxq6oyZ3Iatz0njyBH/L0Hw3w6peGFzQsaobgx/7DFm7/SDtb783z1jfHbjxz8TVCSklpLHpAi0M2X/2PZ/BXmOj7+w7PldSmXPJdMVp6l+65UnVBti2qrJoevjHlsZoWRwiVeKqDWKIVRdWwrRJmPIfTLGGYGcLQh0SIlKAbSXzPIgx8NCNOsz5FItUGQlCaOEkwQ3E/eNrmd37lPLopeORzbZQnI29XNwXd62LE4grlos/koEPH6ih0lSloVEs+o+cdjFi0nRlTmB73mBpxr2m9EEifAesw7bE1tMfWEtey1Ly5xa0qdNrMProTm8npnWhCxw4bTDmDDFpHqHlFLjfSCiot5iq6E5vJG90YSgwntCi5Iww0jlBxx2YNRc7o4ubCo5yrvU3NK7I6uYO8EamI1v1phq3jjDZP40sX37XQzSRCUdCMOKHvRpIZdh2vWcVzLIxEFjPVQqq1D7dZxbXKIMBpFHGbZTy7jqrqgKC1XaG3T0NKaNRDLpzzVlyZ9f3AiixC4+A5nP7LEsPv6kpy/rHbO3ehagZWfQLHruLYFeKJFlTVJJXtYXw4xG6WWbf5QxQnjkZlzrk1jI/so7P3dpxmmTD0sRpThMHiv4aqGjPHNEik2hkffgdNj2PGspixHL7vYFvTCKESi+dZve59HHz7T0CGdHTfOst5ls6uYnz4HbK5NbR17aI0dYpkuhNVPU55eukV3qa78iQyOuUxh9HTjQUGBcB3JecPVNj9/lba10RVYgOLNELKkNkeHqFESfRFCSWXgmSWa0kQraq9q8x9YRCN7fbH2unZkiKR1a6Zd+xGIPJ2on8LRUR0LVdpWrxe2HWf4ZMN8l0xNt2V45UlPEkzobLqpqgB99y+xQsargWansD3LIxYFt9rRgssRcGIZUBKjFiKwPcIAxfDTFGeOkOuZR1ShhhmGt1M47sNFst1rt+RJJ5UePHrFRCw/a407b0Gvi/ZfrfOa0+WeO+nWgh8ydiAg6IJxgccdr8nQ9faGI1KwJbbU7zxZImJoWt7LvzQoeSOktIL5I3OS4yKoC+5kzXJ3Tihxah9hiB0SWhZuuObyOitnKi8StmbL5vRFd/ExsxdBNJj0u7HDW3iappWcxUZvZ0TlVeYci6lIhK0x9bRndhKwy8xaB1FUwxazdVsztyLppicr79DszpJGPh0brwPRTOoTZ5HAvFsJ+3r70LVTazSKIqiEc90EPgOTqOI79qLzqs332mybbfJ6eMu05MBwwM+nvvD58mvyKiE9SZufYaf52IQfCmjIpihaiGa3W7ItUusxhTjI1EJr6qaGGYGM5YjHi+QSLZjN8sIBOMjB9C0GKvWvufiYDDMNGMj78x6PosOWyjE4nk0PUk80YZupigXz+DYFabGj+K6UXmsDAIqpfN4fkRTrhtpEslWLpx9jjDw6dvwMLqRBCGw6uOMjbxDa/tNJNOdSxoVIeCm+wropsLUYJPx80uP8/TeMq4V0NITo2dralGjEgYS1w6RocRMqKRadEojy18RSwmeHRL4UZlhoSfGyKkrc47JEM4fqDJxoUn76jgP/kQv3/6f5xc1ZkLMMRC8Wwg8iWcHSClJ5XViKY3GIv0gNxJWxef4ayU2351n4+051t2c4dz++eELMcM43b42TrPuc+CZKzBurwCOXWFq5NBsZRZSEoY+zfokZiKPUFQq0/1EL6SgVhrE9yxKk3NJ+0Z1BCnDWS/lIlI5lZ33pnnnxQpWLcRMKOy8L0PHahOr6pNIqxx+o4aUkoFTTfZ8pwxEWui9G+IcfKXKhRNNHvpsK6s2xa/ZqATSpxlE72FSzc1+ntXbWZO6mbo3zanq69T8YsTyoRj0JG5iY/pOehJbqVdL+DPy00ktz/r0bXihzYnKq1S8cQLpowmDjvg6tmbvZ3ViBzWviBPOPfs5o5Mztb0MWkfwQxdFKBTNQTZn7mVNcjfjzbNYfoXx06+hxzPIwMOxKqRaVtOsTVKdPEd59AS+26A6cZZmbRKhqASeje9YjJx8GYDK2KkZLyl6f44ecHjxexaBH703H/50ki3bDWrVkMe/VKdcDHjfBxNsv9nEDyS//1/KrF6j8/BjCQxD8NLTTQ7te3ebRq85dpW6dztmbzuV59+JKn0sm7DeBCkRhk76vh2kH9iFUBTqe45RfeEdQuv6LyZaQc2MIdtLLJ6j//QzrFr7ntkuX993CAMXqRpRJ3zgcuHsc6QzPazf/GEunH2OenUR+nQhyLduxPdthgfeYM36h2ePKZEsmk2exeJSm1IG+L4dVbmE/kwce3G0r4mzamuKMJQMHK1dcYU/dsZi7KzFhtuzbLg1x4Gnp2hWF4bVBo7UuO3D7XSuT/Kez/Xw1rfGcKwQRQFVV2iUvEWb7i5iaqhJadSm0B3j0X/Yx9N/NBAlnwVousC2AqoT80MZI6cbvPKlET70D/t44PM9ZNoN9nxjjOqkiwwliqYQT2msuyVD18Ykz//p4LJZl68Fp/dWWH9rjk135rjjsQ6OvlzE9ySKCqqmUJ10aNYui50r0XeqJlBUgW4qs/kPPa6QzOm4dhCVXQYyygnN3IMwkBx8ZpJNd2bZ8b5WPvfvN/Od3+9n6HidwJMYcYWt9xX48C+vIfAlL//1MGNnb8z1a6qPqgbYl8nuhoEbPYeIxcOvMqr8WyoxKxS469E8xTGXs4dmGu+Iiim+/cVxTu9vgIgkAnbfn6Fenn+gS5+PmZTNNUMSEszkUXRlLrzYm9yGQDDaPD3PG3HDJkONI6xJ7qLF7CWmJqnPGMyu+EYMJc6FxiGK7hwdjSdthq3jrE3dQsZoJ6UXcJy538gPXQYah2bzOYEMmbQHaDPX0JPYQntsLf2NA/iuhX9Je0Xg29jVCezqXO9PGHg49fk8aq4VFVH4l7VmPPqJJHfeH+f0cZdv/HWd/W86HNnv8IGPJent0zBjgpt2m/z+fyvjOhFP2Xs/GOf4IRfXldz1nhjnz7jUKu+eh3PNRkUIQfK2zcS2rkZNxnEHJyh981Wc/jFim3rJPnoHzcPnQRFkHr6V0LKpvnCNTLNLIPAdVNWktWMbsXgB27pYCjz/hqmqTr5lEyCxm6XZiT2T6yNbWEci2U6usJ5q+QK+Z5PJraK1fRu6OVfm2WxM0t61m2p5gFplEE0zybVsxDQztLRvpVEdo9mYpK1zFwCuU8XzGkDbsq+nZ0uKQk8Mtxlw+q2rh0MOv1hkw+1Z1t+SJd2iL2pUDr9YZMeDLWx/bwsP/VQvN3+gjXrJQzcE8bTGM18c5JUvLZ3gGz7R4MAzUzzw4z3sfqSNdbuzlCccFFUQT2kcfmGKb/3O+Xk9IoEn2fONMXRD4b1f6OHOj3VyywfbqU27BK7ESCikZhQUx89b7wqD8KV48/Extr+3hdXb0nz819Zx72e6cBoBuqlgJFT+7j+f5dBz8z2F1dvT7HhfC4mMjhFTMJMqLT3RBLblnjzJrI5jBbjNgGbdZ883xpgamKvCK405PPV7/Wi6wpZ7C/zE/7uV4lATuxGQaTXIdph4dsCevxvjlb8dwbWv310TwJaNOvmsyuCwj2kKypWosa5SCclmo/vcaKjkcwqVakgqpVCpBGQyCvWGJBETqKqgWg/JphWatmRgyKdnXYyHP9PKK9+a5sHPtOC7kle+Nc2ZQw223ZmivcegUQs48fZCj7nZCBg63WTbXWnW3BQnnlIZOn11Ab+lr1MgiKrrAhktiBRUMloLAkHWaEMVu+ftEyXgJaaSRBX6zHEUUloBRagktCxrkvP3uXguQ4mhi/m5sUZQJpDz3zdJgOWXCWVISi8sOnarNIJVuvbCmie/1uD571rIEPItCp/48RTnTnr09ukcfNvBMAWuK3FtSRCAloB0RmXLdsHURMDRg+6y6FuEpkfh72XSbV2K68qya+15Gt89hTs0SfKWTWQ/eCcTf/xt9PY8QanO9NdfQro+oeWQvPMmqi8dWFL/5HL4XpPhC6/Pc8Enxw7hX/J3oz7G2PDbCKEweP4lfN8m8B0Gzr2AlCG+ZzE6sAfft2lakwihYjUmqFejH9XzGpSLZ6lMn8d160gZUp4+i+vWEMDguSG8mZXCyMAe4olWPK+BRBKGAXZzmvOnvofvW/h+k/GR/STTHYDAbk7je02q5UEatWjVVKsMYdXndydfhB5TWL09TSKrURyyOX/g6kbl2CtFPvrP1lLoidG7JcXE+YUvanXS5e/+81lGz1psf6BAS2+cXKdJs+ozPWxTGruy99is+Tz3fwcpjzvc9uF2OtYm6N2awmkElEYdpobsRRukmlWfF/5iiAtHaux6qIUNt+co9MQwYgpOI2D0tMX5A1WOvVqcpVSZB7mCiOlVNpwatPnSvznF3Z/sZMs9eVpXxUFKrKrP+DlrHn3KRfRtS/PgT65aoMMipaRtdXweXYvnhJzdV5lnVACGTjT48n84zc6HWtn1cCtdG5O0rFKpT7scfanI298e5+SbZerTi7+4i3m+V9pO1+HWXSaxmMKWjTqv77W5eadBOqVw+JjLg/fHAIHvS6ymxHElwyMBE5MByUQkPXznrTGOnXLZtSOGKmBg2GdgyKdW9vmb354rGgl9iQzhwMtVJodd4kmVZiPAtUNe+dY09fLchCtDOPhqlalRFzOucvj12gJp25VACBVTjUru7ZmQlKYYKEJDFTo98a2wJJuOnMl7gjqzvUChM7aBztiGJc+pXBZhCMLFfzNfukhCNGESSxTwvSa+18Qw00gZ4rnzPVIhFBRFIwhczFgOxy4vfeGXPQ5SQqFVpWlJgiBiS54cDXBsyS/9eg6nKfnrP67y5itNdt1h0t6lMTURzKP+Xwp6PIOqm7j1EoG7sgWAkMt8csVloZ/0/TtJ3rqJiS8+RVi3MPs6afuZDzH8H/+CzPtuJra1j4k/+BbSdkns3kDrF97PwK//wbsbQP97DiOuoJsKYcCitPaXQwiIZyKZUscKFhA7XgpVj0I4ijoTzpsp/fXs8KpsuxAl+fXYXAgICWEo8Zyr95JoRtToqKhRMFHO7Ou7ksALF6TlVE0QS6lIGSW9l+rTMJNRXb3vSpxmcFXjcuk4Zu+BL3HtYEHZs2YoGPHF+2cuh5TgNILZvJGWidP5yTspvX4SozVDdvdqRv/s+ejeRU3mBH6IZ89de3rnarRMgtKrJ2bHaiZUMrdvoHRkDHu0vOi542kVRRW4doiuwoP3x6hWQ9as0vjOcxa37TLxg0gYLpNWCcJI08f1JJVayOCwz9Cwz4PviROGkEwI3j7gcN+dMZJJhdffsjl28t3NQV0OU0lyb/vnsPwKh8vP0vBLl32fYGf+/RSMHvZNf4spZxBNGDNd+PGZ3MjYoseWgBtYhASoQmd3/gPkjR5OVF+lOC8ZPx9u2CSQPnmjm5sLH6LuTbO3+PiC5svViZ1sytzFlDfESHwcxyoDkliyBadZQtPj+F4TTYvheRZIiMVzlKbOkCn0US1dQFE0zHh+toK1UjxL4DvokYM1j4Q2nphTsnRmvBPTFMw4Glh1iapGZJNCRPu6y9BJ0RIZkm19yDCgOnhs7v4tw1xcs6cSuh7SCyIjMXMeJRVHa80iYgbikhZn6foI7dqFom4EhKkT29CDEjMIG03s82PzOupXdjCBubYTxdCxz43OUrdcL9xmuKLSYCnnN9cpqkCdmTSdhj/7u5hpDafmE3jR7JxqjVGfilbVmqnMMyqpvD6bY4mnVTRDoT7tEQZySe2Pq8F3Jb67/H0DX9IoX92oOo2AlWTpVjIO3w2vvRRaCJSEgWLqJDZ24Ns+ZNIorWkIQhpnxpBeiNmdx2jN4NeaKDGdWG8L6V19uOMVnLEy0tRQJ238hoMwNOK9BZS4CUiss+PohRRqIUXQsPEHi3SvT3CmrFKecHn59SgM9Z3nmvPITC8Z4rzPvvvc/NXo4eMu8ZhCLqPCEh36PygUjB5yRid1f5qqF4UtfelhBw1iagpVqLOJ/CshkB52UEcAumIua5+LiKtpFKEQzFuNCOJaGiEUfCVAAIlUK1IGOM0yhpmOQmPZHqzaOGYsS6V4PmpfCFwMI40QKqlsL75nkUx34bmNyJPBwfcEKhrgIVBQUHCsmf4iQiSCNBksp47vXCyCDiBQcRqCAB+TODEENlem0VKEimqYeNby78lFXLNR8ScraK1ZCp98AG+0SHz7GghC2n/uI5FSogAlZhDYLnp3C2Hj6nr17ybUTJLUHVtwzo9idBXQWrLU9hyDa5FtBdR0gsS2NXiTZfziD8dLZ6Z02jdnUXVBecgiltGpjFh0bM4ysG+KwpoUuqnStjHD2PEKzYrL6ltaOf3SKHbVQ9UFH/3VtZx9u8KhF4q89ws9OI2AIy8WZ9h6//9YLsKmi5Iw0HNJ7OFS1GOoKiQ3dRE6Hs2hado+sIvqgf7ZUmc9F0dLx0ht7mb0628Cgsyta/EbNl6xTv7+LVhnImOi55MYbVnswSnifZE6qB5zUHWBd1l+ZrHF5dUWnEdPeKSSgnrjB/fOLoSg1VzFhvQdSBkyZB3FC+eoX8aap2kxe2mLrWXKGZjhB7v8CGKedPWE3U9nfCNtZl9UsRUsDDtfvg+AqSYoGD1MOnOM7HE1TVaP2C/G66cpVyZQ1WiBLYSC49Siwh2ngVBVqqUBPM+i2YgMY7U8gO9aUctEs4RtlaLtvSYChawooKJSlkUyooCOgYKKj4cvPSyqtIteJuUwGgamiFOWU6REBh2TCTlEhgJCCBzZXHBNl0ISoqgaWuzKMiSL4ZqNinNhjOpLByh8/H5EzMAbKzLxxScxulpQ4ibGqna6/vlnCcp1jDWd1F48AFKidbbQ8oUPYXQvP4F9NZS+9hz11w9d9U0Ja00a+8+gpuKk7roJLZciuXsDsQ3d+KUG5e+9RWLXetyhSZz+MXIfvAPr8Dm0XJrUnVuQrk/1pYM4F8ZxhyYxV8+pAppru8jcvwPF0KntPYE7MkXu/bcjVAUpJZXv7SWoN8k+fCtGVwvu0CSlp94kfedW1EIavTWH3T9K7dXD5N5/O+aaDoJ6k9I3XyOoLW9CVzRBz448gRfStj5Ds+LiNnwSeZNY1qBtfQbX8om0a0AzZkInVuQVCBHRyquGoNBlku8wOfryNLkOk4n+JoqhohhXeWSkxLfcufWDEBidnajZLN7EBFprK/apU+jtbXiTUxFpl5SgKGiZNP50CVQ18oBn/Hotn0dNp3H6+2cuVKDGtHne8Lzf2QsInUs8HUVcOZd32bJdqJHC4JViX379yj6SW6xjtGUIbA+hKiQ2dEaeSUsaLZvAsFyklFT3R9ekZeNYZyeo7u8ntbUHISCoNXEnq3M8TWWL+rEhYqtbydy8FrMzi56PBOfqxwRhIImnNXxvvlFRYhrKNUQKmoB6+ZwyMxYpgTCqeJShRAbhsvOly4UmdFJaC4YSJ6FlaDX7KBg9qEJjpHmSkeapeeGnMfss7c46Ws3V7Mw/wrB1AiuoIFBIaFkKRg91b5oLjYOznfJTzgBjzTN0xzexI/8wI9ZJav4UAkFMTZM3ugmkz5naW7MVZwChDNmcuRejkaDsjmEoMfqSu8gaHRSdIYrNC4QEi/p4TrOMECqBH0ULbCuq/KpXIolnayYHe2k+WcNAx6Qio21N4tjSIi9aGZODJESKQAZ4uAgU0iKHRGJgEhCg4KOi4eMSXNL1vzQEjYmBq1S8Lo5rT9QHIbUXD1B79TBqwiRoRFTx9okoLqkkY+Q+fDfm6g6qz+2j8vTbESeNpqK15CLhqxsEJXEFpchFENpu1ATW20Zi93pK33yd9H3bMVe3E5TqxNZ2EVQtzN426m8cI/3YPVRfOojR00p862rckfmVQiJmkNjWR23PMdyRIoWP3Yv0fPT2HKP/6+/I3LeD2MZegnoTrSVD5bl3yD16B0Z3C0rChDBk8q+enn0p9a4CtT3H8camo/t6GYSho+bTCEXBmyzBjAiZDCUjR0oYKR234RG4IZ4doOoKqdYYqq4QepLSQINmxcV3Quyah5nUaVZcZBjR0ptxlTU7MyiqmFFNjFbZaz57C+t/5u4r3tug6bH3n36d2qmoIEGJx9HyOawTJxGqitHdjdB1jO4ewmaT2Pr1hLaDNzmJViiAoqK3tuIXi9HfmoZz4UL07xmk17aw/TffT2pD66JjGH7qGCd/7yWCZvRKtz6yk+kXj85wv/nRBAgocYPMjlWo6Tj1o4M44xWQULh5FTf9xsPE2hYneUTCix//I7zq0pxrQa1JcnM3jTNjJNa0YbRlaJwYgU3dgMArN1AMjcSGDoKGG3Hq+QGz4jtCoGXi6PkUZkcO6YWR6JyMqGv8coPQcqge6CdourgTFbLrMyTSGumCQWVybjrb9usP0/m+jdc0Qcy77FASegHSC/EbDm6liTtt0Ryr0hgoYQ2VcKYtnKkGXuX6Pduklmd3/gNRYYwM8KVDM6gxYp1gyDq2gEIlkB7Hyi+yLn0breZqbso+gCo05Mx3bmhR9eZTS0lCTlRfxQubtMfWsSlz92x1WCh93LDJWPMMXJY7mXQu4AYWG1K3Y6gJBAIvdCg6gxyvvHpFSphIwHBl0Y0ADw+XgmhnSo7iSIuESOHQxMfFxSEkxMVBEQoNaigIHJpoUicQEa2Mi0tSpKnJyhXJOIUQGKk8WixJs7hI+8UVcP0cK35AUF3oZoYNm+mvvHDdh7/hEAK9qwAIQttFTcTQOwvYZ0bwJspIP8Bc00H24Vuov3UCCSimjt6RJ7QcvLHp2S7zuUPOKU0y89ILTZn5e+ZzIRC6hpZJonfmaew7RTDTSOqNleat8qYff4345l6yD91C6ck9BOX5ZZrG2m7yn3wfQlOZ+D9fnxUhs0ou/W8u5GM7+PgFYhl9tnR37GhpdmF+8rm58sYwlJzeWyae0nCbASf3lEgVdIZOXDy/WFCwcTnUmMaqj+3g+O+8gPTDSFZW1dA7OpCui5rJIEwTNZ1GTWcIanVELIbQNLRcLmKS9jxQVZR4DCWZIiiVov00Den7F4ey9Fgu+7j1kZ3EV7WgpmN4UzUmntiPV6qTu2M97Y/dil+xSN3Uy/BfvIxfuSh+tPS1Xm2VF9oujbPjuNN1nOFpnJFS5KVn4linR7FHS4S2R/HZI5hdObxyA2esjDtRJXQDym+eQYYSNWHSHJiaMYKS+vFhwqaHM1rGK1sIITC7cihNF2+6Tmncpa0vvmB8UV/I1X+7q0GoAkVVIAZ62iTeOad7JKUkdHya4zXq54tUjo9ROjhM7fTkrBFfLnzpcra2d6YMOCKd9aWHEzSoeVPY4dLMz05ocbL6OqPaKVJ6AU1ENDhuaNPwy9T94qLG6HRtL2P22RnPKFqkeqGDFVSoecUF5cOqUDld28OEfY6klkcIBTuoU3ZHFw27XS8kkrKce7dLTFK65G9vxosak0sIJM48Eh4uDXn1ylLPquFZJ0i09q54rNdnVITA6GlF72pBmPqCrxtvHUe683+MoFSj/PiLqOklav6EIHXvLmKb+oDoBa1+7w38YvniBhf53i7+D/bx/qsHiaVE78zT9oVH8Et1aq8exh2ewjp4ltjGHgRgHTpHULeQno+5uoPpb7yK9Hzqe44T27IKAH+qgmIa5D98F2ZfB2ouSenbb2CfHyNz/w6EomCfGcYv1lBMndbPPYgSNyg//TZB1SK2rovYxl6k61F/6/iipIn5j9yFomtR2GaRDKu5upP4tnWETRehLy+sYVc9xk+Uo1DFErdKhnD27TL5zlhEpS6hMulgVf05doSrQQgKu3rJbO6gcnQU6TjY5y5qoPtYR48iHQfr8BFCuxkRGSpROWtoNwkdF8UwkK6L3YjKL6XnEdTrs7rnK4UQkNjQSfmtMyQ3ddH+0VsZ/vOXSG7sorznNJV95+n6zN0YbZlZo3I9CN0Ae3AKeyDyaN1ifWH3n6Jg9U9inZ+YDf9dRO1gNDE4E1WciersQgUl6hqcPZ6UNC/MTSyZlgRvPTG5rMrBGw0hopBhqq9AcnWetrvX4kzVKR8Z5cJX36F2dmrZKdVAelxoHLyGQUT3MCSk7E/MNUDOPrsL3zVmvwmoepMLPJklT4VCIH2K7hBFd2jRbTJ5lZ/6jQ5aOjRKUz7PfLXM8X3WlQtgZ+e2dwHLPLZQVBKtPeiJLEa6QGNi+Uq+cB1GRUnEKPzIA6Tv3UHo+ouWCjcPnyO4zKiEjSaNNw+zZEutEJhre2aNivR86m8dxT0/EhmctVtQVJ3GwOkZNTmublCIjMHY//kWQogohDCzepp+4o25F3omjFR++m3Kz+yb3aa25xi1vcejMc94I5N//ey8YzUrdZonZmKQQYjensOfqlD8yguR4Zg5VvFrL88ZiyCk+vLBBT/01N88Nxfnv2yVp8RNzPW9S+YTroTwKrxfqi74zL/aiFX18ZyQRsnjuT+NXhixzJC8EIJ4V4aO96yndmaS0PEJG3O1+YHjEBNJWustVIIiTVlHEgAS4UjAJ+EkqMsaqh0S/ccHe/n0/pdDBiGDf/Ic1tkJ9HyC9b/5cQCUmI5XauBOVAgsBzVuXPlAy4EiyH/mUZxzg1hvHUZJJch98iGm//pJCEKUVILsxx5EzaaRrod7YZjaC3vp+I2fwZ+I4uW1F/YiNIX8Zz6INzaFP1mi/so+UvfdQuymdRBKmodPU3/5bcL6nBF0miFb78lx4UidkdM3frW8XAghUE2NRE+OeFeW1rvWMPzEEYaeOELzKmy714pYoZPWHe8hVuhAUfVICOzFvyXe0kXbzvcQ+h729DiTB1+6IqHrjYSmC1raNX7714ZZvcHk07/Yyl/+9gTnji/+LOuGYMddSUbOO4wN3tjin/XbYmTyKvtfvTpzgwwDmuVxmqVxVGNlqQW4DqNirusisXMD5Sf30DzWH5UXX4aL4Z0FuMTLWPz7Rbp8Zj5TNAPVTCBUHeQKX5wgXHjWULKgESKU88cnJVw+IV9+LMk8AxBYNtaRRe5LGM4Pzy6W3LxCuOCiUbne+PhSaJR8/u6/nr2u1ZJQFdruXsvoMyepnVm48rNlA1/62LJBTmnDlo2oq1lkqIUlkkoGN7TJKAWklEyFI1zPgNxijVh3AXu4hNmVRy+kyN6+Hr0lNefpXe2ZXCbUlihBqiRiiJg58+F8ixyUKtRfeJPQ9Ug/dDdKIob0fIp/8vXZbcwNq7H2H6f27B7a/tHnqH3vVSrffB5/uoz0fKw98wXx4mmV2rTHVdmEvs8QisDIxlnzo7eS2dzB2T/bQ/nIjddAsafHGHrpK2TX7URPZpk6/AoAimZS6T9G6fS+H0iPnCQy9kfesti0q8GdD6cZHXC56bYELR0aVj3k8JsNmvWQux5Jc/+Hs5w50mRs0OOlb0c5vs5VOttuT6JqMHTO5cR+C1UVbNodp7vPIPAlx962GBv0yLdp7LgzgRlTOHfc5vwJm7WbY3z484WoWbJD49Aei8nhKxstVY+hqBqetXKi02s2KmomgV+qUX1xP0Hl3eNtmgcpaQycRs/kF1WL+2FCWGtS33vihh9Xa82hdyxOAXEjkOsy+cSvr6Ne8rDKPq999domgERPjrZ71lI/N7UgB3URAoWAAEvWaVN6UdHQhUlcpGiKOq60iZG47ohA8fmj9PzkA7R+YBd6NkF5z2naH7sFoSpkdq0haDjohSSBdf3PVGLXFuyjZ1ALWbT2AsH0wpdSzWdJP/oekCHewChho4kSM8h/7kNIKak9+waoKvGdm9FXdWHtPULoXHlsgS8RCjSq/g+NDMKlEKpC4dZV6JkYJ//PK5T2Lx4yuvEnFmRWbSbRvor6yBkq5w4vK7LxbmBswOXWB9JRcWMgKY779G0yufeDGZ7+SplaOUBKKE35FMe82YfeMBVqlQBVgw/+aJ7Bsw6FNo3bHkhx+lAT15FRvlTAx366hdOHmpSLPh//mRb+4rfHaczw2tUqAVOjy38+zGwbejJHffTMiq7z2psfbW8mIX3j9VSWQnrDdhTdREukCR0b11lBhYkAETMxettJ3rmd2Ppe1EIWoSkE1QbeWJHmwdM0j5zFL9dmQ2FLQlVQ04nZ65dBSFBrXH2/i7tnU3NaNFIS1KzFmyg1FaFrCE1DGBrJO7fN7acItHwGFvESLyJ0PcKatawXKfQlL/7FEEIRyFCujCb/MghVYdVHdzD0xBHc6YUe5UQwQEiIFzpIJJNBNMlIJLVwejaZWmV6GeWPV0Zl3zncySqJ9R04o2Wss2MITUVKScfHb6f7c/dSevUk9kjp6ge7AoShY25eg7l5DUoqgbQcgtLCcE9QqWHvOUhYa5C892a0tjyh41H51gtRia7touWz2CfOIW0nei6uUq4rQ5gecYgl1RXNmVJKAtvDry2jjVTMdG+rCoqmoOgqiq6CsrwiACEE6Y1tbPqFezn+P1+kemL8qvtcL+pDp7DG+lF0g/abH8SrV7DGV5YjuBShDLCDOm7YZKVLnVRGxaoHxFMq225LUGjXybdpDJ5z8D3J2aM2U6MeJw80uXBy5vcQ0Natc9fDkUTCttsTmKZCZdpHUeCm2xK88UyN0qRPrkXjfR/Lsv4mkzCMwmktHTon9jeZGHKZHPU5+PryHAAZBmhmApHQv39Gxb0wRmjZZB+5lfreE4QNGxnMp8rwp6sQSpREHKHpyDBAIAjqS1dvXAmNwTMomoGWyuA3V+AdKQqxzX1kHrmTxK1bUIz5RQVaIYu5ppvkndvxxovUnn2L2isHCKtLn0PNpmj9yY+QuHUrQlUI6hbTf/1dai/vv6qbrfd20PHPPofe1Rrp0BcrjP/Pv8U5PUcTIUyD2JY+zHU9GD3t6F2t6J0tiLg5N4ZEjO5/9XNXPJd18BQT//urkWG5CqRkHkX75rvyV93nSjBakvQ+toNzf/7mgu/CmRjgRYNxaUVOMC8+eANWlaGk2T9Js/+SUNxMH8vo37zG+Df2Ejav30sx1nTjnhui+vRr6D0dxLdtQJg6aiZFfMcmpB/gjUygGAbGqk7CRjPKHbtRL4uxPioG8QYi71C6HvWX3ib/+Y9gn+wnKC0diujdkiSd1zCTKpODNuXx5V/P2HOnOPm/X77yRkJEhsTU0NMxYq1JEr05UmtbSKzKk1xdwMwnrso+LIQgu6WTdZ+/naP/9Vm8yrXnypYDKSWBZxMGHr5toWjXlzereOO8Pvm3K9pHCEF7t8b2u5K8/p0qO+5MEIbwf/7tKA9+PEvvenNmrNH2mjZ3E2NxhU//Uiv/8zdHcJohXaujaqx6JeRL/2uS7rUmj/5YnlXrTF79ToXxIY//8ZsjFMd84kkF24repSAAI7b8uKiiaviOhWosSaK2JK7ZqGitWfTOAsnbt5C88ybCmrWgdHD0v3+FsGaht7ai5QsgBH6xSGjbc6WhK0DouiS710Ylho0q4TI9lcRtWyl85hH07tZ5KyoZBBCE0cp/puTS6Gwl/+mHMHo7KP7lU4TW4g99MF2l/MQr6L3RhK+mEmQ/ej/2mUG8ocVJIwHUbJLcY/ejd0SdraHtUP7mSzhnBudvl0uR++gDxLeu+b4EyTvXJ6hMuGy8Mxe1SQA7H27l5J7rW713vncjo08ff9cStMuCopC7Yz2Jte0opjZv4hv7xl788o1JagflGta+oxCE+GNT2JoaFaa8cRBUJfIAHZfm0dMo6SSEEuvtIwSlCtWnX7vEA1XwxouEjkvYaFJ75o3ZMTunBxZdtAwer5PvMMl1GBSHViYxEfrhbE/PFa9v5v+dyTr1c1Pw1gWEIjDbUmQ2ttF29zra71+Pno5d2bgIaL1jDZ3v3cTgNw9dYcPrR7yth+zqm7hI+W8Xv7/S2/Gkws/+fzpQFcHAKYdDexps2BFn1z0pfvQft5FIK9Qr0Z117ZDpCZ8Pfb7AaL/L1/5wKvJgjjT5yBfyNKohmhFFEdq6dR78RBYzphB4ktKUT70S8uK3yvzIL7Xi2pJmI+RrfziF50pOHoiO0dqp8/zjZYbPXXnREclKK9dUEHQd4S+Xxr6TNPadXHpgM4YjaFhoLa1R1ZOuR5P5NSDR3YdRaEeGIc708kr/zA2raPnCh9Bbc1Etve3QePMo9TeP4E9MI4MQNZ0gvm096YduR2vJosRMUvftImw0KX7p6SVFJpyzQ5S+9jxtv/hJhKmjd7bS8uOPMv4/voRcLAauqaTu3knyjpsQqooMAmov76f+2sEF4SnpejhnB+cfR4De047eFnkQ0g+wTw0sfq6LYzw/HDXVXQWqJlB1wc2PtHL89VKk9KhfZ1/DxUqw926k/2/3/cBYeloe3Eb3j96DPVQkaMyfcG8kJ50/MT37b+l6uOdmOqTfOjxvO+dk/4J9m/uOLfgsrEYe/cXjAPhji4t5+a5k9bYksYSGVfWjpP33ATKU2OM17PEaxXeGGHv+JJv+0XtIrWm5oqSBYqj0ffYWxl44dcUm0pWiNnhynmaRU5qg7kq8wMZ36gTu1c9lailSsXZKjQuEcrlzlaCQXI2UISUrWiCWiz7/7VeH0Q2B50qqJR+nGSXVR/odVFVgW+HsGsGxJU/9zTTpnDpbO+R7ki/93iTprIrrSp75aolS0UdVBU9/pYymK3iupDJDFfXM18rkWjRULXomvBmy16NvNxgbdBEKlCevvqBXjTh6KkvorlwD6zrCX+NMX1heTFSoatRr0LRwZnoWrgXWSD+qmUDP5FhAK7sI1EKG/GceRmvJRl3I49MU/+JJrP3zDaE/VsQ5PUj9jUO0/9KnMDf3gaqSum839pkhGnsOL36CUNLYcxhzTRfZR+9B6BrxbevIPXY/5W+9vCBHEtu0muzHHkCYBjKUNI+eo/LUa4t6Q0GpxvTffG/+h0LQ8oUPkX30nuj0tsvkFx/HH1l8olkJhk82EAq88uURzr1TjVaay/SQZCjxmy5a3FgwkSimRvu965h49RzW4PV5PdeKwr2bGPvGW0w+uf/7c0IBRj5BrC0NiqA5WkGGknhXBkJojlbQ0iZ+3cGvOagxHbMthTNVJ7m6gNBV3FIDZ6oR/a0p+A2H5mh10SrLi5gacth6d3xZrNPvBgLLpbhvkP2/+S22/fpD5G9ehaItvdKNtSbpev9WBr52436X8DK9awOTDn0NRbeful/D1FKoioFA4Ph1/NAhabSgKCqu38Tx66iKTtMtEcoQEMT0NJpiIoSC5ZZQhIqpJZFILLeMqSXR1RgJI4ftzREwhgFMjiw07r4nmRpdfGK3aiFWbf7c1qiGNKrzP4sS/YJEtoMw9PHcERRVj449FtH7h0HUX6aoKmEQMDkqI6XVQKJqJmHgIZGYiQKeHfGSXfToZBjMo0paCd6dLLuqYq5qwx2aRPoBSsxEei6hdQMaywIP36pfnYJZCBK7NxNb3xspU9ablJ94FevQ6SV38SemKT3+Im0//4nIY8kkSdy6heaRs/P6AeZBSirffR29p43EzVsQukbqgVtwzo9gvXNi1gNR82kKn30ELRcl3PxShfI3XsQfn178uEuca9Fy6xuARFYjllQpjzkUuqMY78k3lmcEQtenuHeA7NZO4h3ped8JIUhvaKOwu5fmSBn5A5jwZAhe8dryeNcCIxun5yM78GsOvu0hg5DsTZ0opg5SklrXilAFoRcw9swJMjd1kt7QxtgzJ2i5cw3JVXmGnzoKQtD78Z3UTk2ipQyqJ8aZ3j+4ZNI+kdG4cLQ+S+3/g4I9UePUH77K1l99kOzWziWT+EJXabl1FSPfOYrfeDeqOQWmlsLU08T1DLZboTW9ASEUmm4JP3TxQ4eYkSGmZVAUldHyMdKxDhJGjoHpyLvuyGyGGVLJlNkWkS0KBVUxSBh5kmYLjlcnpmfnGZXrhdbRRmLHTTQPH8MbXxiZSeVXRVIKMkSPZYin2tBjaQLPRtUNKpPniCXyGPEsTmMaM1nAqoziOjWSuR4QgkZpiLZVuymNnURRNYxYhvL4ibnf7Brml3fFqKipGPlP3M/k/32KoNLAHZ9AScRRk0twKS0TsdZOmiMXEJp2VbdMSSeI79yAiJtIKXEvjGIdOHllVmIJzvkRnLNDqIVMRIOxvhetNYe7lFEhiqVXvv0KekcBvacdrSVL7rH7cfpHCIoVhK6R++gDUX8JUdiq9PUXsE9eexXKjcbG23OsvzVLptUgCCSqJpi80OTJ3+1f1v7VU+OEnk/soS0LvBU1ptP1yBbGXzo9F+q4uIlkrtNXQG5tlvpIA9/xb1i4bPrlY7Q8tB3r/ERE0HgpbjAJIkBqQxtIydATh5FeQKInh56NM/LkUYSq0PnQZop7++n5yI7IqGzuoPhWP27JonRgiKDpUT44RKw7iz1ZZ/SZ4yT7CuR39VA9Ob4kmaURV0jndFp7TJo1n+nR6xHCur71Su1ckcHHD5HszaOlzUUNixCCRHeW5OoCleOL658AaG2tpO66Fb23G6GqeOMTWHsP4FwYvMogJZZbouEUmar34wUWilCoNEepNKPciiI0kmYrmqKjqTEURaVmT2BocwlqP3SpNcfxQ4e+1jujlTwhoQxRhY6UksnamStyac1c8PJvqiKIb9tC7rEPIMMQb2Jqwb6aEceqjpIurJkxHjlUzcRuFAkDD8NMk23fiAyDGb4xcJoV4uk24pkOVFWnOnWewHcJQ49s+wYEAkWLRa+eUJbPpHHpuFa0tRBRXuTixLxEzFSJm1HISVEQponZtxo1mUKJmbhD116fbrZ0YrZ0AdAYOI1/Ba5/LZsivrkv6nr3A5xzwwTFqzfyhDPlxYQSVIHenkdryeL2XyHBJ8E+dYHyN1+m5Sc/gpqKY25aTeFTDzL1l0+RunsHqXt3RYSGnk/1ubeov74wj/KDxOEXpjjxeokP/oM+nvq9fhDwkV9es7ydRUTpMvbsSVpu68PIxRdMIrntXbTcvpqx504BsOr+VSTbElQuVDGSGl7TR1EV0r1pal01zLTB+MEJ6qPX3wNldudJbOhk63/9PF61ifTmQg/n/vO3cMbK132OS2HkEzhT9dlQlWJqSC8gdP1Z1urA9nGmLVLrWwk9H2fqStcp8ao2ijZTwrsIVF1wdn+NVFYjCCTTY9dmUBQFdm4z6GzT2H/YYWo6IGZGEsOOKynkokmmUg3RdUEYSkwj+q5Wv+R5DiXjL52h+4M3Ubh5af4oo5Ag0Ztb3KgoCold28h/+qMophlVjYYhek8Xydt2U/nOc9Re2bNkzhPmEs4xPU0QukgiosiLSMXa0BSD6cYAheRqBAqGlkBTY+hqAi+wkDKc0SuRhKGH5Zao21PYfrRA6czeRMzIYmhJ/GBxgx/fuQ29q4PaC68sT38plLhDI9gnz+BeGFp0rqhNX6DQvQ0kNMrDKKpG4Nt4Tp3AswkCl3ppkFgiT+DZeE4DGfpoehwZBniBBzLEdy3MeB67PommJ/BdC1WA16xhJLNXH+tlWJFRMdd1E9+ymsrTe9E78yRv3Tzzzfz2NDWTRGuNBhNxP52HMIwIA68D1ugFvMrywkVaewE1G3lG0vNxr1CRdTmCagPp+wjVQKgqWlvu6vTpEuqvH8Lo6yT7oXsRikLyvt0Elk185wbUdAIZhjSPn6f6vT1I+4ereTMMwPdCjLjK1vsKqJpYtna8UARa3GB6/xCV42O03b120W36PnUzk2/0E1gu6gzhZqI1RuCG5NfnaExYuDWH/NoczZKNZt4YR9o6O8Ho37y26Hf+MmUFVgJnsk7+llUopkbo+PgNByWmoyYMhCoQioJvuRTf6qfjvRupnhjHbyzteV9c0QeOT2AvPiHFUyo9mxKYcYXSmHvNXl7MFKxfo/ONJxs8/J44+4+43LLTJJMS7D/ssrZPIwyiwg7bDunt1shlFQaGfJ54er43Hzo+Y8+dpLC7d8lqMC1pEutIL/p+6d2dZD/4EMI0KT/5NNaho0jHxVy/luyjD5H90CO4QyM4Z84veT1+6FBtjpKOteMFTWr2OK4/95s37CnSsXZieoqaPYEkJK5nCUKPhJGnbDVoOFO4vkUoA4r181humWy8C1NPUbaGKDcGSZvtOF6dpreIHotpEN+6CSWZmMfxdjU4p84ycerskt97do3xc3tm/7aqCw2z0yhy+YiqU+eoTs3lticH9nH5HB76Dk558moV4otiRW+t3pknedtmqs+/g7mmi/zH7pvtRbkUQtdmCSPVTAZz9SpAoCTi1N9aQQ7hMizXoEREl22zSSaha2QevoPkrVuWtbvWUZjX1Kkm4zPHusqbGoZUnnoNY1UH8Z0bEZpK5v13zTbaBeU65W++jDdeXN51fJ8R+JI3Hx+je2MSKSWvfWWZ5ZeKQInrhG7A4N8dpO3ONbBIXD+1toW2u9Yw9vwpJg5Polw0XBKKp6JKPEVXCd0JJGBP35iqoMpbK2veul7Uz02R3dbFhp+/l6DpMfHyGazBEqs/fQsyCCgfHsErRyX4WtLELTeRfkisI03nQ5uJd+dwSw0qJ8ZJrsqz7qfuxm+6TL58ZkmjUi/51Ioe8b4Y9jUqdMJMEELCPbfHyOdU7rrFJJlU8DxJZ7vKxGRAPqeQSykoQiERFzju/N6KS1F8ewAZhAhlcQ9LKAKzkEA1VAL7Ug0chdim9ejdndRffZPay2/MeiTNw8dQ4jHyn3qM9P13X9GoAEw35sLMtjc//BlIj+HSfPLK0crReX9XmnOsElP1aDK23Lm5KDrm/JaAS6HE4xh9vfhT1z73vfuYm9uEoqKZCfRkJqLDWiFWZFQabx7H2n+asBmtqup7TzD95ecjfZJLoLfnaf+FxwAI7SbOhQGklKjJlauIXSuUzNy5hKYS27jqmo8lDJ2rdnXNICjVKP3dC5FmTE9bxDbMTB7la89hHz//AyutvSokVCcdzISKqgriqeU9HkIItET08JUOj1B8e4DWO9YsuGVKTKP7A1spvj2ANfmDIzyMBiPo+fz9TD17OKKmv4HwqjYDX9s/I2gmCZoe9fNTTO2JfvvA9pCBxKs0OfPHrxHOSBw7U3XO/MlrUeWOFxA4Pid+5/lIDsAPIoNyhWenfXWMqSGHZFajqImrEoguBseRPPmMBQLePuCgKFERkGYoCFXgOmHkVASSmfUAsHQxpluK9FaSq5ZupNWzcRRDm2dUhGkQ27QepKT+xt75Ia4wxDl/AX9yitjmDSjpFGGtDqpK97/5DZyz5yn93RPRZxePZ+i0/dJPgR9Q/NtvEEzP/OaKgt7VQfqBezDX9aEYBu7oBI09e2keO7mwXF8I9M52UnffHp07kSB0bPzJaayDR2geOhYVJKkqiZ3bSNy6C3NVN2ohj97dSfeGX58NZUk/YPQ//fa8cJje1UH+kx9B72wHVUUoCtNfeRzrnaX7eZR0isTuHSRv3YXWkie0mtgnz1B75Y3IkM2cT+/qoP0f/SzTX36csNEg/eD9GL2Rvo9zrp/6K2/gXBhCqDpmpnUu5LbCBNuKjIr0g9meh6Bq4Zwbwa8spCYJqg3CmRslXQ+lUMBc3Yc3vnQy7oZCgBKfY9eUUoIfXL1ibAmslHLdG5rAOT+M3t02O7H6pSrWwVM/NHkUoasIVYnodmYQyQmvY+yMhe+GWFWP/sPLqGYRzCglRpVgg986TG57N1pyfveyEILM5nZablvN2Aun3lXjKhTliiFLRVcx2jPLlg5YKULHn68+CQupUCTzmg5lIBdsczWFyUtRGndp7TGREtLjLpWJawux2s7Ce1ZoN9lwdyunX5/CTGlMDzQwcwahL/GcACOm4pdcAvdyKeOoj+VKRkWN6Qh1flhIqBp6ext+sURQW1i5F5QrBNUaekc7ekc7Tq0ePYfpFEo8tkjoVqAmE0g/mGvoUwTxHTdR+OzHkbaDOzyK9H30tlYKn/sU9Vf2UP7OM/PmN727k9af+CxKIo47MEzojiEMHS2bJXnbbtwLQ5FRmYls+JNThI0GyTtuJZguRYZqpn9PhuGChvGgUqP++l601gLmuj4Su7YjdH1J2no1m6Hwo5/E3LAGd3AE+/Q5lHiMxM07iG/fSvFvvjbnyakqajZD8u7bMHq68ScmcfoHUOJxEju3Ya5ZxdSffxl3cBjfbkQd9Y3yiuesaw5aN08OYJ8dXpTrKqg3qXz3rVmPhlCimAZK4vvkqUjmNVhK26Xy3TfwRpfXMHkpdFOhPdmgpkkKvTHcZkj5Si+rIojv3EB8+/p5D7bWkiX7oXuZvkIz5Y2Elk0QX9NG49QooetjtKTwyg3UmDHjNcZQEwbuWIXA8WaLL6pTLs/8ycCKniMhBIqmRmE+L6B6YpzSoeFFcyt6Nk7bPWspvj1wQ5veLkfnp+7AHqsw9fQhOj99F2Znbv6YNYXU1pULEC0FRWgYShwnaKApJr500YSBHzooQkURCn7ooQiVUAZXrxS6Blw4UufCkRt+WACmBy2cXQGV0Sbr72qlNmGzamcOq+LhuyGZ9hhnXpukeZlRQYJ3FcOoaMqCoh+hCpRkAn9yatH3RTou0nUjaen0tVWV6u1tZB55L9JxKf7VV3EGhsD30bs6yH3sUdLvvYfmsRM4Z/tnBiUwVvWg93Yz/bd/R2PPvkhQTtPQ8jmUmIk3MTPH+D7W/sNY+w+jtbaQ2PX/Y++/o+w60/NO9PftdHKqnAs5AwQDmMlmN9lNsoNa6qCWZGXbkq2xfG2PZ42vRnfZy2lGo7HloDTKWS11tzqwGTowZwJEzqGqUDmefPbZ+bt/7EIFVEBVAWDTc+/DhQXi7H12Ot/+3vd7w/PswxkZo/jsd5HWys8jME3MYydBQOLQXcTv2LfqPaQee4jojq1UXn2L8itvEJQrCMMgunMbDT/+OTJPPc7MX3wFvzifWYnv30PxG89TfecwQc1EicdIP/4R0k9+lOiu7ThDI9TzYeh7Iy20GzYq0nJWdDSl7VJ95yxIiZpMEuntCa1kIr7R060bC/tKpB9gXbhK/cTFVb8jFOjencSIKlhVn6buCINnaiQPJEFKjKiCbihEEyrZVoOB01Ws6uIBrzU3kPviE6jZ1OwKyQupz4Ug9ehdOEPjVF87fttXLFo6RnxLK+aVCfRMjOSuzjBx7PrYowX8ukO0PUesu4n8a/Pd3I2dUX7qf99FZcahWnD53h+sHCteCKGHBIO+62Pna0y+2Ud2fwd6MrJ4PyFoun8ziW+donjy9lFm+HV3bhWWfWA79lgRrzpvxBS4Zb+BQKE1vg0BVJwZGmNd1NwSMS2J49exgzDJqwkdQ40zXlt9HH5YEXgBmqGQaYtimx6plrD0tDJlIwNJsilCvbx0GpLe6gZ0OaE6CJVS5SoRhmvVdSKyMT4vY0svRlc7pRdewu4bmPvcHZugfuos0e1biN91x7xRkTI0ZEGA3twEqgK+Ap4XGr8PGGo2Q+zAHrx8geqb7xCUw6iCdBzqp89RP3WO+MF9RLb0LgqfOSOjVN85QlAL58jArGOePkvykfsx2ltvmhZqXUZFiUVQEmsXbfHyZfxqFWd8Aul5aJn1l6dtCFLizUrsQuiVXqtGWw2aodDUGeHSkTIHn2jAdyWZFgMjphJNqOiRkL/JdQJSDTradTQmSjJO0899eo4o0i9Vmfnr75B88A5i+7agJGNkP/0I3kQB68LAbQ3/uMUaXtVCuh7xvV1Ee5uwx4oAxLe3UTk5SLSnidrFsbAixQ/wPcmz/31gbkx5ztov8Fq5qw8gYfrtfto/vpPcgc4l5cVawqD3C3dSOjt+wwlno5h89ugclb1ftRj+45cXNUAqEZ3eX37ylpxLINCVCFP1AZJ6A6rQiaoJNGW23h9BwR6mM7mPoj22IuuyECqxWMNcyadpTuMvU6IqhEo0lkPXYpTLwywcSLqeIBrLIQOfavXW6paceiE83pGvDaFqAkUVDLyfBxk6ZCvlVdTo6tNM4HjLyCPIMFSlqiszIM9S7GyER1DoOkZrC0LXkZ5HdOe2RduVVArpB+idbYs+t/sHqb1/nORD9xLdvYPa4WPYl/pwJyYJzFtfSbgatNZmlFgMd2QMb+a6vKCU2Jf7SD58H1pz0yJD4QyOhsZx4e6OS2BZYf74Jntn12VU4ge3kXni7jXvP/ZfvkJQqRNUq8T27Mab+eCqH5zBCQLLRolGwgHU08Zc1nEF+E7AxECdRFbj0pEymqFQnnbQDYFmKNhmEGpWlLwlSVAR0ck89QCxPVvC3hjXo/T8W1RfP4ZfrKC3N6I3ZdE7W8h85hHc0Sn8VViQbxaB7eGMF1EiOs5UmcB2CeouMghQIjpeyWT6eycxmlIh0aEfjrum7hgd2xOoumDyap2pwbW9KEJTUPQFnEszNcZfukh2T/uSvIUQgqZDPaR3tFA6e5vybAu824lvHlkiExy4HtVzowSrlPKu+VRIAumRjbRT90q4gY0dmCSMBibNK7QldmD7VSrOFFE1iSK0Rb0S15BIttHadgDbKhMEPq5Xx68vY1QUlUSylc6u+zl14s/mGtuEUGhu2Us0lqNaGadaHed2eS6+Jxk6WZw7/EoGRQiBkV09QuGZzhLnQgYyDM0kYktEziA0CooRMhQEa2Y9XzBbKgJhGAghyH36yZUN/XUlwH6hSPEbz2NfGSC2bzfpJx5FfuRBrHMXqb51GLv/6geWN1V0DaGIFbV2glm1VEXXFxkVadur5JcFN2tV1mVUvOkS5pmBuX/HdvUQ2dRG7dglvOlSyHnU2UJkSzvll44iZ8MPSjyOdeXKB7dSIexyd4Ynwy52RRDZ1IHe2oA7tvIyNQhg5OLSqqTydHgfC+nEF1GLC0H8jh2kPnoPzJYP146co/LK+yHt+pk+yt9/j4YvPI7QNeIHtpP51MPk//o715/qhliU2BNLB/3cfo5H5VRIpe+V64u+s/D9cafnE/GKKtj3WAPTgxZmyaVrd5L3n11bf4+iKSjXkTOOv3SR3i/cuWySVono9PzIHZw+P7GiiNetQvnoMiWngWTmpdME9s0TL0oCJs1+NMXA8qvUvTK+9Kg409helZHqGfzAxZMumjCQK8zAkUgK1zUZGX5n9qUPn0sy1UF7+91IYGz0MLXqOMV8Hy0t++e+q6gG3d0P0ti0C8euYJq3PxxzfVJ+WSiCWHtqxc1SSpxiPZQkX/i55+NN54ls34wSi+Jf54irmRRKMon0/WUoTJaZFAWISGR+VRNIAsdBSsnMV76BN7Y8j2FgLzXqfrFE9Y13qZ88i9bSRPzgPpIPHEJrbiL/t9/AHbn1ypbLX5uLDCRKNLLsdiUWC42u6yy2+rc79L6ena3Lw2FyHohsbie+dxNj/9eXsa6Mzl2oUFVSjx4guqs3XJ7OrgyimzbhFT44QkGvUME8cpZIbztC14hs7iDxwAFK315jR+s6YPS0kvv8x1Bz4cvj9I9S+vbr+KVZD8rzKT33JpEtnSQO7Q37Vz5+H87gONW3T61L5nRhrkgoClpDBndkHQUINxhPVs1n8qqJbfp07Fh7YYVQFcR15IFexWbwq8fY9U8fW1Ldg4DcHZ3kDnaRP7q2vM3NQMvGUeORJVVB9ngJRSoIBJ502ahn7wQmThD+NrYfTlxeEE5IdW++N8JZZoVyDdXKGLmGrWze8jhTk2eo1SYAQe/mjzLY/wrRWI6unoe4cPbvlnw38B2Gh99BCEGpOEix2L/he7mViHdkVl2pSC/AnqrOlVXPfe44WJf7iO7eTuLuOyiOTSwqcTW6u9BbGnGuDs3rzMjwe0osGlZMLYCaTqM1ZHFqYXRAui7exBTSdVEiEey+dVImSYlfKuOXythXBgiqJpmnHsfo7lzGqEhkIJe+AzcJb2KSoGaiZjNozY14Uwv63xRBZPsWgpoZfv4BDoX1Jeol8zXPzVkC18Mdzy/i05KBhzM8Tebjh1AiOhIFrakJJZFAcT7ALnLfxzx6gfg9e4hs7ULoGplP3Ic061ReO7aiTso1KKk4Rk8bfqm6qj6KkoiR+8ITYXgN8Gt1is++gd03snhHz6fwN99Db2kgsrkDETXIfvYjuJN57Etrn1SdkanwNxBhIjN+5w6sC1dviaEMfMm51/NUCy57Hm1k7PLae0mEqiz70ky9PUDnp6ZJ72hZvL8QGI0JWh7ZSunc+Jr0PDaK+NZWOn7yEfRMjOu92P7/8xkyxQYUFKbtIVx5e0WjVoNtl+i7/B3SmR46Og8xNXWWujlDNJIl1xDG/CulIVaaIWTgIWVAMPv3eiAUjUgsi+eYeO7Kv7uqzedU9UgSu14IGW1XQNP9m1ZN/Dql+vJaO76PdeEy3n13k3z4fpyRMaxLfWF1VlcnyUfvR2galVcWMCVIiTM6htHRTmTbFvxiGen7qLkM6U88tqSb3eobwBkaJfXIA7gTUzgDQwT1OsIwUFMJtJZmnP6r87kSITA620EI3OkZZH02vBSPoSTiSN9fVmZCej5BtYre3obW2DBvdHQN3PXng+YeUblC7chxMp/4KMmH76fy0uv4pXJY/bVrO/F9u0PGgf7BGx/sFmLj1V9SomVTiKgB5QWDUIDWmEKJzy7JFAVF18Jejw+glHYhnJFJit96jZZ//HmIRlAzSbJfeJzIrk3UT1zC7h8JVxOBDBX6sin09iYiPW3oXS1oTVnKL7y9slFRFTJPP0j84A4gfCaVV97HPLxUGwPAnchTevYNGn7yabRsCr2jmeynHmH6j781v6q50T0NT+BOFdBbGkBVSDxwAL9iUnn12CI9dCUaQc0kQlr6meKaiBNlABfeLQJQGLexzbX/XkIRiGW66O18jfGXL5Hc3LiEt0pRFRoP9TL6wlnKF9ZOo7NeND99EL9SZ/xr7yKvC7M4+SpSyaGrURSh/ECde1WNEEifYqGPRLyZaDRLuTSI55lMjB/Dtsuo6s0pF66EaLwBzYiRzHbiWOWQDdypY8Qz+K6FpsdxrCJGNA0IaqUxEpkObHPlPKmWMGh5aMuqIXonb1IbLi67zR0ZpfzS6+Q++zQNX/ws7vgk0vPRmnKo6RSVV97EurCAxiQIqL11mMiPfY7spz5O/I69SMdFzWUQmoY9MLTIvnkTU5Se/z4NX/phGn/887gTk0jbQegaSiyGmssy+Vt/MG9UVJX4oTuJ7dmJXyyFyp0KKMkkRk8n1pV+nIGlK57ANLHOXiD1sUfC88zkZ4sPJNN/8uX5SIWqhiwCbS0o0ShGb1jyHr/rQNjUaNl4UzPUz16Ym0urb76L0dFK8sFDRHq78YulUDa9s4PAdii98CJ+Yfnne7uwcT2V4SmCuk3bP/silVeO404UEIZGdGsHyYf2Uz97lcBykLZL7dSpcGm6ikdzWxBIzPfPM/0n36bhJ55CTSdQEzESh/YSP7gjJBa8tsoSIlTnU9Uwsawoofe/0pJVCBL37SP1+CGYJQm0zvZT+tZriwgLF19PQO3wWYzedjJPPQCaSvzuXaRHJin83ctrMrp+vkzltWPkPvsRhKaGhvKHHyPz5AP4pg2BjxIxQm17RaH69inyX/7OmrjGVE3wxM93853fG8QseTz9S708/9trCwsIRSyb35FewMzhAdo+tp3UtuYllTzxjgytj26jcmX6tlWCRdpyTHzjMNXTS1eEitAoMEJETeCvEpq6FRCqhvSvP8c8RXM2u4n2zkMAmLVJhgbfwvMsBgffZMu2p1AUjempc5RKV+nueYRYvJEtW59kavI0peIAQMg4u2ZhqXkoqk7gu+hGIqye9Cyyzdtx7AqqFqE4dYl04xYUJZwyzMpkWJCycoaelke3kehtRKxgVWQQULkyTX2kuPx216P69mHc0XGSjz6A0d2JYuio2Qz1Mxcov/pW2CeyAObxUwSOS/LBQ+gd7SH34MXLVF57m8ShuzB6OuebmaXEOneRyf/+ByQfPER0xzaU5iaCeh1vcorKG+/gLiwV9n3M46dD2pXujrDrXUq8Yonyd16m+u6ROWG1RffhuJS+/yp+tUb87juIbuklsGyc4REW0aPoGvEDe4nu2Rm+J4qCVyxjdHZgtLeF+aeBQaxLV+b68IJqjfzffpPYgb0kDt2JsbmXwKxTO3aS6uvv4E0vCIn5Pn6pEibwr8+r+D5BpRo2bt5kzmXDRsUdmWb6L79H7tMPkHnyXpSYEXYIV01qRy9S/PbbcxPZasqEtx1BQPWN4/jFKpmnHiCyszcsjY4YsEp9u3Q93NEpvBWYjY3NHWQ//TDabD+KOzZN4Svfv2FFl3Rcis+8jrGpPWyQ1FSyn34YZ3CM2ntnbugpS9ej8tJh1HSC5MMHw3sxdDD0OWoaAXMhByWirxp+uIZIXKV7T5Ku3Un2fqQBRRVkWpZPAC6LFVYqANW+GabfvRqqAV5fCaYIOp7aw/CzZ6iP3phFeiOonh8hsaONypmhJVr0DUYHilAwlDjT9hCef5vGqqKQ3XYnpb6wX0Aoatg1nsjglKdR9Aglc4TK1RkIfHzHQjEMVCWGY/hcuPhNjHQDTjmPUFQGhl/BvVhZlIANAo/h4bc3dHmuXSWWaqFenSKabMZ1apTzA4Ag8F1cu4ZtFnGdGhCKPEkZoKgGwTLPLLWtie4f2o+eWnkM+ZbHxCuXVi/U8H3svoH5PhJVofWf/EMim3uI7d1F7d33F+UkpetRP3Ga+omlXaClZ7+79PhS4k3PUPzWCytfw4J9nf6r5PvXL1kRVGuUv/8q5e+/uvLhLZv833x9/ceumdTePkzt7cOr7ueOTTDyq/9h+W3jk4z/+m+u+9zL4aZoYO3LI0z87rcw2hvD/hUJXqmKN1FY2Vu/EaSk8sYJ7P6wMU66XlhZdjMIJPWTl3CGJojt2UJ0dy+R3nbUxgxKPIbQQkp6v2LiTRdxR6ewB8ax+4ZXDH1J26H80hGEeB8Ad3wGa4Hs66qXU6mR/4vnie7snf/McliRi+E6+IUKha+8iH15iPjBnRi9bai5dJjD8nwCy5n9HWaon+lbU9xWqBBNaghVkGzQEULw9t+tvYpFCLGi8ZKBZOx75+l4cjeRpsSS1YrREKfz6T1c/sONTYg3gjNVov2LDxBpz+FMlRfFvWeeO4VW1QjUAD+4fXmdSKaJSLqBZOc23FoJNZrAqxWJZJtQNJ3Ac4g2tKHoBtLzsAoTRNKN1GdGiTV1UJ8ZRYul8MwKseZu7OLE7Erh1lyfY5VwrBJCKNj1EvXq0nFfnFrctGnVlq8wi7am2Ppz9y/Jo12P8sVJ8sfXKYXhB5ReeJHGn/4SmaceR7ou5pHj6zvG/wOgKPBDn46ya5eO60gOv+/w9jsO7u0bwmvGxvRUFkC6HvbgMuV4qrKqIFbCaMRQ41huebY6Zv7tsM72YZ3tI6ql8QKbIFhHL8FsCEt6/pKqKr9QpvrmcWpHz6HEIghdQ6jqHEeU9PywCch2wlXWKm+sOzKFND0afvjTaI2NiLsUqk3vU3rtjTWFsZzBcZzBjfdoBFUTaQqEl2LmD5/FKxVn+3BkuLz3/Ln7WItGvVXxOfPqDIVxi5HzG+ifWdmmAFAbzDPx2mV6PnfHstvbHt/JyPNnb8tqxWhMU786jZaMosaMRTX6QleIa5k5OpXblVPRYikKl4+T7NgassDGU1gzYwgEQlXRjTRwrZFPEsm2hMSSnosMfLRIFCOVJfAcFE3HSDWECqi3OKQsZUC9un46IwiLNVLbm9n5Pz1KZk/bqtVOvu3R/1dHlvCjrQXW5X5Kz32P7KefIvPU49iX+xfRkPz/AoSAe+4xeOVVm0pZ8plPR5mYDLhwweNaW4qigOuG06Cuh//2vPDP7cS6jEps/2aS9+5Z8/4zf/U9AnNlg5CKNmO6RSJqgqieChuQpEQiqTrTRPUUNcclqqWJaEmq9hS+XMUUKwq5T3yc9Ec/QuHZ5ym/+vqyu8m6vWxT2XrhVyoUv/8yRnsbmY89hppOhd7jTR95bZCOE1atjE/fkmScBMySF/KdbY5RK3gUJ27+OV07+ODXjtP++I4lJaZCCKJNCTqe2k3fn763hGTvZjH612+suC2jtRE3UihaDsu/dVKw16M2GiaU7cJiB6xw6RhhS/pyTLDhynXm7NsgJflz7y3Zdnuw9uMKVUHPRIl3Zml9bDvtT+xET0dX7oIH9D5rhgAA1ENJREFUAtdn5NnTa6PpURRExAhD6NecRN+n+vZhglod6bprMijC0MPoyYeE0PVWQEoYHvaZmg4wTUk8JmhsUPilf5QgCCCVEnz7OYtyWfKZT8XI5QRDwz5/+dcm09O3J38J66Vp0fU5nRQk6B2N6K057P5xgoqJBPTGNFpLDvNU36pj0/aq2G4V1zdpT++h5uRpjPdSrA+T0Buou2UiWhI/cIgbjZhO4YYJSDWVwujpQrousT27qLz59oYoHNYK6Xk4Q8P4pTLJQ2tnGrhVME+dwTx15sY7rhGqJnjoR9u58HaR7fdmUXXBM7+xulbFemBPVRn7/gV6Pn9wyaSjGBpNh3oZf/Eitau3mHlhuXEoIH3nZszLE0SdBLoSXXcZ7q3BtZb05S5yDds+CMw22SqGihrT0ZMRjFycaFuaeGeG1JYmMnvbieRuzO0nA0nx9CjDz5xBaWpC8QP8ShUlFg2jBI4Dvj9XIq+3N6NmMyDAOnMJJR4NV95CYF2+EvZtaSpKNEpg1lES8bAsWIiQgsX3ka6L1tqENzkTGilFIaiZiIiBEo+Fq/5bHDfSUhFyB7qIdWYQisCeqlI8M4Y1UUaJaDTfv4V472xTcCBxKzaVS5OhAmYgEbrKph+/Z8XKOXsoj6pO8LkfiVEuSWbyAYNDfkhEmVD42tdNDh9xicUE//yfJlEUuHjJ48B+nU296ofHqJinrmBdDCtotNYcjV98jNIL72Ge7kPOdiYriSipR+4IZVNvGAYKXwzHM0kaTahCI6ZnURUdRShEtRSaYuD6FqloM3W3ONdQtuzNNObQW1upHTtBbNcO9PY2nKH5mK3e2kL2449TfOkVIj09xHbtQKgq1uXLVI8cnSNYE9Eo8Z07iO7agZpOgedTv3SZ6uH3kct02K4EYRg0/+SPY546TfXw+4u2xXbtJHnPXZReegVnNMxdKPE4iTv2E922FSUaxa9WsfoHqB07Pl/soKokD91N8q6Dc/Xype+/tJQCR1WJ7dhGfN9etFyWwLJwRsepHTu+Il2OAJI5g+aeKCdfnObhL3Ws+V7XgsD1mXzjCi2PbCXWkl7ywiS3NNFwVzfmcAHp395JU6gqDY/sYmK6ijV2rWLnJkmPgJbdWRp6U5x/YYjND7Xi2QFDRzYWTgLI9SbJ9aToe/32dWm3PLSFRM/K1PQCZgsxQioexdDQYjpaMoIWN9bc1CelpD5W5vIfvYOnJpFWHSUSIdrWgtqQxc8XcKfC/o9rXFZqJo0Sj6LmMniTM+jtLSiZFPbFfqK7t2G+dwK9qz3krJIBQlUJbAclaoSEZIrAOnkBozuUIdfbmlEyKeqHT6J3taF3tmG+ewLdTRIEAZ5rohsJ7Hpx7roVVQcJwRpzbnomxq5/9lFSO1pwZkxAYjQmufrXhxl9/gxqVKf1YztIbW2ifHESxdCId+VABgx+7Tgjz55GKILMrra5IZm7sxt7uoo5VAAJlcBHBhOcv+Bx8aLHyKhPoRDQ2KhQLAbM5EOjoWkQjQpOnHTp6/d4512H/oHbG/9an56K4+HP1vlHd/UgJdSOXsQvzpfR+aUa5skrNP29j6PEInP7Xw8vsJmsXkYimar1oQiFXKwb0ylgeRUkAYOFo9fOjEAhYBUjpShEN28mqJlUjxwhccc+otu2LjIqSjRKdNsWGrMhXYx9dRAtmyX78SfQMhkKz38H6XpEerpJf+RhvGIJd3wCrSFH7qlPoDc3UXjmuTWvfqTvE9g2iYMHqF+4hF+ebfISgtSD96NEI3ilcOmuxKLkPvM00a1bsc5fwCsU0JubSd13CPPYiXm/NAiwrvQR1Osk7jxIpKcbYSytsEnecye5Tz6NdaUPe3gELZMhvn8vdl//ikYlCCQzwxZaRGFmqE41f+srocoXJ5l5b5DOT+5ZMhkphkrHJ3Yx+cYV7Km18jktj2hXI27FwhkvYrRlwgq5BVCjOnpjCkUomH6JQHqrh1bXet60QaYj9NgTTTFcyyOS1AkCiWt6JBoj1EsOekzDiGuohoJT86gXHeINEVRdQdEEtWmLwJf4TsDk+XCCVTRBPBcJJYkR1PIWgSfD7xkKiiKoTtXx7LV7oUIIos1Jos0bo49fK6QfYI6UOPUfXqB8cZLonp3IfJEgCND37EBaNiISRYnF8JepFg2qNdSGLFp7M/gBxuZujO4OzCMnCWom0c07EIqCeexM2MfS2ED9/VMYm7pmWwRU1EwKv2oifR8RjaAkE2Fe1QtIZTfjBx716hSxRBNB4JHK9VKvTBJPtSADH8+zULUIvu+iaVEcq4yUPoqiUy2NIKWP0BR2/ONHSG5t5uJ/f5X8sSGQEiMbx3e8Rc5S4cQI5//ry8hAokY19v3KU3Q8vZfiqRFqA3lO/Otvh7+RInjwz36Gydcvc+WPwmIWVZEEv5LkzFmXCxeuo7hZQPpcq0kGh3zSaUGxFHCNOH1VaNpNJV42XP0lNBUlFllWc1mJRVCT1yR4V8Y8iZskkD5laxxfunNaEws1J+RqBoWwxju2dzf20BDu5BT28AjR3m6qifjcCiTcUUEoKlN/8Vd4+QLCMMh98inidxyg+NIrSNfD6utn4g//lGCW0gEhaPrxHyXS24Oay+FNrdHz9H1qx0/Q+PkfQW9pnjMqWmMDRlcnlbfenrs2JZ4guqmXyltvU37tzbn4sRKPLeYfkqHwjzc1jdbQEFJwL4P4nj04IyPMfPXrYe05IUX4agYx8OHFPx7kWu732/9tYG33uQ74psvEa5dpfnAzkcbFNDChiFcrjff0Mvr8zYX12j53L/WhGUb/6k22/i8/hJqILuKXEqrAaE5jqDFiegRNRHADG1feXA5JAI1b0ux4vJO2PTnGTufZ9lg79aLDwDsT3Ptzu3j/Ly+y55O92DWX9r05xs8WOPvcEA/8w90Uh6tse6yD7/2Ho9hVl32f7SXwJe/8/nlSrTEe/af7GT42Ta4nyYXvDVMeNbnnp3ZQm66z5ZF2nvvVw5THfsCqmtfBtz1mjgzS9+fvUb44CRLckTG05iYCs47dPzg3LoUQi9h+vUIROTKO2tyAny+GKyYhkIHEutSPdD1kEOBNTuPlS2jNDfjFMkHdCpsFp/OgqmGEQQj8fJFA18IoihAE1RpKIo6qRRGzKxEjmkZVI6iKhqJqWGYBRdGIxHPY9SLxZAuV4iCWmSfbuJVAzmowA6ntLWQPdjH63JlQ6XMW1uTSfJ0MJIHrQyDxXJ/xly6w9WcfmGV+YI7aX14rjgok0vURuoGWSnPkuE2xuNiBsCzJseMOVVPFaGzEmZnkK181efqpKJ/9TIyxMZ/vfM+ivgpPbKSnG2dkFOk6a2qavh4b71OZKqJEDRp/9KNUXj+BN1NB6CpGTwuZJ+7BnSws6V6+4TGDjVNkaLkcRmsLtSNHCeoW9bPnST/6MFpDA85CoyID6pev4M3KiUrHwRkfJ/XAvfM62p5HsHDylRK7/ypGV2fY97GeexqbwC8Wie3cjtXXD0FAbOcOhKpgnpyvpZeOjZcvkjh4B95Mgfr5C0jX3TCdtjM2Tuq+Q6TuO0T1yFH8SuWG/UKKJnjgR9p48yu3lxCvcHKE0rlxmh/asiS3IhRB7+fuYOLlC4s1yxdgLcN87G/fxp0l0pSBZPD3X8SdWUCeGdHp+ImHsPwagVsPVyrcfFhAEhItOjUXz1nqCM02UiMU0KMahcEaI8dn8N0AVRcIRTB4eIrC1SqBLxk8PEX7/oa573tOwPGv9LHziU6STVEq43VUXUFK6H9r4kNnUJxinYG/Pcr4Sxewxuefv18s4xdDJ2s1AkZvVljPL4XfXcgaMbfP6ATeaFgAcf1a0x0OKyzNw4vleEXEIChXCHQd36qTL58LlRhlQDk/gOealPMDSCkJAg9F1bBnS64dq4Tn1MP9kTj14lw+LrWtGdXQFhmUtSLSmMC3PYIVxv01xHu34kxP8OyLKlqmFz1XRonEkL6LE0hev5jENWeIb+7BLRWwEm383SsezuTa3mvFMIhu3oQzMopfWX/xyoaNit0/RuGbb9D4xceIH9x6rSk4jPOP55n56itL+LUECnGRIi1yGGKpLkshmKIsZ5Z8vhYk9u8jsGz8chk1mcSdnEJJJDA62sPO1Wu60IHEy18X/rlWVTI7vwnDILZ7J/G9e0JFt0gENZ2e9fjXF3f3ikXqFy6RvPtOSi+9ggwCYtu34gyPLOrW9as1Ct/5HrmnP0Hj5z+LV65QffcwteMn51dM60D5jTdREnFSjzxI6qEHqJ04SfXdw+E5V6iAEQJy7RE0Q4SrFSnXw3W5ZgS2x+DXjtN4by+qsXQIxntztH50O6PPn1v+AFLeUBraHi/O8YlVzwxRPTu8qPFRaAr2RAmDGE3xXuzAZNoeuiUVYMXhKgPvTJJsjeN7AUiIZgxiuQip1lhIoRfA5IUihcEqZiFcHdlVj8H3JjELNhJQdQUjpqFFVPRYqCtiV0Jm2sCXoWSBlNSLNgNvT1AvOuuVE7/lkFIivQC3bDH97gBXv3aM2mAB6f4giiBCxI0GsoluyvUxqtYUAoHiSmTfNG5QB8/HlQECERqJmo+qGthWGUWEzz0d7aBQG5yTLJAyQAiVSnEYz513/IxsDKEqWBPhOGq8t5ft//hR1IhGbTDP6f8w32SpRDQiDXEUQyOzp42uzx4gf2SQ2uDqhSpaMk3gOkRa2qlduUBi6y7sqXHUeAOKFgqbucU8Qiho6Syxzh4C18WZGl/T4JCBj5pMbVh+fePNj35A9a3TmKf7iO3uRculIJA44zNYl4aR9aVecbu6ia3qAXx8/GWEKh0cyv76jUpIb7APNZmk8Ue/MP+5phLftydMdC8kXFxlphSGQfbJJ0jefRfVI0cxT5/Br9WI79lNfPeudV8bQYB1+TLJQ3cT27UTL19Ab2uj8Nx3Fv/AUuIMDjHx+39MbOcOEnfeQfaJjxHfvYupv/wywWrr1eVOW62R/7tvUnn7XZJ3HSS2Zxfx3buY/puvYl9dnmAu5KkUPPylDiozLlbN48yrt0cDp3BylJkjg7Q8uGXJNkVX6XhyD9PvXMUpLON5S1iPGu/wnyztYpZewMQ3DuPO1Aj8Or50cPyb9/LNvE1+IJxQymM1PDvALNjserKbvZ/upf+tCYyYBki67mxiy6PtTF8qMXmhiKIJtn6kg1x3kiN/fhEJtO9vwEjobH6wjYnzBaYuFgGoTtbDZG5HHCOhs/1jnWS7Erz9++coXL25fNR6IaUksD3smRr1iQqFEyNMvnaZ6sDa2HG1SIJYpoXK5ABGIotmxDCLY0smQNWIEcu04tYr2NX5eULVI/jufNhS0Qz0aAq7mgckppMnE+/E8UwSkUYiehI/8EhEGjHtPKqhIYSCEAp1p4SUPpoaRUEhm+imak0CEkWopOPtIKFkDhNIH89Z7PCFlywRs1kBc7jI8DdO0Hiol0hTchFLdvMDm8nsakX6Es90mHz9Cle/fOSG5KrWxAhaMo2Tn0JLpbFnVyB+rYqSzYEAJRJWMwpF4ExP4tUqa/Y21EQCJRoNK+rWrFUzj5vqqAcIyia1d1fwKBdAoNCpbmM6GGPEv4zHUqPjbDCebXR1oWbSVN55l/qFS9dOSHzvHhIH9qEmEnhOcU3H0nJZotu2Uj9/nsJzL8wZoNjOnRu6NgB7eARnfJzk3XdhnjmLDPwVJ3aCgPq581iXr5C85y6yn3ySyKZe6ufOr//EUuKOjlEYHaN+7jwNP/JZ4vv2YA8OLTvAZCDpP16ay4W51u3zLqUfMPzMKRoOdqHFF9PlCCFIbm6k8VAPY987v2RiktcaPG8S9mgBgSAaiWP5EiEU2ABv1kJMXyoxfSkM0Qy+N597e+f359+RTGcCNaJRnbaI2j521SWWNfBdSW3aQo+qeI7PTF+FyfPFRcc/NTIAwOjJ0Nhve6wDz/KpTVtoEZXgNvGnwewqxJf4dRe3XMcp1rEmK9THy9QGC5gjRczBAk5xfQ5QLNNK1x1PcfGVPybbsZtYtpWho9+eEx+7BkXRSLduxbXrTF16K/xMM8h172e678jcfkIoKJqxpJVHCEE8kiOip5kqXyKiJ9HUyGzbQoaqNUXNniEZbSamZ9DUCAhBzAhVNiN6EoFAUw2EUJcdK06+RuAFRFvTOIU69dESI98+jZaM0PLIYnXJwskRrn75CIEbruzqY6U15TDssWFWmikDtwuCAL9apnwyfCbO9PrIWgPHQU0mF1EArQc3Z1RUhdiuHuJ3bMPLl6m8fpKgZqEkYyAgqMwPLgEYRJgKhjcc4loJsV07QCiU33hrsVa07xPfvYvozh1U33lv5QMsRCDDhJgfIBQFKQRaLkfy4IHlk9zXWlev0ZRc+/8Fk7a0HcyTp8l96mnQVKxLV+aS53OHMQzUdAqvWArDO0EQJugDuTTiNnuua9QoQlnQzj57XqOjLSzPnJ18ffNaDJgV++ZkAJffL9G6Oc7U1Tq+e5vFsy5Mkj82TPODm5fkVvR0lOaHtjBzeHDJaiU0Kuu8tlk2iCXBywA0JUpKiWEHtVtSAXYjlMdMTny1D1ULG2WlqpHc1MjF1yapT1bpf1sSCI3s7haK5ybnwlzXxpWiq6iGiltzmB6xmbrcH8pXuwHVaWuOIWItkFIy9UYfA189tspOQBAQOD6B5yN9SeD54b9tD99yl+ihrBdOvUyisRtFM/Adi0RjN0Y8y8zAUVp3PUpx+Ax2dQazOI4eC9kHtGiSlh0PkuvaSyzbzvj51wg8l5bt9yEUDas8hZwNV01VLuH7DsVgCCEUXM+iUL1KIH0UoVKxJmclA3xMO4/llJDIMCQmAxRFxQ9c6k6YV1mJ0qdyaZLA9mh6YEvIvL3K6sDJmxRPj60vGT7HP7pgjlGu/b/AmRwFxDzTwuyYX8/7omWzc4UMG8HGq78iOrkfepj0R+8MQzdjM9QOnyeo26Qe3k9szyYmf+ebBLOd6xKoYxIR1zQtbs2EpaRSRDb14gwNLTYogD00jDs5ReLOg1TfO7LCERbDKxSonztP8oH7aE4lka6H1tRI/fxFIls3L3gAgui2rUS3bELNZNCbm1BiUbJPf4KgVsM8cx53bD4xVjtxiuyTH8fo7KT8+ptLmq20XJaWn/tpAtvBL5UQuobW0IDV10/94uX5+43HST14X1gevWUzWiZN+rFH8fJ5vKlpqkfCMuzGz38OEY/hFwohXXhjA9K2qR07vuIgVjXBJ39pE6lGnVf+YoT7f6SNv/m3l9b03DYCJ28y8colcvs70NOLc2xCCJru7SW9q4XptwcWbZNBsC6PXE1FaXhkN7HNLSiGNjf8/LrD+N+8jW86KEL9wJofZSCpTs47XNndLVRHy/h1l+zONnzbo3h+kkhLkvTWRjI7mjHHKyiaip2vYaSjRJoSTL8/RKwrS+HUOOmtDchAkt4Xxa3Y5E+P49XWVhJu5WsUT4zceMfbiNrMEJn27fiujWtXUbQIWjSsDjTiGRR16VTlWVWmLr6NEcswdOzbc5Nscfgcue59iyZFzw/zu64/n+d1/fA3uN4c+oGztNZ0jUOjcmmKqbf6aP/EbuypCsXTowhFLKl03CjS25sxR0rkDnZS7ZvBmqzS/NBmnOkaei6G9AJqVwuoMZ36eJncgQ7UqM70e1fXrFnkV6sQBBvmb9ywUYlsaiNx13YKX3+NwPVIPXIg3BCEBib1yAEUQydmhZOFQFAMJmlVepAyoCpLS6ptHGnhLljYtTQrNDYqXB30Mc2Vk8vm6bO4Y0t5tIKaSfmNN9GamkIa6VKJ8utv4oyOomqClt4otZKHNTJK6aVXCCwb6XmUX38DZ3ISo6U5ZAV++12csXESB/bjlytE4ip2PSCejaBEdbxqjcq7C5bfuo64TlpX2jbOyAhKLL7stXqFIoVvP4fe3BzKnjoO7vS7WJeuLKoZT0QaEIaBDCT1y33UL/fNnlRBGGEYSRU6hWefx+jqQInHIQiwz1ykdvnioiKFqJrC9qtzpd1ChJLCZ9/Iz/37diN/bIjy5Ska7uxaslrRYgZdn9lP/shQWHo5C+nLdVG5ND95B40f20vpSD/pAz1UTl7FaMmEzp4foAgVXYmiCA1usqR4I6hPVmm+uwtFV1F0FadUx8hGiebiGOkoCEGkIY5Xs3ErNm7NQTFUpC+JNSWpNyfwHZ9ERxq3auNZLmpExVtrfceHgLnEMUskGrqolyaQfrhiELM0+1pk5QlZymBpZCBc/93S69MaGkns2oU9Po7Vd2XVfQf+4jBCU+j+/J10/8hBAsdD6CrF06MEboBiqKt+fzVEm5NYU1WSPTns6RrWVJVEV5ZYawoZSErnJvAtl2RvDmuiQm2wgJGJrUsEL6jVcIZHQ3aDDWDDRkVrSOPXLKrvncPoab3uoiyEoaMpEQ7o9899rqAQFQnSSgOutAmuM/9X/fOM+vM/2J49GuMTAY88bFAsBtRMie+BqoJpStrbVfL5OhNn3qa3XUU7qCMETE8FbN6sMjTs05G6xMTQBcqeh18sUX45TNp2704gZah22NFQRoy/S8sdUQRRSlMODfFBSgOXiSZUXCPAavTJ+ucoNbjsebCZ4y/lyXqDTL1+kXSTTrXgkchq5FoNRi+bOOOLfxARiaC3tGCeOh2GuK6DdBzM08uLe809cyVCk+xg4rvvEtezOL6JrkZn9c8dDCVOXM+Ri3ZSGBpBDleRQsULXLLRdpy6Rybag+3XUIVOOtLMaOXcXMgnCMAsu9z1VAu26XPlyO0n6bOna0y8eons3nbUyNLh2HhXN+ndrYt4oqQfrEt7JXWgl/FvHGbmxTNEWtJMfPN91LhB48f2oegqZr2E447jBGvPBcRigl/46QQPPmgQBDAzE/Dqqzbf/Y5Nrba+Cc0zXWaOjxL4QRjGmiVZ9GoOvuWhGCpe3UWL6fh1D9/1CFwf3/aYeGsAp2yhGCrVwQLSD1dxK5Vj3wiqESXeton6zChebRlFxhtAGAaJPXuIbdmGms6AIghqNdzpKeoDA1j9/bAcCaaUOGYRzw6p9Z1qgabNd9N1x9NhfgRBqmUrDb13oGoRPKtCceQ8MvBRFJWug59k4vzrCKHQsu1+Yrl2fM9luu8IvnPzBRiJPXto+MRTmBcvYF0dWJU01imaXPn9N4l1ZNESoQPo1x3smRp+3SFwFPr+5J3QMVpLWCqQnP73z2PP1Eh0ZWi4s4vA9kj2hqXmXs1BT0VwinXcsoWUkkhLiliHiVfdgJOkakS2bMEZHp5v2F4HNp5TkSt7A2oyBn6AH3gM+RfWfMhKsLjSKJFUeHyvzoULHrt369RNydCIT9QQpNKCU6ddHvtIhHffdThwQGNiIuDoUYeHHgo/27JVZcsWjcbGgMuXF79kRkxB1RT2PpTF9yT1iocRUzn7ZoGDjzdilj2ybQYzIzYjF2t07UrS2BHBLHnY9YBqwaN1U4xIQiXbYpBri9DcHcWxAjxXUpg1KmoqCYpC6sEHAKi+f3xdmvQL0RDtIpAuzfHNzFhDZCNtuIGDlAG5SBf5+lAoNhU4eIFNzEgT0zNMmX34gUdczxLTM8S0NJZXxfPnB5yqCRRN8PqXR2nbmsBzAsYub4CteAMY++55uj97B6ktjUu2KRGNTV+6mxPnJuabwfxgTczLc5ASr1QHP8CrWhjNKcy+yVnd+ijRahIvcGdLStcGVYNduzRGR31eftlm2zaNf/JPkrS2Kfze75rr+on9ukt9GU/SrSyeELzqvKNi2+FEWRu5tYY/vXkfpb6T6IkM8c17cStF1FgizKl4DooRxauVMbLNmOMDeOZ8CbbR1k7jp3+IaG8v0l3Ajq2qJPbuI/sRGPvD3w8n5QWoTPUDgsLw6WsliMjAZ+DdrwLhLCN9DyEEtZnBue0y8PEDj/53v4JAEMwKoA0ff252nwAZLH7v4zt30fjpH2Lkt3+ToL52Y2OPjmIPD1Hvu7ImFnKv5lC5tIJshhdQ7VteNmAlFE+FTpU1Xg4psK6tzAJJ5cr8sa45WyPPnw3zKFJSv67xMnX3PWQefpSR3/xvy4jGAb6PmkkvibasFRtvfhzPoxg6iXt2Ih0PoSqo6Thac5b0R+/EGZrEs+sM+5dvfLAV0N/v8fbbNrt26Zw96zI1HSCATEYhX4BsVuHYcZdoTDA2FjAy6lOtSc6ec9myRSWfl1y86DI8vHQQTA1atPTGGL5Qw6r5mBWPWFKjVvK4cqyMEILStAMSHEuGK6Bhi0rBJT9uE0up+J7EiCkMX6jRtiXOmTcLpBsMxvtnB6um0vRjX0SJJxARg9LLr+KOb5zu3var5K0hMpF2HN+k5hTwpI0vfXzbR1Mi1N0SkgBV6EgZYDoF/MDBCUwsr0IgPWzPxFBjSII51oLeAyk6tieIxDWklCiqoKknyuFv3T6Z32vw6y6DXzvGnn/xsSXULUIIMrvbaDjYxczhUBzpmje+VphXJkhsbaX07mXMvkkan9hP5NQQWiqG9H186ZHWm3EDa92qiRcvenznBZvvYIOAjz8R5Y/+wMR1oatbZfdujWxGwXEk5855iyg1mpsV7rxTJ5tVsB1Jf5/HuXPenCZGc7PCnj0azS0qMpD09fucPuXeVs0M6bvoySxaPIVdnMa3TbR4CjUWxzXLqEYU3zJRdANFjwDhhKVEo2QefpjYtm1UTx6nevw4XqEASLR0BqO9Ay2TwR5dJncz66DORbCuzZfXVX+F1WdLf3fpe4ucgeu/NwchwuvIrcxzthKsviuM/t7qYa8PAmGRynVjdJnVzqKV/MJiASGIbt4ShsVXgNC12ebwDzhR74xMU37lONlPPwBSomZTNP/cJ1FScQLTYvpPv7Okg1vDwMddQM8yexMIdCK4OIuoWc6eDV/At966Pra3+ovf1+fT17f6PuVpl/L08oPvcmFpA9ylI/PLwNKkM3eMuc+mQo9xcmBBw6cfUHn7PVBV/FIJe2ipnO16ULLDruGZeji5rtRXca2Br+7Ne7H5eljCbLohk4DpFRZ9pzzloGqCez7dyvHvTCFUwc77cx+IUQGYfneASt806e1LhZ2MTJSWR7dSPDOKb7phTmUdRmX6pdNos+zaxbcvkr6jh+anD1J49xJuoYahNoW6JkJsOBTv++DYEt+fz089+WSEHTs0SiXJps0qP/73FP7pLxeZGA9QVfhXv5LE0AQjIz7pjMLOnRoXL1Zx3fD7B+7Q+NSnouTzksZGhZ/8aZV//+8qvH/k9lmV6mgfih7BKc3g23Vk4GMVJhECAtfBrRYJPBffNgnc+fdSiceJ9GzCK5fJv/ACXn6+wtMZG8O8cD5kDf4Bqkgp0ShGW9uGPfD/J0BNp8O87TL0WgBqLotfrhA4Tpiw3wA2bFSk61F+7QTWxSGS9+9Bb29EBhL7zVPUjlzAK1QW14gj2K0doiSnGbwuJKaic0B/hD7/NPlgMZWAEJBIqyjaDXjE5CyXTgCBJ3GdgOVWdstB0wWxpLKoMWk98ByJWVk+Thz0n8OIKmhAJKsAC35MOds4FoDvSTxH4q2hjFfVIJZUUVaQ710XJJgVn+khi+K4zcFPtDBwqoJQBHc8vjyv2LogQGvMoiSiOCNTKLqGEo/i5cuLPCinUGf0O+dIbmpEuV5yWFVouqeHsW3NFE+OhuqW7tpXFPZwfq78wy3UGPivLyAMFd90EK7EMSxiampDt5dICFpbFXbt0vjoR6M8+20LzwsjnF/+ch0BuG5oFP74T3Pcc4/Bs9+2yGQEd91p8Gu/VuGtNx18P6xGt2Z9EinhzTccjhx2sW1JIqHwb/9dikcfjXD0ffe2dc2H4azFTpVbWRCWXintJASKriEdh8Benm5pJYMiNI3Ylq2k7jmE0d4OQuCMj1N5/zD1y5eXfK/97/9DvEqFwne/Q3TLFlJ33Y2WyyFdl/rlS5Tfexd3amoulJbYu5f4nn1EOrvQmxpBKHT/8/95Ucd4/eJ5pv7ua4vGpNHWTutP/L2QsHW2iKR2+hQzz3xzyT0o8Titf++nqJ0+hVcokHv8CaTnUXjpRezREbIPP0pi7z6cqQnyzz+HO704/BXmovaSvONO9OZmCHyswUEq7x/BGry6KOSmxGK0//w/oH75MqW33yR54A4Se/ehZjIEpol57hyV94/gFWcdR0Uhdc8hYtt3EOnoQM81gKLQ/b/+q0VzdOmtN3AmRols3oQ7OYnVdxV/A8n6m+tT8Xyc4SnyX11Zd/kaBIKUkmPSWyofGuDj4ZAQKfIsNiqJjMqv/sl2Nu+NrXhsKcGxAiwzoDjlMjnkcOFolcsnTQbP16mVV5+A9j+Y4hf/Yw+5lvXxel3DsVfK/B//cOnSWNXgJ/5lJ0/+5PKTs+9JLDOgVvIYuWLTd8bk4tEafWdMyjMrW8RNe+L80q/10rVtKdXNelGvBvy3f9HP0ZfL+L5k9EKVT/5SL4o2XwV2M1CScWJ7N82HLYQgfnAb5RffJ6jMr7SkHzBzZJDK41Okd7UuqQSLtqVpfXQ75fMTBH5AsI6citGaIbBdvGJ4Pt+0YfbUOaMTAeTtIbxg/S/Ql74U54knonR1q/zpn9b4ylfm8ymGDps2aaTTAk0XKArkcuF95fOS55+3+JmfjXPwoM6bbzqcOH5dmbkm6O5WaWhQMAxBLCbIZj+AkrwNQNo2zsQE8Z27SOzZS/XEceQaJiQlFiP72EfJPPAQXrmEN5sYNto7aP3xn6T01psUXn5xXnJCCNRUCi2TpemHPovR2RWW0xcKqIkkmYceIbp5K1Nf+Ruc8TFQFNRMFqFpeIU8ajKJmtSxhoYW5ROcyaUksX6tSvXkCdREEqOzk2hXN+pKYSMh0FIpEvv2hysyz8doa6f5c1+gevI48R07Caw68V17kL5k6qt/M/d81HSGhiefInnHQdyZabxSEaEoxHfsILF3H4Xvf4/S2/MkswiBmk4T3bKFSFcXeksL7swMXqGAlsmQ+/gniG7axOTffBm/WkEoCnpDQ5hbLBRQkymEqmJfHVxURh9SSl3Er5l4M/mwmvQGCr7L4aY76pVkjOjWDpR0ImTbnCpiXx2f01eZR0jXvVwnPYSGRWGFZalgVSU5ISAaV4nGVbJNOpt2xzn0RIbCpMvJNyt87bfGmRhcvQoipC1b/wu7Fn6clY6r6YJkRiGZ0WjtiXLnYxmqRY9Tb5V54c+nuPB+bVWPdCPXuxpkAIefmaBtWwIhoDR58+W1QlGQro8zNIHWnEWJGGi5FEoiusioQEhpMX14kOTWpiWcYEII2j66neFvnaQ2VFxX+Kvt8/dSOTFI4c2lRSN2YJLSGtCEgRD1dXfUf/3rdb7xDYtf/MU4jQ0KmhY2wXR1qfziP4qj64KxMR/HgXh8ccjhv/xGlbvuMrjnkM4v/GKC06dcfvu3alQqkmRS8HM/H2frVo3BQR/LkuQalGXzgx8G+KZJ9cQxIl3dND71SSIdnZjnz1Hv71vZuAhBfM9e0vc9QL3vCoWXXsSdDif3SHsHuU88RfqBB7EGr2KeXcxarbc0Iwyd/AvPUb90Cem5aNkcDU89TXzXbuI7d+JMToDvU37zDcpvvoGWy9H8xS8RS2xl6qt/e8NEvV+pUPj+9wBIHboXo63ths8h0tnF5Ff+BnvwKg0ff5LUvfcR37GTyb/9G4K6SdvP/jxGcxNaNoc7OYHQdFL3HCJ5xx1Ujx+j9NYbeIUCQlWJbtlK7omPk3v8CayBfuyRxQ55tKcHd2qKqa99NdzmBxjt7TQ89Uli23cQ3byZ2qmTSM8j/8LzABidnbR+6cdRYnEmv/xXyybq9eYm9IYG5Cx1lFcs3vC+F2LjRkUI4ndspeELH0FrzIRxShkuca0ro+T/9mWc4XnrL5F4eETF0ppzBYWIiOOzjNb9AkgpsesBpeu8eCHAiCpEEwqqKlBVgVCgoc3g0R9uoLnL4L/98wEKkzeO50op8T25bNXjsvvDmkJWEK5M8hMuQSARgB4Jr1nTBIoqUFRI5TTufzpH+6Yof/a/D3Pm3eoyNCVhyM1ZgUZFKKHBumZ0PDdY8X5cO5hzgBRN8Mlf3kQ0oeHZPtWCywu/uwKdzBohHRehqSQf2E/1ndNEtnZSeeMkenMOb3zxSkh6AePfv0DHk7uJtiSXGM1IQ4LOT+3j4u+8TuD6SCnXZFijnY0U31m+YEQgqHgzmF5pSa5vLSgUAq5c9viLv6jzb/5NivvuN/j+92z279c4eNDgX/7PJQYHPRoaFT73+fmVpRCh4/neew7Hjjm88brD//nrab79bYszpz2amhQ+/vEIv/s7NV591SEaFezbv7GV9AeCIKB2+jTS82l46pOk7r2PxP4DeIU8laPvUz11cgmPlNB10ncfQvo+xZdfwh68Oret3ncF7fC7NH3u86TuumeJUUEoVI4cpnryxFxoyBkfo/z2W8R378Ho7AodmtvBiLoKvPwM9tAQfqWCPTJM0rkTe3QUZyys3nImJojMrnhcwhxHct9+fNOk8P3vLprAa6dPY7S3k3vsoyTvvGuJUUFRKbzyMvWL886SNdBP7eQJops2EenpoXZqMTvzWuCXK6jZTEhOuYZKt+txU82PjT/2OH6pyvS338adLIafb2kn/bG7aPyxjzHxW99Y0FEvmQlG6VS34sg6VRkmkVU0OtWtqGiUgxvQt0g4+nKJ//YvBpZsEkAkrtK9I8qhj2d58JM5GtsNhAI77kzwyZ9p5q//8+gNjYVlBvzxvx3i9W+uPfSz1kbsmTGHX/nceaoLwnGartDcZXDXYxke/FSWnp0xdENh054YX/jldsb6B8hPLDaGfadN/t+fO79ic+LWAwl+9Y+3EU2EK7/f/ZVB3nxm+fuRcn5VrYjQGP3tv7u0YYbS6xHUbSpvnCB+cDtBzaLyytFVk+G1wTzjL15g048vI88soP0Tuxj+9mkC20MGErGGvFLl9BCx7kYqJ64uqR6KqEnSWhN1rUTeGV1Xr8pCnDrp8txzFr/8TxOcOukyMRFgO5JPfTrC1KTOjp3aIvGknTs1fuEX4/T3+9Trkr37dM6e9RgdCceGaUomJgIe/UiEbE6ht1elq0thbPT2qvbdDKTrUjt1kvqliyTuOEhy7z701jaaPvNZMg8+TOH736V66uS8VlAkSmTTJtypSdRUimjvpkXHU6IxpOMS7e5e0uAY1Oth4ct1k55XqRDYNkr0xnpOtwN+tca1ZG5gh83UCxuOpW2HSXI1fDe1dAqjvR1rcBC9qQktk110PKGqSD8g0tW19FyVCvbgdU6flHjVCtJ1UWM3lndeFqqC9ENdqQ+U+l5vDcvyJv/oObyJ+Uoiu28UL1+h6ac+gYjoUL8WQpGMeFeI6Ul26/dhSxOJJCJi+NJjwD9DRRaWOdNihA2Ly28zKz4X3q9x4WiNS8dq/Mz/1kVTh4FuCHbclaCp3WBy+MZx3jBxfsPd1g1J+A4svH7HDxi5bDFy2eL9l4r89K90cfCRNIoq2HVPkp13J3j7ueLSa1zFOAa+vK7EUq7pfiQQSWjc+9lWrIqHbfqce/PGv8kNEUjMY5fmT3IDjDx7mo6ndhNpWLqq1ZMROp/eE4a/AslKEdOFqJ4bpv2LD6BEdeyJ0iLDUny/n7I5QYA/K7a0NjgOfPc7NuPjPkEQ6sC8flQl3gANDQonT7r8p1+v8PSPNaLEbL75jSqvvuowNRX+cCMjPm+95dDZqZJMCt59x+GVl20KhfABTU8H/Of/VOXhRwyamxXee8/l5ZcddH3NZLM/MASWReXdd6gefZ9od09oYPYfoOmzP4JXKmENhFojajKJUFUi7R20/fTPrni85YZ6YFkEzgrh2SD4QdgTYLa8+doPNPt34K0cIbmW34ht3kzsF/7x8seUEiWyNH/q12rL95lc8142+BDUWAyvUEJaGwt/b7z6S4JfqiKtZaQ/TWvZz+tUueAeJaVkSYgsKgo2dSpBkaosbCj8sPzFwck3yxx7tcwTP9aIEIJss05Dm74mo/KDwmifzbN/NMnue5LEkiqqKrjroxnefr74gVBpyEBy8Z0Cqqag6QqedgtDB+uYCesTFcZfukjP5w8uFfHSFBrv6aE6cI0s88ZWJXtoG1oySuNH9+Fbi9XsZJ+J7itE1STT9iB1f20dxI4teeaZBVVOUmIGBn/653XSrRk69ksujNgYZ9Ocf3kMI5FkeMhHKIKuAwr1ksOx4RhvnnGJZwyqMxZBXKXrgI5ZdMh2xhi6VOH3f+/DJbq1HkjXpd53BXt0BOk6ZB58mOTBu+aMyrVBbQ0NUX7nLQJr+VWi9Pyl40fKDakS3m4su8Jf5TLlrDZQ/fIlKoffXTHctKz0hQxuy7wQ1OtEerrxK5UlxLdrwfqMiqog9PAr3nQx5CTa0hHqp3ghq6USNYjt2YTVN7pIFOkaHOrMBHVmGJ/l9bs9A6NeDRjts+YMdiSuzIWDPsw4816Vct4jlgyvtWdH7BbSb66MTQfTtG+No6girKYrBwycunnBqo1AegHjL16g5aEtxNozi7YJIUhuaSTWkUFZY7/ByJ+9uqzsNQC2T0xJUfOKGw59waxjqIR/ZztjjF8oIxQojpoEnqR9ZwbX9qkXHAZPFth6fzOaodDYm2ToeJ72XRmcuk/fO9PsfqINAnBqPtXp671FQTrVhaJoBNJD1+LUzCks6/bo3twKBJaFPTREYFloDfONh36lMpvEl9SvXF4qnncTWPF9ubbhB7WUuQ5+pRyyn0tJ7dy5+Sq3DwIrPQJNw+of2PBh12VUYns3k7xvd/gPKVFiEVr/px/BujiEX66BEOjtjRjtjVReO7HEu1DR8PGZJV647RNl4Msw36FA4IX9Kx92BJ6kOOXS2hMBIJn9YAyhW/cxS7M64Qo0dUfpPZDimd/ov8E3bw+qVwtMvTNA1w/tR7muy17RVJTk2p9LYK8c+0tqDcTUNIpQ8Bx7w9T3iioIPImqK0z1VTELDr4nmRmoUpm2Gb9YxszbqIaKXfUYPVskkYtg11zMgoM2WCPwJbmuOOPny2gRhZllxLaEEERjOcrlIVLJDiyrQCya/cEbFUUJE+PLyUOoKlouJEJ1Z+bzpoFtY166SHzHTqKbNlNdyajcIjlLuSCurSbiBOYHQ0O0GvxyGXtokGhPL5HOruXJKq+Ttbi5EwbhcxACJRbHryxdmbuT0+hNjfjljTmV6zIqiq6iJuZje95MCW8mTLgr0ZAh18+XqefLqNkUQlfnFBcFgm3aHeSDCaaCpb0qtxq6Ici16HMNgpWCR3H6w5vkXIiFTY1rrSy7WYxcqDFyYf4lU1T42V/f/YGcezn4psPUW320PLSFaMvGGhOvIXWgh9rlcQJzQQd4RCPS2UBiOk1gu+hKFFVsvBgy8CRXjy6dFGszoec5eN22mYEaMwPzz7sytTYPVcqAcjlMzpYrwyhCxbKLG7zqWwejpYXMI49iDQ7ijI+HCV4pUZNJ4tt3kLonrPKqHjs69x3peVTee5dIVxcNH38SNR6n3neFoF5HGAZ6YxPRnl6qJ4/jjI6ucvalWM4JDywr7IMRkH7wYUqvv4pvmihGBAT4pdtPoHo9vEqFyrGjGK1tNH3mhyi99SbW4CDSCYsN9OZmoj09lN54fd2lvcvBr1TwTRO9qZnUvfdSOXI4FOWKRAlch6BWw8vPhJJN6gqr+xtgXW9R7cQV6mevLv4wbPBYdv+FGvUCQZPaSTFY2mR0O9DSHeHAw2mECEt5L52oMda/fKfvhwnRhEJTx3zp6GjfB3PN2w9l6NoTTt6KAk09MQbPfLCytNejcHyE4pkxWq+TYV0v2r54P0O/9xKWOd/FrCaitH72EJN/+x5OJZxM1rNKuUZT/0FAwhyZJoBlFT+Q864HSjRKcv8BEnv3h3mBa8liRSBUjaBuMvPNr2MPL6AqkpL6pYvkn3uWhk88Se6JT5CdDQXNiaoJhfqV9fMHLueKSdumevIE0U2bSd9ziOS+/WHzn4TamdPMfOsbc/uqqRTZhx/FaG9HiUZRM1kUI0J89x46f/n/NWegKoffuyEV/qrwfapH30fRdLIf/RiNn/z0/PMTYo5Opfzuuxs/x8LT1apUDh/GaG0j95GPkrn/wfAZBJLia69iXrpApLsTNBW7b2BD51ifa+b5853MqoLR0YTe3hiuXpZ56StvnFrUBOlJZzb8deshlHB1ksxqtPVE+OF/1MrmvTGklFw+UePZP57EdT7c4S+hwH2fyBJPhT9LEEiOvlL+QKp9StMu6qUaiDD/d+7NwgfGUrwSAtdn8O9O0HTfpiWSw+uBGjWWGCWhKejZOIES4Mn1F29s+Zn7CJwPZuXrWx5Df3cCO19DVQw0LYLr1gnkh2flbY+MMP6Xf060uwc914CIhhGNwDSxR4YxL5yfJZhcDOn7VI8fo97XR/LAgdlJPDarJzRNvb9vMauxlNSvXEExDPxlmhcDq4554Tzu9NSyaof1ixeY+Ms/C+lQGkNWbK9aXdTrAYRGbbZPw6/V8Gu12dXS/DGFqiJmS4PxfOpXruCVy3PJdq9cCu97Zt6ZscdGQYRyAHO35LqU3nwd8+J5Evv2o7e0oBoRAsvCmZqkfuUK7tQ8B5/0feqXLhLYDtJdOnb9cgnz/LnlyTuB6rH38YoFEvv2o2UyEAS4pRL28CDe1BTe1M05/hvvU+lppflnn0ZE9DCfsswPWH333JxRCftUxsgojeSDcYKNGBcBm3bH+al/1blkk6IKonGFXKvOpl0xcq06thlw4o0K3/jdccb61xZe0A3BQ5/O0btzZVqYhbBMn6/91viamyVXgqLC7kNJnv7pFoxIOAEOXqhz4vX16xmsBBWNuEhhyzo+HhI59ztM9ptM9psIBDGRxJHuxnJeAlJbQv6uan9+ThvkRkh0Z6kNFZd8Xjo7RuH4MM0PblnfZagKmXu2EN/WhtGcpvnpg7jF+Rc50hI27AbW+nMoQgi6f2j/ur+3UTilOuMvXsDO10inuvC8Ooqio2sxHLeGEApCKHieRcRI4bg1DD2J41Sw3dtTbNGidJMVIf3QZDBM0Z2ifuEC9Qvh5BwlQbvai04Emzr1FchPr8Evlyi98fqazr0c99Y1ePk8k3/9l6t+3xkbIz82tuo+frm86nmuR2BbTH/z64s+s/r7Q/2YBSi//RZZ0UyjSDKJtkio0J2aovjySzc8l7Rtpr76lRW3WwMDWAMDqx7D6u/D6u+74bk2gpvqU5FBwNTvPbOEHPAagtp86EYimQyG2KTuYZd2D0U5iXtduKEmS5hy5ZdACEHn1iidW1fnvKoUPJ7940lOvlmh/7S5pAN/NWi6wp0fyXDnRzI33hkozbh843cnCPy10LWERks3xOy5BMmcRseWKIeeCM/Z0KaDgMKkyzN/MMn06K0rgY6LdKg7gU9CZHCkRULJoKHh4SJQMGUZQ0QJCIgSJyJilIKZJSqdK0KCdAO0TJRoS5JYWwqnWCfamMApWwSOj5Y08E0XPR3FzptEGxPE2lLLGhXpSwa/dpyGu7tRI2vvKJdSYk+ViW9tRWgK0c4cWna+Gcwr1xn727dx8j/YEN96YdanSSc7UBSDmjlJNt2LbZeJRnMgJdOFi6QSbUQjWVwjzVTh/LrPkRMtbNcOzuYlBBKJJWuc9t6Zc0JqQQldMehSt2FhUvQXe7ceDqVghialgw5lM1PBMO5tUNVUUGkQreTl+BLRv1uFOClUoa2pj+5GEAjSooGc0sx0MLqm9+rAPRE+//eSRGKC99+2+eZfV9igKONKF8Vd90VoaFb5/jM3X8K+YaNiD4zjzZSJ9LaGesbB0pppv1qH2clWQWGf9hAKCghoYCmPzoB/FtNf2aiENd1hjuR6XJPCVRRBMqty/9M54qmQOubSiRq10g+eM6m50+C3X9+3oKxx9i8R0soIETY1Dl+2+PrvjPPWs4WbXgEthCnLNCjt6CKCJx10oRMhihAKEeLkg3HSogEHCxWNBqVtdj9j7UYF8CwX3fFJ9uaoDRVpuqcbPWnglCzMkRKx1hS+GzBzdJhIQxy7aBJtWVkytnxpiqm3+ml9bPva+c4CiXV1mrHBGWI9TYx95R3qg9NL9vkfDboWBwSaapCINeN5NroWw/dtPM8inezE8+q4Xo2quTrt0UqoyAIXvWM0K520qj1c9k5SlcVF0YUaZdzAoUnpWPYYHi55OYEaaDQqN+bM2ijiJOnRdlJypwlW4BW8GQgEzUonQihU/dIiaY4PArou+KlfTPOf/nWeQj4gEhG4btiQ39SikkgpWHXJxKhHMq3Q1KIiJUxP+JRLAZGoIJVRiMUEmgaTEz6WKWnv0ojGBKYpmRzzSGUUNm3R2bxNJwgkI0Meq/RsroqNNz/ONiQ1/dwn8fNlAttZYlRG/+Of45dDyxcQcMZ9e1XZl7q8cQx/8GKdN59Z6jGoqiCaUMg26/TsiLFpT4yPfbGJBz6Z481nCjzzBxOMDdzYU/LcgJNvVBi6uLaeBcsM5jQ0bgQhQrba5SClZGrY4ciLJV77Rp6+07e+6U1BnWUyCF8MCSFdjoSESGMQoSpLc8Se+WACkNhyff0bXs3BmqphF+roCYPi+Un8uoOejiK9gEp/Ht/1cSsW0g+INieoXl3ZC3QrFpOvX6Hhrm6MzNrCknOQkqkXTuDMVP+HNCLXo2qOUzUniEWyeL6F6228t2YleLgU5RQxmaBJtlOQk9hyY+NxuSceIUaT0sFEMIhHOHPpRGhRupgKRnFm+fWjxMkqzRgiRiA9TFmlJKfx8TCI0aC00KR0hIZF3YmPhy3rjAUDQDjeG5V2qkGBqEiQElmkkEwHY9RldfYcCTJKAxHCcVWTFfJyHIkkKbLkRAutajeedBFqGHEpBJOU5HxpdEKkyYpmVKFhyRr5YGLuvgAMojQqbegiQl2G4cq1IggkV/tcHno8xntvWIxc9ZASerfqPPhYDNcLiUZf/14dRYW9ByNkGxTGhn2e/3qVjm6NH/mJJOMjHpYpOfK2RVunxr0PR5mZ9pka9ynO+GiqYMceg0oloGezxne/aXLiyAfcUR/Z0kFkSwdTf/ht3InCsi+sby6+qJJcn4TmEkgYuWzxzf97eQ9MiLB6qrHd4KFP5fjkz7UQjSs89oVGjKjgL35thOLU6h6360jeeq7Aa1+/9XX/vi+pFv25rlshQl2Ua+Gw8as2z/7JJFO3qevfxV4xBGFLExdnxVyXYG0vQrw1TqozRfFKEbt040HpWx523kRoglhTjPr0cp3DkD8+QuXSFA13d6+bnbly6uZIMT98kNTtIh8IzcJtQEwk2aTuZiYYn5t8I0TZpO2m4hZxZB0Nne3aQRQUTFnFUCKkZA7TL+PjoSBQUNHQF9QPCxYWE2voIdegYoW6NtIhImKUyVMnNCqtapgbsqSJLgw6xTb6/NNMBIOoqKhCRUXDEy7IpeMuI5rYqu3HkRYeDq1KNznRygX/KCARKOzU7iImkpRlnoxoJC5SWGtwoCGkdfryH1a458EoP/ozKc6edHjpOZMD90S479EoQ/0ujS0qQwMeV6+4pLMKqYxKOqPy0nPhO+t5kpdfMBkb9hECfuaX0nz5jypcOufOF+4KuHTO4Wt/VuGxp+Ls2Gt88EbFL1ZwhiZwBidxp4vLe4HLUg4INDRUNMJ4bYCHc0vioVKGnfTDlyy+8XsTSAmf/cVWdEPh3k9kOftulZe/NrNmAshbjfyYw7/+iYuYs4SSQhU8/dPN/PAvtmFEFXbclWD3oSTTo/kP/BrtFdWX1oeG7Q0UrxSJN8dBQPO+ZmINMQJ3lkTQUCj1l4g1xrAKFlpMw67YWHmLZEeSwA1oPdiKVbKIpCP4ts/o4VGcfI2xFy+Q2duOFvsQs/V+YPgf06CsFRoGKZHlgn+MQjBf+XTN6bEwGQv60YWBJnWG/Eu42EueSoQoEp/z3vs42LM5xfmXa8i/xDCXCJCzQoL30Kb0MhEMUpIzmH6VtGigKktc9c/PSnDLuWvsUrdRDvIM+GcJ8MmKFvboh5gMhijISZqUdjJKI6fddyjLGTQM9usPrvk5CAH5aZ/vfqvGuZM2P/4P0rz7Wviuvvy8yXe/FcpjxBIK//RXsvzOr5do7VB56KOxOftaLgVY9QXiY4ZCrTYbrZit3vY8SakY4HlgWxLtJkRRNh7+cjzUdIK2f/FF3IkC0vGWJOsnfuebBNX5yUpBpUnpoE3dRFo0oAgFW9aZCcYY8a/MLUlvBWwz4PD3S9z3ZJbuHTGicZV9D6Z49zvFG4p23S4Es0bPrM4P6te+nufOj2TYdkecaFzlM3+/hbPvVJge+8HJri4HKSWVK1OMPH9m2e32dA2nWKdQqNJ+qB0AtU8l3Z3Gt0POK6EIZCCJt8SRUtKws4HC5QKFSwUimQixxhjloTJ6Uqc6XqVhewN2OZwIJJLJ1y6T2tKElly9vLh4anQJG7FQNDLZHiLRkCbEqucpFZZnC7CmaxjTE3R0uXOrovNvTFO+QYOi0FS0ZBTftG9pubFvurjVFc69gMNHTUTw6+487fQs8sdH8C1v+Y5AGVbYfdjg4VKTFbqV7USIhhP8dUU8cpn/rodEMiPH55ym6/cQCJIiS0TEwpUJOoaILPh+MHec68+hC4O00kA+mKBF6QZAEzoKKmmlgYI/SUY04UqHopwGJC4OxWCKpFhbIVAsIbjnwSi6JsjkFCZGPep1yeVzDo88Eee+R2PUa5LxEY9KWbL7gEFbp0Y8sXxkQUp4/UWTT/5IkkvnHCqlgLMnl6YubgYbNiqB41E9vHpliXQXv1hNSgdbtQOUgwJXg3P4+MRI0Kx2ERUJLrpHcbh1zX5Twzbl/Pw1tPVEMKLKD8yoLIfJYYfv/tUUW/b1omrQszPGx3+iib/+Tx+yFz2QlI8WSU7ruHaV4atvcG0k6nqCni2PISoxfKPE1MkpgtlJfey9MXzXD3ednQCFIpBSUrxcxC7b+K6Pb/sULhdAwvSZaeySzeg7o7imO9dv4NUcLvzWaxu6fIHAiKRJpjtobt1PMX9lRaNSG5ghMXCRvQ91o2rhy/nG197n0turh0RjvU0YzWm0dIyZV86iJaNhqHP2nr2qFRqeRAS/7oRGoGoT2C5aLoF0ffyqhZZNzHLphYbKK5lEOnIkdndi9k2iZ+O4hbCnKH1wM7XzI3hVi0hblvrgNEo8GnaI12zURITx1/sYfubUh3txIxaHrjwcLvnHaFI6aVN76WQrY8FVxvz+dRWNSCTeCk2tOga96m5SSpZykMfDRV0L7fW1S0ZBRSVGYlFIdsIfohoUgTAE58tr1FThFflyBQMvBGo6hRKP4U5Og+/juZJqWdK4o4mCiPDmN65Sr0nOn3ZwXWhuVfE8ycyUz9/9RYXWDo1zJ23ef6uOZQZMTQpe/36dWlWiZjP4lSqvvFBn350+iZSC64Z0VudPO1y9Ej6nC2cchq9u3Clav1FRFEDijk5TGl9B/2S2E3ShUREodKs7mAqGGfDOzSlAChTGg6sc0B8ip7QyEVxd/pgbgGMHuAtoTqIJBeVDyCn5zvNFHv1sA/seDDvaH/t8I0dfLnPh6C1qPlQU4tt3Ebgu9tjwHIFdWG4mUSIRhKrim2bYxBoE4e88uw0pCWwL3YjT1LIXw0iQnz6PWQvLSFUtQlPbfvLTFynMTGDl1+8Y2CV7SQ7GKtw6ByMIXKbGTzE9eYZkemmf062AmoiiJKLoTWkibVniW1qJ9jThFqqAoHJiAKM5g9GcwqvUUeORUBagb4LE9nbM/kloTBHtaSLW04g9VUZLxsi/eoZIcxotE8fNV0nsaCewXGrnR0nsaMe8PA5I4tvbQUr05gyR5hTlk1dJ7OpES8WY+f4pvNKHg/H4msevLMjTRYgtmWdNWWXIv8i4P0Cz0kmPuotyMENZLtAnuYnO4LRopE3t5ZT7JhVZRCKJanHSNCy53mXvQ/q40mUiGGIyGFr0jWshNgdrdvWizH4m0BeshK47IGo2jZpO4U7NoDZkCTSNE+cdkk27qB0+jjcToLW1ENTqXLoq6csncadm0LI5zIrOlTdmUGJR1HiMIGnD3l30nzhDEEiMbJqgVsNP5zhxwSMwLZRUApFLMzE6XxI+OeazvODA2rBuo5J+9AB+tU7tyIUwnqMoxHb34AxNzlV66a1ZkvfvpfTdw3MiXQJBVEkw6J5fJCksCajLKqasEhUbFJVZAbGEOtdICGDVVlZA/EHCrgd87bfH6d0dJ92gkWnS+dTPtzDaP0SlcPNhFKEoqIkkVCvEN29Heh5+3USNxZBBQGDVEYqC0dKKnmnALRcRqopbmMFoakH6PuaViwAEvoPrKnT2Pszlc99CriC/qyga0XgjkUg6lCV1KtRrU3Oa2EYkTSzeSLU8iu/bs9/RSaTa8FyTuhk6LIaRIhZvpFIeJhprIBINj1c389hWEZAIRSMSzRCJpFEUHSk9rHoRq36dsqT0Zykwbl/CSro+XrmOlooRac0gXQ8hBG6xhhINtctrF8eI9TRhNCSxRgt4JROhq8Q3t2BPloi0pAlcH69k4k5XUAwNt2gi1HCfWE8z1mger1LHr1oEjotQFISqoDelkL6PWzLRMwm8Qg13pooa0/HWSG0lUNDQ0TAQKBhE8XEXVTQps2lyZdZb19Dx8efCReJaIl1oCAQqYVgowMeRFg42LWoX4/5VVKHRrvay0H3XMYiJJK60CZA42EgCxHWmx5YmBhGSIoMpK0jkuqIdgQzm7jcmkmRF86JilYAg7OcSaWIigS89fDw8XBxs8sEYbUoPNVnClhaKCJ9XaPgkM8E4Hepm2pRN5IMJIiJKg9K6YqJeui6BWUcogvid+5G2gzMyFjp2NZPY7h0EjkN062aklHgTk2iZFMlHH8CfKaDlsvimSfyOvdSOnECJR0MnMpAYPZ2hk6iqaM0NuGOTqJk0WmOO6qtvEdRvjRO3bqOSuH8v3kQhNCqAiGi0/pPPMfn738Y8Gk48WlOWzCcOUX7txCKRLl966GJp46KCik5kXcvataC1J0K2eT6pOz3m4Do/oCz9DTBwxuSd5ws8/mNNqKpg730p7vxImje+lb8+RL4hCFXFmZ7CaG7FnhgNDUokgppI4s5MocYT6E0tSCRqIklQN5G2jVcqInRjLl8mgbHh92jrvJtUupNyaWlllaIatHXcTXNbyK0khAJCYWLkCOMjRwDINW6jZ8tHOXvir6hVwlCfEUmyZcdTFPN9XL3yIgCZ3CY2bfs4QwOv0dC0E1U10Iw4EyPvMzb8HlJKkql2erZ8FFWNIKWPridw3Rr9l16gWl4fEeHNwJ4oYo3k0RuSuIUq0vNRYhHim5vxqxbORAklahA4Hl6xhtvZgFuoIb0As28CpMQeLYb5SUXBK9WQgcSvWgjTQYloSD/Aq1p45TBHULswiho1kK6PNZIPP5cSmYxi9k/OheD86tonjJTIskndQ1wkiYo427U7qAUlLvknCPCJEqdH3RGW6SpZDBkjLlJUZJFRvx8flxaliyalg5hIEhFxtqr7cLAZ9i9TkQXG/D461W3klGYCGVCRJTILEugxkWS7dscs60NoTKaCkSV5laKcpiYrbNX240qHiszT5y+f97seFVkgL8fnqrcCAvJyYo4pAMLCgKlghM3aXnZqd+FLj9Ggj+lgDB+P4eAKvepOtmkH5lYngfQ5672HR0BJzjDq99OlbqNV7caVNhVZCKvWrocQqKkkamMD7tgEsm7hjI5DEBDUTIJqDel6KLqODAL8UglnZBwlFiGoVHHHxlGSSYyGLEoygaxbyECiGAZSUVBnPwvsUFNICIE3PQOeh9B1+EEZleshCBOwN6rylEjywTjd6nY86ZAPQrW9mEjQre5EFRql4CZLjhcgElO48yNpmjvDpK4MJP2nTerVD6dRMasBbzyTZ9+DKdo3RUhmVZ748SZOvVWhMHlzSXvp+1TPniKom+Ef1yGom3izmuFGYzMgqV04G4a9PBehGwS2jW9bCEWdMyqKolEuDpDJ9tLUto9qZemknc5009Z1iKH+VykXryKEQnvXPXRv/giV0hC16vqa8oxommzDNoavvoFtFVEUHc+z5lY9tlVkqP8VXMckCFw0Pc7u/V+irfMeLpe/dVPPbj1wZ8LneS3M5BXDFUhQtzGvhPfs1+ZDfNXyPDeTeXl8Luxeu7h8Pm258FX17Dzjd+X4wJLt6zEmc9ciq1z1zy0+Dv7cpOniMBZcRUHh6oKFqoc7R/9TCvJYy/S21GUViWQsuEpBTqPNUpVY0mQyGJor1qnKIue992erRJnb53rH08HivHeEiIghELgLoiAuNme9d3Hk8s/AweKKd4qoiCFQcKWNS1h2vBAFOUXdfRddRGbZBebvqy6rXPZOEhVxFFQkElc6C1Z1kqv+OSaCIVRUXBw86aAJY1HEJtxV4gyNIianQ1mAk2dnWd4lXiFcZtp9AyjxOMgRAsdF2ja+61J79yiBbYd8ZJqGde4SXqmE+f5JAstC+j61944RWPacTEFg1kGANzFFcAt1XG7aqKwVEslV7xy6FmGnfvecpQ4IsKTJZe/4LaFBMKKCdKPOw5/J8cmfbUHTFaSUDF2yOPlWZdlu/A8LLhyt8fZzBT77C61ousLOuxI88WONfPU3x28uYiMlwSz5XmCHL5gMgnBZLATu9CSB4yyWJl0wyBY+MSEUgsBnePBNtux4mmSqA8epLtre1LoPz6nhuSaGkQTArE2haVEyDVvWbVQC3yU/dZ5ycfl8m2NXCHwP3Uig6XGEULDtCtFYw7L73yyiSRUhwDb9UHxPgqqHlW1BEDbi6lEF1woIfB/ralgSq2pi5fH3IRqWHs6i5r7r4ePd8F21qK3aixHgY8rFvHZVWVywPaAm18Z752Atazgk8obHWK536/rEviSgTm3F5mwPN2wiXgE+PrXrtrsrkJgGZh3McBUaVBeQTs5KiEjHxXeuO5fv45fKs9d63aZCcf46p5cvNLnVQ+8DMyoQ9kJc8I6QCZpIiAwKYUlxQU6urRlIhCGtx7/UuHSTgEhMpaFVZ/vBBNvvTKCqYZWRZQa8+JVprp67cS+GpgvufDRNumHtj2ZyyOa97968FoMM4Pt/Pc29n8jSvT2GEIJP/EQzR14s0X/m1ndOhyeVy7K93gi18hiWOUNjy27GR+c1MhAKsUQT8UQrvVsfX1RmXqtO4Lvr95yDwMWyVp7EkulOOrruw4ik8H0HiSSeaMKsTa74nZvBloNp9KhKregyPVQnktBQVEEkpjA9bNHcEyPXFsFzJeUpm+KETRBAuslg+NxywluQbY/S2BUj3RwhmtTQIgqBJ3Etn8qMQ36kzvRgHe9WhG8FNPXEad2SINVkYMRUfC/ArvkURizGr1SpFTa2OlZ1QevWBI3dcRJZfc64liZshs+WqUx/eOW8FyKW0WjqipFtj5HI6egRFZC4dkC97FGatJi4UqNe3njIXo8otO9IkuuIEs/oaBEFpx5QHLMYPFW6qWMvhKJCQ2ec1q0Lfm83wKp4FCdsJq5UqeZvXQvDhoxK/M5ttGW/CIRssEoyTu6zD5N69A4A1EwCNbM8l5OHy0wwxgwbK5ndvDfOz/5q95LPhQgHtDIbirum/WzXA77xu+O8/JWZNQle6YbCQ59p4KHPrM3LlVJy7JXyLTEqADPjLt/+w0n+0X/sQSiCVIPGp/9+K7//q4NY5ocndOe6JtOTZ+ne/BHy0xcXGQ8hoVwYYLD/ZXxvYVGGxHNXM44CluncD3/L5QsCdD1BV+/DRKIZ+i+9gG2VCHyPnfu/sC46jPVA0RRUXdDQEaVWdGnZEkf6kmxrhHrFp21rnFhKwzZ9jKjC6KUaqSaD7j1JRs5X5x6VZgh2PNjI3seaad+RJNVkEEvrGFEVVRMEvsR3JfWqR3XGYexShTf/epirJ+bHmjB0Itu7EYqCdX5gruJSKPDZ/3UHjV1h8cu3//MlJq7USOR0HvrxbvY81kS2NUospaEaCoEv8eyAat5hasDk8DdHOf3SFJ69tjEnFOjel+bBH+2ie1+aZGOEaEJF1RV8N6BWcskP16lXvGVdYyklZ16e5t2vLaVr/9g/2MTmO7Nz+/35vzyFa934uqJJlcf/wWbatoer5cn+Gt//v/vDa1gBbdsSHPxkG70HMmRaIiRyOpGEhqaHY8l3A5y6j1kKHYrjL0xw8rsT2LW1VwApqmDroRz3f6GTjp1JEg0GkbiKqil4TkCt6DA9WMcxlz+m7wUc/fY4J793Y6epsTvGQz/WzZa7s2TbF//ebt2nVnIpjFq8/8wYJ76zvvtYCes2Ku7IFFoyhtY437zjDIyBoiz+7Oo4eD5NSifd6g7Ouu/cdNe2EAJVBTW2NIFzrR8g8CWuE2CbAQPn6zzzBxOcfa+K9yHXUlmIw98vcv/TWQ4+GoqM3fFwmnufzPL6Nz/4TvuVIclPX6Sl/SAd3fcRBLMvqgyoVkZJZXrwfYd6fWEYZb5Tz/PqCKGgafPllUYkhWGsTCy5HDQ9SiLZwuT4ScqlYZABimoQiWZx7FsnG7AQ597IzxUqBb5k8mpYrSMIueNmRuqzjZ7huPRdSX7Y4sjU5JxBSTUb/OxvHKBjVwo9os4Sii4e16oiUHUw4iqZlgjtO5PsfqSJb//GZY58YxTfkwhdw+hqCY3JxXkjKoRgyz05unaH1XLnXw/zlT/0v+xg+/0NqLpYdD5FEWi6QjSp0dgdY8vdWdq3D/K93+2/4epIUQV3f6aNT/6z7aQaDYQSrrpdy8d1wuq3ZM4g0xJZkWInCCQzQ8vPD9170+x5rAkhQkO7UBl1Nai6wqY7M2w9FDqIiZyOaizvaBgxhY/9g808+KUuYikNRRPLXquiquhRlUTOoKk3ztZ7cmy7N8e3fu0iteKNvX09ovDQT3Tz0Z/fRDIXUswEfrgCcm0PRRGkmyJk26IrPivXDrh6cvWxrWiCnQ828vlf3UWmLYKiLv97x9I6jV0xeg9k2P1IE8/918tMDdxc6fm6jcr0n393XfsrSiO6MFi+2+fGcB3J0ZdLqxI8qskYCIGdr2FWfKZGHK6crDFwtr66MNfsHJefcHnvVZNYrL5IY1soIhQgCwK82gqJLAmDl2zUuBGK79gu0putAgng8okarybDpXOl6CN1HYS/aiDTNOHV9+Oou5pQBNiTZSIxhUhUWdNqpZL3eO91G+E6SM9ncmjlkIMS04l15KhdWX+oyHNNJkaOsmPvD+POhrWkDJiaOE1D0046uh9gauIkge+halGisSxTE6cJfIdaZXI2/7KfIPBRFI3mtgMY0fS6rsH3HCyrRCrdRTIVdvI3Nu9B02KLjIoQKroeRygqiqKhahEi0SxB4OG59RVXQsufc/GP5weShT9o6MAs3kdKFnnXtbyL50oi8fAVdG2f/HCd8pSDWXZxrQBVFyRyOh07UiQbDBRFkMgZPPlLWyhP2px7bRrp+2G/QSyy6iu257Fmtt3XwK5HGsMxP1xnarBOveQS+JJoSqNlc4LGrlgYyktofPTvb2LqqsmRb64eVdj+QAOf/Vc7iafDPGlhzOLca9MMnSlTzTtEYiqtW5NsfyBHz/4MyqxgmlX1yI+Eqxez5DJ0ZvmJ8oNwBx0roF520aMKqh6GHkvTFoUxi1rewa6H4yOW0mjujdPQFUPVFIyYyj0/1E55yubZ37h8w4vd//EWnvrlrRhRFSkl01frnH9jmuGzFcySSzSl0b49yc6HGunYmUSIMIRfL3sUxizqZZdq3mH88srsI4omOPDxFj73v+0ikdMRQuDUfcYuVSlP2jh1H0UNx1bLlgSZ5ghGTOWOJ1uJZ3X++lfOUBzbeCXYB5pT2QhsM+Bv/8vKg1prTBHpaSGoO9TPD6EkonMd20oyiaiGJZZaJolftxGqEiapLZf4vl7skRmuXizzF79dxs1XQvqZTAK/VEONG6T2dqKnY+TfHgo7n1NRvFIdNR3DK9eRrk+8t5HE9jb8mo01WsD3HJSYgZaM8NozRd4/rYOUWOMljMYkomgjAzAaEviWi9DCRkOvEv6QStRgMtnDH/zaKG7RxB4vUb249sq4iSGHv3s5ydT3z66h4U0sq9q5VsxMn6dWnSASy819Vq2M0XfpBdq7DrF152dm1SR96uYMUxOngZAmZWjgdVrb7yST3YTvWZRLg1RKy6vVrQTXrTE2fJiezY+yffdn8X2bWmWCqYmTJBKtc/sl0x1s2voEQlGJJ5qJxhrYue+LBL7NYN8ry5ZG304EvuSNvxykZXOcS+/kufRugYkr4UtvlkKjomiCZKPBpjuyPPELm+jcHRrcdEuEAx9vYeB4EcsJefjs/tElDBYLse3eHEIRBJ7kyDNjHP7GKFMDJuasUYmldVo3J3j4J7s5+FRrGBXQBA9+qYuLb+VXpKiJZ3Ue+5leYrNqpZUZh2/+Hxc4++r0ohWOUODoswk+///ZxbZ7w5VDvezy9f94gcKohVl2sao/QCVLCadfmuLQj3RQnXE4/8YMoxcqFEYsKnkHxwyJYGNpnZbNcR740S7u/kz7nIG8+1PtHPnGGBN9K+eGU40GH/v7m9Aj4WqpOGbxlX9zlv5jRfwFoXmhwMnvTfLFf71r7jcvjNb5u39/geKEhVlyVw1Tde5M8fg/3DxnUCb6arzxl0NceneG0oSNY/rh2GowaN+e5JGf7GHXI40IIdh2b46P/+Jmvv4fz284uvOBGJWkyHKn8dgNSSOH/YuMyauzutGrrTDE/PZAojdlsAYm0HJJYru6iXQ0InSNwHGxBydxhqeJ7e7BaMtiDUyipeOU3zpLdGsH3kwFDzC6m5GA3pJFqAq1U/0ohooa1dHSMdSYQXpvJ0JXkV6AmorOlZCqiQhaIhL2H9RshKaSOdCNW7FwiybRrhyB6eAWa8Q3NWFPlMjeuSkUj+rIYY0WMJqSTDx7Yk6L3K9YlE8OYU+WCZzws9z9W2l6bDcykEy/eIbyqWGaP7GP9L4uAIb+9A2coknLE3tp+9RBktvbqJwbZerFs7R96g7iW5oJHJ/BP3oVt2CS2NpC66fuwCtZ1C7duCKrVh3n5JE/WFTtFfgOZ47/JYqi485+LgOP/NQFysXB2fCWQEof33MI/GurJsnY0LtMT5xGUbSwO9mto6oGckGH6sz0BcqloUXnXAgpAwrTF6iUhsLvymAub6Nq8xxhteoEl84vU14s5YrHvt0499oMv/lTR6gVXKza0lyD70pK4zYnJyZw6j5f+Ne7ybVHURRB99406eYIItWJ1taImk3hTRWWcJ5BGArToyq+J3nrb4b53u9cWZKYNYsu/ceKFMbq5NqjbDqYRQhBY3eM3oMZTq0Qv+/em6Z1W2LOoz78jdElBgXCcNjElRov/GYfv/j7GfRIGEJq7I5x5fDNV33eCswM1/mjf3Icu+ZTr3gEy1TqmUWXgWMlJvtMch0xth3KIYQgntXZcii3qlHZdm+Ohs7Y3LN67c8GuXK4sGSqkwEMnSrx8h9f5cf+w15UTZBpiZJs1Ok/Vlz1HqJJjQd/rIv22TzS9JDJM79+kfNvzCwSEvRdSWnCpjRhM3axys/99zvo2R+mL/Z9rJlTL05y/vWVKwBXw+3JZF6HgABbmliytuofJZUi2bMDI92AkW1CT2ZRIjG0eApFN9ASaYx0I7HmLhQjbKL0axa1k30k79qKmklgtDWEXeKehzMWltDFdnYR6WpCzaaoXxzGq9SRfoBfqYf0/CLstdEbUihRI6Ty966x6mrk37qEW6jhmw7V82PouTh6Oob0fPSGBPZEOQyPKQI9Fw85nRwPZ6qM9Hy8Yh2vaoGioMYM1JiBnonhTFUQAmqXxnELJsoCZcNoR5bun3qITf/ocbJ39QJgDkwz9vUjlN7vJ72vCy0VJd7TyMRzJ+j/rRexJkoEdYfxZ45R659i4PdeYfybR/FNm8LhPka/dhhnukLu3q0A1K5MMvbNo+jZtTEZyMDHtorIYLFH6TpVbKtAECycqCSea2LVC1j1PLZVwrtO+0NKH8cuz20PfAfXqS7aL/CdZc+5+DgBrlOdPU4R37fxfRvHriw6jmXOLP1Tzy8wdBuHpkF0dUFSAJIJQSYTereeEzAzVA899FV8KCmh7/0CfYcLc7QkDV0x4hkd6/Iwdt8I7uj0qnoxUkqGz5Z568tDq1b6lCZt3v270bkJKJbWad2ycp6rbVuSRCYct47pc+VwftUczNRAjbFLoRHXowq7H21ac47ktkNCftiiVnCXNSgLYZZcXvuzq3PPSTOUuYl8JXTvy6BHwym3XvG4+E5+Rd9ZShi7WGV60JwzWlvvyXGj2pOm3jh3PNmKooar0qPPjHP21elVlWlLUzbf//1+XNtHCEGiweCOT7TOrajWiw9kpWLKMmfd97BZPRSj+1kMpwGhahipHL5dJxpN4Nt1tHgKr1ok8FxizR1I38OaGUOoKmoiinnmKu54geqxy3OTs1+pI4MANRnFzVdCTfKajX11Aul6WJdHUOMR/HINd6YMgcSZLKI1pBCaglezKZ0YxJ4ogRDUx4r4VYvCO1eItmexxorUh/LEuhqwx0NqE+kHuIUwdKalYzBWwhoroGfDF9OeqoAQlI5fJdKSpnJ+DK9iYfZNEtjzL3t9OM/YN97HngjjzEpEo+Xj+7AmSujpGEos7MyeefMSyR1tpPd3M/H8Cdz8Qk8pHEhGLkHLUweong3vV4nq1+/y/8dNIpdTaG5WOHfO4//b3n9HSZZd573g7/rwJiO9K+9Nl2lTbdEWaIBogLAEBRKERBnyiXyaeSPzRElPbjSPQ4kSNVqS6EWIFEB4oAE0gEZ7X13e+6r0PjN8xPVn/riRkRmVpjLLAJRWfWvlysyIG9ecuPfss/f+9rc7OxWSCQnLEgwNe3R1Bj1zLFMgSdDaqnDw/dUZMqvsMX6tjGv7aIaCHlZQDRlJV1FTcbz88t6W7wquHs4ycW156r7wYaq/QjlrE282UDWZWFpbssYmklRRa8nvSt7BLC2fm/IcQWGypvsnBXH9cFxdUZL7rxomr1UoztgkWwwkOci3zFeNvh7RJq1uQEvTNo65/FjZVa9O7ZaVIBRqRJRlx3jPs22EYsG0bpseR763ApatgImrZab6K3RsjiPLEi1rIyTbDKYGVk+u+iuXU1Fr3olXLQVJVVVDkmQkRUWLp3BKBTzbQo3EYEbGr1qY1+aqka2+hWGc629Xezhw68yrY/XXqufnKpOdsTl33KrW6JtCYE8EE7xXsYNOgrP7m174QFfmJb6t8ULdONiTxYbX68evLK+Aq0QMwr0ZRr59mOTuXoz2FEIIKlcnqFybpOMT+4lt7SD7zuXgdG0XJWLgZCtoTTEUQ2P6ncvEtnTM7VSq5VNmf9dWuqmNe2ne8VBQSV9D/0/+O3Ypt+w5zsd8jaalBPluNyRVo2XXoyTX7lzR9oXB80yeeB3fufVqYl0LvBBFgQ89Y1CpCkwT4nGXzZtUwmGJalXw1tvWDdUnlkI5a+M5As0IJhlVk/FyRSrHLyDHIkFL7yVgVz2uHcutiD1oV4PwT7w5YOZpoRo12F04mcmKVCcI3My3LCHdkMPzV8SPWQDX8alka0ZFkuolDYt6BVJQ/DqLm9PBbFRyXuztLQ/PlULMDFeZGlwZk8sseWRHTTo2B6K2yTaDePNfUaPiYlMWBVbS29kp5iiUT9TlN+YQmH9JCpLsjNcqq2e/mf/FVtvC87GmivjO3EPs5Mrkj/ax5m8+jpMtBxLnmkL3X3sIJWLglqoUT84ppU69eo7uzz9I8fQQ029exC2ZrPu1JzDH8ji54EbLPLqZ5N416M1Ruj57P+M/OIFbNNEiCSJta5GVOaMiKStvjJVWOrgn/IGgm6QwyboTjDiXV9wvJyLHsYWFu0TV8VKQJBk9kSHavnZF21uF6dtWy2I70NGhsNuFgQEP2xGcOePyuV+I8J3vVtm1S2N01KO9XaG1Ra4bmdXAdfwGVV5JAr2nDa2jBbU5SfGVw/iVxVk7ju0zfmVlqte+JxrCP7IqLRl2KecdXFugGRKRuFZP2C8F1ZBJtQfGSgiBWXKxyssn6P+qPt7CFw21b5K0jIEUUJwOSBGKKhFr0tAjy4+VEVWJZ+ZkpqpFZ1nvJtFs1OuSAMpZh66t8RWNXySh1ds8zB7biNycpPsdNyoz/nit1zn1ZkvLQSwqI1wTM5ylfS6xC0nViHdtwkg2N7wuhKA6PUJ55MrKT1ySaNpyH4q+MFBemRyiPHoVgG2PNzN8rkhh/PZp53hli9FvHq7/r4cV7KrH+A9Pwg9PNmx77T+/hGoEBWbzbXG0PEX/f/xhncba/0evLTjO9BsXmH7jwm0771lIQN6b4qJ1CBmFHn0L64zdXDAP4S3wGxdivX4PQ/ZFcuLOVMTfCUxO+nz3+YUT+n/+r4EhHR6Zu6+PHlt8DGJNGolWg2hKx4gqQRGkFhRaKqrEur2pehHeLJzhSbx8KaCym0sbYd8VlKZvfzX72MUSlZxNsi2EEVPZ9EATF99dOq/StSVG27ogFOy5gsHT+b+yNWR6WKmt2HVCUbUeclRUGUWViDfr9Ul/JRg4mcf5ZCdKTCaS1NnyUBOjF4qLei2zxaRNXYEOmVXxGL1QWlZmapYOPovND2b4P76xUH1kJdAMuR7WXC1+auEvCZlt6v1M+kPM+GO3XZEYQNEMmrbeT2r97obXhRBkLx2lMta3hNFaCFkz6Hr44yh6eMF7E8dfozx6lXBCZdcH20i2hnjva0OL7OXWEUlqbLg/vST7RlYl1u9PM3K+SGlmbtKoFl38ZRK3dxoCH0dY2MJk0D7PttCDROUEJT9Hk9pBi9KNJhsUvSzDziVsUSUuN9Grb6VF7a57KzPuKIPOeSQUWtQuMmoXqqSS96YYti81yLH7rsP02XepjPejGBFUI4ISCqMYEbRIgnBz16KLhJ8l9LDMun1pdjzRQvvGKJGkRiim1h9qWZWQlbmf6wviJE1Fa2/GHp5YdrkmhMC+QQz/ZtB3Is/opRKJWmHj/o93MHKxyOHvji6YLDu2xPjQb2xAq9VoVPIOx364Oh24nwbaN0bZ+XQra3YlSbQEKgdaKPg+VE1Gmvd9yKug4194Z5rp4Sqdm4P6k0d/qZfxK2XOvjG1YKG8bm+KJ/76GlQ90C7Mjpqce3P5soJQQm3wlG6l18xsp9abwU81pxKVE2SUe/GEy7g3wLg/gCnKuLjcSSdXkiT0aBI1ksAprYy+GG7qQJ5X7b0YunYkuPjWNOvvS5PuCrP5oSaOvzDG2r0pfF/QdzTPs39vI7GMjl1xqeQcvJr7KysyL/zuRTY9lGH9vWl8V3Dp4AybHmxC1WRcx+fsK5PseKqF7u0JjKjKmZcnUDSJh3+pl1iTzpHvjmJEFB78xR6m+isc/+EYQ6cLbHigiQc+3cX3fucClZzDo7+8hkhKY+JqmeyYye5nWnEdwcSVUlCZvQL5mltBxS/iCIu4kqboZ5GQmPKGcVyLbm0zXdom+uzTlP08V6wTpJQ2+u2z5L0pPBGo3kq18Oe404ePz1p9B67mMuxcnDuQ8KlODlGdHA4YfVItXyRJ6LE0vU/+ItG2Nbd2MXKQ38PzGhco82nuK8DsSvTDv7mBNfek0MNKPcQk/IAZNhuG8hyB8AWqLqNHlAbDInwfKWQQ3rmBypHzdeHBBaipTdxumEWXH/2nK3RuiRNv1omldT75T7Zy78c6uPRelsKkhR5V6N2ZYNOBJhLNRiCfVPb44X+8zGT/nW4ctsKJUYJEi85jX1jDA5/sxIioKNpcssh1BL4XfCfCDSSgJEnCiCoNYaPlUMk5/OB3L/HL/24XobhKss3gr/32TvqO57hyKEtpxiGSVFlzT5JNDzQRSWlBlCXv8MLvXSY7snxBohFRGvJ1Zq2o9GbgWIEczc3gp6hS7HPEfomE3EyL3ElabqNDWUdJ5Jjyh8n7QQ/qO+HBAKjRBFosuWKjEmnrXT4nJkt0bIrVlGgFbRujgdyGJKHWtHWMiIIsS1x+bwaz7NK5OcbktTJO1WPjgxkiaY2eXUmGzxYIxVXW708hyxKv/vE1Nj2YIZwMDElp2uHwdwKJeSOqcO61KZrXROjdneTQt4fJrIlw5pVJ8mPBTXelZpxkWaJ7RwK76vHmn/fzwGe7aVkToThl89ZfDPDYF9aghxWqyxTNzYcsqxjhdE2p2MWsrIzHLmpdMQJpcJ+CN01UTmJIYTxcwnIMCQkfD0tUEPhYfrVBZNTHI+dOEJWT6JKBKxyi8lJ9vkXQU2TeHOq7NrdD48ZoakVPN+M7NtZkQPQQwkNvasUcHWxUel4CkgRbH2nmM/9iG6n2wHMSvmB6qMrEtTIzgybTQxXKuaAg0K56OKbP9g8088jnexfGuv1aXdeN+0/cEQycKvCNf3mOZ35tPR2bYxhRlU0HMmw6sDD04nuC8Ssl3v7yEEe+N3ZHEyaSFHjyK0GmO8zH/9Fmtj3WXDcSlbzD6KUS0wMVpoerFGtqB7PfRySp8dzf30Rz78qbC158b4bv/PZFHv/iGlrXR4gkNbZ/oIXtH2hZsK3r+IxeLPL6nw1w9vXJRfbWCMfyG8bz8POjfPv/c/vD2zfCT9VT8fHJ+RPk/AlCREnIaZJyMx3KOrqUTZT8HDP+GJP+UENY43ZAC8fRIktNQgsRaelhOasSSapIkoRVcRk+W6B7e6IufxBOaJSzNmbJQVYlcqNVxi6XaVsfxTF9HNNH+CLoiKcFRmhmsMr0YJWubfFgheqJgEniN7JG1u5JkVkTCeTWdQlE4IktN5/Mf26FCOiMvituokpJIhxtxnNNND22YqOiSQaqZFARJcJSjLXGThzfpCpKSMgNbWWXQkxOs0bfTtUvYokKkiQji58+L0g2QiDLaMmmwN1A4ORnMJpaMccGb/h5gNb1UZ75tXUk2wJP2HN9jjw/yqHvjDJ6uRSsLheZbNs3xRALQprBGCx8/aeLs29MoRoyH/sHm0m1h/BcH88VqJqMY/lUcjaT/RWuHMpy4e1phs8XV+wh3+y3HBR93vjeUg2Zh36hm62PBgZF+IKB0wXe/sogVw5nyY2ZLKbik+kJBxP5KuC7gmMvjKGHZT789zYSSQQikkIEz7ljBjTi8StlLr0/w8V3phm7XF7ReqhacBoWUtH0ysk1txM/M0qxRZW872NIURQ0wlIUTdZpktvoYiNX3JNk/VuLt1r5KWTNQIvEkfUQRqI2EdzgG5I1AyM1J/FRnRkllGptoNjGmw0qBYdTP5kg0WKw46lWNEPmsS+uQVYkLh+0iKZ1QlGFTQ9m6NmVrIcgZhVhyzmb/mM51u1P09QdZvhcMUhwiiCJ6XuC3IhJx5Y4936yk9M/mcCqeHRuiVOcsqgWXayKh2t7PPJLvRz93ijjV0rsfKqV7u0J9j7XwZmXJghFFT70mxuZ7K+QG62SagshIFCgXcVc5PsOldI4ifQaXPvGVEOpZjLSShsSEiVvhpjShCFF6HNOY4oKmhQiLs9JvASqWQJZalyNJ5VmZElhyLmIK2xichrpp1O7uwBqJAYCZC1I0s62DpAUtUE7blFIsOlAE51b4/XK6hM/HueF/3i5Xr+x5HG1hSwsSQbZ0PCKZSJ7N1N+/yy3pVXoKtG2Lsrjv7KGeEanlLX5wb+/xJXDuSAq6Au8mox/teiuOty6wIyu0MrIqkQ0eeNEejSlce/HO+u9l6aHq3z/dy9x9Uh22alCkiVUbZUmT4K1e5I8+AvdhKIq00NVXvgPlxg8W5wbKyfIf5lFd1X9n7KjZkOIs31DbNm6mTuFn7JRkTAIE5UStCo9ZOR2PDyy/jhnvKuURI6IlGCtso1N6h7OOgcbGvesFk4pjxqOokWCBzjU1I6s6fj2DWKTqRaUULgeu65MDGAkmhuMytilEmO1yuCZoSpvfmlhA6l7nm3j9CuTTPVXuOfZNl7+g6t1Ntal94K6lAtvTXPhrYUr/nOvzbm7X/2t0/W/+47l6LtOquHg1xv1sk78aJwTPx6v30yv/nHfotf5yh9eW/T15SBJMpKk4NjL01NDcpQ2bR26FCIpZ+i3z2AJE8O3kJBoVrsRCJqUDqyGDoGCnDdBp7YBQw5T9goU/KmaAdJpVrtR0YgrGYre8rU9dwLV4T6qw30LXs+dPLiiz4eiak2ZuFZZXXA5/qPxGxoUgGhaXyR+L4GmonW24E7mUOJhvPzKqMO3C3pY4ZP/bCs9uxL4nuD537l4QxHK1cCbzySTQDOWLwCcRTih1b3B5dC9I0GsqbaqF3DtaG5F0jGaIRNOrs4biGd0Pv5/bglC55bPN//1uZuWQ7ke2WGTmeEqnVuCWpOm7jCZrjDTQ3eoF9MS+Kkt9SQk1irb2aEdYJt2P7pk0Oed46TzJhfcIxRFttapLc8V9xQ+PiFp5bHKxeBaFVyzXGdBGKlWZPXGKxcj2YKi1bj0vo+Vm1qkdubGuPz+DAhBU3eYUy9NrLg3xW3BHVqdSMjIsopuxJfcpuIXmXD6UVAw/RIXrSNMuoOAoOTP0G+fRZYUBB5X7ZOMOlca6piuWifJe5PoUhi5tjTPueMM2OfRpRCOsLhiHWPCXbwT5F9lqLpMJKHWFyylrL0iqm+opo6rXLcy9m0H6/Ig9sAYfsXEK9zpxPdCdG2Ls2Z3EkmSyE9YdZn924Xr+5+sxFAAbLgvvSIJmETL3P58X6y4nqdtfbQuUbNSrNmdrKsPzwxV64vL24Xzb88ZKFWX2f2htmW2vjP4KVKKJbrU9Ux4Q1x1T1EWBRwWr+3w8XCEfevzohSEwKLta0FSAqOi3fiGNFIt9e3cagnXLN1UCWx5xlmECjxbIHX9zS5utsx2hVjsuKJmfBY77uLnMttZcb7Xdj1MUeKqfXKRdyR8STTULs0da+54lqgw6DQmGD1cprwhptw7Q93+aUEI0RCikKSVUTc7N8fqE/fchyF67zaQ5Hrx4529hxZHU1e4HpZTtZuvb1gKUwNzhlKSYMP9TQydLS7zicCLuO/jHctuMwt/nginJEkrMkSKJnHg012rpt3OT+rPUpQ95/ZRvY+/MMaBT3URSWoomsQ9H2zl3BtT9ajKTwO3zahoXe2oTWn8Wm9z6/K1BoE7H5+D1o/wcG9YAGljcsp564aqxjeCrGiUp0cRnockKyh6iHCqFTu/NJNC1oyGUJeVn8J37JUHcheBJCuokTjh5i7i3VsIN3eix5tQtIBe6VaLmDNjFIcvUx67hl2Yvi3SIQBKKEq4qZ3kul1EWnvR42lkzcB3LOziDKXRqxT6zmJmx/Gs4OENVKIX359mxCjMXMO2VniTynJQI5LpIt6zhUhrD3oshawZCM/DNUuYuQnKw1coDl/CLmUXDU/qrQmi61uxxvOBfpofkB2M1iTmSJZwTxPVgWnUVISgRbKNb3tBG4Tb8NDqYYVQXF2xByiEqDMD58MxPYqTdp2SmmgxaFkboe/40hIqzb1hnvm19aS7rquxEWCe68N3XLTW9NJ04juM7EgV3xUoKsSbdb7w73fzzl8OMdlfWVABLvyAmGCbPtW8g7VEd8P5uHY0V0v6B8/g/T/fwelXJpheQkLEiCo89oXeehjoRpjqrwTfqxTkqNbck6wXHC+GUEzhsS+sYcP96UXfXw7TQ9U6Ua+pO8yv/N5uDn1nhOnBha2i/dpYOVWPcs5ZUbfLyb4KR74/ykOf7UbRZLq3J3j2767nh//pChPXlk/4ByQjlUhKozBh3XQXyFUZFUnXUdMpvHIFv3TdpOL5yCEDJRHDGZsMkpbzVGsjUpywFMMXHmVRwGb5vIbPrU8EsqpSnRmtKdzqSJJEuK2XfP+ZJT+jhmPo8XR9RWgXpgM66k1Ci6ZIbdxDasMeIq3di8qCqKEIoXQbqQ27ccoFcldPMnPhMNWp4ZunwUoysc71ZLY/RHLNdiRVa1jlKnoILZok2raW5u0PUeg/y9TZdyiPXsN3ndqYLbw9bLNAJNaCHkqQm7q87Cmo4TjpTXtJb9xHuLkzqO9YsE2UULqN5NqduNUS+b7TZC8cpjzWmO9R4yF828UrW6TuXYdbMrEniyT3rsHJlWstBHJE1rYE8u8SODNlhOdjDt16iOHhz3Wz68lWVmpVrIrHu18bYuxyYyjFrvoMnStgllzCcQ0jovDQL3STH7dqCr/B/iUpmKDX7E7yyOd72HQgg1lygyZS8/IqSjpOeF0XomoFSsU/AwycKnD+rWl2PNmCLEus3ZNi7Z7Ugu1mu2CapaDhVP/JPGdemeTqkeyyE+bY5RKDp/Ks2xc8l63ronz8H27h7a8MMnS2QCXvIMvBhNi+Mcaup1uDXieKhFl2CUWXn+bGLpeZGqzQsiaQ8F9zT5KHPtfNkedHKc4LTeoRha6tcfZ+uI17P94JgFV2MW6w//m4cijL1cNZ1t+bRpYltj7SzNZHmhdsJ4TAtQNpluywydWjWc68OsXAyfyyKtBWxeOdvxyic0uc9ftSyIrErmdaSbQaHPruKKMXihSmbJxq0FNFCylEk0HuqWVthJ6dSVrWRvjyPzrN8PnlvcGlsCqjoqbTGGt78coVqqcbJ2bfskFVEK6LMzmNcOYMSpvcS6+6lZAURQifMgUuOkcpi9vT130pSLKKWyngVIooRuB2BlThpaGGYmixFAC+52EVphG+1yCQuFIY6Ta6HvoY0Y719RzNLBo1nGb3LaFFkzTveJho+zomjr1M/trpFasAzEdy3U46Hvg5jGTzgirs2WPPFgcqRpjUpn2Em7sYee/7+I6F8BYTD9QwwilkRUPTl18FhtJttN37QZJrdtRZUtefw/zzkiQJLRIns+0AsfZ1jB95ieyVY/PCORJGRwrhevimg7Bd3KKJb7vImoLekkBriuLmKygRA2uyQPr+DUz+5NQqR25xLPbgL4dy1ubs61MLjArApYNZhs8V2VDrxdGzM8Gn/tlWhs8Xa/RVQTSl09QdomVdlHhGpzBp8fZXBjnwmW7SHXMei7BshOUgaeotedO3Atf2ef1L/TR1h+nauvR9EdRwBc2hYk063dvj7PhAM2/+xSDvfHVoSc/AtXze+PMBWtdHa2Edme0faKZzc4ypoSpW2UWSwIiopDtDpDtDyIrEpfdmyI9b3PvxjiVb80LQgfL9b43wod/YgKJKRFMaT/3NtWx7rJmJq2XsqoceVkh3hmheE6GpK4yiSBz9wRi+J264//moFh3e+POBYBJfs3RLAUmS0AwJzTBINBv07Eyw88lWXvmjaxx+fnRZVtjE1TI/+k9X+Oy/2k5zb7huKDu3xMmNBU2+XMtHUoJyhlBUJZrWiCQDFeXc2M13fYRVGhWvUgkqiheJI8rxCFbfIH6hhF+ei4FGpQS96lYQcMk9iiJpdCub2KLeyzHn1RUJTd4sZkNY5fF+QukgYRVu6Q68qCWK1LRoAi0a1LP4dhUrN46sqAtTIDdAuLmb3id+gVCms37DCSEQnovv2sFvz6vJIajIqo6s1RSZZZlwcxfdj30aSVbJXj62Ko8l1rWJ7kc/hRaJUa9jmD22Y+F7LsL3kRUFSVGRNQNJVjDSbXQ+9DGKA+cXNWS+52BWZrCqOTR9aRJFqKmd7kc/RbR9Xf1eEUIgXCe4dt/Ddx0kRa0rUcuaUau3kWrn8RySqjJz8TD4PpW+Scyh6VoTqoAnKTzB1Mtn8R2XiR+dwHc8bABZwmiOUx2ewavcfr2rlWPxBz83avL871zk87+zi+beoC1tc2+ETE+4Hi6T5DnF29yYxQu/d4njPxqnZ0eCVPtcr3dnbAZnstZ24acd/pKCJPfDn+vm/k91EU1qOJaHU/XxvEVyhJKELAe947WQjKxIpDpCfOg31pMbMzk+j7E4H0LAuTemeOWP+/jAFwPasqxINHWHaeoOX7etwLV9Lr+f5av/9AybH8yw76PtDbVe18NzBO9/e4Tm3gh7PtKOHpKJpnU23p9mw73p+gJoNshgVzze//4Y3//di+x8qpVdT7fW5eaXHCoZUu0hnvzVtdzzoTZCcTUoorQ8fI/Fx0qh3rJYkoMw6Mf+0RYmBypcPZxb8lhCwNXDWf70N47zid/aEoTzQkG7hNZ1Sxuy2bGrFlw89+bn5dWFv2QJZ3QUObrwxITlEN6xGa9QonL4RP31kBRFx+CE+2adHlz28+zUHiIhNZEXd85llxQFJJny6DUyW+8HQNF0Qk3tVCcXJnwlWSHU1BYYEcCzqpi5CUKpNlZjVYxkC50PPrfAoFSnhshfPU1x6AJmbgLfNpFkFTUSJ9a5geTa7cS6NqMYwepCDUXpevQTeFaFwsC5FR1bjzfRcf+zqOFGg2JOj5C9fJxC/xms/BTCc5E1g1BTO4nebSTX7yKUaiOUbEHfnkaSF0+2qlqYRHpNrc/82ML3wzE6H/wYsc4N9dc8x6IyMUjuynHKI1cC789zkWQFLZYi2raW1Ka9xDs3ImtBmFKLJmnb/0yQ9xm+DJ7fkFCdxWwPGt8MfgsAD5xCFXM0t6IxWwzD54oc/+H4TesfWRV3WZrw0Nkif/obx3n8i2vo3ZUg1R4iFFORlaBvSbXgUJiwGLlQ5K0vDzJwKmiT8P63R2oaXgHTCgDPX9DxUQjB+bemmbgaLPDKuZUTXyp5h3NvTjFyMQhxD5zML9q0qnVdhJ//x1vYfCCDEIKR8yVOvDjOtaM5ilPWgtW0osqEYgpN3WE23t/Evo+2E46rGBGVJ/7GGk69PLFkDYtd9Xn9SwNMXCtz/yc6aV0fI57R0cMKsirh2T6VgsvUQIXzb01x8JsjlKZths8Vef9bIxhRlan+ypIMzOKUzXf/vxcZu1Ji11OtNHUFTdA0Q0aIoB1AacZm4lo5oOy/OI5d9Rk4WeDgt4aJZwwGTuYXL0KVgg6Zn/itLfTuSuK5goGTeU78eJz+k/mgKdh88gYgazLhhEpzT5jND2XY+5F29JBCOK7y1N9ax9Ujx5aNxAoRdNr8s793kl1Pt7Dj8RZa10eJZQJxTEWV8P0gxGaWXMpZm/y4xdDZAidfmlgxA24xrM6oKApyJIJvLuIeSRLWtUHkaOMKVkHFFhbOPBnzgphBQsKQwne2MEeSg+Zak4NBCEsOjEy4uWtJoxLOBLFSIQSuVcYuTBNqWhmLBIICuKZtDxDtWNdgUAp9Zxg7/OMgTzIPwndxSlmyFw9THDhHauNeOh74SF34UNHDtO1/GqswjZVbXrVXUlRSG/cQznQ1uOPVqWGGXv8GlanBhhWR71hUxvupTg5RGDhP18MfJ9Lai6wuTZMUwsOszKDpi694mnc8TLx7c/1/z7GZPvsuUyffxL5OIkf4HnZhGrswTXHoIq17Hiez/cH6tRuJDK17nqQ81o/wVrcK98orJzpImkJ4z1bs/lHciRm0zhbODCY5/E/OwSI9RG4GoW3rgmZww3Pf4WRfhe/89gVa1kTIdEcIJ9RggnSCCTI3YjLZX0bbtZ3MF9eBEIx4Phf+wyGckeVlO4QPL/yH5XNeSyE7YvK9f3dp2W0UTeKRX+xh84EMkgwTVyt841+dY+hs4YZO9dDZImdfn0LVJB74dBcQqAUkWw1mhpcOvfie4MyrU1w9nKN1fZRkq4ERVdAiYTxHolqWGTkzRm7Cw60G883w+SJf/xeNC7JgMdVGZXwANRzDNctQk+F//UsDnH/HJNXiEWvS0QwZ3xfYFY/ClBU05pqXZ5m4Vua7v32R5RCOqzz2y71BAbQE/SfzfONfnQsm7hvMf4OnCpx5bYpoSmPnk60AdG2NE2vSV0RFN0suh74zyqmXJ2ldGyHRahCOqyiaXC/CrhYcClM22RGTSmFxNYfVYFVGRXgecjiMHI5g0ZhIFbaN2tmKv4gLHggCSvMqoIOzllEbqqJFjVoqo6ApIWyvQkiJo8oGtlcmpCZwfZuyu7LEq0QQTnEqBeziDEayBUmSiTR3M8PCYjVJUQhnuur/m9Nj+I69qsiXkWwms/1A3dsRQlAeucLowRcwswtX9vPhmmWmz74LskLXQ8/VCg0lwi09pDftZfzIy8u21dWiSZLrdzfkMNxqieG3v0NlcmDJzwnfozLex+DrX2fjx/431NDSoS3h+5SLY4vW7URae2jacm89th8Y09OMHX7xhgWnbrXIxPFX0eNNJNfvqhMaYl0bifdsptC3NLnilqEohDb14OWLuBMzqJkkxvouzLNXEbfJqNgDY4vuyzF9Ri6UGLmwNJsu2tuOMz5D9XhAs3Zn7mwuciUIxdV6Mtz3BUe/P8bgmcKKJyTX8jn31nTdqMiKRLI9tKxRmUW16NJ/Ym4M9EQTihFFT6Qx82G0uIGkGhjpVtxSHtesoMdT+J6LGopSnRxCTzZTnRol3NJNefQaRjKDEoph5SapWBmypycJNWVwynlkRUM2wpSGLiLc1YcYk+0hdjwRkBicWjfG8UVybUvBrnhceHu6blRUXSbRfJ1Rme3lcr2nVBM6NYtu3du901idp2IY+KaFpC9cyXrZHJVcHn3twkR4VE6wRbsXvy4WKaFJBj3KZlqUzvp2Y14/k/4QuhKhK7qN4fI5mkNr8ISDq8QJqXEmqqvpiRL88l2H6tQIRrIFZivrVQ3/uhtEDcXQEzURPOFTHu9r2M9K0LLrsQa5fM+qMH3u4A0NyiyE75G98D7J3q3Ee7YEh5cVkut2k7t8Ytn9hDOdRJq75/YlfGYuHlnUK1sM5swYU2fepm3f00smHlUtjBFKYltFPHduApBkhdTGfWixVP2znllh9P0XbmhQZuFWS8xcPEysayNqKFrfb2bbAQr9526LIORqIOkqWlsT9kAw5lpPG+74NCChdTQjaSqSquBO5XCncqAqaG0Z5JCOpKl4+RLOxAxKKoGaSeKOT+NZdlAV3tmKcFyUZAy/auGMToIAtTmJHI0gh3T8chVndCqgSGcLwd/zIMciaO0ZkCW8fBl3Iii2lRNRtJY0KApetoA7mUUKGcE5q7XXpnL1/SgRDVFrACZWGEtvWx8LKNYAAvqO51e9wr0+pHazatlutUy0fR12YQYhfNRQFN+20MJx8LzAM8l04JRyaLEkdjFbz+EpeiioSZMVfNfGs03UcAzhOpjTI8S7N+N7bkC3v8kaoPYNUfSaCKjr+AydWf3k7s0Lj4majNMsJF3D2NSLpKlYVwbxqxb4PpKioLY24YxPgxComRRerogcj+BXTETVAlUN7I7jgiIjaSrCtJGQ0dCRkLBYXUX+qoyKX6ngjI4ihRr58pKmora1IIdDKKkk9tW5VbEpykx710s2CCa8xcT3goGKaRlUWcdQIoGn4VlUvTyaEsL1V79SEK5DdWaU1IZ7ghvJiKDFm7CyjdpikZbuhlV2ZWLp1f1iUMMx4j2bG8JeVm6S4uD5Ve3Hs02yl48R7Vhfa6csEUq3EmnpxsyOs+jTK8kk1mxvyIW4ZoXS8KWVU6KFT3HgPM07Hl7SW3GcIEav6mHm32taPE2ktaehKDLffwantLpVdXnkKq5ZQTEidaHMULoNPZbCLt45WRZJVYk/tp/wjg2obU34pSpKMk76M08z/rt/AYpM6hNPkP3qixjru9G7WhGuS2jHBvLffxN3Kkdocy/hnRvxCmXC92ymcuQs7lQOtSlB8iMPUz54mvK7J0FRSH/2GexrI/iWjbGuk9x3XkN4HvHH9uHlSoR2rMedmCH33ddAVYjetwOtoxnheRR+chBRtVCbU8FkosiobRmyX3sRSVGIP34vIBC2iz04hjudI/74/qBmR4DWniH7zZfxC8FquXlfD9XxQiByKkvYeRM1rOGZLrKuIKsy5ZECvjXnJS8ocLyJCXfNPXMCr74r6irbq4XvWJjZcezCDLJu4JoVPMesUfIFyDJWdhzfc3HNEsJzsfNTyJqOXc4HuVfh41arSIqCXczilgMPx5wZQ0+1BHT4m2TXqbrcuEhb5VBJUlCJPwvP8SlOzT3TwvUCoobjgoDwrk14+VKwuDF03MkZZCNE7OE9lN87RXj3JszLA7ijU2jdbSjJGOaZK2jdbUiainn+GoYXJixF8XCxxB00KnIkgqSqeLlcw+vC8/HyBfxSBWesMdZbFDnOu4dZCWZrUyJqkrHKZTQ5BEgU7Ak8XDrUJAm9mRlrePkdXQfhe1i5CXzXQVY1lFAYYzGjMq/XhmuWsPKrIxFEWtfUqcvBgQXlsWtBzHZVJywwp0dr+Zx2IFixx3u2kL18bFFmliRJC3qF2IXpVV+DU8lj5SZQF2nJK0kK8WQ3imogfI9Sfu57MBIZQqnWeZcgKA5eWDUd2rOrWPnJed07pWClmW67o0ZF+D523wj24BiGaaMklmbJGBu6qZ66jDMyiZyIYQ/WPJmOFtypHOX3zyBHQjhDEwjHxbo0gHVluEHoUTZ0KscvYPePkv7sM2htGbxSBSSJ0rsnA0q3LOGXTfAF9vAE1bNXwRfB5FGDmkkiKTKhrWuRQwZqcwopbJB//nX8chVkGTkcIvHMAzjDkwjPQ2tvRutswaoZlUhnosZskij1z9ByXw+l/izxDRn0RAg1ojP04gWseUalMGnVCwaRYN2+FJffX1lbCQjyAnuenZMQGblQopS9eaberDfuWRWcYnAebnlpj8Ap5YJtqkHYcfYzAOXhuVxUeWKgLvW0GM1+JSjMK3ZVNZmeXQmGzq28BmTt3hQ7npiTxh86UwhyH7PwffxKFWG7IARaWxN6bzvO6DSSqoCq4psWftXEnc7hmxbuZBalKYmxsSdgmvWNIEfDOKOTyJ5MUs6gomNTXbURXF1OxXbQOzvQmjNUTs6JHOL7+MXFJ06Bj8vqbpbB0qka1VhCYrBOO76cPxjkZxQpeLhWcbFOKYdTzmMkm1GNKHpyYd3BfKNSGetf9YQYae1pKPATwqc0unrRRgC7lMMqztSNCkC0Yz2SrCx6XooRQk/MXZMQAqecxynnVnVczzKxCtOL9nkXwqNUGEZCahSUlKRALy0Unbef6k0bgdkHfhayqtVrhwCiHTG0qE6sK0FlsszMualblyfxfeyBUayLA8i6hrx5DfXSZ0VG0jWUSBDWLL93ivTnPoQzPIF5oQ+vNjmb567R9IvPoq/twBmexBq4QQ5tMghXCccFVcYdn0GOhGn6pY/g5QoUfvxu/dyckUmsC3NaZ5Kukf7002S/9iJevkRza1NtgpdA+Ii6ARNBeKxUZepPv4tfMZFUBX9e6+HKUI7KeJHEhmasmQpuxUGLGXhVF1d1MCdKC1hw2eEqIxdLdG2NI0nw4Ge7Gb9S5vL7M1QL7mIMWVRDJpLUWLcvxTN/Zx2ZnoDlaJse73xtaFWKvD81+D5eaZJYXMZXfGbtiiwHa4TZ3myxmES5LBYViJ7sKzPZV6F1XRTVkHnk873MDAfFn2bJXTBpSxJoYYVoSmPzgxme+bV1RFNBysGquLz1laEFn/FtBxwX4fk4E1m0tibc6SzhnRvRWpvqOT21LYNfqmCs78a6PIA7nUfSNbxSFblQxi+U8XHJ+YFzcDP6i6vLqagKfrWKsG5fP/bFMFe7IhokXdLroqiGQqTJYPJinvLUyt1lp1zALuUwks3IqoqRyCApWp1VpEbitUr6YPvyeP+qJyojkWnUxBJigTe0UnhWBbdSbCgS1KIJFCO8aDjLSLZe9+AL3GopkJhZBXzXxq0uvYpSFJ14qhezPEU+2wcERaYLiywFybU7g5DiKmGkGhsWSbKCYszlqZSQSsvedrSwjqzJZC9MLdrv4lbhV0z8ikni6Qdq3kGNYBKP4OVLWFeCh1sOG/jFCnLEwDftWljLQYlFcG2H8I4N6L1tKKkYXsXEvhY0XFswmejB4+gMjePlSyipOF5+iQS+ELgzeYwtawI1i2gYhMAZnybsbSD+gf1BrmZ8GuviANUTF4k/eR/uVFDTUnzzKLOP2fg7fQAUrwRihKOv3pg1Zpseb39lkOf+X5sIJzRS7SE+/S+2cem9GfpP5CnN2Hi2H8jD64Gab1NniN5dSXp2JurhM7saJK7Pvjp5Z5mgt4BQWOLhR3SGhzzGRj1CYYlMRkaWJUoln3JZsHOnyptv2BSLCy+iOG1z+PlRnvpbazEiKh2bYnzu32znwtvTDJ4pUs07uI6PrEiB8nFCo7k3wtp7krRvjqFqwViZJZd3vjrElUMLF2vOvAVM9ei5emTavjKXTy2+dDBQmhgcq1vDysG54mD7ylxKQkIiJEUxpDB5sToV5RUbFcnQ0Xu6g/BX/mfDPlE0Gafq4lSUVbdGdapFnHKuPknr8SYUI4xbCYxKuKm95mVICN9fcXJ7FrKqIxvh62KngbcAYHSmCXWmcXIVlLCGPVVEeD7C9XDLFsJqZHUJ38MzK0Fyera3iCShx1L1fc6HEoown1EgfL/u2q8GwvPwbJO52EYjfN9DUXQUbW6Sl2QZNZps2E4NRWnb99Sqj78opKBAdBZu1UWPGdgFCy2mk9neSvbSNJ55c11Dhe1SevMYbjYwpnb/GO5MAa9YJvf866iZFH6pgnV1GDyf0MYeKkfO4lcsjI3dIMtUDp9BX9eFef4abq6I1p4hsm8rxdeO4FeqlN4+AUIECVLHJfvtVwMVCqB88BS+aWOs6cDLFXBGJpHCISL7t+PlSpTeO4VftdAzrcS370GLJ/BdF+dKDjefwy9XmfnKj/DyZYTtUHjlfbTOFiRFDvImwqfwk4OkHj6ALBvYo6O33HNF+HDix+OkO0M8+vlejKhCLK2z98Pt3POhNuyqh+cIJLkmMmnI9X7uQgTteO2qz9t/OchbfzFIOXfzhZuKEaFp/R5CqXY8u8L0xUO4VoXmLQ8wfuq1G+9AkjHiTdil7KJRgFJRMDrisWGDSmeXTHZGkG6SSKVkLl4QZDIyLS1LC6y6ls/Bbw2TaDU48KkuFE0i2Rrivp/v5N6PBYbVc0VQGKrLaPpcgfnsWFVyQSX+u18bXpEG2JKYnTZvsGB2cXCEhXcTzRJXbFSE7WAPDhNavxY5tnS8GaB3vcrf++cZetZq/NHvZvnJ84uHxp76aJRf+4dpZDmgFMpywIjzvUCC+r//5zwvfL1Ydzlzg8Ek6XsC31ndwArXwcpNBkV3qlYLg4VxK0HcNZTpQlYCF9MuZReduJeDpGp1GnH9mL6HX6vctyfyxLZ14cyU8S2XxN51ONMl3LKJAShhndL5YbzinPflubVY7NxRkEOLj72iXS82KFbtpdQ+iHCdetJ2wbvCZ2rsNK4zXzlWRjVW7yavCvPrbibKXPjLU/XnQvgC/1ZEI30fe3DOo/QKJbxCLdY+NIEzNFdborakUZIx7DeP4Zs2+toOQCBpGmo6QfX0ZZzhSZR4BDkeBc/DurSQlGJd6Kv/7QxPgiKj7N2KVyhjXR5E7WhGX9MeLExqtS2erJA7+i6pfQ9ijg5RGbgCtdyLcBxk3UDICn6hil0eBil4HQHCdCi8fRjPrCAcB0lVkfSABCI8D9+2An04VUWSZYTr4tvLRySqBZeXfv8a147meObvrKdtfRDeUTQpqAKv3RLCB+EJbNvHc3yqRZdrR3O8+ecDjF4srbp74vWIta5F0UKMnXgJSVbwrCqyphNrX8fUhYNIsoxnm4GKhKYjKyp+TV0CJPRokubN9zN54SButbhoJODUSYezZxwkGVwnuB1lGVw3KIc7dtShUll6oi5O2nz/313k6uEsT/7qWpq6wqh6MFZGRKmv34QfzG+eFYxVOe9w+b0sb/x5P1MDc6KTWksCLROnem0CPA9JVYNFymxcDgLPuWrPrQ9X2B1UQiIpZYhIcXx8iqvsabXy8JcQSJqKMzGJ2tqMkkzgFYqLWrxNOwy232MQick89GSE139UwbYXbnftks13v1IknpDZutvg3ofDnD5qcuKQSSnvc/G01bCg6t7bjKzJRNIG/e9PYJVWZ0XNmVF810ZWNfR4U1B1nh0HSap5KkptuzG8FXQ2nA+pVmg5H77nMLs0EG7QR1wgCHWkKJ7sJ7KxA1UGr2KjxELImtogoyk8d8H4yvLiX9kCSf+aLMvNIKhBWfwGVNUQimrg2DrVco0EIEn1sZvbhwhi+7chpCF8v4FOLHyBW725a7tVuJNZyofOEH/6ARDgjE9ROXIOYdpUjpwlcu8OIvu24WULQcLdWeF5ej7V4xeIPbqX5Mc+gDBtym8dx8vNC0X6Hl61jO/Y+FYVYVtE129BS2XIHX2H5g88S/HscaKbAjl8SVFwZqbIHT9IdO0mYlt2kDv6HuboIPGtu4ms2YhbzCOHI0y+/H1Sex9A1g30lg7sqTFm3nv9hnUZjuVz/s1pLr07Q8fmGN07ErSsiRBJabXCQXCqQcfH3JjJxLUyw+eKlLO3T1LG9xxkzUANxzGzYwjfQ9Z0tEiStp2PocfSFIYvUp4apHnjfUiKgu+5NY+mRHr9HhJdW0CSKY1dJT94duF1OsHPkuOwyPx2Peyqz/EfjnPmlUm6tsXp2hanuTcoelX1oBjRrgbFiDMjVSauVhg5X1zQT0bSVWK71+Lmy0iAsa6N8IZ2CgcvYXSk8SoW9kSe5ufuo3DwIiChJsKUzw6uSLFbICiILBZVvJuIK6+OUmxZhNavRdKCFc1irSpDYYnt9wQT3FCfw9pNGt3rVK5eWPiNXL3gcPVCHkmGn/t0jHsfDvPWSxX+x+/nF/XOB49OkeiIIHxwzdVfrJkdD1bvoSiypmOkWimNXEUNRWv1FUHs0spN4N1glbYAYqHW0fU9R0oXRnELFeyJAl7FCpgZgFs0caaLC4rjJHmhoVqqWdiCokgJuEmJkWCHC1+SZBVNjyJJMlbD8RZeu12cYebcQZxl8jMrPxexQIngZ4nqiUtUTyysOLeuDAcsr5uEO5Uj9+1Xb/7EpLk/CqePIjyXxLY9yJpOue8SajLVsHl1qI/8yUO0PfsplEgMSdXwbQtrYpjqUP+qCv08VzB0tnjDPid3ApXJQRQ9RKpnO6J7K1MX3weCUO746dfRYxlatj8EkoRZnGL60iFSvTtJrtnBxOnXmb7wPkY8w9iJl1e9mLwZOJZP3/F8UNtzExCOR+XcEOEN7cixEL7l4JVM1FQEo6cZSZWxhqcDqrEkEd25BjmsYfZN4q6wK6gqqcSldKBI4q8ujL46SrGu41WqQBV3enFmTzIts/dAiIunbc6dtPjkFxJs3qEvalRWC8/xadsaFNfJC9qq3hhWfhrXLNcL9MIt3SBLaLEUajhQV/VdBys/uWpZEN9zAsrhLGOIQDZFkhSECCZga7hxzKp9c/TrxY4mq/qCIkRviULChUZQqofzVgtJVgM3+jpoWgTfc1D1CLY5b/IQYkHIwLctctdO3YCoMHtti63y5q9Yrl+9LLKa+VlAlucZ/to5+SKIy88aWVkmuf8AqfsealggTL30AuULt64SIDwX2TCQVA0t2QQEYy/cgFgghF/3JGd/qIW8gvuVmg5b8Jqdm8GeHMctr844RDZvp+nhJ8gfeofimRMNnuVSkBSV6JZtxLbvRk83gyzjlUuUr1wk//7bS3rakY1baXr0KfJH3qV4+jieY5LrP01p7CpNG/aR7N5KYfgCrlnCs01810JWVGRFqxcxOlaJSKZz0f3/LKA1NdP6c5/AGh1h5s2X8a2lSUiSIqG1pdDbUsiXR/GrDloqhmxoKNEQvmkjHA/h+GgtySAEJoFXXflC2RUuFYqEpZX1pJmP1akUF4Nwl5JOLbnN2k06G7bq/Ml/yPLuq1U++zcS3HNfiDdfrFAu3SrtU5AbLJPojNxcHZLwqYz3E24OpCEirb1IkoweS6NFEgC4lSJWfvU9o33HwrOrDeltSZJRI3Gc6zSvVoSaJD3z+68IgbsERdizG9vISrLcwJha+XHlRaXqIej6qGgGqhYimVlX76cifB+30jgJKUZ4QY7pugPR3LoNz7MpF4OCTs9zMMIpHLtMItlDIdeP59lEY+2US2OoaggBRKOtFAtDCCGIRFuolCdR1RCe7wTSPLJSozzfGcMjqRpGZxfxHXsIr12PlmxC0jS8Shl7apzSuVMUTx3Hr9YmsHwWc2wEJRIl1N6JmkiihMJzfNTVQIBbyOGZwYramhgjsm4zmUefxhwbxrNM3Hw28DKEwM3nQAhSew+gN7eixhJ4ZhWvUqodWuBkp2qK0TLRdZuIbdqONTFG/vjBFXorEpHetYR61mCODlI6f2pFlfnphx4j8+SH8aoV3GIefB81kUSNxZdVsQj3riXcswZrbJjSudPo8SRaOI7wPRQthFlrwtfQDNAXmLkJYh3ribauId62gdJEX7CdCFSzoy29VLNjOJWbJyLJoRDhtRsxh/rxSis3zEZrO6HutUiKihKJLmtUhOtTOnGN0sk+qAmJTr1weEHuZOr5g8H8IWrK3qu412RkLFGlKFY/d63OUwmHEZ6HdXXx2gtJgg88G6WY97lwymZ00OX8KZvd94VINimUS7cWB5dkiZbNActoUTXQFaA8PkBmx0MAhJItKEYEPZ6uT8BOtbhA+HClsAvTActgdjKtVcLfjFFRjDBqJN7gqXh2Faey+I1qF7M0TKKSjBpJLFnXshRkRUWtVbNfD881yU4uFM8Tvlc7/hzUcAw1FFv2WIaRwjJzJNPrURQVszqDEUpRKo5gGAli8U6qlSlC4SZ830HX46haCE2N4PkOZmWaUDhYnataGFUNyAqSJDM9eR7/JtQXbgQ5FA48jwcfQ43GcLIzmMP9CNdFicYIdfagpTJU+65i14xK5eI5KhfPgSzT+uGfJ/XAIzd/AsKnePZ4/V+vWmbqtR82bGJPzXmHhTNHAZh577XGbeb9nT30FmoyjaSqWGPDyEYIYVurkCcSFE4exauUqVy9XPOSloccCpPY9wCeWWXmrVconTmBcF3kUBhh28vuo3jqGL5pUrl2KfiMohFu6kQCylNDFEcuIykK2avHAXCtCrn+01SmBpEVlXC6g8p0sB0Eoqe5vlOE0m21Z+zmjUqoew2tH/kEY9/+CtVVGJXqwDWmX/0RTnYGp5C78Qf8QCex8f/GlwIpxXn1SquAhExUjqOLEAWxunqz1bUT9gVaRztqOo15aSGXPRSRePCJMP1XHIYHHEzT5/03Kvz1v5dm4zadkYHbkFyVqDWXurmPVyb6mTXpkqoSbesNhCZlOVAmrhQXFN+tFNXpkRrlNhhWSZIIN3dRHLxwg08uhBqO172nWZjTo0saCKeUD0J7tc9IkoQWjqGEonWG20oga0a9n8xKIXwvkPL33Lp3Iqsa4eYOisMXl1wh+b4TGAstgkBgO2UUNYwkydh2Gc+zUbUI4UgG161iVrMkw+vwhYeqGGh6lHAkg+87VEoTpDMb8YWHY5eXzD3dEhSFxD330vToU0iKwsybL1M6dwqvXAqYRbqOGk+ixOLYkzdXn/SzglvMUzhzrO6lusVCQ6O9G8GeGMOeWJm+HYAaTyAbBm4hT+XS+cCjArzyjeP39uR4w/hWZ0aozow0bCN8t25UPKtCbiAo1i6MLKIoLHxK41cpjV9d8fkvhVBnN7IRuvGG18GrlMm99+YtH/92wcOl4pfQJePGG1+H1VXU+z5KNIJYglJ84AMREimZ139kMTbk4rpw6ohFIefz9EejvPWTyi3R4zMbElx7a4ze+1u5WavilHI4xRx6ogmQiHdvqVetC9+jOjNy06yp0shVPKs61+VRkol3b2Hq1FurbkkcSrfVG4sBN5Q9Eb5HdXIIbc32+mt6IoORbF6VUVFDUYx5cisrhZWfxMpPEp7XJiC1cS9TZ96tUTcXnDFjI0fmFXdKCOFRLU8hhKBUGq8bo3JpvM5IM6vBqmm2e2W18lYQ5hA+kxNnSKXXI0kKsqzg3aSsxlIw2jpIP/IEsq4z+ePnyR16p6HewwOcmembC2stBllGCYWRjdC8XIiLb5p41aUFDiVVRQ5HkHUjyPkIge+6+JYZhFUWewh9H7dYQIlEkTQNJRZDjkYRjjP3ueuZiKEwarxx4eOVS3iVxZPBciiMHAojKQpGW0ct5CY1EAiE7+MWcgsMmmyEUBONi53ljtUwHooSjIcRNKMTIqgP820L36wuHA9JQjZCyKFQ0AZiHu3aq5QXbC8bIWQjFHiqveuQNA0tlcZrmff8ui5uMd/ogckKeqZR2cO37XoocFnIMko4Ur83hOfhW2Zwfot8T0osjlcs4Dt28LlQOFhIex6eWcW/bhw1SUdGISRF71zxIwQV9V6hgBRZWJMgK/DIM8Hr6YzCR38hSPA0tyrYps/+h8OkMgozkzf/oIcSOnpUw8zbDe14VwPhe1QmB2tGBWLdm+p6XcHEfAvsnWqR4uAFMtseAAJvwUi1EO1YvypRSVnTSazZXu8rEuy7RHHkytKTlRAUBs4T7902V4EfSxFt7aUyvnLJmXCmY57u1sph5aaoTAwRSrfVWXTh5i4Sa7aTu3xsiVP2a7/FgtdoeM1b+P4i77lOhez0RYQQtz/0JUnEt+1CS6YoXzxH/tj7Sz/4t8GgyEaI+D37iW7YjNHRhRpLBMnWchlzaID88UNULp9fECZS4gkSe+4jtnUHeksbsqYjPA+3mMcaHSZ38G2q/Ve5PhyipjMk99xLdMsO9EwzkqohPBcnl8MaHSL79mtYY/OfDYnIxi20ffTTQb2LoiJJElMvv8DMm68GYeDrkLzvQZL7HkCJxoMJXpJQwhG6v/B36tu4xQKjX/sS1f7GEHtkw2baPvYZJF2fO9arP2LmjZdhmcWDmkoT33EP0c3bMdo6gloez8MtFzGH+pl5/aVGr1KSiO/aR3TzNkKd3ajJVFD7Ylaxx8conDhM6ezJuZyHJJE68Cjx7bvR0hlkwwBJov0Tv9hwHuboMOPf/grW2JxHpcYTdH/x1wPDoAU1Q+VL5xn79pfxSkt7bJKmEd+5h9iOewh19qCEwnhmFWt0iMKxQ5TOn2nIhcV23EPLBz/K9Gsv4uayJPc/QKh7DbIRwquUqQ72kXv3jdp9EXy3rrBJSBluJi+5cqOiKKjJJL7j4vUvVO/t7FHZtE3HMCSefi7G0881xtNdR3D/o2F+9K3VV3nPYvxcFiOuM3kxkIC4GQghqEwOkdpwDxB0aay/57m3TF2dPvseqQ17UPTAW9EiCdKb91OdGlpxhXu0bR2pdbvmnzSl4UtY+eUaMwXilU45j17TyZIVldSmfWSvnFhRXkdSNTI7Hlqy6+Ny8B2TQt9pkmu312XrQaJt75OYM2OYM9crVd8ZeN4dah8sSUQ2b0P4PsXTx1cVGrqpw+k68e27UZMpKlcv4cxMgSQT6uwmumU7elsHY6UC5tDcsygpCqkHHiV94FHsyXFyB9/CN03kUAijvTMwTvE4108UshGi6eHHSey7H2togOw7r+PbNkokgtHZTaizBzl0PelDUO27yug3/gJZ04ht303inv3LXlP16uUgzCVJaMk06UeexKuUyB18q+5xCMfBnlp4n1cHrjH6jf+BrGlEt+4kufe+G46hEovT+uzHiWzaim9blC+dwy0UkDQdo7UtMNQLBl4iunkb4bUbqPZfxT55BOH5GC1txLbuRG9tQ7guxVPHmKXSV/uv4uQCJeDkvgcw2jqYeevVhtyWX63g5BqfQa9cZOxbX0bSNIz2bpoeffKG1wSQOvAoTQ8/gW9ZFE+fwM1nUZMpYlt30vKRT6BEY+QOvXudYZdI7N6PbBg4+SzZd99AUhQiG7YQ27IDNRpj/Ltfw56aQEEhLMXx8dBYnLSzHFZsVOSQgZCCG9CpVBa8v3NfiOZ2hdd/VOEv/7gx0bV9j8EX/m6KDzwb4SffLS23sFgWdtnFLt9iXkb4VKeG5zpBzoNTyi1IOK8W1ZkRZi68T/OOh5FqlNPUht04pSzjx15ZvreIJBNu7qT7sU/ViQOzwpDZS8fwbqB2bBemKQ6co2nbA/O8hU46H/gIg298Y4kwVO3Qqkbb3qcXFZJcKQr9ZykOnCe1aV+933wo00H3o59i5L3vUZ0cWpnHJMmBiGQkQbRzPTPnD62IononIWkaenMbXrkUTPC3I7y1DLxyibHv/GUQ1jDNgP4rgawbZJ58ltT9DxPZsAVzZKjuMUmqRnznPbjFPOPf+wb2+ChC+EGzN1VF0jT8RXT7lEiU6JbtONNTjH37L4PwkxDB/auqQf1KdWH9hlcqULkchFa1pgzcwKiYwwOYw4ERNDq6SB14FK9Spnz+NE52+WSwVypSuRx4+2oqDdzYqKQfepzolh1Uh/qZ+P43cbLTtbGSanV20sIutr7P1I+fD3rRVCq1AuQgSmOODtHy7MeJbNxM+dK5IHQGVPuCHk9KNEZ041b0ljYqVy9Svba8hppwXSpXghyPX63Cw4/f8JrCazeQfvADuKUiky98m+pAX30uKxw7RNfnf5XUgcewxkfr5wWABHprO/kjB5l54yd41QoSkD/8Hp1/7W9gdHQRXr8Je2oCHx8ZBQvzzhY/zq7MJFVB7+3FvDCX8ApHJHbuM4jFZL73l0VOHWm8cYf6HD78qTjrNums36Jz6ewdWk2uEEEnyOyCME95rI9bpaEK12HqzDuEM521lsIysqLSuudJ9Fia6fMHsXKTgZy25wbxW1VHjzcR69xAy+7H5hqFEYTkZi4cWlH4zLNNZi4cJtq5odblUkKSZFIb94IkMXX2XazsOO6sppgsoxpRjFQL6U37SG/eD5KM79pIsrLA6N7w2n2PkYM/wEi3EWnuCuojJJloxzrWfeiLTJ87SHH4Em6lgGdb9euXZAVZ01H0MGooSqipnVjnBqLt64KE68WjC3qwL4YgRq8gKSpy7bekKEiyih5LLVAdUEMRQs2deGY5qNuoyeoI30PUf3uAQKnFoH2zepPyN6uE7+PmFi5w/GqF8sWzpO9/OJjIry+Odd0g/xCLYY354PsI/GCsl6CpBs253CCXEo3h5Grqyb5fC6/dXJ+T5dAQvr4D9lmOREnsuRevXGLmjZewxxs95eWo0m5xYQ5S2B6ls6doefbjqPEkkqaDuVih5B1cbEgS8V17kY0QhWPvU7k6V4ArfB9rdIjcobfJPPlhohu2YA71N4RH3WKB/JF361RnQUBPL184g9HxQbRUGmQZ4ftkxc0TTVal/WVdXpwd0dKusm23weS4x5ljC1dC2Wmf00dNPvjxGDv2GT9zo+JZFazC9EKjMtvp8RZhZScYO/wi3Y99am5ylyVSm/YR69xIdWYUp5zHc6ygnkQPB4n5VGtDjYgQgtzl40yeeH3FOZHKxAAz5w7Sfv+H6zL8gbe0h0jbWqrTw7jlAsJ3kRQdLZog1NSOHksjyTJOpUCh7yyJNdtWzQKDwNsbeee7dD70ccLNXXWPRYsmadv/DJltB7CLM7hWJXiwJRlZUZD1EGo4hhaOI+uhel7IWSHJIL1pP7HODciahqQEOmyBHlsQ71d0Ay2aavhMtH0dPY99Gt+1gwS469aKWF1810F4DuXRa8xcOMQsMeSnXXKpppsIdXSjpdL12LuWCvKBkqI2lIH6rkPp9HHSjz1F8wefI9y7jvLlC5jDA8uG6/xKmfLFc6Tuf4jWn/skpQtnqFy+gDk6tGy+4q8yQu2dyLqOOTyIPbH6CVKJxYNxzzQHBANNq7O6JEVZsjPqnYQcjqA1NYPvYQ72L7pN5eolmp/8MEZnF5KmNxgVr1zEnppY8JlZI1rXfbtFsdHVUYqXQM96jfWbNV74VolKZfETeu1HZZ77XJzt9xi89HyZUsFnxx6DZz8ZI5GSWbs5mEw/8ukYm7brFHI+L3+/zPH3zdse+fDMCnZ+CtE9r0uj71GZWKwb5c1AUBq5zOCrX6Xnic9hJDNzk2ssiRZLNqzUrr9BRU23K3vpCGOHfhxUAa/0yL7H1Jl30GJJmnc8HGhASRKSLGMkmjASTfVjB4edU0P1XZvxoy9RGr5CuLXnpowKQGn0GkNvfpOuB58j0ramlqOZNS4JtOgisezFrmUR6ZulEOvaQNPW++thv5VA0UMNZIiFx/eRFJWZC4fq7CdZ0xt65twpyEaI5P0Pk9i9DyUSAVkJmFi2tah8DwCeR+79t/Ftm9SDj5E68BjxPffiTE2SO/wu5fOnF63/8G2LmbdewTerJO9/mKZHniC5/wHs8TGyB9+ievXSTTMif1ZQ4snA665WgyLUlUKWSezeT+rAowEDTlHxa8yqm23SdbughELIuh5o3y1RA+OVy/iehxKLL9Dj8yuVxRcJ9QXrrDLEreGWnw5FgbYOhbMn7SBfssS9d/KQycHXq/g+xBIypYJPKiOzfosOEpQKPifeNxFAplUl0wKZFjNgZ97qSV4H37Wx8lN1xWIIdMFW3aFxOdS6Pl79wR/Stv8Z4t2b0aLJugFZaqXjuzZWbpKps++SvXj4pkItvmMx+t4LOKU8mW0HAqabJC96bCECWRErP8nE0VfIXjqKpCi41cZeLqu79kC54MoLf0LrnsdJbbgHPZoKVHBXsD8hRNDBr5ynOHSxgeH1s4Jv2ziFHGoihRJfmVG8FaQOPErmiQ9hj48y+eL3qVy+UKcRR9ZtpPuLv77o57xKmew7r1E4fpj4nv3EtgQssPZP/iLlC2eZevH7QW7h+s8VC0y/+mPyRw6S2Hsv0Y1bMbp66Pzcr1A8eYypV36It0hY6K86Gjsy3Rix7btp+9hncAt5cu++ESTCi/lASSQaY/0/+Bd36lRvjPn1jss8R/W3rrvw1TYdvFncslHxPPjWnxf51p8vXz1qW/APf7XRDX375Spvv3z7BNx8xyZ35UStj3tAw12qAr04fAnpyIvIauAhWbnJJRPZ1ekxxo+9XM8xlFfRzdEuTDP81reIdqwn0bOVcHNXTSE5iqSoCN/Hty2cch4zN0FlcoBC/1ms7EI3dTXwXZvJk29QHrtGYu1Oom1r0BMZ1FA04LW7Lq5ZxspNUBq7Rv7a6RpDK/CSps++R2V8oH6HuqvwlurnYFcZO/RjcldOEO/aRKRWaKpFEyh6OBhPIfA9B8+xcCsFnHIBKzdBdWqEyng/VnF6Rd5Kof8sTrmw7MO2aghBdXq2oZZPte8KyX0PEN24hcqlcyuqHL8pKArJ/QfwzSrTr71I6dyphrcl/cYFaV6lRO6d1ykcfT9I7j70AWJbdmCNjZB969UlPQ+3kGPm9ZfIH3qPyIZNpB9+nPjufZjDA+SPvHfHCQq3C16pEBiCcBglHMZdiUCsJJHcfwDh++QOv0v23TcaW0CvYNzvJDyzim+ZQf+iJRY2SiweUKCLxQVG5Kf1za28SZck09q5l0R6Db7nMDl2ikKt89+CnWoRED6ua6IoBk2tW8lNX8Gxb55OvMRJNdzkvmsvWRNxPczpEczpkYVvKArx/fcSWr+e6e89j18uL73tYqdkGGQ++hy+45B76Sf4lQq+Y1McOE9p+DJaJIESiiCrc4VpwnNRJR3N18jOXMFzV54YlaWAs+/5DiEjiWnNMe+E71Ee66MyOYQWTaIYkSB8I8lBUtq1cauloMPkdTdg/upJ8ldPrvg8loTwa+M3ihKKoIaiKHqo5rXUrl/4+F4Q2vFsM0icr3JVlb92mvy10zfe8GYhBMWzJ4nv3kd85x6Kp441smtuI2Q1SJi7+exCyQ5ZJtTdu+J9+WaV8vnT+JZJz1//3zDaO5F0HXGD1gFepVSjzULHZ36ZUFcvhWOH/qcJg1ljIwjHRsu0oLe01Sv2l4OkKKixOL5jz2OKzSHcu27Zz9fDtRI30L27OfhmFXtynPDa9YR71gaLjeuMfHTjFgRgjQ4jfhqEkkWw8iuXJFTVYHL0BFY1T+eaB7GqWTzPxnWqyLKGLCv4wiNTEwosZPvwfZdwJINZmUGWFVzHxPMsVC2Couj4votjl1FUHUUxkCQZ33cae6DXIIdChDZuIr5/P3pnZyDzkM9TvXKZwltv4c7cXE/0648R3ryZyLZtFA6+h3Vt5V4JBDdmaM0aPNMMaIvzIDw36Nu+oHe7REfLbiazFwkbKWLpNhy3giLrOG4ViWDsHbeKIutUzSzhUBrPs5EVFUXWyRUGiEc7UWSdaKQVx60gSQqqGmJ65mKgS8bqhTJvHwSeWb4hLfpWIMfDKIlajYzn44zd+v0wH+ZgP8UTR0nsuZf2T/41Jl/8HtX+q7VGWCJI4GoBMcCZmVp+Z8s4VL7j4FVKKNEYWjoTUIM9D0nTCXf3krr3wUWLfyXDQG9qxi0UAq/b8wJ2naqht7QFYcVqZUFhohyJoCVSuMUCvm0H70sSsm6gZVqCz5VLN11w/LOAVy6RP3aI9IOP0fTY03iVMs7MdDCOcjAmkqYH11WbfIXr4pVLaE0Z9ObWwPjWGprpza2kH3liWU9N2BZepYIkyUGdy2BfjYwiBVX57sL+SHWsxMEWgsLxw8S27yK6dQeVvitU+wKtNUlVMdq7SN77IM7MNOVFCmN/WlidTAsElEsEvu+ih5JkWrfTd/FHpFuCpHelOEEyHegzKarB9PhZVC1MunkTkqximTmmx8/StfYRXLuCqoUZHzlKItVLPNmNWc1ihFJcu/DDhqpoJR4n9dRTxB94ADebwx4ZCUT8Eglie/dhXr12W4yKX61SOn4MZ2ICe2Rl3sntgURzejOGnsBxyhhanEJ5hHikHVUN47gVDE0lW+gLaMqSghFuJlu4hq7FEMLD0OO4nkWxPEJTcgOe7+K6VQQ+cixMZPcG/KpF5fjl+s0thXRi922lerYPd3p1MXM5YqB3tWBeHamrpf4sEdmxjsRT+9E7m5FDGld/9Xdu6/79aoXsO68h6zrRrTtp/8QvYk+MYk8H+TklEkPPNOOWigz96X8GQE2kCHX3BtIpmo7eGkgChddtDOibjovwHCrXLs/VgvgehaMHST/6NM1PPIvR1oFfraJlWohu2kJ1sI9QZ8+C89OSTfT89b+LOTqEPTke6GgpClo6Q2zTtmCyOXe63sZ4FqH2bjo++8tYo8NYk+P41QqSoqI1txLduAV7YozS+dMNxkgOhYms21ivYwl1rwn21dVLcu99+E4gClkd7Mcr3lr78euPFe5ZGxyrsyc4Vk2A0hzqxy3MHSv77utoTRmim7bR9flfpdJ3Ba9cRtY01GQaJRoLaj3651it+aMHCXX3krz3wYBenZ1BS6aIbtqKPTMVyLYsAeG6lK9cILZ1B8l7D6DE47i5bNCCvVKmcOJInc4rqSrh3nXIkWjQNLCtHRQZNZkisXs/brmEcF2c6UmsibG612SNDTP92otknvwwrR/9FJXLF3ALOdREksimbQDk3nsDc2hxdthPA6syKqpi0N5zH2ZlhvzMNUr5IVKZjUTi7ahahEK2j2p5klz2Kq5dYWbyPKoWxvddJkdPgiSRad1OPNmD79kM9b1Ba+c+4sluQFDIDTAxepyN2z6OpkewzOAGkVSV+AMPEL/vfsyr18j+5EWciYnAqMTjaC2tmNduXQwOAN+ncvo0ldN3MJSyAIKZ/DVURScvAgaa5zv4noPrWjU16+CmctwKsqRSqowjEDhOJaDBCp9cYQDHreC6JvniIPFYJ7IchJnU5iSZzz2JbGgM/uM/wp0JDIgSC9P8Sx9k/Pe/u2qjoq9pJ/Xs/Uz8wfP4lVU2NbsDKB+9SPXCIOmff4T4gzvuyDHsyXEmX/welf6rQRK8rZ14WyfC9/CqVZzpSYpn58KGod61tD336YD+Wyu4A0jsuY/E7v1BPYznMfSlP8CqzrEPc4feDbTjdu4Jqqc9F3tqguw7r1Ptu0LLh39+wbm5pQKF08cId68hvntfIEni+3ilAqWLZygcO7yoRIs9M0XpwhlCXb0kunsbpF0KJ49QPHEEa3So4TN6ppm2j382mOiVuf47sa07iW7ehnCDWp+x7/wl5XO3ZlS0dNPix9qyg+imrfVjjX/v65ROn6h/zisWmPzRdzEH+ohu3UF041ZkXce3HdxinsqVizjXhcVK506hRGMk9txLcv8BEAInO03xzAkKJ47Q/OSHUBarxK+hfPEsU0aI5L0PEt9xD5Ki4pkVyhfPNdR9KeEImac+jNHaHlxTjaZstLbT/MHnav1uXPJH3sN+9ccIe24hUDxxBL9aIb57P9HN21AiEbxKBXNkiPzRg4F8z8+QqSaJFfq0sqLS2XOAamWaQq4f17VA+BjhNF1rH6aQ7WdmIpAbb+3aFxTtTZ5HkmQ6eg4wMXocWVbItG6nkO2jpeMe+i+9RFv3vVRKE2haCM93mR4/y4ZtH2Wo7y2salD8pXd10fq5X0SJxxj+T/8Jd/rGYRw5GvQH9y1rocBaOKhW9805kTxJVZFquj0AiIC/v2xiUpICLaJamEu4LpKi0PF3fg3fspj4iz/HKxSW3B7Pw3ecO1QLIGHocYQQ2E4JY20bbb/xSdTmJPkfvc/0V18GAWpzkp5/87cY//3vUjkWFFNJmoqkq0iKHDS0dFyEOXdTS6qCFNJJPL6XxAfuYfTffw2/EuSBvGIlkOFWZOSwgTDtho6WUkhHkiX8qhXMbbIc9NKumEH4KBQwxHzHQ5hWff5bcE6uizCdRb+fpl94guRT+7n2t//dHRjXGmQZLRwj1bIJ08xhmbmAdOE6aHIIqzwT1OBoKnI4CMlJSDS37aCQ68e2SghqfS4IKsbxfXw/KLaEmjDkrGBgLfc2e88q4UhAA7+OLitpOtGUQSiqglRT3rY8SlkTz1xGUUHXkVUNSVXY/0iUTdsNvv1nM1TyJsKx0Q2Jf/37HbR1qfz4m0W++d+L+NrirQ0+8YUkySaFP/u9GbxqGVyHn/uFBLYleOm7xWDRLSso0Sj4Pl6lsrxigqKgRm/cLMqrlhevx5EVZEOvsw+FEPVnL9heLNheCYXq1HHhufhWUKw7K4i5mHDj3OfloLZlVgTU9xGu0zgXSVIQ3gxpaBEFWZYQAuyKi2vNjUVd9PJ6SBKyriNper22ZFb8c8Gmmo4SCuN77gLhyPr74cjSx5qHlZiLVfWor1amqVamcZ25A9tWEeELbDNfD1eVckO0dOxG06OMDx2mWp7E92yEr1AtT1EqjqKHknSvewzTzFLI9hFLdNQeKCgXx/BnNZwkCb2zE62tjcI7b6/IoKAo9P7WP8G8coXJb3y9YWKXNI2Ov/13EL7PxFe+jDsVxL7DW7bS9JGPoESjyKGgdmHo3/1bnKnFY+OSphHZto3Egw9h9PYiXBdrYIDi++8vGsuUdJ3orl3E77sfvTNQaHWmpigdO0bpyOGgAdpthcCyGz0P4fsUXjtG7MA2im+dxB5aqLGkJCKkfu4hwtvXIEcMkGWc8SwzX3+t3io3vGs9yaf3Y6zvRElG6fj7vwBecLON/vuv4ozNYKzvpP03P8n0X/yE0vvngjFQFTKfeQKto4mJP3geL1/GWNNG229+ksk/+QGRvZsIb1uDHAlhXR1h8k9ewK+YyJEQqY8+SGTnOqRICEmRcSdzzHz7TcxzPyM33/dxygXcUAGzOE46sxHXrmD5BZpatpKVLhKJt+E5JkL4OE4F16miWOAVSyRibfjCxfdcXKeKlsqg6zHy2b45JWbXxXMXJ7cspc4rHJsv/O0EDz0dZXTQQQRF9XzjTx0Ov7X05QjbxquthvNDFiOKhl0oI5zge7UtwW/9zRE++cUUqSYFfA93ib4fuicREkr9fUmC7JSHZYq5edj3Vk5R9hYeK9UZpn3r9XVUtZojIRg8kaU8Y9ePFYQWV8g09b0lx/dGk26wkY9fKbNsQFgIsMs89MVNbHmiHVmWMEsO7/3FNc78eAVhdyECI7WI7M6CTR0bd5mk/Y3eXy1WXlEvfGYmG6VCjHCappYtOHaJcnGul0KlPEH/5Zfq/0+Nz4WSpifOBq+NnWJqbI4qmZ/HJBsbOlT/W1IU9NY2JFmmevnOsG0ArP4+pr79bZRYlMSBBwmtXbv0xpJEaOMmMs99DOG65F57Fb9qore0kH72WeRQCGe+8VMUEg89ROqJJ7GGhsi9ElA6Q2vXkXriCbRMhqnvfPuOVy9Lmkrl2CVC6zuJPbSTmW+9vmAbIcAZn8HqG8XNFlFiYVLPPUTmMx9g5Le/DIB1dYTpv8yTeHIv0Xu3MvEH3ws8D8Cdzs8O0RInsfjL6Y89TOVcP9NffhlkCUlV6vsEgTuZI/fj93GnC4GR+cgDZD7zOMP/+r/fOZqrIhPdtwUvX8a8uFBEVZIVdCOGZkYQvofrmrhuFdepICsaiqzhSza+8KiUxvF8F7M6E7TDlpVak7I8tl3CMBJBPU4tqZt67mGUVBzheWS/+VqDp7gSvPK9Il/74xxGSOKjn0vyC387zeG3VkYLP3/S4vzJhZOV4OaGWgh4+6XbS9Do2Jbk4b++EYBwQiPdE2HyagmnGnh6P/q3Z+eMyl9RZHqj7P35Ho5+e5DLb08gSRK5kdVT9/+q4ZZ4b45dIjt5Edc1b6gOO8v+nf2tatDSpjA55uHOefwLW1HIMko8COO480Xnan23ZyEELFl5uQJ4pRLe5UtImkZ485ZljYqkqiQefghJ15n61reoXDgPvo9kGCQf+wDpD36wwaiE1qwh8cABnPFxJr/21cBzEoLyyZNkPvocsX37KJ88SfXSIg2EFh6dm2WcS4qMbznkXjxE6iMHKL17Zt7EHcAvVii8frym2wVIEsaGLhKP76kf2suXg59cGeG42MOT+OVb04fySlXyP3gP4SxS8V2xKLxxIjgnAFnC6G0l9XMPgizVvaSVIvmRB1GbEsx89SWEM2fIm37xGYTrkf36K0Agb2Ns7sUdm8a8NLhgRhW+z8zURTzPxrIKCBHoh01NnMXzbKrlqZr3LuF5QZglO30J3/ew7TISUlCcJ3ymzDxIckAnF4LKqStEdm8k8dS95L/3Nt4qjYpjCyoln3IR+i/b3Pdo0N7huV9MouoS3/5SDoCHno5yz31h/uv/HXjk//T32uns1Xj3lTJf/9MsZuXGY6uo8JlfTXPvIxFGBx3M6twaXdMl/s0fdRJPyHz/L/P88BuFer7/N/5ZM5fP2ex9MExTs8LB1yo8/+U8tiWIxGQ++zdT7NgXIhoLFARe/X6R57+cx6oKrrw7yciZYAGz7v4MH/oHO3jxd88ydbUECMrZ2UgHKKqM5/pIEsiqHNzGvsBz56layCArUr041/cF/vz3JZA1Gc/xkRWpHq7yPX9B5C7Yl1wv3Ba+wPdE/bGVFQlJkWjZEMO1fa69P8XouTxCsEB9fXZbafac5u1n/rE8x0dWa+cF+K646e64t4pbMiq+59Rd9fnQDYmetSqaDqODHm2dCuGIzPioS+96jcFrDpWyoKlZQVEkItHgCxoecOlZq+F5gqsXnZqgaE1RtCZ6N4voPffQ8pnP1vMT9sQEw797B2Po8yCHQkQ2bqJy/jzW0GCdmSEsi9LhQ6SeeGJuY0kitH49alMT2Z/8BC8/l7T0anTo8NatJHbvIzxkIoSgYI3hCw+BQEIiqjdRsbNIkkxbfAtjxfOAIGG0UbKncf3VJcmrp6+R+MA9RPdtovjeucZri4SI3r+N6N6NKMkYkqaiNieQNW0Ri3/7YF4cXNSgwBxDLbJvM2oqhqRrqE1x5HDQk2O1Z2RdGyX28G60jmbsgaBQVm1JEdm1gex33qhvJxyXmS+/WPtnsaOIedT3uVj+bD2Wv8hCy63VIN2o34t9bRQ5HCL2yD0rvKpGrNmk8+izMaIxmUc+GOXr/y0HQKZVQdPn3MVEWqGjZ47R9H///TEe/7k4ex4Io8grW8A89Vych56K8oe/M0UoJPOb/1cLh94MxsWxBf/kb43whd9sIt2sNDiqazcbbNxu8KX/3wyWKfj132pmYszljR+W+NAn47R2aPyr3xxjz4Ewn/pimh9+vYBVrYXjKh52JQhFlbM2vi8oTZrkxxrDU5k1UT7+L/fw2n+9QMe2JFufaCeS0pm8UuT5f3mCSs5B0WX2f7qXrY+3E2sxkGWJ6f4y73zpCv1HZ0DA+gMt/Nw/3cVLv3eOXR/ponldDNfyOPfyGIe+2kc1H3yfobjKvk/0su3pDkIxDd8XzAyWePu/XWHoZA5Fk7jvs2vZ/sEOUh0RYs0GP/+v9+BaHuWszTf+0VGK48E90rIhzn2/sIbevU2ouszMYIXDX+vn8tsTgXEBdn24m/s/t4af/N459ny8h64dKSQZ3vnSFU58b7i+3U8Td0TEaO0GlV37DeJxmaPvmzS3qLR1KaSaZNZv0pgc9aiUPTp7VNZulBgZdOldp9HcqtDRo2IYwWuVclBMJBw7kOHW58QWnclJCu++gxJPENm8+aZ6gNws1HQaFAU3n18gJe7bdmMOR9dRU6mgaG3d2uDvedA7OpBkmXBzB+FQO6qsYXklVNnA9S184RHWUlScHJ5wAB9DjRJS4qTDXVScPLA6o+IVypTeO0fy6X1UzvbPJd8kifiju0j93IMUXjtO9fS7eCWT5NP7iD96c5NbAySW/J786tIr8dgD22j69OMU3zxJ/kcH8YpV4o/tJvWh+2/qNOyhCYTtoPe01o2Ksa4TZInquT4AQpt7CG1dA7JM9fRVrMuN7CelKUF453qURDTw1gbGsS4PIhwPKWwQ3b8F89Ig7niNbNLTirGhm+LrRwEJvasFY2MXciyCsB3Mi4PYfdf3nLn5CaG5TWXzDgNNl8hNe0Ri8orEBjwXPGd1x33wyShvvlji9OFgMjx+sDGE4zoCb5HJzXMFh9+qcOzdKrIMl85YtHUEU1IyrVDMe1TLPpOjLooCirp6tQQJCVmReODz65juL/P2f7uCEIJIUscsBosYSQ62O//KGNnhClpIYe/P9/Dkb27lL37tII4ZtB0IxVQe+pUNnHlxhCPfGKBzR5J9n+xlZrDMmR+NIARsfbKDA7+0ntd+/yL50Qp6VCXdFamF5YJrPv/aGAPHZ1h3XzMP/LV1vPZfLjBxpYjvCiozwbMcSmg88//Yil31eOMPL+FaHhsfaeWZ/+c2StNm3UuTZEj3RNn3qTWMnMlx5scjRDMG4xcKPxODAnfIqJRLAk2TKJd9LBOmJrxajQuEwjK2Lci0KKzbqGGZcPANk1STQrksCEdk8lkP2w4GRHg+br6AEAItncYeDGiX9sgIM6Oj6B0d6O3tCwoNl8UtSnlImlY7t0WKmYRoYKAEPSmC7WN79y2qRCR8H3wPxytju6ArEUJqHMsr4/oWmmwgSwq+cAGJsJbE9z2cVXoodfiCyskrJD5wD/ED2+Y8BFkismcTVv84hZeO4BVqq3BFqdM4Gy9VLDmWwvHAF0jGvCY/soySWaVuliQR2bsZZ3Sa/E8O42VrPH9JAuXmFhLCtDEvD2Gs66R86HzQhGldB9a1kXo40CtU8HIlEs8eQDhuo1GRZTJf+DA4LvbIFGpTAjWTrBEZPJRIiMST+/FL1bpRMdZ2kPzQAxTfCKrUow9sR0nG8Apl9C29xB/Zzdi//ype7vYQNo68VeEv/ksWWYYde8P85r9o4djbtcl+3lemLV12sWJE4zKF7FwYMTftEY3f+LvxPZgen9+5U9QNx5svlvn138rwL/9LB44j+O6X8xRzN59zVHWZ1//rRaxF+jG5ps+hr/XVQ0uSBKG4xlP/+1bkeYZM+NB3aJqDX76G7wrGLuRZs6+Jjq1Jzr00huf4hJMayNB3aIqZwbnxru9FQG64Sm64SrI9jGt7TF4r1Y3ELNbemyHdHeU7/9dxhk/nAMgOV+nZnWbbkx0N28uKxNDJLEe+0d8QsvtZ4Y4YlZFBl2/9j+DhcIOQMpoq8fRzEd57o0o6I3P+tM2X/mshSAzbgjdr/evPn7bAr30OwHOxx8bA8whv3kL5VE2aoPYjfH/x0MTshHf9pCdJyNFoI9V3lfBrTcpkIxRMuPNpjJIUUJNrhWzCdeuNgMb+5E+wRhdndhhSmDZjA4qskTdHCWlxmsI9TFX6COspok4TllsioqZwfQdF0TCUKEL4yLqC7/oBlXeFcCdzFN85TeYzjzfE671CJQgtJSIIP5hsw1t7keSFxsMvVVCiIbTWNM5kDkmW8EpV8AVuroRXqhLZt4nKqSvg++hrOwhvX4N5YTVq0AKvUEZNx+pegd7TSnjnugVej6SptSS/GjzIYR08EXD25xVnCsfFPNtH8sMHkGNhJElCX9tB4eXDUKM/O2PTuNkikX1bFpyRHDUwelrJfvM1KicuI2ynvt8VwRfkng+oWML3UeIROv+vv0FoUzflQ+du8OGVQZIl1NqE6PkCVQ38nkrZp6ddxwhJSDKs32IsXC9ILMWnWPT14T6H9VsMjHAJSYKe9Tozk4swIBdZgCylsl4ueBRyPn/6u9NMT7pYVXHDtu3LYeBYdlGDAiCrEmv2ZdjxwQ6aeqMYMZVYxiCc1Brue8/1GTqVrU/cru1TnrEJJ3VmxbHPvTzGpkda+fx/eYAr705y+oURxi8XsEqry/f27msi3RPhs/92f93jkGTQQgrRpsZujGbBYfx8Ht8V7Nymca3fpVwRRMISmzZoXO13Mas+jguqQvD9ShCPyeQLwaBuXK9xrd/BdYO1mi+CdKWsgG2vLup9U0ZFiyZxynOWUlI0hDc3sQoRCEgG76kIz8VVQxx626S5VeHaJQfXCVYms5hNlyzWGNEeHcUeHSWycyf6u+9gD9+g5a8QQRvVaBTZMJi/vtFaWlETiVsyKm4uh1cooLe3o0SjuPO6x2lNTajJJG4uF5yK42CPjSIsi9D69Zh91xb9hkxM+quH6/+XnblcVd6cM0SXZ95u/KAs0bqvl1L/TI0THxhbWVOwZiq4laVj98W3TpF8an+DtEnxzRM0f/4ZWr74YfxSBUlTsQcm5raZh+qFQcwLg7T+2sdwp/IIz2fyz36IN1PEyxYpvHyE1Ecfov3/+Cx+xUJSZKqnriLpq1geCyi9eZLwxg/T8isfwsuXkQwNZ2QarTk1NwwRg/THHkaOhQlv7kGOhGj5wrP4pk3l5BUqxy81RJPskaA9r9bWFJAsFBln5Dr6+BLS+36xSvH148Qf30toSy/V831Uz/Qtb1Sum0/leASjpy0waqoS/IRvn2Dhzv0hPvOrKVRVYuN2gzd/XGJi1OXUoSr3PRbh87+exvcDRfDZK+zoUdmxP8w994fp3ajzzCfiXLtoc+Jgld4NGtv3htm+L0QkKvPBT8S5fM7i/AmLF75e4Nf/cTO/8r9nqJR8IjGZmRpbfd1mna33hNi8M4TvCz74yQSXz1pcOrO8lx1NKrR2qNz3WASzKpgadzl3zKRUvDnLYhaWfg7W3dfMc/98N5ffnuTd/36VwqTJxodaePRvbmrYTgix6H7m28rccIWv/f0j7PxQJ+sfbObn/9976Ds8zRt/dInc8MqZXZqhkBuu8PofXsLMNx6zONU4SXquwK566Do89+Eo77xncv6yw9ZNGpvWa0hAR7vC2wdNdm7XCRkSI2MeH3wizJe/UaJaFfR2q/QPuOzarhGNBAuSatWnt1vlBz+pYportyqrMiqzzaSMpjYq4/1IsoLvWIRbeimPXUWLpXArpVrRTyBaGG7qoDRyhXBLF5MjVyk6Lfi6SyQeAiEws+PLtrkFcKYmKZ08Qfqpp8l8/OcpvPUmZn/Q1UzPZJANY0FjGWtwkPCmTUR37iL/1psIx0Fvbyf9oQ/dcvjLt23KJ08QP/AgiQMHyL3yCn61itrcTOqppxfsv3rxItbICPEHHsArl6icO4dXLqOEw6hNTRhr1lA6ehS/tHrBTSMVJrYmhRbTQZIwp8rEelPkzo5jbGxm5mQQp3cmc0z9+Ys4I3OsNL9UZeJPfoCajGH1BZTw6vkBJv7we2jtTSAE9ug0frGKsaFzgSfkDE8x9Rcvove2IRkaomo1sMAKb5wIwkPpRNAWeWQS33bRmpP1CnxnMsf0/3gJa3BpVWbz6gjjf/A8ekfQ6dAZm8HLlyi9f67eEVJ4PtbgBJKiYF5szH94+dKC9IQ7ncceniC8ewN+sYIznq2rDKwEuR+8Q/X0FYyN3SQe20t42zpmvvYyfqmWKL7ueJKmBUs/QOtqIf3Jx/FLFZyxaXzbvelQ3mJ46btF1mwMVrOeJzhz1OTciaAv0YVTFn/8b6fp6NWoln1e+X6JVCZgUfo+uLbg5PtVTr5fDdhItVW574Nt+rxTowYHTKTgeJfPWvzh70zR0atRzPm8+eMSobBUP75tCV79frH+/2x+5Wt/nGV0yKnv/6XvFrEtgSzDYx+KcvGUhaJKxJMSex+M09Si8ONv3u56LtjyRBvlaYt3vnSFmYHg+tbub0LRbu47MQsOh7/ez5kXR+jameaj/2wX2eEyb/7R8u2F5yM7XGGtn2HycpGxCyu7L3fv0NEU2LxRI5GQ6R90UVTo6VL54JMhzpy36e5UkQQUSz6FYvAD0NqsYBgSe3bpnDxjs3tHYIzSabmeilgpVmVU9EQTnmujaAbx7s14tklx6CIgMJItQRvcNDilLOXx/qDSE4Fnm6ihKGoogqKH0BNR1FCU8ng/WjSJlbuBzLvnUXj7HZRolPgDB2j+1KcDoTYhQFGRNQ17fJ6svu+Tf/NN9K4uko8/TvzAAYTrIKkazvgYlXPnUGJz1cBKMkls3z605haUaASjuwdkmeZPfyYQ5zOrVC9enJNu8TwK776L1t5O/MCDRO/ZUxeec8bGqF680CBP7s7MMP2db9P82c/S9OyHST/9dNCrBKmWqxBUzpy5KaOiGCrZ02NEOhOEmqMIx0ON6kQ6k5jTc7UBftmkfGhhS2Lz/HX1F66HdW0U61pj0nipCdcZz+LU8gYL4PmLhrrcedv7pSrlIxeWurz6fuz+cez+xtYJ7szc9QjLofT2KqR1XC8IgT17AC9fonzs4sJaELkWJ5j9Peu1yDKSpmANjGMPTWJeHKDtNz+D2prGLlVrEhsecjKGpCmgqmg9rci1/FJoYzdaexPjv/eTILTXnAT3kcZj1+jc9fNYBS6etrh4evGFml8zLBdOzb0/UCv/Gh92GR9e/B4cuuYwdG3x1b4QS9e2DFxxGLiy+OeOvdfI1Jo959ZOlYefjvEPvzhMIeuh6hLP/WKSNRt0VHUuqnG7YFcCkUnNkFENmWR7mI0Pt6Lqqzcq8dYQnu3jWB6u5TNyNodreYRiq0tenX95jAOfX8f2ZzoojJs4pockQzipU8nZ9cT/fGxYq/Hfvlxk03oNRZW4f79BZ7uC6wpmtSw72xV0XeLgUYtYVKazXcX3BZs3qGzZqOG6gsFhl54ulXVrVIolH1UBexUO4qqMimtWMJLN2KUcnlWpyZRX8B0Lt1pCkmTscg4tEsdINmPlJhGujRqO1mQFgopXzywHn19NR0PbYuYHP6B64QLhLVtR06mg4rhYwh4dxbzSWBhpXrvK+J/9GdF7dqM1tyBsC7O/n/KJE0R27EBv70DUhPUkVUNNplBiQYjHGh6CWoRNNnRkQ28wQgDOxASTX/kKsXv2BBX1nofZd43y8eNE77kHNZNpoEDbIyOM/f4fENm1k1DvGuRoBL9q4k5PU71y+abFMCujBSqjBbJnJ8js6WT62DBNuzrInZ/Ad+5sMeX/7Kie6yP9qcdBUxqKGyVDI7S5F629KQiPyRLeY3twJ7KY5/rQuppJf/wx3JkCwnbQOpsxLwzgTgTG0i+bARHiyX2BuKWhoXW21MNjztg0wnFJPHM/fqmC2pyqy9wAKJkk4a1rAsWCWJjYo/fgTuWxLg7Wi0v/V0ZuxmO43+Gjn0syMmCTalLZtT/EC18r3HaDAnDqhWE2PtTCh/7hDnLDVeItBq7lU5pePRHmvs+uYdOjrRTGAkOQ7AiTH61y5sXVidNmh8v85D+c48FfXk/37jTlrEUophFrNvjm/3mMqWsLjf9Xvx0sIgeHg+deloNFxOx6qDkjc+S4xVvvWQgB//mPg4WiEPDPfzsHwPtHg2u+eNlhatoj06SQTsmMT67cqqxY++tn0ZP5LlYHWVPwHQ9Zk/Gdn71q8P8MiN6/HRSZ8sGz9ayxHAkR2bsJJd3IVHMnc5QPnkEK6YR3bUDNJJCQcPMlzHN9eLm5B12OhQlvW4uaSeLmijjjWfSODKV3TwX08o3d6GvaA2/u8hBKIoqbLeAMTaJ1NhPZs6mRced6VE5dxhm+gaT+/yLo7NXYfX+YaFzGqvpBHuastWh9c6orwqZHWjjz4iiVbKO3GU5obHyklamrJUbPL26QJTmo0O/YlkRRZaaulZgZKLP2vgynfzSCa/ukOsNseKiFS29OUKjVkai6zLr7m/F9wbWDU/ieoKk3StfOFJG0HhSx5h2GTmTJDi1cQDf1Rlmzv4lLb05QmlpowGRVonVjnPatSYyoil1xyQ1XGDyRreuDtayP0b07zcU3xm+oIKCqEAlLFIo3nvI1Dbo7VVxPMDg0tzhdibm4a1Tu4i7u4i7uYkW4rYKS/zM16LmLu7iLu7iLnw1+emXod3EXd3EXd/G/PO4albu4i7u4i7u4bbhrVO7iLu7iLu7ituGuUbmLu7iLu7iL24a7RuUu7uIu7uIubhvuGpW7uIu7uIu7uG24a1Tu4i7u4i7u4rbhrlG5i7u4i7u4i9uGu0blLu7iLu7iLm4b/v/bsEyvadqtfQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -662,7 +664,7 @@ "id": "HFifXKl_eKsN" }, "source": [ - "## ✨  Data Preprocessing" + "## ✨ Data Preprocessing" ] }, { @@ -1290,11 +1292,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:00:09,809\tINFO read_api.py:374 -- To satisfy the requested parallelism of 48, each read task output will be split into 48 smaller blocks.\n", - "2023-09-14 15:00:09,814\tINFO dataset.py:2180 -- Tip: Use `take_batch()` instead of `take() / show()` to return records in pandas or numpy batch format.\n", - "2023-09-14 15:00:09,816\tINFO streaming_executor.py:92 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle]\n", - "2023-09-14 15:00:09,817\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:09,817\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:40:08,636\tINFO read_api.py:406 -- To satisfy the requested parallelism of 64, each read task output is split into 64 smaller blocks.\n", + "2023-09-17 22:40:08,640\tINFO dataset.py:2380 -- Tip: Use `take_batch()` instead of `take() / show()` to return records in pandas or numpy batch format.\n", + "2023-09-17 22:40:08,642\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:40:08,643\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:40:08,644\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -1305,7 +1307,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:00:13,416\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:13,418\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:40:11,641\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:40:11,642\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:40:11,642\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -1399,7 +1401,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:00:15,650\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:15,650\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:40:13,022\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:40:13,023\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:40:13,024\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -1478,7 +1480,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", - "2023-09-14 15:00:17,756\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:17,757\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:40:15,114\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", + "2023-09-17 22:40:15,115\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:40:15,116\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -1655,7 +1657,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", - "2023-09-14 15:00:19,882\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:19,883\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:40:17,172\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)] -> LimitOperator[limit=1]\n", + "2023-09-17 22:40:17,173\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:40:17,173\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -1902,7 +1904,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00\n", + "\u001b[2m\u001b[36m(MapBatches(preprocess) pid=348475, ip=10.0.34.101)\u001b[0m Traceback (most recent call last):\n", + "\u001b[2m\u001b[36m(MapBatches(preprocess) pid=348475, ip=10.0.34.101)\u001b[0m File \"/home/ray/anaconda3/lib/python3.10/site-packages/ray/data/dataset.py\", line 5222, in __del__\n", + "\u001b[2m\u001b[36m(MapBatches(preprocess) pid=348532, ip=10.0.34.101)\u001b[0m if self._current_executor and ray is not None and ray.is_initialized():\n", + "\u001b[2m\u001b[36m(MapBatches(preprocess) pid=348532, ip=10.0.34.101)\u001b[0m KeyboardInterrupt: \n", + "\u001b[2m\u001b[36m(MapBatches(preprocess) pid=348485, ip=10.0.34.101)\u001b[0m \n" + ] + } + ], "source": [ "import os\n", "import random\n", @@ -2171,21 +2187,30 @@ }, "outputs": [], "source": [ - "class CustomPreprocessor(Preprocessor):\n", + "class CustomPreprocessor():\n", " \"\"\"Custom preprocessor class.\"\"\"\n", - " def _fit(self, ds):\n", + " def __init__(self, class_to_index={}):\n", + " self.class_to_index = class_to_index or {} # mutable defaults\n", + " self.index_to_class = {v: k for k, v in self.class_to_index.items()}\n", + " \n", + " def fit(self, ds):\n", " tags = ds.unique(column=\"tag\")\n", " self.class_to_index = {tag: i for i, tag in enumerate(tags)}\n", " self.index_to_class = {v:k for k, v in self.class_to_index.items()}\n", - " def _transform_pandas(self, batch): # could also do _transform_numpy\n", - " return preprocess(batch, class_to_index=self.class_to_index)" + " return self\n", + " \n", + " def transform(self, ds):\n", + " return ds.map_batches(\n", + " preprocess, \n", + " fn_kwargs={\"class_to_index\": self.class_to_index}, \n", + " batch_format=\"pandas\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 🤖  Model" + "## 🤖 Model" ] }, { @@ -2194,7 +2219,16 @@ "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created a temporary directory at /tmp/tmpswqswp9h\n", + "Writing /tmp/tmpswqswp9h/_remote_module_non_scriptable.py\n" + ] + } + ], "source": [ "import torch.nn as nn\n", "from transformers import BertModel" @@ -2206,17 +2240,7 @@ "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Some weights of the model checkpoint at allenai/scibert_scivocab_uncased were not used when initializing BertModel: ['cls.predictions.transform.dense.weight', 'cls.predictions.decoder.bias', 'cls.predictions.transform.dense.bias', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.predictions.decoder.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight']\n", - "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", - "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" - ] - } - ], + "outputs": [], "source": [ "# Pretrained LLM\n", "llm = BertModel.from_pretrained(\"allenai/scibert_scivocab_uncased\", return_dict=False)\n", @@ -2262,6 +2286,9 @@ " def __init__(self, llm, dropout_p, embedding_dim, num_classes):\n", " super(FinetunedLLM, self).__init__()\n", " self.llm = llm\n", + " self.dropout_p = dropout_p\n", + " self.embedding_dim = embedding_dim\n", + " self.num_classes = num_classes\n", " self.dropout = torch.nn.Dropout(dropout_p)\n", " self.fc1 = torch.nn.Linear(embedding_dim, num_classes)\n", "\n", @@ -2275,7 +2302,7 @@ " @torch.inference_mode()\n", " def predict(self, batch):\n", " self.eval()\n", - " z = self(inputs)\n", + " z = self(batch)\n", " y_pred = torch.argmax(z, dim=1).cpu().numpy()\n", " return y_pred\n", " \n", @@ -2283,8 +2310,27 @@ " def predict_proba(self, batch):\n", " self.eval()\n", " z = self(batch)\n", - " y_probs = F.softmax(z).cpu().numpy()\n", - " return y_probs" + " y_probs = F.softmax(z, dim=1).cpu().numpy()\n", + " return y_probs\n", + " \n", + " def save(self, dp):\n", + " with open(Path(dp, \"args.json\"), \"w\") as fp:\n", + " contents = {\n", + " \"dropout_p\": self.dropout_p,\n", + " \"embedding_dim\": self.embedding_dim,\n", + " \"num_classes\": self.num_classes,\n", + " }\n", + " json.dump(contents, fp, indent=4, sort_keys=False)\n", + " torch.save(self.state_dict(), os.path.join(dp, \"model.pt\"))\n", + "\n", + " @classmethod\n", + " def load(cls, args_fp, state_dict_fp):\n", + " with open(args_fp, \"r\") as fp:\n", + " kwargs = json.load(fp=fp)\n", + " llm = BertModel.from_pretrained(\"allenai/scibert_scivocab_uncased\", return_dict=False)\n", + " model = cls(llm=llm, **kwargs)\n", + " model.load_state_dict(torch.load(state_dict_fp, map_location=torch.device(\"cpu\")))\n", + " return model" ] }, { @@ -2356,7 +2402,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 📦  Batching" + "## 📦 Batching" ] }, { @@ -2372,16 +2418,7 @@ "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created a temporary directory at /tmp/tmpbeivcg5y\n", - "Writing /tmp/tmpbeivcg5y/_remote_module_non_scriptable.py\n" - ] - } - ], + "outputs": [], "source": [ "from ray.train.torch import get_device" ] @@ -2438,9 +2475,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:00:23,986\tINFO streaming_executor.py:92 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", - "2023-09-14 15:00:23,987\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:23,988\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:40:22,793\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)] -> LimitOperator[limit=128]\n", + "2023-09-17 22:40:22,794\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:40:22,795\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -2451,7 +2488,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:00:26,139\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:26,139\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-18 21:57:50,561\tINFO read_api.py:406 -- To satisfy the requested parallelism of 64, each read task output is split into 64 smaller blocks.\n", + "2023-09-18 21:57:50,565\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-18 21:57:50,565\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-18 21:57:50,566\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -2876,7 +2921,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:00:26,513\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:26,513\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-18 21:57:51,011\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-18 21:57:51,012\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-18 21:57:51,012\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -2955,7 +3000,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", - "2023-09-14 15:00:27,772\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:27,773\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-18 21:57:53,336\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", + "2023-09-18 21:57:53,337\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-18 21:57:53,338\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -3132,7 +3177,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:00:29,415\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:29,416\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-18 21:57:54,975\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", + "2023-09-18 21:57:54,977\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-18 21:57:54,977\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -3365,7 +3410,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:00:31,130\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:00:31,131\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-18 21:57:56,897\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", + "2023-09-18 21:57:56,897\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-18 21:57:56,898\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -3542,7 +3587,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00Tune Status\n", " \n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "
Current time:2023-09-14 15:02:25
Running for: 00:01:52.74
Memory: 6.4/30.9 GiB
Current time:2023-09-18 21:59:12
Running for: 00:01:13.39
Memory: 22.2/62.1 GiB
\n", " \n", "
\n", "
\n", "

System Info

\n", - " Using FIFO scheduling algorithm.
Logical resource usage: 4.0/24 CPUs, 1.0/1 GPUs\n", + " Using FIFO scheduling algorithm.
Logical resource usage: 4.0/32 CPUs, 1.0/2 GPUs (0.0/2.0 accelerator_type:A10G)\n", "
\n", " \n", " \n", @@ -3790,10 +3827,10 @@ "

Trial Status

\n", " \n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "
Trial name status loc iter total time (s) epoch lr train_loss
Trial name status loc iter total time (s) epoch lr train_loss
TorchTrainer_2044b_00000TERMINATED10.0.50.151:49611 10 106.8 98e-05 0.0400874
TorchTrainer_1a81f_00000TERMINATED10.0.34.101:727773 10 68.3685 90.0001 0.0525064
\n", " \n", @@ -3840,36 +3877,260 @@ "name": "stderr", "output_type": "stream", "text": [ - "(TorchTrainer pid=49611, ip=10.0.50.151) The dict form of `dataset_config` is deprecated. Use the DataConfig class instead. Support for this will be dropped in a future release.\n", - "(TorchTrainer pid=49611, ip=10.0.50.151) The `preprocessor` arg to Trainer is deprecated. Apply preprocessor transformations ahead of time by calling `preprocessor.transform(ds)`. Support for the preprocessor arg will be dropped in a future release.\n", - "(TorchTrainer pid=49611, ip=10.0.50.151) Starting distributed worker processes: ['49656 (10.0.50.151)']\n", - "(RayTrainWorker pid=49656, ip=10.0.50.151) Setting up process group for: env:// [rank=0, world_size=1]\n", - "(RayTrainWorker pid=49656, ip=10.0.50.151) Some weights of the model checkpoint at allenai/scibert_scivocab_uncased were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.decoder.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.bias']\n", - "(RayTrainWorker pid=49656, ip=10.0.50.151) - This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", - "(RayTrainWorker pid=49656, ip=10.0.50.151) - This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", - "(RayTrainWorker pid=49656, ip=10.0.50.151) Moving model to device: cuda:0\n", - "(RayTrainWorker pid=49656, ip=10.0.50.151) /tmp/ipykernel_117917/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n", - "2023-09-14 15:00:53,439\tWARNING syncer.py:844 -- Ray AIR no longer supports the synchronization of checkpoints and other artifacts from worker nodes to the head node. This means that the checkpoints and artifacts saved by trials scheduled on worker nodes will not be accessible during the run (e.g., resuming from a checkpoint after a failure) or after the run (e.g., loading the checkpoint of a trial that ran on an already terminated worker node).\n", - "\n", - "To fix this issue, configure AIR to use either:\n", - "(1) Cloud storage: `RunConfig(storage_path='s3://your/bucket')`\n", - "(2) A network filesystem mounted on all nodes: `RunConfig(storage_path='/mnt/path/to/nfs_storage')`\n", - "See this Github issue for more details on transitioning to cloud storage/NFS as well as an explanation on why this functionality is being removed: https://github.com/ray-project/ray/issues/37177\n", - "If you are already using NFS, you can ignore this warning message.\n", - "\n", - "Other temporary workarounds:\n", - "- If you want to avoid errors/warnings and continue running with syncing explicitly turned off, set `RunConfig(SyncConfig(syncer=None))`\n", - "- Or, to re-enable the head node syncing behavior, set the environment variable RAY_AIR_REENABLE_DEPRECATED_SYNC_TO_HEAD_NODE=1\n", - " - **Note that this functionality will tentatively be hard-deprecated in Ray 2.7.** See the linked issue for the latest information.\n", - "2023-09-14 15:02:25,773\tINFO tune.py:1148 -- Total run time: 112.90 seconds (112.71 seconds for the tuning loop).\n" + "\u001b[2m\u001b[36m(TorchTrainer pid=727773, ip=10.0.34.101)\u001b[0m Starting distributed worker processes: ['727834 (10.0.34.101)']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=727834, ip=10.0.34.101)\u001b[0m Setting up process group for: env:// [rank=0, world_size=1]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Auto configuring locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=727834, ip=10.0.34.101)\u001b[0m Moving model to device: cuda:0\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Executing DAG InputDataBuffer[Input] -> OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=727900, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=727900, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00train_loss\n", " val_loss\n", " timestamp\n", - " time_this_iter_s\n", " should_checkpoint\n", " done\n", " training_iteration\n", " trial_id\n", " date\n", - " time_total_s\n", - " pid\n", - " hostname\n", - " node_ip\n", + " ...\n", " time_since_restore\n", " iterations_since_restore\n", + " checkpoint_dir_name\n", + " config/train_loop_config/dropout_p\n", + " config/train_loop_config/lr\n", + " config/train_loop_config/lr_factor\n", + " config/train_loop_config/lr_patience\n", + " config/train_loop_config/num_epochs\n", + " config/train_loop_config/batch_size\n", + " config/train_loop_config/num_classes\n", " \n", " \n", " \n", " \n", " 0\n", " 0\n", - " 0.00010\n", - " 0.579703\n", - " 0.498519\n", - " 1694728846\n", - " 16.904209\n", + " 0.0001\n", + " 0.577060\n", + " 0.499463\n", + " 1695099495\n", " True\n", " False\n", " 1\n", - " 2044b_00000\n", - " 2023-09-14_15-00-53\n", - " 16.904209\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 16.904209\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-15\n", + " ...\n", + " 12.883882\n", " 1\n", + " checkpoint_000000\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 1\n", " 1\n", - " 0.00010\n", - " 0.480723\n", - " 0.407913\n", - " 1694728856\n", - " 10.286396\n", + " 0.0001\n", + " 0.497796\n", + " 0.454631\n", + " 1695099501\n", " True\n", " False\n", " 2\n", - " 2044b_00000\n", - " 2023-09-14_15-01-03\n", - " 27.190605\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 27.190605\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-21\n", + " ...\n", + " 18.986689\n", " 2\n", + " checkpoint_000001\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 2\n", " 2\n", - " 0.00010\n", - " 0.402693\n", - " 0.324105\n", - " 1694728867\n", - " 9.887647\n", + " 0.0001\n", + " 0.432476\n", + " 0.324219\n", + " 1695099507\n", " True\n", " False\n", " 3\n", - " 2044b_00000\n", - " 2023-09-14_15-01-13\n", - " 37.078252\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 37.078252\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-27\n", + " ...\n", + " 25.088869\n", " 3\n", + " checkpoint_000002\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 3\n", " 3\n", - " 0.00010\n", - " 0.278217\n", - " 0.256301\n", - " 1694728877\n", - " 9.893445\n", + " 0.0001\n", + " 0.319699\n", + " 0.250069\n", + " 1695099513\n", " True\n", " False\n", " 4\n", - " 2044b_00000\n", - " 2023-09-14_15-01-23\n", - " 46.971696\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 46.971696\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-33\n", + " ...\n", + " 31.192535\n", + " 4\n", + " checkpoint_000003\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", " 4\n", " \n", " \n", " 4\n", " 4\n", - " 0.00010\n", - " 0.203579\n", - " 0.249053\n", - " 1694728887\n", - " 9.843567\n", + " 0.0001\n", + " 0.243872\n", + " 0.208918\n", + " 1695099519\n", " True\n", " False\n", " 5\n", - " 2044b_00000\n", - " 2023-09-14_15-01-33\n", - " 56.815263\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 56.815263\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-39\n", + " ...\n", + " 37.338241\n", " 5\n", + " checkpoint_000004\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 5\n", " 5\n", - " 0.00010\n", - " 0.152601\n", - " 0.180287\n", - " 1694728896\n", - " 10.026406\n", + " 0.0001\n", + " 0.188871\n", + " 0.183051\n", + " 1695099525\n", " True\n", " False\n", " 6\n", - " 2044b_00000\n", - " 2023-09-14_15-01-43\n", - " 66.841670\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 66.841670\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-45\n", + " ...\n", + " 43.458540\n", " 6\n", + " checkpoint_000005\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 6\n", " 6\n", - " 0.00010\n", - " 0.105872\n", - " 0.184052\n", - " 1694728906\n", - " 9.971822\n", + " 0.0001\n", + " 0.145348\n", + " 0.139673\n", + " 1695099532\n", " True\n", " False\n", " 7\n", - " 2044b_00000\n", - " 2023-09-14_15-01-53\n", - " 76.813491\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 76.813491\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-52\n", + " ...\n", + " 49.559415\n", " 7\n", + " checkpoint_000006\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 7\n", " 7\n", - " 0.00010\n", - " 0.074756\n", - " 0.184786\n", - " 1694728916\n", - " 9.988855\n", + " 0.0001\n", + " 0.102919\n", + " 0.126615\n", + " 1695099538\n", " True\n", " False\n", " 8\n", - " 2044b_00000\n", - " 2023-09-14_15-02-03\n", - " 86.802346\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 86.802346\n", + " 1a81f_00000\n", + " 2023-09-18_21-58-58\n", + " ...\n", + " 56.116772\n", " 8\n", + " checkpoint_000007\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 8\n", " 8\n", - " 0.00010\n", - " 0.055098\n", - " 0.201344\n", - " 1694728926\n", - " 9.961005\n", + " 0.0001\n", + " 0.074093\n", + " 0.135746\n", + " 1695099544\n", " True\n", " False\n", " 9\n", - " 2044b_00000\n", - " 2023-09-14_15-02-13\n", - " 96.763352\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 96.763352\n", + " 1a81f_00000\n", + " 2023-09-18_21-59-04\n", + " ...\n", + " 62.219563\n", " 9\n", + " checkpoint_000008\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 9\n", " 9\n", - " 0.00008\n", - " 0.040087\n", - " 0.210514\n", - " 1694728936\n", - " 10.036337\n", + " 0.0001\n", + " 0.052506\n", + " 0.113568\n", + " 1695099550\n", " True\n", " False\n", " 10\n", - " 2044b_00000\n", - " 2023-09-14_15-02-23\n", - " 106.799689\n", - " 49611\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 106.799689\n", + " 1a81f_00000\n", + " 2023-09-18_21-59-10\n", + " ...\n", + " 68.368526\n", " 10\n", + " checkpoint_000009\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", "\n", + "

10 rows × 25 columns

\n", "" ], "text/plain": [ - " epoch lr train_loss val_loss timestamp time_this_iter_s \n", - "0 0 0.00010 0.579703 0.498519 1694728846 16.904209 \\\n", - "1 1 0.00010 0.480723 0.407913 1694728856 10.286396 \n", - "2 2 0.00010 0.402693 0.324105 1694728867 9.887647 \n", - "3 3 0.00010 0.278217 0.256301 1694728877 9.893445 \n", - "4 4 0.00010 0.203579 0.249053 1694728887 9.843567 \n", - "5 5 0.00010 0.152601 0.180287 1694728896 10.026406 \n", - "6 6 0.00010 0.105872 0.184052 1694728906 9.971822 \n", - "7 7 0.00010 0.074756 0.184786 1694728916 9.988855 \n", - "8 8 0.00010 0.055098 0.201344 1694728926 9.961005 \n", - "9 9 0.00008 0.040087 0.210514 1694728936 10.036337 \n", + " epoch lr train_loss val_loss timestamp should_checkpoint done \\\n", + "0 0 0.0001 0.577060 0.499463 1695099495 True False \n", + "1 1 0.0001 0.497796 0.454631 1695099501 True False \n", + "2 2 0.0001 0.432476 0.324219 1695099507 True False \n", + "3 3 0.0001 0.319699 0.250069 1695099513 True False \n", + "4 4 0.0001 0.243872 0.208918 1695099519 True False \n", + "5 5 0.0001 0.188871 0.183051 1695099525 True False \n", + "6 6 0.0001 0.145348 0.139673 1695099532 True False \n", + "7 7 0.0001 0.102919 0.126615 1695099538 True False \n", + "8 8 0.0001 0.074093 0.135746 1695099544 True False \n", + "9 9 0.0001 0.052506 0.113568 1695099550 True False \n", "\n", - " should_checkpoint done training_iteration trial_id \n", - "0 True False 1 2044b_00000 \\\n", - "1 True False 2 2044b_00000 \n", - "2 True False 3 2044b_00000 \n", - "3 True False 4 2044b_00000 \n", - "4 True False 5 2044b_00000 \n", - "5 True False 6 2044b_00000 \n", - "6 True False 7 2044b_00000 \n", - "7 True False 8 2044b_00000 \n", - "8 True False 9 2044b_00000 \n", - "9 True False 10 2044b_00000 \n", + " training_iteration trial_id date ... \\\n", + "0 1 1a81f_00000 2023-09-18_21-58-15 ... \n", + "1 2 1a81f_00000 2023-09-18_21-58-21 ... \n", + "2 3 1a81f_00000 2023-09-18_21-58-27 ... \n", + "3 4 1a81f_00000 2023-09-18_21-58-33 ... \n", + "4 5 1a81f_00000 2023-09-18_21-58-39 ... \n", + "5 6 1a81f_00000 2023-09-18_21-58-45 ... \n", + "6 7 1a81f_00000 2023-09-18_21-58-52 ... \n", + "7 8 1a81f_00000 2023-09-18_21-58-58 ... \n", + "8 9 1a81f_00000 2023-09-18_21-59-04 ... \n", + "9 10 1a81f_00000 2023-09-18_21-59-10 ... \n", "\n", - " date time_total_s pid hostname node_ip \n", - "0 2023-09-14_15-00-53 16.904209 49611 ip-10-0-50-151 10.0.50.151 \\\n", - "1 2023-09-14_15-01-03 27.190605 49611 ip-10-0-50-151 10.0.50.151 \n", - "2 2023-09-14_15-01-13 37.078252 49611 ip-10-0-50-151 10.0.50.151 \n", - "3 2023-09-14_15-01-23 46.971696 49611 ip-10-0-50-151 10.0.50.151 \n", - "4 2023-09-14_15-01-33 56.815263 49611 ip-10-0-50-151 10.0.50.151 \n", - "5 2023-09-14_15-01-43 66.841670 49611 ip-10-0-50-151 10.0.50.151 \n", - "6 2023-09-14_15-01-53 76.813491 49611 ip-10-0-50-151 10.0.50.151 \n", - "7 2023-09-14_15-02-03 86.802346 49611 ip-10-0-50-151 10.0.50.151 \n", - "8 2023-09-14_15-02-13 96.763352 49611 ip-10-0-50-151 10.0.50.151 \n", - "9 2023-09-14_15-02-23 106.799689 49611 ip-10-0-50-151 10.0.50.151 \n", + " time_since_restore iterations_since_restore checkpoint_dir_name \\\n", + "0 12.883882 1 checkpoint_000000 \n", + "1 18.986689 2 checkpoint_000001 \n", + "2 25.088869 3 checkpoint_000002 \n", + "3 31.192535 4 checkpoint_000003 \n", + "4 37.338241 5 checkpoint_000004 \n", + "5 43.458540 6 checkpoint_000005 \n", + "6 49.559415 7 checkpoint_000006 \n", + "7 56.116772 8 checkpoint_000007 \n", + "8 62.219563 9 checkpoint_000008 \n", + "9 68.368526 10 checkpoint_000009 \n", "\n", - " time_since_restore iterations_since_restore \n", - "0 16.904209 1 \n", - "1 27.190605 2 \n", - "2 37.078252 3 \n", - "3 46.971696 4 \n", - "4 56.815263 5 \n", - "5 66.841670 6 \n", - "6 76.813491 7 \n", - "7 86.802346 8 \n", - "8 96.763352 9 \n", - "9 106.799689 10 " + " config/train_loop_config/dropout_p config/train_loop_config/lr \\\n", + "0 0.5 0.0001 \n", + "1 0.5 0.0001 \n", + "2 0.5 0.0001 \n", + "3 0.5 0.0001 \n", + "4 0.5 0.0001 \n", + "5 0.5 0.0001 \n", + "6 0.5 0.0001 \n", + "7 0.5 0.0001 \n", + "8 0.5 0.0001 \n", + "9 0.5 0.0001 \n", + "\n", + " config/train_loop_config/lr_factor config/train_loop_config/lr_patience \\\n", + "0 0.8 3 \n", + "1 0.8 3 \n", + "2 0.8 3 \n", + "3 0.8 3 \n", + "4 0.8 3 \n", + "5 0.8 3 \n", + "6 0.8 3 \n", + "7 0.8 3 \n", + "8 0.8 3 \n", + "9 0.8 3 \n", + "\n", + " config/train_loop_config/num_epochs config/train_loop_config/batch_size \\\n", + "0 10 256 \n", + "1 10 256 \n", + "2 10 256 \n", + "3 10 256 \n", + "4 10 256 \n", + "5 10 256 \n", + "6 10 256 \n", + "7 10 256 \n", + "8 10 256 \n", + "9 10 256 \n", + "\n", + " config/train_loop_config/num_classes \n", + "0 4 \n", + "1 4 \n", + "2 4 \n", + "3 4 \n", + "4 4 \n", + "5 4 \n", + "6 4 \n", + "7 4 \n", + "8 4 \n", + "9 4 \n", + "\n", + "[10 rows x 25 columns]" ] }, - "execution_count": 63, + "execution_count": 232, "metadata": {}, "output_type": "execute_result" } @@ -4201,22 +4545,22 @@ { "data": { "text/plain": [ - "[(TorchCheckpoint(local_path=/efs/shared_storage/madewithml/GokuMohandas/llm/TorchTrainer_2044b_00000_0_2023-09-14_15-00-33/checkpoint_000005),\n", - " {'epoch': 5,\n", + "[(Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/llm/TorchTrainer_e2941_00000_0_2023-09-17_22-40-33/checkpoint_000009),\n", + " {'epoch': 9,\n", " 'lr': 0.0001,\n", - " 'train_loss': 0.152601088086764,\n", - " 'val_loss': 0.1802874505519867,\n", - " 'timestamp': 1694728896,\n", - " 'time_this_iter_s': 10.026406288146973,\n", + " 'train_loss': 0.052506402134895325,\n", + " 'val_loss': 0.11356845498085022,\n", + " 'timestamp': 1695015703,\n", " 'should_checkpoint': True,\n", " 'done': False,\n", - " 'training_iteration': 6,\n", - " 'trial_id': '2044b_00000',\n", - " 'date': '2023-09-14_15-01-43',\n", - " 'time_total_s': 66.84166955947876,\n", - " 'pid': 49611,\n", - " 'hostname': 'ip-10-0-50-151',\n", - " 'node_ip': '10.0.50.151',\n", + " 'training_iteration': 10,\n", + " 'trial_id': 'e2941_00000',\n", + " 'date': '2023-09-17_22-41-43',\n", + " 'time_this_iter_s': 6.128554105758667,\n", + " 'time_total_s': 66.49748063087463,\n", + " 'pid': 842775,\n", + " 'hostname': 'ip-10-0-35-174',\n", + " 'node_ip': '10.0.35.174',\n", " 'config': {'train_loop_config': {'dropout_p': 0.5,\n", " 'lr': 0.0001,\n", " 'lr_factor': 0.8,\n", @@ -4224,9 +4568,8 @@ " 'num_epochs': 10,\n", " 'batch_size': 256,\n", " 'num_classes': 4}},\n", - " 'time_since_restore': 66.84166955947876,\n", - " 'iterations_since_restore': 6,\n", - " 'experiment_tag': '0'})]" + " 'time_since_restore': 66.49748063087463,\n", + " 'iterations_since_restore': 10})]" ] }, "execution_count": 64, @@ -4254,7 +4597,6 @@ }, "outputs": [], "source": [ - "from ray.train.torch.torch_predictor import TorchPredictor\n", "from sklearn.metrics import precision_recall_fscore_support" ] }, @@ -4266,10 +4608,29 @@ }, "outputs": [], "source": [ - "# Predictor\n", - "best_checkpoint = results.best_checkpoints[0][0]\n", - "predictor = TorchPredictor.from_checkpoint(best_checkpoint)\n", - "preprocessor = predictor.get_preprocessor()" + "class TorchPredictor:\n", + " def __init__(self, preprocessor, model):\n", + " self.preprocessor = preprocessor\n", + " self.model = model\n", + " self.model.eval()\n", + " \n", + " def __call__(self, batch):\n", + " results = self.model.predict(collate_fn(batch))\n", + " return {\"output\": results}\n", + "\n", + " def predict_proba(self, batch):\n", + " results = self.model.predict_proba(collate_fn(batch))\n", + " return {\"output\": results}\n", + " \n", + " def get_preprocessor(self):\n", + " return self.preprocessor\n", + " \n", + " @classmethod\n", + " def from_checkpoint(cls, checkpoint):\n", + " metadata = checkpoint.get_metadata()\n", + " preprocessor = CustomPreprocessor(class_to_index=metadata[\"class_to_index\"])\n", + " model = FinetunedLLM.load(Path(checkpoint.path, \"args.json\"), Path(checkpoint.path, \"model.pt\"))\n", + " return cls(preprocessor=preprocessor, model=model)" ] }, { @@ -4278,15 +4639,29 @@ "metadata": { "tags": [] }, + "outputs": [], + "source": [ + "# Artifacts\n", + "best_checkpoint = results.best_checkpoints[0][0]\n", + "predictor = TorchPredictor.from_checkpoint(best_checkpoint)\n", + "preprocessor = predictor.get_preprocessor()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:02:31,960\tINFO read_api.py:374 -- To satisfy the requested parallelism of 48, each read task output will be split into 48 smaller blocks.\n", - "2023-09-14 15:02:31,963\tINFO streaming_executor.py:92 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:02:31,964\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:31,965\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:41:46,264\tINFO read_api.py:406 -- To satisfy the requested parallelism of 64, each read task output is split into 64 smaller blocks.\n", + "2023-09-17 22:41:46,268\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)] -> LimitOperator[limit=1]\n", + "2023-09-17 22:41:46,268\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:41:46,269\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -4297,7 +4672,7 @@ "version_minor": 0 }, "text/plain": [ - "Running 0: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)->MapBatches()]\n", - "2023-09-14 15:02:32,387\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:32,388\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:41:46,831\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches()]\n", + "2023-09-17 22:41:46,831\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:41:46,832\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -4349,7 +4724,7 @@ "version_minor": 0 }, "text/plain": [ - "Running 0: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor)]\n", + "2023-09-17 22:41:47,785\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:41:47,786\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/4096 [00:00MapBatches(TorchPredictor) pid=348532, ip=10.0.34.101)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" ] } ], "source": [ "# y_pred\n", - "z = predictor.predict(data=test_ds.to_pandas())[\"predictions\"]\n", - "y_pred = np.stack(z).argmax(1)\n", - "print (y_pred)" + "predictions = preprocessed_ds.map_batches(predictor).take_all()\n", + "y_pred = np.array([d[\"output\"] for d in predictions])" ] }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 71, "metadata": { "tags": [] }, @@ -4440,12 +4802,12 @@ { "data": { "text/plain": [ - "{'precision': 0.8906159283331904,\n", - " 'recall': 0.8848167539267016,\n", - " 'f1': 0.8833617666401639}" + "{'precision': 0.9138952286238713,\n", + " 'recall': 0.9109947643979057,\n", + " 'f1': 0.9114851103432928}" ] }, - "execution_count": 70, + "execution_count": 71, "metadata": {}, "output_type": "execute_result" } @@ -4458,7 +4820,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 72, "metadata": { "tags": [] }, @@ -4472,8 +4834,8 @@ " y_true = np.stack([item[\"targets\"] for item in values])\n", " \n", " # y_pred\n", - " z = predictor.predict(data=test_ds.to_pandas())[\"predictions\"]\n", - " y_pred = np.stack(z).argmax(1)\n", + " predictions = preprocessed_ds.map_batches(predictor).take_all()\n", + " y_pred = np.array([d[\"output\"] for d in predictions])\n", "\n", " # Evaluate\n", " metrics = precision_recall_fscore_support(y_true, y_pred, average=\"weighted\")\n", @@ -4483,7 +4845,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 73, "metadata": { "tags": [] }, @@ -4492,9 +4854,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:02:36,046\tINFO streaming_executor.py:92 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)->MapBatches()]\n", - "2023-09-14 15:02:36,047\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:36,047\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:41:54,734\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches()]\n", + "2023-09-17 22:41:54,734\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:41:54,735\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -4505,12 +4867,21 @@ "version_minor": 0 }, "text/plain": [ - "Running 0: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor)]\n", + "2023-09-17 22:41:55,456\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:41:55,456\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -4519,7 +4890,7 @@ "version_minor": 0 }, "text/plain": [ - "Read progress 0: 0%| | 0/1 [00:00 TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:42:00,134\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:42:00,134\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/1 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:02:39,952\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:39,952\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:42:01,332\tINFO read_api.py:406 -- To satisfy the requested parallelism of 64, each read task output is split into 64 smaller blocks.\n", + "2023-09-17 22:42:01,337\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:42:01,337\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:42:01,338\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -4740,7 +5134,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:02:40,403\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:40,405\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:42:01,795\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:42:01,795\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:42:01,796\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -4819,7 +5213,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", - "2023-09-14 15:02:41,750\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:41,751\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:42:03,339\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", + "2023-09-17 22:42:03,340\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:42:03,340\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -4996,7 +5390,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:02:43,297\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:43,297\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:42:05,078\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", + "2023-09-17 22:42:05,079\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:42:05,079\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -5229,7 +5623,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:02:45,163\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:02:45,164\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:42:07,292\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", + "2023-09-17 22:42:07,293\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:42:07,293\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -5406,7 +5800,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00Tune Status\n", " \n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "
Current time:2023-09-14 15:04:48
Running for: 00:02:01.46
Memory: 7.4/30.9 GiB
Current time:2023-09-17 22:43:31
Running for: 00:01:21.68
Memory: 20.8/62.1 GiB
\n", " \n", "
\n", "
\n", "

System Info

\n", - " Using FIFO scheduling algorithm.
Logical resource usage: 4.0/24 CPUs, 1.0/1 GPUs\n", + " Using FIFO scheduling algorithm.
Logical resource usage: 4.0/32 CPUs, 1.0/2 GPUs (0.0/2.0 accelerator_type:A10G)\n", "
\n", " \n", " \n", @@ -5639,10 +6025,10 @@ "

Trial Status

\n", " \n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "
Trial name status loc iter total time (s) epoch lr train_loss
Trial name status loc iter total time (s) epoch lr train_loss
TorchTrainer_701e4_00000TERMINATED10.0.50.151:50696 10 106.195 90.0001 0.0361183
TorchTrainer_1bd07_00000TERMINATED10.0.35.174:844750 10 63.6994 90.0001 0.0421994
\n", " \n", @@ -5689,47 +6075,274 @@ "name": "stderr", "output_type": "stream", "text": [ - "(TorchTrainer pid=50696, ip=10.0.50.151) The dict form of `dataset_config` is deprecated. Use the DataConfig class instead. Support for this will be dropped in a future release.\n", - "(TorchTrainer pid=50696, ip=10.0.50.151) The `preprocessor` arg to Trainer is deprecated. Apply preprocessor transformations ahead of time by calling `preprocessor.transform(ds)`. Support for the preprocessor arg will be dropped in a future release.\n", - "(TorchTrainer pid=50696, ip=10.0.50.151) Starting distributed worker processes: ['50741 (10.0.50.151)']\n", - "(RayTrainWorker pid=50741, ip=10.0.50.151) Setting up process group for: env:// [rank=0, world_size=1]\n", - "(RayTrainWorker pid=50741, ip=10.0.50.151) Some weights of the model checkpoint at allenai/scibert_scivocab_uncased were not used when initializing BertModel: ['cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.predictions.decoder.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight']\n", - "(RayTrainWorker pid=50741, ip=10.0.50.151) - This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", - "(RayTrainWorker pid=50741, ip=10.0.50.151) - This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", - "(RayTrainWorker pid=50741, ip=10.0.50.151) Moving model to device: cuda:0\n", - "(RayTrainWorker pid=50741, ip=10.0.50.151) /tmp/ipykernel_117917/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + "\u001b[2m\u001b[36m(TorchTrainer pid=844750)\u001b[0m Starting distributed worker processes: ['844833 (10.0.35.174)']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Setting up process group for: env:// [rank=0, world_size=1]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Auto configuring locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Moving model to device: cuda:0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000000)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000001)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000002)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000003)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000004)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000005)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000006)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:43:01,995\tWARNING worker.py:2012 -- [tqdm_ray] Failed to decode {\"__magic_token__\": \"__ray_tqdm_magic_token__\", \"x\": 47, \"pos\": 0, \"desc\": \"Running: 0.0/32.0 CPU, 0.0/2.0 GPU, 0.28 MiB/8.95 GiB object_store_memory\", \"total\": 64, \"ip\": \"10.0.35.174\", \"pid\": 844909, \"uuid\": \"54df93474628434c, this may be due to logging too fast. This warning will not be printed again.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/checkpoint_000009/dict_checkpoint.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/checkpoint_000009/.metadata.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/checkpoint_000009/.tune_metadata -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/checkpoint_000009/.is_checkpoint -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/params.json -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/events.out.tfevents.1694728971.ip-10-0-41-50 -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/params.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts\n", - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts/rank_0\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/result.json -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-02-46/TorchTrainer_701e4_00000_0_2023-09-14_15-02-46/progress.csv -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/cb6a74df7c4e43988598be5aee45e660/artifacts\n" + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m 8d2fe8f67788261f\", \"closed\": false}\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:04:48,385\tINFO tune.py:1148 -- Total run time: 121.54 seconds (121.43 seconds for the tuning loop).\n" + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000007)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000008)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=844909) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=844909)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=844833)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-42-09/TorchTrainer_1bd07_00000_0_2023-09-17_22-42-09/checkpoint_000009)\n", + "2023-09-17 22:43:31,004\tINFO tune.py:1143 -- Total run time: 81.76 seconds (81.66 seconds for the tuning loop).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.72 s, sys: 758 ms, total: 2.47 s\n", - "Wall time: 2min 1s\n" + "CPU times: user 1.23 s, sys: 1.31 s, total: 2.53 s\n", + "Wall time: 1min 21s\n" ] } ], @@ -5741,7 +6354,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 86, "metadata": { "tags": [] }, @@ -5772,18 +6385,22 @@ " train_loss\n", " val_loss\n", " timestamp\n", - " time_this_iter_s\n", " should_checkpoint\n", " done\n", " training_iteration\n", " trial_id\n", " date\n", - " time_total_s\n", - " pid\n", - " hostname\n", - " node_ip\n", + " ...\n", " time_since_restore\n", " iterations_since_restore\n", + " checkpoint_dir_name\n", + " config/train_loop_config/dropout_p\n", + " config/train_loop_config/lr\n", + " config/train_loop_config/lr_factor\n", + " config/train_loop_config/lr_patience\n", + " config/train_loop_config/num_epochs\n", + " config/train_loop_config/batch_size\n", + " config/train_loop_config/num_classes\n", " \n", " \n", " \n", @@ -5791,257 +6408,336 @@ " 0\n", " 0\n", " 0.0001\n", - " 0.575292\n", - " 0.488448\n", - " 1694728980\n", - " 16.911473\n", + " 0.577780\n", + " 0.493102\n", + " 1695015745\n", " True\n", " False\n", " 1\n", - " 701e4_00000\n", - " 2023-09-14_15-03-07\n", - " 16.911473\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 16.911473\n", + " 1bd07_00000\n", + " 2023-09-17_22-42-25\n", + " ...\n", + " 11.882575\n", " 1\n", + " checkpoint_000000\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 1\n", " 1\n", " 0.0001\n", - " 0.477536\n", - " 0.394798\n", - " 1694728991\n", - " 10.108304\n", + " 0.489653\n", + " 0.431958\n", + " 1695015751\n", " True\n", " False\n", " 2\n", - " 701e4_00000\n", - " 2023-09-14_15-03-18\n", - " 27.019777\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 27.019777\n", + " 1bd07_00000\n", + " 2023-09-17_22-42-31\n", + " ...\n", + " 17.654435\n", " 2\n", + " checkpoint_000001\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 2\n", " 2\n", " 0.0001\n", - " 0.352722\n", - " 0.354552\n", - " 1694729001\n", - " 9.832275\n", + " 0.398824\n", + " 0.306201\n", + " 1695015757\n", " True\n", " False\n", " 3\n", - " 701e4_00000\n", - " 2023-09-14_15-03-27\n", - " 36.852052\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 36.852052\n", + " 1bd07_00000\n", + " 2023-09-17_22-42-37\n", + " ...\n", + " 23.353752\n", " 3\n", + " checkpoint_000002\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 3\n", " 3\n", " 0.0001\n", - " 0.270199\n", - " 0.237122\n", - " 1694729011\n", - " 9.836403\n", + " 0.300513\n", + " 0.238803\n", + " 1695015763\n", " True\n", " False\n", " 4\n", - " 701e4_00000\n", - " 2023-09-14_15-03-37\n", - " 46.688455\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 46.688455\n", + " 1bd07_00000\n", + " 2023-09-17_22-42-43\n", + " ...\n", + " 29.118992\n", + " 4\n", + " checkpoint_000003\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", " 4\n", " \n", " \n", " 4\n", " 4\n", " 0.0001\n", - " 0.192776\n", - " 0.225016\n", - " 1694729021\n", - " 9.903057\n", + " 0.220608\n", + " 0.174411\n", + " 1695015769\n", " True\n", " False\n", " 5\n", - " 701e4_00000\n", - " 2023-09-14_15-03-47\n", - " 56.591512\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 56.591512\n", + " 1bd07_00000\n", + " 2023-09-17_22-42-49\n", + " ...\n", + " 34.897485\n", " 5\n", + " checkpoint_000004\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 5\n", " 5\n", " 0.0001\n", - " 0.141014\n", - " 0.196045\n", - " 1694729031\n", - " 9.963775\n", + " 0.151499\n", + " 0.158648\n", + " 1695015775\n", " True\n", " False\n", " 6\n", - " 701e4_00000\n", - " 2023-09-14_15-03-57\n", - " 66.555288\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 66.555288\n", + " 1bd07_00000\n", + " 2023-09-17_22-42-55\n", + " ...\n", + " 40.645384\n", " 6\n", + " checkpoint_000005\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 6\n", " 6\n", " 0.0001\n", - " 0.093777\n", - " 0.201736\n", - " 1694729041\n", - " 9.954871\n", + " 0.105087\n", + " 0.112829\n", + " 1695015781\n", " True\n", " False\n", " 7\n", - " 701e4_00000\n", - " 2023-09-14_15-04-07\n", - " 76.510159\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 76.510159\n", + " 1bd07_00000\n", + " 2023-09-17_22-43-01\n", + " ...\n", + " 46.387568\n", " 7\n", + " checkpoint_000006\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 7\n", " 7\n", " 0.0001\n", - " 0.070405\n", - " 0.174259\n", - " 1694729051\n", - " 9.840459\n", + " 0.077385\n", + " 0.091922\n", + " 1695015788\n", " True\n", " False\n", " 8\n", - " 701e4_00000\n", - " 2023-09-14_15-04-17\n", - " 86.350618\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 86.350618\n", + " 1bd07_00000\n", + " 2023-09-17_22-43-08\n", + " ...\n", + " 52.153343\n", " 8\n", + " checkpoint_000007\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 8\n", " 8\n", " 0.0001\n", - " 0.048866\n", - " 0.159393\n", - " 1694729060\n", - " 9.945646\n", + " 0.053857\n", + " 0.109810\n", + " 1695015794\n", " True\n", " False\n", " 9\n", - " 701e4_00000\n", - " 2023-09-14_15-04-27\n", - " 96.296264\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 96.296264\n", + " 1bd07_00000\n", + " 2023-09-17_22-43-14\n", + " ...\n", + " 57.901084\n", " 9\n", + " checkpoint_000008\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", " 9\n", " 9\n", " 0.0001\n", - " 0.036118\n", - " 0.137778\n", - " 1694729070\n", - " 9.898459\n", + " 0.042199\n", + " 0.121122\n", + " 1695015800\n", " True\n", " False\n", " 10\n", - " 701e4_00000\n", - " 2023-09-14_15-04-37\n", - " 106.194723\n", - " 50696\n", - " ip-10-0-50-151\n", - " 10.0.50.151\n", - " 106.194723\n", + " 1bd07_00000\n", + " 2023-09-17_22-43-20\n", + " ...\n", + " 63.699444\n", " 10\n", + " checkpoint_000009\n", + " 0.5\n", + " 0.0001\n", + " 0.8\n", + " 3\n", + " 10\n", + " 256\n", + " 4\n", " \n", " \n", "\n", + "

10 rows × 25 columns

\n", "" ], "text/plain": [ - " epoch lr train_loss val_loss timestamp time_this_iter_s \n", - "0 0 0.0001 0.575292 0.488448 1694728980 16.911473 \\\n", - "1 1 0.0001 0.477536 0.394798 1694728991 10.108304 \n", - "2 2 0.0001 0.352722 0.354552 1694729001 9.832275 \n", - "3 3 0.0001 0.270199 0.237122 1694729011 9.836403 \n", - "4 4 0.0001 0.192776 0.225016 1694729021 9.903057 \n", - "5 5 0.0001 0.141014 0.196045 1694729031 9.963775 \n", - "6 6 0.0001 0.093777 0.201736 1694729041 9.954871 \n", - "7 7 0.0001 0.070405 0.174259 1694729051 9.840459 \n", - "8 8 0.0001 0.048866 0.159393 1694729060 9.945646 \n", - "9 9 0.0001 0.036118 0.137778 1694729070 9.898459 \n", + " epoch lr train_loss val_loss timestamp should_checkpoint done \\\n", + "0 0 0.0001 0.577780 0.493102 1695015745 True False \n", + "1 1 0.0001 0.489653 0.431958 1695015751 True False \n", + "2 2 0.0001 0.398824 0.306201 1695015757 True False \n", + "3 3 0.0001 0.300513 0.238803 1695015763 True False \n", + "4 4 0.0001 0.220608 0.174411 1695015769 True False \n", + "5 5 0.0001 0.151499 0.158648 1695015775 True False \n", + "6 6 0.0001 0.105087 0.112829 1695015781 True False \n", + "7 7 0.0001 0.077385 0.091922 1695015788 True False \n", + "8 8 0.0001 0.053857 0.109810 1695015794 True False \n", + "9 9 0.0001 0.042199 0.121122 1695015800 True False \n", "\n", - " should_checkpoint done training_iteration trial_id \n", - "0 True False 1 701e4_00000 \\\n", - "1 True False 2 701e4_00000 \n", - "2 True False 3 701e4_00000 \n", - "3 True False 4 701e4_00000 \n", - "4 True False 5 701e4_00000 \n", - "5 True False 6 701e4_00000 \n", - "6 True False 7 701e4_00000 \n", - "7 True False 8 701e4_00000 \n", - "8 True False 9 701e4_00000 \n", - "9 True False 10 701e4_00000 \n", + " training_iteration trial_id date ... \\\n", + "0 1 1bd07_00000 2023-09-17_22-42-25 ... \n", + "1 2 1bd07_00000 2023-09-17_22-42-31 ... \n", + "2 3 1bd07_00000 2023-09-17_22-42-37 ... \n", + "3 4 1bd07_00000 2023-09-17_22-42-43 ... \n", + "4 5 1bd07_00000 2023-09-17_22-42-49 ... \n", + "5 6 1bd07_00000 2023-09-17_22-42-55 ... \n", + "6 7 1bd07_00000 2023-09-17_22-43-01 ... \n", + "7 8 1bd07_00000 2023-09-17_22-43-08 ... \n", + "8 9 1bd07_00000 2023-09-17_22-43-14 ... \n", + "9 10 1bd07_00000 2023-09-17_22-43-20 ... \n", "\n", - " date time_total_s pid hostname node_ip \n", - "0 2023-09-14_15-03-07 16.911473 50696 ip-10-0-50-151 10.0.50.151 \\\n", - "1 2023-09-14_15-03-18 27.019777 50696 ip-10-0-50-151 10.0.50.151 \n", - "2 2023-09-14_15-03-27 36.852052 50696 ip-10-0-50-151 10.0.50.151 \n", - "3 2023-09-14_15-03-37 46.688455 50696 ip-10-0-50-151 10.0.50.151 \n", - "4 2023-09-14_15-03-47 56.591512 50696 ip-10-0-50-151 10.0.50.151 \n", - "5 2023-09-14_15-03-57 66.555288 50696 ip-10-0-50-151 10.0.50.151 \n", - "6 2023-09-14_15-04-07 76.510159 50696 ip-10-0-50-151 10.0.50.151 \n", - "7 2023-09-14_15-04-17 86.350618 50696 ip-10-0-50-151 10.0.50.151 \n", - "8 2023-09-14_15-04-27 96.296264 50696 ip-10-0-50-151 10.0.50.151 \n", - "9 2023-09-14_15-04-37 106.194723 50696 ip-10-0-50-151 10.0.50.151 \n", + " time_since_restore iterations_since_restore checkpoint_dir_name \\\n", + "0 11.882575 1 checkpoint_000000 \n", + "1 17.654435 2 checkpoint_000001 \n", + "2 23.353752 3 checkpoint_000002 \n", + "3 29.118992 4 checkpoint_000003 \n", + "4 34.897485 5 checkpoint_000004 \n", + "5 40.645384 6 checkpoint_000005 \n", + "6 46.387568 7 checkpoint_000006 \n", + "7 52.153343 8 checkpoint_000007 \n", + "8 57.901084 9 checkpoint_000008 \n", + "9 63.699444 10 checkpoint_000009 \n", "\n", - " time_since_restore iterations_since_restore \n", - "0 16.911473 1 \n", - "1 27.019777 2 \n", - "2 36.852052 3 \n", - "3 46.688455 4 \n", - "4 56.591512 5 \n", - "5 66.555288 6 \n", - "6 76.510159 7 \n", - "7 86.350618 8 \n", - "8 96.296264 9 \n", - "9 106.194723 10 " + " config/train_loop_config/dropout_p config/train_loop_config/lr \\\n", + "0 0.5 0.0001 \n", + "1 0.5 0.0001 \n", + "2 0.5 0.0001 \n", + "3 0.5 0.0001 \n", + "4 0.5 0.0001 \n", + "5 0.5 0.0001 \n", + "6 0.5 0.0001 \n", + "7 0.5 0.0001 \n", + "8 0.5 0.0001 \n", + "9 0.5 0.0001 \n", + "\n", + " config/train_loop_config/lr_factor config/train_loop_config/lr_patience \\\n", + "0 0.8 3 \n", + "1 0.8 3 \n", + "2 0.8 3 \n", + "3 0.8 3 \n", + "4 0.8 3 \n", + "5 0.8 3 \n", + "6 0.8 3 \n", + "7 0.8 3 \n", + "8 0.8 3 \n", + "9 0.8 3 \n", + "\n", + " config/train_loop_config/num_epochs config/train_loop_config/batch_size \\\n", + "0 10 256 \n", + "1 10 256 \n", + "2 10 256 \n", + "3 10 256 \n", + "4 10 256 \n", + "5 10 256 \n", + "6 10 256 \n", + "7 10 256 \n", + "8 10 256 \n", + "9 10 256 \n", + "\n", + " config/train_loop_config/num_classes \n", + "0 4 \n", + "1 4 \n", + "2 4 \n", + "3 4 \n", + "4 4 \n", + "5 4 \n", + "6 4 \n", + "7 4 \n", + "8 4 \n", + "9 4 \n", + "\n", + "[10 rows x 25 columns]" ] }, - "execution_count": 85, + "execution_count": 86, "metadata": {}, "output_type": "execute_result" } @@ -6052,7 +6748,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 87, "metadata": { "tags": [] }, @@ -6084,19 +6780,19 @@ " artifact_uri\n", " start_time\n", " end_time\n", - " metrics.pid\n", - " metrics.epoch\n", - " metrics.config/train_loop_config/batch_size\n", - " metrics.iterations_since_restore\n", + " metrics.config/train_loop_config/lr_patience\n", + " metrics.time_total_s\n", + " metrics.time_since_restore\n", + " metrics.config/train_loop_config/num_epochs\n", " ...\n", - " metrics.lr\n", - " params.train_loop_config/dropout_p\n", + " metrics.epoch\n", + " params.train_loop_config/num_epochs\n", + " params.train_loop_config/lr_patience\n", " params.train_loop_config/batch_size\n", + " params.train_loop_config/lr\n", " params.train_loop_config/lr_factor\n", " params.train_loop_config/num_classes\n", - " params.train_loop_config/lr_patience\n", - " params.train_loop_config/num_epochs\n", - " params.train_loop_config/lr\n", + " params.train_loop_config/dropout_p\n", " tags.trial_name\n", " tags.mlflow.runName\n", " \n", @@ -6104,68 +6800,68 @@ " \n", " \n", " 0\n", - " cb6a74df7c4e43988598be5aee45e660\n", - " 917462352875586010\n", + " a67f6ec4e10b49a7845b91db61efc7e0\n", + " 703905858072772764\n", " FINISHED\n", " file:///efs/shared_storage/madewithml/GokuMoha...\n", - " 2023-09-14 22:02:50.670000+00:00\n", - " 2023-09-14 22:04:48.292000+00:00\n", - " 50696.0\n", - " 9.0\n", - " 256.0\n", + " 2023-09-18 05:42:12.863000+00:00\n", + " 2023-09-18 05:43:30.925000+00:00\n", + " 3.0\n", + " 63.699444\n", + " 63.699444\n", " 10.0\n", " ...\n", - " 0.0001\n", - " 0.5\n", + " 9.0\n", + " 10\n", + " 3\n", " 256\n", + " 0.0001\n", " 0.8\n", " 4\n", - " 3\n", - " 10\n", - " 0.0001\n", - " TorchTrainer_701e4_00000\n", - " TorchTrainer_701e4_00000\n", + " 0.5\n", + " TorchTrainer_1bd07_00000\n", + " TorchTrainer_1bd07_00000\n", " \n", " \n", "\n", - "

1 rows × 36 columns

\n", + "

1 rows × 35 columns

\n", "" ], "text/plain": [ - " run_id experiment_id status \n", - "0 cb6a74df7c4e43988598be5aee45e660 917462352875586010 FINISHED \\\n", + " run_id experiment_id status \\\n", + "0 a67f6ec4e10b49a7845b91db61efc7e0 703905858072772764 FINISHED \n", "\n", - " artifact_uri \n", - "0 file:///efs/shared_storage/madewithml/GokuMoha... \\\n", + " artifact_uri \\\n", + "0 file:///efs/shared_storage/madewithml/GokuMoha... \n", "\n", - " start_time end_time \n", - "0 2023-09-14 22:02:50.670000+00:00 2023-09-14 22:04:48.292000+00:00 \\\n", + " start_time end_time \\\n", + "0 2023-09-18 05:42:12.863000+00:00 2023-09-18 05:43:30.925000+00:00 \n", "\n", - " metrics.pid metrics.epoch metrics.config/train_loop_config/batch_size \n", - "0 50696.0 9.0 256.0 \\\n", + " metrics.config/train_loop_config/lr_patience metrics.time_total_s \\\n", + "0 3.0 63.699444 \n", "\n", - " metrics.iterations_since_restore ... metrics.lr \n", - "0 10.0 ... 0.0001 \\\n", + " metrics.time_since_restore metrics.config/train_loop_config/num_epochs \\\n", + "0 63.699444 10.0 \n", "\n", - " params.train_loop_config/dropout_p params.train_loop_config/batch_size \n", - "0 0.5 256 \\\n", + " ... metrics.epoch params.train_loop_config/num_epochs \\\n", + "0 ... 9.0 10 \n", "\n", - " params.train_loop_config/lr_factor params.train_loop_config/num_classes \n", - "0 0.8 4 \\\n", + " params.train_loop_config/lr_patience params.train_loop_config/batch_size \\\n", + "0 3 256 \n", "\n", - " params.train_loop_config/lr_patience params.train_loop_config/num_epochs \n", - "0 3 10 \\\n", + " params.train_loop_config/lr params.train_loop_config/lr_factor \\\n", + "0 0.0001 0.8 \n", "\n", - " params.train_loop_config/lr tags.trial_name \n", - "0 0.0001 TorchTrainer_701e4_00000 \\\n", + " params.train_loop_config/num_classes params.train_loop_config/dropout_p \\\n", + "0 4 0.5 \n", "\n", - " tags.mlflow.runName \n", - "0 TorchTrainer_701e4_00000 \n", + " tags.trial_name tags.mlflow.runName \n", + "0 TorchTrainer_1bd07_00000 TorchTrainer_1bd07_00000 \n", "\n", - "[1 rows x 36 columns]" + "[1 rows x 35 columns]" ] }, - "execution_count": 86, + "execution_count": 87, "metadata": {}, "output_type": "execute_result" } @@ -6178,7 +6874,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 88, "metadata": { "tags": [] }, @@ -6186,46 +6882,45 @@ { "data": { "text/plain": [ - "run_id cb6a74df7c4e43988598be5aee45e660\n", - "experiment_id 917462352875586010\n", + "run_id a67f6ec4e10b49a7845b91db61efc7e0\n", + "experiment_id 703905858072772764\n", "status FINISHED\n", "artifact_uri file:///efs/shared_storage/madewithml/GokuMoha...\n", - "start_time 2023-09-14 22:02:50.670000+00:00\n", - "end_time 2023-09-14 22:04:48.292000+00:00\n", - "metrics.pid 50696.0\n", - "metrics.epoch 9.0\n", - "metrics.config/train_loop_config/batch_size 256.0\n", - "metrics.iterations_since_restore 10.0\n", + "start_time 2023-09-18 05:42:12.863000+00:00\n", + "end_time 2023-09-18 05:43:30.925000+00:00\n", "metrics.config/train_loop_config/lr_patience 3.0\n", - "metrics.done 0.0\n", - "metrics.config/train_loop_config/dropout_p 0.5\n", - "metrics.config/train_loop_config/num_classes 4.0\n", - "metrics.time_total_s 106.194723\n", - "metrics.config/train_loop_config/lr 0.0001\n", - "metrics.config/train_loop_config/lr_factor 0.8\n", - "metrics.should_checkpoint 1.0\n", - "metrics.val_loss 0.137778\n", - "metrics.train_loss 0.036118\n", - "metrics.timestamp 1694729070.0\n", - "metrics.time_since_restore 106.194723\n", - "metrics.time_this_iter_s 9.898459\n", + "metrics.time_total_s 63.699444\n", + "metrics.time_since_restore 63.699444\n", "metrics.config/train_loop_config/num_epochs 10.0\n", - "metrics.training_iteration 10.0\n", - "metrics.trial_id inf\n", + "metrics.iterations_since_restore 10.0\n", + "metrics.config/train_loop_config/batch_size 256.0\n", + "metrics.pid 844750.0\n", + "metrics.should_checkpoint 1.0\n", + "metrics.timestamp 1695015800.0\n", + "metrics.config/train_loop_config/num_classes 4.0\n", + "metrics.done 0.0\n", + "metrics.time_this_iter_s 5.79836\n", + "metrics.train_loss 0.042199\n", + "metrics.config/train_loop_config/lr 0.0001\n", "metrics.lr 0.0001\n", - "params.train_loop_config/dropout_p 0.5\n", + "metrics.val_loss 0.121122\n", + "metrics.config/train_loop_config/dropout_p 0.5\n", + "metrics.training_iteration 10.0\n", + "metrics.config/train_loop_config/lr_factor 0.8\n", + "metrics.epoch 9.0\n", + "params.train_loop_config/num_epochs 10\n", + "params.train_loop_config/lr_patience 3\n", "params.train_loop_config/batch_size 256\n", + "params.train_loop_config/lr 0.0001\n", "params.train_loop_config/lr_factor 0.8\n", "params.train_loop_config/num_classes 4\n", - "params.train_loop_config/lr_patience 3\n", - "params.train_loop_config/num_epochs 10\n", - "params.train_loop_config/lr 0.0001\n", - "tags.trial_name TorchTrainer_701e4_00000\n", - "tags.mlflow.runName TorchTrainer_701e4_00000\n", + "params.train_loop_config/dropout_p 0.5\n", + "tags.trial_name TorchTrainer_1bd07_00000\n", + "tags.mlflow.runName TorchTrainer_1bd07_00000\n", "Name: 0, dtype: object" ] }, - "execution_count": 87, + "execution_count": 88, "metadata": {}, "output_type": "execute_result" } @@ -6280,19 +6975,19 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 89, "metadata": { "tags": [] }, "outputs": [], "source": [ - "from ray.air import Result\n", + "from ray.train import Result\n", "from urllib.parse import urlparse" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 90, "metadata": { "tags": [] }, @@ -6304,79 +6999,15 @@ " return results.best_checkpoints[0][0]" ] }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-09-14 15:04:49,356\tINFO streaming_executor.py:92 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)->MapBatches()]\n", - "2023-09-14 15:04:49,357\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:04:49,357\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Running 0: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches()]\n", + "2023-09-17 22:43:36,692\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:36,692\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor)]\n", + "2023-09-17 22:43:37,552\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:37,553\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/4096 [00:00MapBatches(TorchPredictor) pid=845827)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"precision\": 0.9168092951711627,\n", + " \"recall\": 0.9109947643979057,\n", + " \"f1\": 0.9105512639658029\n", + "}\n" + ] + } + ], + "source": [ + "# Evaluate on test split\n", + "performance = evaluate(ds=test_ds, predictor=predictor)\n", + "print (json.dumps(performance, indent=2))" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-09-17 22:43:43,282\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:43:43,282\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:43,283\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/1 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:04:52,761\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:04:52,761\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:43:44,422\tINFO read_api.py:406 -- To satisfy the requested parallelism of 64, each read task output is split into 64 smaller blocks.\n", + "2023-09-17 22:43:44,426\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:43:44,427\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:44,427\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -6481,7 +7211,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", - "2023-09-14 15:04:53,538\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:04:53,539\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:43:44,885\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> LimitOperator[limit=1]\n", + "2023-09-17 22:43:44,886\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:44,887\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -6560,7 +7290,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", - "2023-09-14 15:04:54,841\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:04:54,842\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:43:46,122\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> AllToAllOperator[Aggregate] -> TaskPoolMapOperator[MapBatches()]\n", + "2023-09-17 22:43:46,123\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:46,123\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -6737,7 +7467,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:04:56,619\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:04:56,620\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:43:47,913\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", + "2023-09-17 22:43:47,914\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:47,914\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -6970,7 +7700,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)]\n", - "2023-09-14 15:04:58,288\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:04:58,289\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:43:50,092\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> AllToAllOperator[RandomShuffle] -> AllToAllOperator[Sort] -> AllToAllOperator[MapBatches(group_fn)->MapBatches(_filter_split)->RandomShuffle] -> TaskPoolMapOperator[MapBatches(preprocess)]\n", + "2023-09-17 22:43:50,092\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:43:50,093\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -7147,7 +7877,7 @@ "version_minor": 0 }, "text/plain": [ - "- RandomShuffle 1: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/48 [00:00MapBatches(_filter_split)->RandomShuffle 8: 0%| | 0/4096 [00:00Tune Status\n", " \n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "
Current time:2023-09-14 15:08:20
Running for: 00:03:20.50
Memory: 7.7/30.9 GiB
Current time:2023-09-17 22:45:41
Running for: 00:01:49.07
Memory: 21.8/62.1 GiB
\n", " \n", "
\n", "
\n", "

System Info

\n", - " Using AsyncHyperBand: num_stopped=2
Bracket: Iter 5.000: -0.2885470949113369
Logical resource usage: 4.0/24 CPUs, 1.0/1 GPUs\n", + " Using AsyncHyperBand: num_stopped=2
Bracket: Iter 5.000: -0.2372603341937065
Logical resource usage: 4.0/32 CPUs, 1.0/2 GPUs (0.0/2.0 accelerator_type:A10G)\n", "
\n", " \n", " \n", @@ -7493,14 +8216,14 @@ "

Trial Status

\n", " \n", "\n", - "\n", + "_patience\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "
Trial name status loc train_loop_config/dr\n", + "
Trial name status loc train_loop_config/dr\n", "opout_p train_loop_config/lr train_loop_config/lr\n", "_factor train_loop_config/lr\n", - "_patience iter total time (s) epoch lr train_loss
iter total time (s) epoch lr train_loss
TorchTrainer_55490282TERMINATED10.0.50.151:514600.5 0.0001 0.8 3 10 107.565 90.0001 0.0393358
TorchTrainer_45b199dfTERMINATED10.0.50.151:520630.797623 2.6943e-050.2671435.21456 5 57.5858 42.6943e-05 0.482763
TorchTrainer_639d7776TERMINATED10.0.35.174:8467050.5 0.0001 0.8 3 10 68.3885 90.0001 0.0520358
TorchTrainer_145c1bc2TERMINATED10.0.34.101:3497160.841192 5.18042e-050.7586272.25374 5 30.7297 45.18042e-05 0.392521
\n", " \n", @@ -7547,86 +8270,424 @@ "name": "stderr", "output_type": "stream", "text": [ - "(TorchTrainer pid=51460, ip=10.0.50.151) The dict form of `dataset_config` is deprecated. Use the DataConfig class instead. Support for this will be dropped in a future release.\n", - "(TorchTrainer pid=51460, ip=10.0.50.151) The `preprocessor` arg to Trainer is deprecated. Apply preprocessor transformations ahead of time by calling `preprocessor.transform(ds)`. Support for the preprocessor arg will be dropped in a future release.\n", - "(TorchTrainer pid=51460, ip=10.0.50.151) Starting distributed worker processes: ['51502 (10.0.50.151)']\n", - "(RayTrainWorker pid=51502, ip=10.0.50.151) Setting up process group for: env:// [rank=0, world_size=1]\n", - "(RayTrainWorker pid=51502, ip=10.0.50.151) Some weights of the model checkpoint at allenai/scibert_scivocab_uncased were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.predictions.decoder.bias']\n", - "(RayTrainWorker pid=51502, ip=10.0.50.151) - This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", - "(RayTrainWorker pid=51502, ip=10.0.50.151) - This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", - "(RayTrainWorker pid=51502, ip=10.0.50.151) Moving model to device: cuda:0\n", - "(RayTrainWorker pid=51502, ip=10.0.50.151) /tmp/ipykernel_117917/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + "\u001b[2m\u001b[36m(TorchTrainer pid=846705)\u001b[0m Starting distributed worker processes: ['846788 (10.0.35.174)']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m Setting up process group for: env:// [rank=0, world_size=1]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Auto configuring locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m Moving model to device: cuda:0\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000009/dict_checkpoint.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000009/.metadata.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000009/.tune_metadata -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000009/.is_checkpoint -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000009\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/params.json -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/.lazy_checkpoint_marker -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/params.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts\n", - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/rank_0\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/events.out.tfevents.1694729104.ip-10-0-41-50 -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/result.json -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts\n", - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000008\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000008/dict_checkpoint.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000008\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000008/.metadata.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000008\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000008/.tune_metadata -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000008\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/checkpoint_000008/.is_checkpoint -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts/checkpoint_000008\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_55490282_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-14_15-05-00/progress.csv -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/97a3692584eb4a51999f7e97176e3297/artifacts\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n", + "\u001b[2m\u001b[36m(TorchTrainer pid=349716, ip=10.0.34.101)\u001b[0m Starting distributed worker processes: ['349780 (10.0.34.101)']\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=349780, ip=10.0.34.101)\u001b[0m Setting up process group for: env:// [rank=0, world_size=1]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Auto configuring locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b']\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/params.json -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/events.out.tfevents.1694729233.ip-10-0-41-50 -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/.lazy_checkpoint_marker -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/params.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts\n", - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts/checkpoint_000004\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/checkpoint_000004/dict_checkpoint.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts/checkpoint_000004\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/checkpoint_000004/.metadata.pkl -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts/checkpoint_000004\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/checkpoint_000004/.tune_metadata -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts/checkpoint_000004\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/checkpoint_000004/.is_checkpoint -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts/checkpoint_000004\n", - "creating /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts/rank_0\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/result.json -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts\n", - "copying /efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-14_15-05-00/TorchTrainer_45b199df_2_dropout_p=0.7976,lr=0.0000,lr_factor=0.2671,lr_patience=5.2146_2023-09-14_15-05-04/progress.csv -> /efs/shared_storage/madewithml/GokuMohandas/mlflow/917462352875586010/57c609dd76c9477896863f04f2a46bb5/artifacts\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=349841, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=349780, ip=10.0.34.101)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=349841, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:44:16,982\tWARNING util.py:315 -- The `callbacks.on_trial_result` operation took 3.185 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:16,983\tWARNING util.py:315 -- The `process_trial_result` operation took 3.187 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:16,984\tWARNING util.py:315 -- Processing trial results took 3.188 s, which may be a performance bottleneck. Please consider reporting results less frequently to Ray Tune.\n", + "2023-09-17 22:44:16,984\tWARNING util.py:315 -- The `process_trial_result` operation took 3.188 s, which may be a performance bottleneck.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=349841, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:44:25,141\tWARNING util.py:315 -- The `callbacks.on_trial_result` operation took 3.025 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:25,143\tWARNING util.py:315 -- The `process_trial_result` operation took 3.028 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:25,144\tWARNING util.py:315 -- Processing trial results took 3.028 s, which may be a performance bottleneck. Please consider reporting results less frequently to Ray Tune.\n", + "2023-09-17 22:44:25,144\tWARNING util.py:315 -- The `process_trial_result` operation took 3.029 s, which may be a performance bottleneck.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=349841, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:44:33,395\tWARNING util.py:315 -- The `callbacks.on_trial_result` operation took 3.181 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:33,397\tWARNING util.py:315 -- The `process_trial_result` operation took 3.183 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:33,398\tWARNING util.py:315 -- Processing trial results took 3.184 s, which may be a performance bottleneck. Please consider reporting results less frequently to Ray Tune.\n", + "2023-09-17 22:44:33,398\tWARNING util.py:315 -- The `process_trial_result` operation took 3.184 s, which may be a performance bottleneck.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=349841, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:44:41,574\tWARNING util.py:315 -- The `callbacks.on_trial_result` operation took 3.101 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:41,576\tWARNING util.py:315 -- The `process_trial_result` operation took 3.102 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:41,576\tWARNING util.py:315 -- Processing trial results took 3.103 s, which may be a performance bottleneck. Please consider reporting results less frequently to Ray Tune.\n", + "2023-09-17 22:44:41,577\tWARNING util.py:315 -- The `process_trial_result` operation took 3.104 s, which may be a performance bottleneck.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=349841, ip=10.0.34.101) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=349841, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:44:49,825\tWARNING util.py:315 -- The `callbacks.on_trial_result` operation took 3.286 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:49,828\tWARNING util.py:315 -- The `process_trial_result` operation took 3.289 s, which may be a performance bottleneck.\n", + "2023-09-17 22:44:49,828\tWARNING util.py:315 -- Processing trial results took 3.289 s, which may be a performance bottleneck. Please consider reporting results less frequently to Ray Tune.\n", + "2023-09-17 22:44:49,828\tWARNING util.py:315 -- The `process_trial_result` operation took 3.289 s, which may be a performance bottleneck.\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=349780, ip=10.0.34.101)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-43-52/TorchTrainer_145c1bc2_2_dropout_p=0.8412,lr=0.0001,lr_factor=0.7586,lr_patience=2.2537_2023-09-17_22-43-55/checkpoint_000005)\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-43-52/TorchTrainer_639d7776_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-17_22-43-52/checkpoint_000006)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-43-52/TorchTrainer_639d7776_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-17_22-43-52/checkpoint_000007)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-43-52/TorchTrainer_639d7776_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-17_22-43-52/checkpoint_000008)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=846864) Running 0: 0%| | 0/64 [00:00 OutputSplitter[split(1, equal=True)]\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=['c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a'], preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(SplitCoordinator pid=846864)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "\u001b[2m\u001b[36m(RayTrainWorker pid=846788)\u001b[0m Checkpoint successfully created at: Checkpoint(filesystem=local, path=/efs/shared_storage/madewithml/GokuMohandas/TorchTrainer_2023-09-17_22-43-52/TorchTrainer_639d7776_1_dropout_p=0.5000,lr=0.0001,lr_factor=0.8000,lr_patience=3.0000_2023-09-17_22-43-52/checkpoint_000009)\n", + "2023-09-17 22:45:41,369\tINFO tune.py:1143 -- Total run time: 109.13 seconds (109.03 seconds for the tuning loop).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 3.63 s, sys: 2.11 s, total: 5.73 s\n", - "Wall time: 3min 20s\n" + "CPU times: user 1.67 s, sys: 1.85 s, total: 3.52 s\n", + "Wall time: 1min 49s\n" ] } ], @@ -7636,149 +8697,6 @@ "results = tuner.fit()" ] }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
epochlrtrain_lossval_losstimestamptime_this_iter_sshould_checkpointdonetraining_iterationtrial_id...pidhostnamenode_iptime_since_restoreiterations_since_restoreconfig/train_loop_config/dropout_pconfig/train_loop_config/lrconfig/train_loop_config/lr_factorconfig/train_loop_config/lr_patiencelogdir
090.0001000.0393360.160408169472920510.023823TrueTrue1055490282...51460ip-10-0-50-15110.0.50.151107.564980100.5000000.0001000.8000003.000000/efs/shared_storage/madewithml/GokuMohandas/To...
140.0000270.4827630.436918169472928510.070868TrueTrue545b199df...52063ip-10-0-50-15110.0.50.15157.58581150.7976230.0000270.2671435.214562/efs/shared_storage/madewithml/GokuMohandas/To...
\n", - "

2 rows × 22 columns

\n", - "
" - ], - "text/plain": [ - " epoch lr train_loss val_loss timestamp time_this_iter_s \n", - "0 9 0.000100 0.039336 0.160408 1694729205 10.023823 \\\n", - "1 4 0.000027 0.482763 0.436918 1694729285 10.070868 \n", - "\n", - " should_checkpoint done training_iteration trial_id ... pid \n", - "0 True True 10 55490282 ... 51460 \\\n", - "1 True True 5 45b199df ... 52063 \n", - "\n", - " hostname node_ip time_since_restore iterations_since_restore \n", - "0 ip-10-0-50-151 10.0.50.151 107.564980 10 \\\n", - "1 ip-10-0-50-151 10.0.50.151 57.585811 5 \n", - "\n", - " config/train_loop_config/dropout_p config/train_loop_config/lr \n", - "0 0.500000 0.000100 \\\n", - "1 0.797623 0.000027 \n", - "\n", - " config/train_loop_config/lr_factor config/train_loop_config/lr_patience \n", - "0 0.800000 3.000000 \\\n", - "1 0.267143 5.214562 \n", - "\n", - " logdir \n", - "0 /efs/shared_storage/madewithml/GokuMohandas/To... \n", - "1 /efs/shared_storage/madewithml/GokuMohandas/To... \n", - "\n", - "[2 rows x 22 columns]" - ] - }, - "execution_count": 107, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# All trials in experiment\n", - "results.get_dataframe()" - ] - }, { "cell_type": "code", "execution_count": 108, @@ -7812,18 +8730,165 @@ " train_loss\n", " val_loss\n", " timestamp\n", - " time_this_iter_s\n", " should_checkpoint\n", " done\n", " training_iteration\n", " trial_id\n", " date\n", - " time_total_s\n", + " ...\n", + " hostname\n", + " node_ip\n", + " time_since_restore\n", + " iterations_since_restore\n", + " checkpoint_dir_name\n", + " config/train_loop_config/dropout_p\n", + " config/train_loop_config/lr\n", + " config/train_loop_config/lr_factor\n", + " config/train_loop_config/lr_patience\n", + " logdir\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " 9\n", + " 0.000100\n", + " 0.052036\n", + " 0.096391\n", + " 1695015936\n", + " True\n", + " True\n", + " 10\n", + " 639d7776\n", + " 2023-09-17_22-45-36\n", + " ...\n", + " ip-10-0-35-174\n", + " 10.0.35.174\n", + " 68.388524\n", + " 10\n", + " checkpoint_000009\n", + " 0.500000\n", + " 0.000100\n", + " 0.800000\n", + " 3.000000\n", + " 639d7776\n", + " \n", + " \n", + " 1\n", + " 4\n", + " 0.000052\n", + " 0.392521\n", + " 0.326320\n", + " 1695015885\n", + " True\n", + " True\n", + " 5\n", + " 145c1bc2\n", + " 2023-09-17_22-44-46\n", + " ...\n", + " ip-10-0-34-101\n", + " 10.0.34.101\n", + " 30.729746\n", + " 5\n", + " checkpoint_000004\n", + " 0.841192\n", + " 0.000052\n", + " 0.758627\n", + " 2.253736\n", + " 145c1bc2\n", + " \n", + " \n", + "\n", + "

2 rows × 23 columns

\n", + "" + ], + "text/plain": [ + " epoch lr train_loss val_loss timestamp should_checkpoint done \\\n", + "0 9 0.000100 0.052036 0.096391 1695015936 True True \n", + "1 4 0.000052 0.392521 0.326320 1695015885 True True \n", + "\n", + " training_iteration trial_id date ... hostname \\\n", + "0 10 639d7776 2023-09-17_22-45-36 ... ip-10-0-35-174 \n", + "1 5 145c1bc2 2023-09-17_22-44-46 ... ip-10-0-34-101 \n", + "\n", + " node_ip time_since_restore iterations_since_restore \\\n", + "0 10.0.35.174 68.388524 10 \n", + "1 10.0.34.101 30.729746 5 \n", + "\n", + " checkpoint_dir_name config/train_loop_config/dropout_p \\\n", + "0 checkpoint_000009 0.500000 \n", + "1 checkpoint_000004 0.841192 \n", + "\n", + " config/train_loop_config/lr config/train_loop_config/lr_factor \\\n", + "0 0.000100 0.800000 \n", + "1 0.000052 0.758627 \n", + "\n", + " config/train_loop_config/lr_patience logdir \n", + "0 3.000000 639d7776 \n", + "1 2.253736 145c1bc2 \n", + "\n", + "[2 rows x 23 columns]" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# All trials in experiment\n", + "results.get_dataframe()" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -7831,257 +8896,324 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
epochlrtrain_lossval_losstimestampshould_checkpointdonetraining_iterationtrial_iddate...pidhostnamenode_iptime_since_restoreiterations_since_restorecheckpoint_dir_nameconfig/train_loop_config/dropout_pconfig/train_loop_config/lrconfig/train_loop_config/lr_factorconfig/train_loop_config/lr_patience
000.00010.5772410.493672169472911316.7593130.5778600.4922271695015848TrueFalse1554902822023-09-14_15-05-2016.75931351460ip-10-0-50-15110.0.50.15116.759313639d77762023-09-17_22-44-08...846705ip-10-0-35-17410.0.35.17412.8284651checkpoint_0000000.50.00010.83.0
110.00010.4762210.417544169472912410.4317730.4757430.3871871695015856TrueFalse2554902822023-09-14_15-05-3127.19108651460ip-10-0-50-15110.0.50.15127.191086639d77762023-09-17_22-44-16...846705ip-10-0-35-17410.0.35.17420.6512862checkpoint_0000010.50.00010.83.0
220.00010.3687100.373515169472913510.0714630.4023740.3723901695015864TrueFalse3554902822023-09-14_15-05-4137.26254951460ip-10-0-50-15110.0.50.15137.262549639d77762023-09-17_22-44-24...846705ip-10-0-35-17410.0.35.17428.2356283checkpoint_0000020.50.00010.83.0
330.00010.2929830.275497169472914510.1220230.3490680.2977041695015873TrueFalse4554902822023-09-14_15-05-5147.38457251460ip-10-0-50-15110.0.50.15147.384572639d77762023-09-17_22-44-33...846705ip-10-0-35-17410.0.35.17435.8737924checkpoint_0000030.50.00010.83.0
440.00010.2102100.23909016947291559.9919250.2568880.2075741695015881TrueFalse5554902822023-09-14_15-06-0157.37649751460ip-10-0-50-15110.0.50.15157.376497639d77762023-09-17_22-44-41...846705ip-10-0-35-17410.0.35.17443.4876125checkpoint_0000040.50.00010.83.0
550.00010.1618240.197741169472916510.0846160.2042790.1612831695015889TrueFalse6554902822023-09-14_15-06-1167.46111351460ip-10-0-50-15110.0.50.15167.461113639d77762023-09-17_22-44-49...846705ip-10-0-35-17410.0.35.17451.1135386checkpoint_0000050.50.00010.83.0
660.00010.1135580.15988716947291759.9532900.1427160.1385461695015897TrueFalse7554902822023-09-14_15-06-2177.41440251460ip-10-0-50-15110.0.50.15177.414402639d77762023-09-17_22-45-18...846705ip-10-0-35-17410.0.35.17451.1156707checkpoint_0000060.50.00010.83.0
770.00010.0767070.174182169472918510.0318240.0976150.1080341695015924TrueFalse8554902822023-09-14_15-06-3187.44622651460ip-10-0-50-15110.0.50.15187.446226639d77762023-09-17_22-45-24...846705ip-10-0-35-17410.0.35.17456.7815268checkpoint_0000070.50.00010.83.0
880.00010.0561610.152457169472919510.0949310.0700970.1022921695015930TrueFalse9554902822023-09-14_15-06-4197.54115751460ip-10-0-50-15110.0.50.15197.541157639d77762023-09-17_22-45-30...846705ip-10-0-35-17410.0.35.17462.6071849checkpoint_0000080.50.00010.83.0
990.00010.0393360.160408169472920510.0238230.0520360.0963911695015936TrueTrue10554902822023-09-14_15-06-51107.56498051460ip-10-0-50-15110.0.50.151107.564980639d77762023-09-17_22-45-36...846705ip-10-0-35-17410.0.35.17468.38852410checkpoint_0000090.50.00010.83.0
\n", + "

10 rows × 22 columns

\n", "
" ], "text/plain": [ - " epoch lr train_loss val_loss timestamp time_this_iter_s \n", - "0 0 0.0001 0.577241 0.493672 1694729113 16.759313 \\\n", - "1 1 0.0001 0.476221 0.417544 1694729124 10.431773 \n", - "2 2 0.0001 0.368710 0.373515 1694729135 10.071463 \n", - "3 3 0.0001 0.292983 0.275497 1694729145 10.122023 \n", - "4 4 0.0001 0.210210 0.239090 1694729155 9.991925 \n", - "5 5 0.0001 0.161824 0.197741 1694729165 10.084616 \n", - "6 6 0.0001 0.113558 0.159887 1694729175 9.953290 \n", - "7 7 0.0001 0.076707 0.174182 1694729185 10.031824 \n", - "8 8 0.0001 0.056161 0.152457 1694729195 10.094931 \n", - "9 9 0.0001 0.039336 0.160408 1694729205 10.023823 \n", + " epoch lr train_loss val_loss timestamp should_checkpoint done \\\n", + "0 0 0.0001 0.577860 0.492227 1695015848 True False \n", + "1 1 0.0001 0.475743 0.387187 1695015856 True False \n", + "2 2 0.0001 0.402374 0.372390 1695015864 True False \n", + "3 3 0.0001 0.349068 0.297704 1695015873 True False \n", + "4 4 0.0001 0.256888 0.207574 1695015881 True False \n", + "5 5 0.0001 0.204279 0.161283 1695015889 True False \n", + "6 6 0.0001 0.142716 0.138546 1695015897 True False \n", + "7 7 0.0001 0.097615 0.108034 1695015924 True False \n", + "8 8 0.0001 0.070097 0.102292 1695015930 True False \n", + "9 9 0.0001 0.052036 0.096391 1695015936 True True \n", "\n", - " should_checkpoint done training_iteration trial_id \n", - "0 True False 1 55490282 \\\n", - "1 True False 2 55490282 \n", - "2 True False 3 55490282 \n", - "3 True False 4 55490282 \n", - "4 True False 5 55490282 \n", - "5 True False 6 55490282 \n", - "6 True False 7 55490282 \n", - "7 True False 8 55490282 \n", - "8 True False 9 55490282 \n", - "9 True True 10 55490282 \n", + " training_iteration trial_id date ... pid \\\n", + "0 1 639d7776 2023-09-17_22-44-08 ... 846705 \n", + "1 2 639d7776 2023-09-17_22-44-16 ... 846705 \n", + "2 3 639d7776 2023-09-17_22-44-24 ... 846705 \n", + "3 4 639d7776 2023-09-17_22-44-33 ... 846705 \n", + "4 5 639d7776 2023-09-17_22-44-41 ... 846705 \n", + "5 6 639d7776 2023-09-17_22-44-49 ... 846705 \n", + "6 7 639d7776 2023-09-17_22-45-18 ... 846705 \n", + "7 8 639d7776 2023-09-17_22-45-24 ... 846705 \n", + "8 9 639d7776 2023-09-17_22-45-30 ... 846705 \n", + "9 10 639d7776 2023-09-17_22-45-36 ... 846705 \n", "\n", - " date time_total_s pid hostname node_ip \n", - "0 2023-09-14_15-05-20 16.759313 51460 ip-10-0-50-151 10.0.50.151 \\\n", - "1 2023-09-14_15-05-31 27.191086 51460 ip-10-0-50-151 10.0.50.151 \n", - "2 2023-09-14_15-05-41 37.262549 51460 ip-10-0-50-151 10.0.50.151 \n", - "3 2023-09-14_15-05-51 47.384572 51460 ip-10-0-50-151 10.0.50.151 \n", - "4 2023-09-14_15-06-01 57.376497 51460 ip-10-0-50-151 10.0.50.151 \n", - "5 2023-09-14_15-06-11 67.461113 51460 ip-10-0-50-151 10.0.50.151 \n", - "6 2023-09-14_15-06-21 77.414402 51460 ip-10-0-50-151 10.0.50.151 \n", - "7 2023-09-14_15-06-31 87.446226 51460 ip-10-0-50-151 10.0.50.151 \n", - "8 2023-09-14_15-06-41 97.541157 51460 ip-10-0-50-151 10.0.50.151 \n", - "9 2023-09-14_15-06-51 107.564980 51460 ip-10-0-50-151 10.0.50.151 \n", + " hostname node_ip time_since_restore iterations_since_restore \\\n", + "0 ip-10-0-35-174 10.0.35.174 12.828465 1 \n", + "1 ip-10-0-35-174 10.0.35.174 20.651286 2 \n", + "2 ip-10-0-35-174 10.0.35.174 28.235628 3 \n", + "3 ip-10-0-35-174 10.0.35.174 35.873792 4 \n", + "4 ip-10-0-35-174 10.0.35.174 43.487612 5 \n", + "5 ip-10-0-35-174 10.0.35.174 51.113538 6 \n", + "6 ip-10-0-35-174 10.0.35.174 51.115670 7 \n", + "7 ip-10-0-35-174 10.0.35.174 56.781526 8 \n", + "8 ip-10-0-35-174 10.0.35.174 62.607184 9 \n", + "9 ip-10-0-35-174 10.0.35.174 68.388524 10 \n", "\n", - " time_since_restore iterations_since_restore \n", - "0 16.759313 1 \n", - "1 27.191086 2 \n", - "2 37.262549 3 \n", - "3 47.384572 4 \n", - "4 57.376497 5 \n", - "5 67.461113 6 \n", - "6 77.414402 7 \n", - "7 87.446226 8 \n", - "8 97.541157 9 \n", - "9 107.564980 10 " + " checkpoint_dir_name config/train_loop_config/dropout_p \\\n", + "0 checkpoint_000000 0.5 \n", + "1 checkpoint_000001 0.5 \n", + "2 checkpoint_000002 0.5 \n", + "3 checkpoint_000003 0.5 \n", + "4 checkpoint_000004 0.5 \n", + "5 checkpoint_000005 0.5 \n", + "6 checkpoint_000006 0.5 \n", + "7 checkpoint_000007 0.5 \n", + "8 checkpoint_000008 0.5 \n", + "9 checkpoint_000009 0.5 \n", + "\n", + " config/train_loop_config/lr config/train_loop_config/lr_factor \\\n", + "0 0.0001 0.8 \n", + "1 0.0001 0.8 \n", + "2 0.0001 0.8 \n", + "3 0.0001 0.8 \n", + "4 0.0001 0.8 \n", + "5 0.0001 0.8 \n", + "6 0.0001 0.8 \n", + "7 0.0001 0.8 \n", + "8 0.0001 0.8 \n", + "9 0.0001 0.8 \n", + "\n", + " config/train_loop_config/lr_patience \n", + "0 3.0 \n", + "1 3.0 \n", + "2 3.0 \n", + "3 3.0 \n", + "4 3.0 \n", + "5 3.0 \n", + "6 3.0 \n", + "7 3.0 \n", + "8 3.0 \n", + "9 3.0 \n", + "\n", + "[10 rows x 22 columns]" ] }, - "execution_count": 108, + "execution_count": 109, "metadata": {}, "output_type": "execute_result" } @@ -8094,7 +9226,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 110, "metadata": { "tags": [] }, @@ -8105,7 +9237,7 @@ "{'dropout_p': 0.5, 'lr': 0.0001, 'lr_factor': 0.8, 'lr_patience': 3.0}" ] }, - "execution_count": 109, + "execution_count": 110, "metadata": {}, "output_type": "execute_result" } @@ -8117,7 +9249,7 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 111, "metadata": { "tags": [] }, @@ -8149,19 +9281,19 @@ " artifact_uri\n", " start_time\n", " end_time\n", - " metrics.pid\n", - " metrics.epoch\n", - " metrics.config/train_loop_config/batch_size\n", + " metrics.time_total_s\n", + " metrics.config/train_loop_config/lr_patience\n", + " metrics.time_since_restore\n", " metrics.iterations_since_restore\n", " ...\n", - " metrics.lr\n", + " metrics.config/train_loop_config/num_epochs\n", + " params.train_loop_config/lr\n", + " params.train_loop_config/lr_patience\n", " params.train_loop_config/dropout_p\n", - " params.train_loop_config/batch_size\n", " params.train_loop_config/lr_factor\n", " params.train_loop_config/num_classes\n", - " params.train_loop_config/lr_patience\n", " params.train_loop_config/num_epochs\n", - " params.train_loop_config/lr\n", + " params.train_loop_config/batch_size\n", " tags.trial_name\n", " tags.mlflow.runName\n", " \n", @@ -8169,136 +9301,136 @@ " \n", " \n", " 0\n", - " cb6a74df7c4e43988598be5aee45e660\n", - " 917462352875586010\n", + " ebc5576cd02e4430bbe949612a25bd45\n", + " 703905858072772764\n", " FINISHED\n", " file:///efs/shared_storage/madewithml/GokuMoha...\n", - " 2023-09-14 22:02:50.670000+00:00\n", - " 2023-09-14 22:04:48.292000+00:00\n", - " 50696.0\n", - " 9.0\n", - " 256.0\n", + " 2023-09-18 05:43:55.499000+00:00\n", + " 2023-09-18 05:45:41.257000+00:00\n", + " 68.388524\n", + " 3.000000\n", + " 68.388524\n", " 10.0\n", " ...\n", - " 0.000100\n", - " 0.5\n", - " 256\n", - " 0.8\n", - " 4\n", - " 3\n", - " 10\n", + " NaN\n", " 0.0001\n", - " TorchTrainer_701e4_00000\n", - " TorchTrainer_701e4_00000\n", + " 3.0\n", + " 0.5\n", + " 0.8\n", + " None\n", + " None\n", + " None\n", + " TorchTrainer_639d7776\n", + " TorchTrainer_639d7776\n", " \n", " \n", " 1\n", - " 97a3692584eb4a51999f7e97176e3297\n", - " 917462352875586010\n", + " a67f6ec4e10b49a7845b91db61efc7e0\n", + " 703905858072772764\n", " FINISHED\n", " file:///efs/shared_storage/madewithml/GokuMoha...\n", - " 2023-09-14 22:05:03.880000+00:00\n", - " 2023-09-14 22:07:09.776000+00:00\n", - " 51460.0\n", - " 9.0\n", - " NaN\n", + " 2023-09-18 05:42:12.863000+00:00\n", + " 2023-09-18 05:43:30.925000+00:00\n", + " 63.699444\n", + " 3.000000\n", + " 63.699444\n", " 10.0\n", " ...\n", - " 0.000100\n", - " 0.5\n", - " None\n", - " 0.8\n", - " None\n", - " 3.0\n", - " None\n", + " 10.0\n", " 0.0001\n", - " TorchTrainer_55490282\n", - " TorchTrainer_55490282\n", + " 3\n", + " 0.5\n", + " 0.8\n", + " 4\n", + " 10\n", + " 256\n", + " TorchTrainer_1bd07_00000\n", + " TorchTrainer_1bd07_00000\n", " \n", " \n", " 2\n", - " 57c609dd76c9477896863f04f2a46bb5\n", - " 917462352875586010\n", + " 0d8a50554ecf498cb6f1471b58aedb9d\n", + " 703905858072772764\n", " FINISHED\n", " file:///efs/shared_storage/madewithml/GokuMoha...\n", - " 2023-09-14 22:07:13.514000+00:00\n", - " 2023-09-14 22:08:20.525000+00:00\n", - " 52063.0\n", - " 4.0\n", - " NaN\n", + " 2023-09-18 05:43:59.010000+00:00\n", + " 2023-09-18 05:45:17.549000+00:00\n", + " 30.729746\n", + " 2.253736\n", + " 30.729746\n", " 5.0\n", " ...\n", - " 0.000027\n", - " 0.7976231355896662\n", + " NaN\n", + " 5.1804178109970566e-05\n", + " 2.253735644669187\n", + " 0.8411920116073033\n", + " 0.7586266131367906\n", " None\n", - " 0.267142900040756\n", " None\n", - " 5.214561723373508\n", " None\n", - " 2.6942959077294993e-05\n", - " TorchTrainer_45b199df\n", - " TorchTrainer_45b199df\n", + " TorchTrainer_145c1bc2\n", + " TorchTrainer_145c1bc2\n", " \n", " \n", "\n", - "

3 rows × 36 columns

\n", + "

3 rows × 35 columns

\n", "" ], "text/plain": [ - " run_id experiment_id status \n", - "0 cb6a74df7c4e43988598be5aee45e660 917462352875586010 FINISHED \\\n", - "1 97a3692584eb4a51999f7e97176e3297 917462352875586010 FINISHED \n", - "2 57c609dd76c9477896863f04f2a46bb5 917462352875586010 FINISHED \n", + " run_id experiment_id status \\\n", + "0 ebc5576cd02e4430bbe949612a25bd45 703905858072772764 FINISHED \n", + "1 a67f6ec4e10b49a7845b91db61efc7e0 703905858072772764 FINISHED \n", + "2 0d8a50554ecf498cb6f1471b58aedb9d 703905858072772764 FINISHED \n", "\n", - " artifact_uri \n", - "0 file:///efs/shared_storage/madewithml/GokuMoha... \\\n", + " artifact_uri \\\n", + "0 file:///efs/shared_storage/madewithml/GokuMoha... \n", "1 file:///efs/shared_storage/madewithml/GokuMoha... \n", "2 file:///efs/shared_storage/madewithml/GokuMoha... \n", "\n", - " start_time end_time \n", - "0 2023-09-14 22:02:50.670000+00:00 2023-09-14 22:04:48.292000+00:00 \\\n", - "1 2023-09-14 22:05:03.880000+00:00 2023-09-14 22:07:09.776000+00:00 \n", - "2 2023-09-14 22:07:13.514000+00:00 2023-09-14 22:08:20.525000+00:00 \n", + " start_time end_time \\\n", + "0 2023-09-18 05:43:55.499000+00:00 2023-09-18 05:45:41.257000+00:00 \n", + "1 2023-09-18 05:42:12.863000+00:00 2023-09-18 05:43:30.925000+00:00 \n", + "2 2023-09-18 05:43:59.010000+00:00 2023-09-18 05:45:17.549000+00:00 \n", "\n", - " metrics.pid metrics.epoch metrics.config/train_loop_config/batch_size \n", - "0 50696.0 9.0 256.0 \\\n", - "1 51460.0 9.0 NaN \n", - "2 52063.0 4.0 NaN \n", + " metrics.time_total_s metrics.config/train_loop_config/lr_patience \\\n", + "0 68.388524 3.000000 \n", + "1 63.699444 3.000000 \n", + "2 30.729746 2.253736 \n", "\n", - " metrics.iterations_since_restore ... metrics.lr \n", - "0 10.0 ... 0.000100 \\\n", - "1 10.0 ... 0.000100 \n", - "2 5.0 ... 0.000027 \n", + " metrics.time_since_restore metrics.iterations_since_restore ... \\\n", + "0 68.388524 10.0 ... \n", + "1 63.699444 10.0 ... \n", + "2 30.729746 5.0 ... \n", "\n", - " params.train_loop_config/dropout_p params.train_loop_config/batch_size \n", - "0 0.5 256 \\\n", - "1 0.5 None \n", - "2 0.7976231355896662 None \n", + " metrics.config/train_loop_config/num_epochs params.train_loop_config/lr \\\n", + "0 NaN 0.0001 \n", + "1 10.0 0.0001 \n", + "2 NaN 5.1804178109970566e-05 \n", "\n", - " params.train_loop_config/lr_factor params.train_loop_config/num_classes \n", - "0 0.8 4 \\\n", - "1 0.8 None \n", - "2 0.267142900040756 None \n", + " params.train_loop_config/lr_patience params.train_loop_config/dropout_p \\\n", + "0 3.0 0.5 \n", + "1 3 0.5 \n", + "2 2.253735644669187 0.8411920116073033 \n", "\n", - " params.train_loop_config/lr_patience params.train_loop_config/num_epochs \n", - "0 3 10 \\\n", - "1 3.0 None \n", - "2 5.214561723373508 None \n", + " params.train_loop_config/lr_factor params.train_loop_config/num_classes \\\n", + "0 0.8 None \n", + "1 0.8 4 \n", + "2 0.7586266131367906 None \n", "\n", - " params.train_loop_config/lr tags.trial_name \n", - "0 0.0001 TorchTrainer_701e4_00000 \\\n", - "1 0.0001 TorchTrainer_55490282 \n", - "2 2.6942959077294993e-05 TorchTrainer_45b199df \n", + " params.train_loop_config/num_epochs params.train_loop_config/batch_size \\\n", + "0 None None \n", + "1 10 256 \n", + "2 None None \n", "\n", - " tags.mlflow.runName \n", - "0 TorchTrainer_701e4_00000 \n", - "1 TorchTrainer_55490282 \n", - "2 TorchTrainer_45b199df \n", + " tags.trial_name tags.mlflow.runName \n", + "0 TorchTrainer_639d7776 TorchTrainer_639d7776 \n", + "1 TorchTrainer_1bd07_00000 TorchTrainer_1bd07_00000 \n", + "2 TorchTrainer_145c1bc2 TorchTrainer_145c1bc2 \n", "\n", - "[3 rows x 36 columns]" + "[3 rows x 35 columns]" ] }, - "execution_count": 110, + "execution_count": 111, "metadata": {}, "output_type": "execute_result" } @@ -8309,80 +9441,15 @@ "sorted_runs" ] }, - { - "cell_type": "code", - "execution_count": 111, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-09-14 15:08:21,709\tINFO streaming_executor.py:92 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)->MapBatches()]\n", - "2023-09-14 15:08:21,710\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:08:21,711\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Running 0: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches()]\n", + "2023-09-17 22:45:42,824\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:45:42,825\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/4096 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor)]\n", + "2023-09-17 22:45:43,741\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:45:43,742\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/4096 [00:00MapBatches(TorchPredictor) pid=350325, ip=10.0.34.101)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"precision\": 0.9168092951711627,\n", + " \"recall\": 0.9109947643979057,\n", + " \"f1\": 0.9105512639658029\n", + "}\n" + ] + } + ], + "source": [ + "# Evaluate on test split\n", + "performance = evaluate(ds=test_ds, predictor=predictor)\n", + "print (json.dumps(performance, indent=2))" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-09-17 22:45:49,875\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:45:49,875\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:45:49,876\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/1 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> TaskPoolMapOperator[MapBatches(CustomPreprocessor._transform_pandas)->MapBatches()]\n", - "2023-09-14 15:08:25,603\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:08:25,604\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + "2023-09-17 22:45:52,090\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches()]\n", + "2023-09-17 22:45:52,091\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:45:52,091\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, { @@ -8478,7 +9657,7 @@ "version_minor": 0 }, "text/plain": [ - "Running 0: 0%| | 0/48 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:45:52,988\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:45:52,988\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/4096 [00:00" ], "text/plain": [ - " id created_on title \n", - "0 19 2020-03-03 13:54:31 Diffusion to Vector \\\n", + " id created_on title \\\n", + "0 19 2020-03-03 13:54:31 Diffusion to Vector \n", "1 26 2020-03-07 23:11:58 Graph Wavelet Neural Network \n", "2 44 2020-03-08 00:32:58 Capsule Graph Neural Network \n", "3 80 2020-03-20 05:59:32 NeRF: Neural Radiance Fields \n", "4 84 2020-03-20 15:18:43 Mention Classifier \n", "\n", - " description \n", - "0 Reference implementation of Diffusion2Vec (Com... \\\n", + " description \\\n", + "0 Reference implementation of Diffusion2Vec (Com... \n", "1 A PyTorch implementation of \"Graph Wavelet Neu... \n", "2 A PyTorch implementation of \"Capsule Graph Neu... \n", "3 Representing scenes as neural radiance fields ... \n", "4 Category prediction model\\nThis repo contains ... \n", "\n", - " tag \n", - "0 other \\\n", + " tag \\\n", + "0 other \n", "1 other \n", "2 other \n", "3 computer-vision \n", "4 natural-language-processing \n", "\n", - " text \n", - "0 Diffusion to Vector Reference implementation o... \\\n", + " text \\\n", + "0 Diffusion to Vector Reference implementation o... \n", "1 Graph Wavelet Neural Network A PyTorch impleme... \n", "2 Capsule Graph Neural Network A PyTorch impleme... \n", "3 NeRF: Neural Radiance Fields Representing scen... \n", @@ -8688,7 +9887,7 @@ "4 natural-language-processing " ] }, - "execution_count": 118, + "execution_count": 120, "metadata": {}, "output_type": "execute_result" } @@ -8712,7 +9911,7 @@ }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 121, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -8727,9 +9926,9 @@ "output_type": "stream", "text": [ "{\n", - " \"precision\": 0.9206853613661888,\n", - " \"recall\": 0.9162303664921466,\n", - " \"f1\": 0.9167279878033617,\n", + " \"precision\": 0.9138952286238713,\n", + " \"recall\": 0.9109947643979057,\n", + " \"f1\": 0.9114851103432928,\n", " \"num_samples\": 191.0\n", "}\n" ] @@ -8756,7 +9955,7 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 122, "metadata": { "id": "jqetm3ybN9C1", "tags": [] @@ -8768,7 +9967,7 @@ }, { "cell_type": "code", - "execution_count": 121, + "execution_count": 123, "metadata": { "id": "1zIAI4mwusoX", "tags": [] @@ -8788,7 +9987,7 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 124, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -8803,9 +10002,9 @@ "output_type": "stream", "text": [ "{\n", - " \"precision\": 0.9156626506024096,\n", - " \"recall\": 0.9743589743589743,\n", - " \"f1\": 0.9440993788819876,\n", + " \"precision\": 0.9146341463414634,\n", + " \"recall\": 0.9615384615384616,\n", + " \"f1\": 0.9375000000000001,\n", " \"num_samples\": 78.0\n", "}\n" ] @@ -8819,7 +10018,7 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 125, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -8834,38 +10033,38 @@ "output_type": "stream", "text": [ "[\n", - " \"natural-language-processing\",\n", + " \"other\",\n", " {\n", - " \"precision\": 0.9156626506024096,\n", - " \"recall\": 0.9743589743589743,\n", - " \"f1\": 0.9440993788819876,\n", - " \"num_samples\": 78.0\n", + " \"precision\": 0.96,\n", + " \"recall\": 0.9230769230769231,\n", + " \"f1\": 0.9411764705882353,\n", + " \"num_samples\": 26.0\n", " }\n", "]\n", "[\n", - " \"other\",\n", + " \"natural-language-processing\",\n", " {\n", - " \"precision\": 0.9583333333333334,\n", - " \"recall\": 0.8846153846153846,\n", - " \"f1\": 0.9199999999999999,\n", - " \"num_samples\": 26.0\n", + " \"precision\": 0.9146341463414634,\n", + " \"recall\": 0.9615384615384616,\n", + " \"f1\": 0.9375000000000001,\n", + " \"num_samples\": 78.0\n", " }\n", "]\n", "[\n", " \"computer-vision\",\n", " {\n", - " \"precision\": 0.9538461538461539,\n", + " \"precision\": 0.9393939393939394,\n", " \"recall\": 0.8732394366197183,\n", - " \"f1\": 0.9117647058823529,\n", + " \"f1\": 0.9051094890510948,\n", " \"num_samples\": 71.0\n", " }\n", "]\n", "[\n", " \"mlops\",\n", " {\n", - " \"precision\": 0.7368421052631579,\n", - " \"recall\": 0.875,\n", - " \"f1\": 0.7999999999999999,\n", + " \"precision\": 0.7222222222222222,\n", + " \"recall\": 0.8125,\n", + " \"f1\": 0.7647058823529411,\n", " \"num_samples\": 16.0\n", " }\n", "]\n" @@ -8904,7 +10103,7 @@ }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 126, "metadata": { "id": "ZG2SgsPAzukL", "tags": [] @@ -8927,7 +10126,7 @@ }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 127, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -8941,9 +10140,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[4, 9, 12, 16, 17, 19, 23, 25, 26, 29, 30, 31, 32, 33, 34, 42, 47, 49, 50, 54, 56, 65, 66, 68, 71, 75, 77, 78, 79, 82, 92, 94, 95, 97, 99, 101, 109, 113, 114, 115, 118, 120, 122, 126, 128, 129, 130, 131, 133, 134, 135, 138, 139, 140, 141, 142, 144, 148, 149, 152, 159, 160, 161, 163, 166, 170, 172, 173, 174, 177, 179, 183, 184, 187, 189, 190]\n", - "[41, 55, 61, 104, 107, 154, 165]\n", - "[76, 112]\n" + "[4, 9, 12, 17, 19, 23, 25, 26, 29, 30, 31, 32, 33, 34, 42, 47, 49, 50, 54, 56, 65, 66, 68, 71, 75, 77, 78, 79, 82, 92, 94, 95, 97, 99, 101, 109, 113, 114, 115, 118, 120, 122, 126, 128, 129, 130, 131, 133, 134, 135, 138, 139, 140, 141, 142, 144, 148, 149, 152, 159, 160, 161, 163, 166, 170, 172, 173, 174, 177, 179, 183, 184, 187, 189, 190]\n", + "[41, 61, 102, 104, 154, 165, 188]\n", + "[16, 76, 112]\n" ] } ], @@ -8955,7 +10154,7 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 128, "metadata": {}, "outputs": [ { @@ -8983,16 +10182,20 @@ " true: mlops\n", " pred: natural-language-processing\n", "\n", - "The AI Economist Improving Equality and Productivity with AI-Driven Tax Policies\n", - " true: other\n", + "Differential Subspace Search in High-Dimensional Latent Space Differential subspace search to allow efficient iterative user exploration in such a space, without relying on domain- or data-specific assumptions.\n", + " true: computer-vision\n", " pred: natural-language-processing\n", "\n", - "Differential Subspace Search in High-Dimensional Latent Space Differential subspace search to allow efficient iterative user exploration in such a space, without relying on domain- or data-specific assumptions.\n", + "EfficientDet (PyTorch) A PyTorch implementation of EfficientDet faithful to the original Google implementation with ported weights.\n", " true: computer-vision\n", " pred: natural-language-processing\n", "\n", "\n", "=== False negatives ===\n", + "The Unreasonable Effectiveness of Recurrent Neural Networks A close look at how RNNs are able to perform so well.\n", + " true: natural-language-processing\n", + " pred: computer-vision\n", + "\n", "Get Subreddit Suggestions for a Post Trained on 4M Reddit posts from 4k Subreddits. End-to-end ML pipeline built with fasttext and FastAPI, deployed to Valohai.\n", " true: natural-language-processing\n", " pred: computer-vision\n", @@ -9059,7 +10262,7 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 129, "metadata": { "id": "3FCrRUb2GANr", "tags": [] @@ -9074,7 +10277,7 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 130, "metadata": { "id": "sKQxFU0iU-w-", "tags": [] @@ -9096,7 +10299,7 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 131, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -9109,17 +10312,17 @@ { "data": { "text/plain": [ - "[{'text': 'Get Subreddit Suggestions for a Post Trained on 4M Reddit posts from 4k Subreddits. End-to-end ML pipeline built with fasttext and FastAPI, deployed to Valohai.',\n", + "[{'text': 'The Unreasonable Effectiveness of Recurrent Neural Networks A close look at how RNNs are able to perform so well.',\n", " 'true': 'natural-language-processing',\n", " 'pred': 'computer-vision',\n", - " 'prob': 0.00060260075},\n", + " 'prob': 0.008757317},\n", " {'text': 'Machine Learning Projects This Repo contains projects done by me while learning the basics. All the familiar types of regression, classification, and clustering methods have been used.',\n", " 'true': 'natural-language-processing',\n", " 'pred': 'mlops',\n", - " 'prob': 0.0076674907}]" + " 'prob': 0.020190474}]" ] }, - "execution_count": 129, + "execution_count": 131, "metadata": {}, "output_type": "execute_result" } @@ -9152,7 +10355,7 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 132, "metadata": { "id": "XX3cORGPPXXM", "tags": [] @@ -9165,7 +10368,7 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": 133, "metadata": { "tags": [] }, @@ -9174,38 +10377,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "*** SIGTERM received at time=1694729309 on cpu 5 ***\n", - "*** SIGTERM received at time=1694729309 on cpu 4 ***\n", - "*** SIGTERM received at time=1694729309 on cpu 0 ***\n", - "*** SIGTERM received at time=1694729309 on cpu 2 ***\n", - "PC: @ 0x4fefa3 (unknown) _PyObject_GetMethod\n", - "PC: @ 0x4fce88 (unknown) _PyObject_GenericGetAttrWithDict\n", - " @ 0x7fe11d01f420 27754944 (unknown)\n", - " @ 0x7fe11d01f420 26229312 (unknown)\n", - "PC: @ 0x4f369b (unknown) _PyEval_EvalFrameDefault\n", - "PC: @ 0x4ff156 (unknown) _PyObject_GetMethod\n", - " @ 0x7fe11d01f420 (unknown) (unknown)\n", - " @ 0x7fe11d01f420 27580544 (unknown)\n", - " @ ... and at least 1 more frames\n", - "[2023-09-14 15:08:29,998 E 123487 117917] logging.cc:361: *** SIGTERM received at time=1694729309 on cpu 4 ***\n", - "[2023-09-14 15:08:29,998 E 123487 117917] logging.cc:361: PC: @ 0x4f369b (unknown) _PyEval_EvalFrameDefault\n", - "[2023-09-14 15:08:29,998 E 123487 117917] logging.cc:361: @ 0x7fe11d01f420 (unknown) (unknown)\n", - "[2023-09-14 15:08:29,998 E 123487 117917] logging.cc:361: @ ... and at least 1 more frames\n", - " @ 0x742da0 (unknown) (unknown)\n", - " @ 0x742da0 (unknown) (unknown)\n", - "[2023-09-14 15:08:30,000 E 123488 117917] logging.cc:361: *** SIGTERM received at time=1694729309 on cpu 5 ***\n", - "[2023-09-14 15:08:30,000 E 123488 117917] logging.cc:361: PC: @ 0x4fefa3 (unknown) _PyObject_GetMethod\n", - "[2023-09-14 15:08:30,000 E 123489 117917] logging.cc:361: *** SIGTERM received at time=1694729309 on cpu 2 ***\n", - "[2023-09-14 15:08:30,000 E 123489 117917] logging.cc:361: PC: @ 0x4fce88 (unknown) _PyObject_GenericGetAttrWithDict\n", - "[2023-09-14 15:08:30,003 E 123488 117917] logging.cc:361: @ 0x7fe11d01f420 27754944 (unknown)\n", - "[2023-09-14 15:08:30,003 E 123489 117917] logging.cc:361: @ 0x7fe11d01f420 26229312 (unknown)\n", - " @ 0x742da0 (unknown) (unknown)\n", - "[2023-09-14 15:08:30,003 E 123486 117917] logging.cc:361: *** SIGTERM received at time=1694729309 on cpu 0 ***\n", - "[2023-09-14 15:08:30,003 E 123486 117917] logging.cc:361: PC: @ 0x4ff156 (unknown) _PyObject_GetMethod\n", - "[2023-09-14 15:08:30,007 E 123488 117917] logging.cc:361: @ 0x742da0 (unknown) (unknown)\n", - "[2023-09-14 15:08:30,007 E 123489 117917] logging.cc:361: @ 0x742da0 (unknown) (unknown)\n", - "[2023-09-14 15:08:30,009 E 123486 117917] logging.cc:361: @ 0x7fe11d01f420 27580544 (unknown)\n", - "[2023-09-14 15:08:30,015 E 123486 117917] logging.cc:361: @ 0x742da0 (unknown) (unknown)\n" + "*** SIGTERM received at time=1695015958 on cpu 1 ***\n", + "PC: @ 0x4edd8a (unknown) _PyEval_MakeFrameVector\n", + " @ 0x7fe3ff0e9420 514711536 (unknown)\n", + " @ 0x72c720 (unknown) (unknown)\n", + "[2023-09-17 22:45:58,798 E 848689 841208] logging.cc:361: *** SIGTERM received at time=1695015958 on cpu 1 ***\n", + "[2023-09-17 22:45:58,799 E 848689 841208] logging.cc:361: PC: @ 0x4edd8a (unknown) _PyEval_MakeFrameVector\n", + "[2023-09-17 22:45:58,803 E 848689 841208] logging.cc:361: @ 0x7fe3ff0e9420 514711536 (unknown)\n", + "[2023-09-17 22:45:58,808 E 848689 841208] logging.cc:361: @ 0x72c720 (unknown) (unknown)\n" ] }, { @@ -9248,6 +10427,15 @@ " computer-vision\n", " \n", " \n", + " 102\n", + " 1451\n", + " 2020-06-16 01:21:09\n", + " EfficientDet (PyTorch)\n", + " A PyTorch implementation of EfficientDet faith...\n", + " computer-vision\n", + " natural-language-processing\n", + " \n", + " \n", " 165\n", " 2137\n", " 2020-08-13 02:10:03\n", @@ -9257,67 +10445,58 @@ " natural-language-processing\n", " \n", " \n", - " 76\n", - " 916\n", - " 2020-05-19 08:11:05\n", - " Get Subreddit Suggestions for a Post\n", - " Trained on 4M Reddit posts from 4k Subreddits....\n", - " natural-language-processing\n", + " 61\n", + " 710\n", + " 2020-05-05 04:01:24\n", + " Differential Subspace Search in High-Dimension...\n", + " Differential subspace search to allow efficien...\n", " computer-vision\n", - " \n", - " \n", - " 41\n", - " 561\n", - " 2020-04-16 16:27:31\n", - " How Docker Can Help You Become A More Effectiv...\n", - " A look at Docker from the perspective of a dat...\n", - " mlops\n", " natural-language-processing\n", " \n", " \n", - " 104\n", - " 1462\n", - " 2020-06-16 03:28:40\n", - " Open Compound Domain Adaptation\n", - " Pytorch implementation for \"Open Compound Doma...\n", - " computer-vision\n", + " 16\n", + " 264\n", + " 2020-04-06 21:33:32\n", + " The Unreasonable Effectiveness of Recurrent Ne...\n", + " A close look at how RNNs are able to perform s...\n", " natural-language-processing\n", + " computer-vision\n", " \n", " \n", "\n", "" ], "text/plain": [ - " id created_on \n", - "103 1459 2020-06-16 03:06:10 \\\n", + " id created_on \\\n", + "103 1459 2020-06-16 03:06:10 \n", + "102 1451 2020-06-16 01:21:09 \n", "165 2137 2020-08-13 02:10:03 \n", - "76 916 2020-05-19 08:11:05 \n", - "41 561 2020-04-16 16:27:31 \n", - "104 1462 2020-06-16 03:28:40 \n", + "61 710 2020-05-05 04:01:24 \n", + "16 264 2020-04-06 21:33:32 \n", "\n", - " title \n", - "103 SuperGlue: Learning Feature Matching with Grap... \\\n", + " title \\\n", + "103 SuperGlue: Learning Feature Matching with Grap... \n", + "102 EfficientDet (PyTorch) \n", "165 Unpopular Opinion - Data Scientists Should Be ... \n", - "76 Get Subreddit Suggestions for a Post \n", - "41 How Docker Can Help You Become A More Effectiv... \n", - "104 Open Compound Domain Adaptation \n", + "61 Differential Subspace Search in High-Dimension... \n", + "16 The Unreasonable Effectiveness of Recurrent Ne... \n", "\n", - " description \n", - "103 SuperGlue, a neural network that matches two s... \\\n", + " description \\\n", + "103 SuperGlue, a neural network that matches two s... \n", + "102 A PyTorch implementation of EfficientDet faith... \n", "165 I believe data scientists can be more effectiv... \n", - "76 Trained on 4M Reddit posts from 4k Subreddits.... \n", - "41 A look at Docker from the perspective of a dat... \n", - "104 Pytorch implementation for \"Open Compound Doma... \n", + "61 Differential subspace search to allow efficien... \n", + "16 A close look at how RNNs are able to perform s... \n", "\n", " tag prediction \n", "103 other computer-vision \n", + "102 computer-vision natural-language-processing \n", "165 mlops natural-language-processing \n", - "76 natural-language-processing computer-vision \n", - "41 mlops natural-language-processing \n", - "104 computer-vision natural-language-processing " + "61 computer-vision natural-language-processing \n", + "16 natural-language-processing computer-vision " ] }, - "execution_count": 131, + "execution_count": 133, "metadata": {}, "output_type": "execute_result" } @@ -9364,7 +10543,7 @@ }, { "cell_type": "code", - "execution_count": 132, + "execution_count": 134, "metadata": { "id": "ZyueOtQsXdGm", "tags": [] @@ -9378,7 +10557,7 @@ }, { "cell_type": "code", - "execution_count": 133, + "execution_count": 135, "metadata": { "id": "coutP2KtXdLG", "tags": [] @@ -9396,7 +10575,7 @@ }, { "cell_type": "code", - "execution_count": 134, + "execution_count": 136, "metadata": { "id": "PbxmLvi-D7lq", "tags": [] @@ -9420,7 +10599,7 @@ }, { "cell_type": "code", - "execution_count": 135, + "execution_count": 137, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -9435,7 +10614,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 191/191 [00:00<00:00, 27560.88it/s]\n" + "100%|██████████| 191/191 [00:00<00:00, 32805.57it/s]\n" ] }, { @@ -9494,8 +10673,8 @@ "" ], "text/plain": [ - " text \n", - "12 Finetuning Transformers with JAX + Haiku Walki... \\\n", + " text \\\n", + "12 Finetuning Transformers with JAX + Haiku Walki... \n", "19 Question Answering with a Fine-Tuned BERT What... \n", "29 BertViz Tool for visualizing attention in the ... \n", "30 The Transformer Family This post presents how ... \n", @@ -9509,7 +10688,7 @@ "31 natural-language-processing " ] }, - "execution_count": 135, + "execution_count": 137, "metadata": {}, "output_type": "execute_result" } @@ -9521,7 +10700,7 @@ }, { "cell_type": "code", - "execution_count": 136, + "execution_count": 138, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -9536,7 +10715,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 191/191 [00:00<00:00, 62729.00it/s]\n" + "100%|██████████| 191/191 [00:00<00:00, 64413.61it/s]\n" ] }, { @@ -9595,8 +10774,8 @@ "" ], "text/plain": [ - " text \n", - "75 NLPAug Data augmentation for NLP \\\n", + " text \\\n", + "75 NLPAug Data augmentation for NLP \n", "123 Offline Reinforcement Learning Challenges, alg... \n", "127 Image Classifier Pure JavaScript Image Classifier \n", "132 imgaug Image augmentation for machine learning... \n", @@ -9610,7 +10789,7 @@ "140 natural-language-processing " ] }, - "execution_count": 136, + "execution_count": 138, "metadata": {}, "output_type": "execute_result" } @@ -9631,7 +10810,7 @@ }, { "cell_type": "code", - "execution_count": 137, + "execution_count": 139, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -9645,7 +10824,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 191/191 [00:00<00:00, 26776.93it/s]\n" + "100%|██████████| 191/191 [00:00<00:00, 27137.02it/s]\n" ] }, { @@ -9678,7 +10857,7 @@ " dtype=[('nlp_llm', ' TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:45:59,447\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:45:59,448\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/200 [00:00\n", " " @@ -46985,7 +48188,7 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 145, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -46995,13 +48198,36 @@ "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-09-17 22:46:15,716\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:46:15,717\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:46:15,718\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/2 [00:00 TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:46:16,784\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:46:16,784\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/2 [00:00 TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "2023-09-17 22:46:17,811\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:46:17,811\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Running 0: 0%| | 0/2 [00:00 TaskPoolMapOperator[ReadCSV->SplitBlocks(48)] -> ActorPoolMapOperator[MapBatches(Predictor)]\n", - "2023-09-14 15:08:58,659\tINFO streaming_executor.py:93 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", - "2023-09-14 15:08:58,660\tINFO streaming_executor.py:95 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", - "2023-09-14 15:09:01,060\tINFO actor_pool_map_operator.py:117 -- MapBatches(Predictor): Waiting for 1 pool actors to start...\n" + "2023-09-17 22:46:24,211\tINFO streaming_executor.py:93 -- Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[ReadCSV->SplitBlocks(64)] -> ActorPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor)]\n", + "2023-09-17 22:46:24,213\tINFO streaming_executor.py:94 -- Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=True, actor_locality_enabled=True, verbose_progress=False)\n", + "2023-09-17 22:46:24,214\tINFO streaming_executor.py:96 -- Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n", + "2023-09-17 22:46:24,951\tINFO actor_pool_map_operator.py:106 -- MapBatches(preprocess)->MapBatches(TorchPredictor): Waiting for 1 pool actors to start...\n" ] }, { @@ -47182,18 +48420,31 @@ "version_minor": 0 }, "text/plain": [ - "Running 0: 0%| | 0/48 [00:00MapBatches(TorchPredictor)) pid=848995)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + ] + }, { "data": { "text/plain": [ - "[{'prediction': 'computer-vision'},\n", - " {'prediction': 'other'},\n", - " {'prediction': 'other'}]" + "array([0, 3, 3, 0, 2, 0, 0, 0, 0, 2, 0, 0, 2, 3, 0, 0, 0, 2, 3, 2, 3, 0,\n", + " 3, 2, 0, 0, 2, 1, 1, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 1, 2, 2, 0,\n", + " 0, 3, 1, 2, 0, 2, 2, 3, 3, 0, 2, 1, 2, 3, 3, 3, 3, 2, 0, 0, 0, 2,\n", + " 2, 3, 2, 1, 0, 2, 3, 1, 0, 2, 0, 2, 2, 2, 0, 0, 2, 1, 1, 0, 0, 0,\n", + " 0, 3, 0, 0, 2, 0, 2, 2, 3, 2, 0, 2, 0, 2, 2, 0, 1, 0, 0, 0, 0, 2,\n", + " 0, 0, 1, 2, 2, 2, 3, 0, 2, 0, 2, 3, 2, 3, 3, 3, 2, 0, 2, 2, 2, 2,\n", + " 0, 2, 2, 2, 0, 1, 2, 2, 2, 2, 2, 1, 2, 0, 3, 0, 2, 2, 1, 1, 2, 0,\n", + " 2, 0, 0, 0, 0, 2, 2, 2, 0, 2, 1, 2, 2, 0, 0, 1, 2, 3, 2, 2, 2, 0,\n", + " 0, 2, 0, 2, 1, 3, 0, 2, 2, 0, 1, 2, 1, 2, 2])" ] }, "execution_count": 150, @@ -47202,8 +48453,11 @@ } ], "source": [ - "# Sample predictions\n", - "predictions.take(3) " + "# Batch inference\n", + "preprocessed_ds = preprocessor.transform(test_ds)\n", + "compute = ActorPoolStrategy(min_size=1, max_size=2)\n", + "outputs = preprocessed_ds.map_batches(predictor, batch_size=128, compute=compute)\n", + "np.array([d[\"output\"] for d in outputs.take_all()])" ] }, { @@ -47244,7 +48498,7 @@ "source": [ "# Define application\n", "app = FastAPI(\n", - " title=\"Made With ML\", \n", + " title=\"Made With ML\",\n", " description=\"Classify machine learning projects.\", \n", " version=\"0.1\")" ] @@ -47264,23 +48518,21 @@ }, "outputs": [], "source": [ - "@serve.deployment(route_prefix=\"/\", num_replicas=\"1\", ray_actor_options={\"num_cpus\": 8, \"num_gpus\": 0})\n", + "@serve.deployment(num_replicas=\"1\", ray_actor_options={\"num_cpus\": 8, \"num_gpus\": 0})\n", "@serve.ingress(app)\n", "class ModelDeployment:\n", - " \n", " def __init__(self, run_id):\n", " \"\"\"Initialize the model.\"\"\"\n", " self.run_id = run_id\n", " mlflow.set_tracking_uri(MLFLOW_TRACKING_URI) # so workers have access to model registry\n", " best_checkpoint = get_best_checkpoint(run_id=run_id)\n", " self.predictor = TorchPredictor.from_checkpoint(best_checkpoint)\n", - " self.preprocessor = self.predictor.get_preprocessor()\n", "\n", " @app.post(\"/predict/\")\n", " async def _predict(self, request: Request):\n", " data = await request.json()\n", - " df = pd.DataFrame([{\"title\": data.get(\"title\", \"\"), \"description\": data.get(\"description\", \"\"), \"tag\": \"\"}])\n", - " results = predict_with_proba(df=df, predictor=self.predictor)\n", + " sample_ds = ray.data.from_items([{\"title\": data.get(\"title\", \"\"), \"description\": data.get(\"description\", \"\"), \"tag\": \"\"}])\n", + " results = predict_proba(ds=sample_ds, predictor=self.predictor)\n", " return {\"results\": results}" ] }, @@ -47298,49 +48550,44 @@ "tags": [] }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connecting to existing Serve app in namespace \"serve\". New http options will not be applied.\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "(HTTPProxyActor pid=52807, ip=10.0.50.151) INFO: Started server process [52807]\n", - "(HTTPProxyActor pid=52807, ip=10.0.50.151) INFO 2023-09-14 15:09:20,168 http_proxy 10.0.50.151 http_proxy.py:314 - Setting draining flag on node 08c7b80ad4cca7d0486399f7e6cef170caf13128856ce8fe7a8ce7f4 to True.\n", - "(HTTPProxyActor pid=52807, ip=10.0.50.151) INFO 2023-09-14 15:09:20,169 http_proxy 10.0.50.151 http_proxy.py:314 - Setting draining flag on node 08c7b80ad4cca7d0486399f7e6cef170caf13128856ce8fe7a8ce7f4 to True.\n" + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:46:46,923 controller 840558 deployment_state.py:1390 - Deploying new version of deployment ModelDeployment in application 'default'.\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:46:47,027 controller 840558 deployment_state.py:1560 - Stopping 1 replicas of deployment 'ModelDeployment' in application 'default' with outdated versions.\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:46:47,027 controller 840558 http_state.py:265 - Start to drain the proxy actor on node 860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:46:49,260 controller 840558 deployment_state.py:2027 - Replica default#ModelDeployment#qtfPwF is stopped.\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:46:49,261 controller 840558 deployment_state.py:1679 - Adding 1 replica to deployment ModelDeployment in application 'default'.\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:46:52,625 controller 840558 http_state.py:276 - Stop draining the proxy actor on node 860a06117a62bfc12416a8163d19974a865e594674344a920da1e53b\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Started detached Serve instance in namespace \"serve\".\n" + "Deployment 'ModelDeployment:fHCaeN' is ready at `http://127.0.0.1:8000/`. component=serve deployment=ModelDeployment\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "(ServeController pid=123971) INFO 2023-09-14 15:09:20,336 controller 123971 deployment_state.py:1308 - Deploying new version of deployment default_ModelDeployment.\n", - "(ServeController pid=123971) INFO 2023-09-14 15:09:20,438 controller 123971 deployment_state.py:1571 - Adding 1 replica to deployment default_ModelDeployment.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Deployment 'default_ModelDeployment:HbolMJ' is ready at `http://127.0.0.1:8000/`. component=serve deployment=default_ModelDeployment\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-09-14 15:09:26,325\tINFO router.py:853 -- Using PowerOfTwoChoicesReplicaScheduler.\n", - "2023-09-14 15:09:26,333\tINFO router.py:329 -- Got updated replicas for deployment default_ModelDeployment: {'default_ModelDeployment#lxbWjk'}.\n" + "2023-09-17 22:46:58,941\tINFO router.py:1226 -- Using router .\n", + "2023-09-17 22:46:58,947\tINFO router.py:537 -- Got updated replicas for deployment 'ModelDeployment' in application 'default': {'default#ModelDeployment#aAAvxd'}.\n" ] }, { "data": { "text/plain": [ - "RayServeSyncHandle(deployment='default_ModelDeployment')" + "RayServeSyncHandle(deployment='ModelDeployment')" ] }, "execution_count": 154, @@ -47352,7 +48599,7 @@ "# Run service\n", "sorted_runs = mlflow.search_runs(experiment_names=[experiment_name], order_by=[\"metrics.val_loss ASC\"])\n", "run_id = sorted_runs.iloc[0].run_id\n", - "serve.run(ModelDeployment.bind(run_id=run_id))" + "serve.run(ModelDeployment.bind(run_id=run_id), route_prefix=\"/\")" ] }, { @@ -47362,14 +48609,44 @@ "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=False, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=350914, ip=10.0.34.101) Running 0: 0%| | 0/1 [00:00MapBatches(TorchPredictor.predict_proba) pid=351034, ip=10.0.34.101)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" + ] + }, { "data": { "text/plain": [ "{'results': [{'prediction': 'natural-language-processing',\n", - " 'probabilities': {'computer-vision': 0.00017186270270030946,\n", - " 'mlops': 0.0002483417047187686,\n", - " 'natural-language-processing': 0.9993651509284973,\n", - " 'other': 0.0002146375336451456}}]}" + " 'probabilities': {'computer-vision': 0.0006470938096754253,\n", + " 'mlops': 0.0003823915321845561,\n", + " 'natural-language-processing': 0.9983959794044495,\n", + " 'other': 0.0005744708469137549}}]}" ] }, "execution_count": 155, @@ -47403,17 +48680,41 @@ "name": "stderr", "output_type": "stream", "text": [ - "(ServeReplica:default_ModelDeployment pid=124072) INFO 2023-09-14 15:09:26,486 default_ModelDeployment default_ModelDeployment#lxbWjk DStehAgrWN /predict/ default replica.py:723 - __CALL__ OK 135.3ms\n" + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m INFO 2023-09-17 22:47:02,865 ModelDeployment default#ModelDeployment#aAAvxd 7abfafdb-67ae-4204-a021-9f7507e22f78 /predict/ default replica.py:749 - __CALL__ OK 3898.9ms\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=False, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=350914, ip=10.0.34.101) Running 0: 0%| | 0/1 [00:00MapBatches(TorchPredictor.predict_proba) pid=849454)\u001b[0m /tmp/ipykernel_841208/1209796013.py:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n" ] }, { "data": { "text/plain": [ - "{'results': [{'prediction': 'mlops',\n", - " 'probabilities': {'computer-vision': 0.2836063504219055,\n", - " 'mlops': 0.6331979036331177,\n", - " 'natural-language-processing': 0.045542024075984955,\n", - " 'other': 0.03765369579195976}}]}" + "{'results': [{'prediction': 'other',\n", + " 'probabilities': {'computer-vision': 0.010165845975279808,\n", + " 'mlops': 0.2043360322713852,\n", + " 'natural-language-processing': 0.05693763121962547,\n", + " 'other': 0.7285605072975159}}]}" ] }, "execution_count": 156, @@ -47423,7 +48724,7 @@ ], "source": [ "# Query (noise)\n", - "title = \" 65n7r5675\" # random noise\n", + "title = \"this is random noise\" # random noise\n", "json_data = json.dumps({\"title\": title, \"description\": \"\"})\n", "requests.post(\"http://127.0.0.1:8000/predict/\", data=json_data).json()" ] @@ -47439,9 +48740,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:09:26,631\tINFO router.py:329 -- Got updated replicas for deployment default_ModelDeployment: set().\n", - "(ServeController pid=123971) INFO 2023-09-14 15:09:26,626 controller 123971 deployment_state.py:1595 - Removing 1 replica from deployment 'default_ModelDeployment'.\n", - "(ServeReplica:default_ModelDeployment pid=124072) INFO 2023-09-14 15:09:26,587 default_ModelDeployment default_ModelDeployment#lxbWjk YyioOkOPpm /predict/ default replica.py:723 - __CALL__ OK 85.0ms\n" + "2023-09-17 22:47:06,943\tINFO router.py:537 -- Got updated replicas for deployment 'ModelDeployment' in application 'default': set().\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeployment pid=350914, ip=10.0.34.101)\u001b[0m INFO 2023-09-17 22:47:06,917 ModelDeployment default#ModelDeployment#aAAvxd 3c3a4798-af4d-45f3-a2b1-c73d15e1ce83 /predict/ default replica.py:749 - __CALL__ OK 4037.2ms\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:47:06,939 controller 840558 deployment_state.py:1707 - Removing 1 replica from deployment 'ModelDeployment' in application 'default'.\n", + "\u001b[2m\u001b[36m(ServeController pid=840558)\u001b[0m INFO 2023-09-17 22:47:09,134 controller 840558 deployment_state.py:2027 - Replica default#ModelDeployment#aAAvxd is stopped.\n" ] } ], @@ -47466,16 +48768,15 @@ }, { "cell_type": "code", - "execution_count": 158, + "execution_count": 162, "metadata": { "tags": [] }, "outputs": [], "source": [ - "@serve.deployment(route_prefix=\"/\", num_replicas=\"1\", ray_actor_options={\"num_cpus\": 8, \"num_gpus\": 0})\n", + "@serve.deployment(num_replicas=\"1\", ray_actor_options={\"num_cpus\": 8, \"num_gpus\": 0})\n", "@serve.ingress(app)\n", "class ModelDeploymentRobust:\n", - " \n", " def __init__(self, run_id, threshold=0.9):\n", " \"\"\"Initialize the model.\"\"\"\n", " self.run_id = run_id\n", @@ -47483,14 +48784,13 @@ " mlflow.set_tracking_uri(MLFLOW_TRACKING_URI) # so workers have access to model registry\n", " best_checkpoint = get_best_checkpoint(run_id=run_id)\n", " self.predictor = TorchPredictor.from_checkpoint(best_checkpoint)\n", - " self.preprocessor = self.predictor.get_preprocessor()\n", "\n", " @app.post(\"/predict/\")\n", " async def _predict(self, request: Request):\n", " data = await request.json()\n", - " df = pd.DataFrame([{\"title\": data.get(\"title\", \"\"), \"description\": data.get(\"description\", \"\"), \"tag\": \"\"}])\n", - " results = predict_with_proba(df=df, predictor=self.predictor)\n", - "\n", + " sample_ds = ray.data.from_items([{\"title\": data.get(\"title\", \"\"), \"description\": data.get(\"description\", \"\"), \"tag\": \"\"}])\n", + " results = predict_proba(ds=sample_ds, predictor=self.predictor)\n", + " \n", " # Apply custom logic\n", " for i, result in enumerate(results):\n", " pred = result[\"prediction\"]\n", @@ -47503,7 +48803,7 @@ }, { "cell_type": "code", - "execution_count": 159, + "execution_count": 163, "metadata": { "tags": [] }, @@ -47512,10 +48812,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "(ServeController pid=124218) INFO 2023-09-14 15:09:31,327 controller 124218 application_state.py:138 - Recovering target state for application 'default' from checkpoint.\n", - "(HTTPProxyActor pid=52887, ip=10.0.50.151) INFO: Started server process [52887]\n", - "(HTTPProxyActor pid=52887, ip=10.0.50.151) INFO 2023-09-14 15:09:32,987 http_proxy 10.0.50.151 http_proxy.py:314 - Setting draining flag on node 08c7b80ad4cca7d0486399f7e6cef170caf13128856ce8fe7a8ce7f4 to True.\n", - "(HTTPProxyActor pid=52887, ip=10.0.50.151) INFO 2023-09-14 15:09:32,989 http_proxy 10.0.50.151 http_proxy.py:314 - Setting draining flag on node 08c7b80ad4cca7d0486399f7e6cef170caf13128856ce8fe7a8ce7f4 to True.\n" + "\u001b[2m\u001b[36m(ServeController pid=850735)\u001b[0m INFO 2023-09-17 22:48:54,599 controller 850735 application_state.py:183 - Recovering target state for application 'default' from checkpoint.\n" ] }, { @@ -47529,44 +48826,47 @@ "name": "stderr", "output_type": "stream", "text": [ - "(ServeController pid=124218) INFO 2023-09-14 15:09:33,163 controller 124218 deployment_state.py:1308 - Deploying new version of deployment default_ModelDeploymentRobust.\n", - "(ServeController pid=124218) INFO 2023-09-14 15:09:33,266 controller 124218 deployment_state.py:1571 - Adding 1 replica to deployment default_ModelDeploymentRobust.\n" + "\u001b[2m\u001b[36m(HTTPProxyActor pid=850784)\u001b[0m INFO 2023-09-17 22:48:55,884 http_proxy 10.0.35.174 http_proxy.py:1441 - Proxy actor 8bf33b9832cc186ec5c3be470b000000 starting on node c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a.\n", + "\u001b[2m\u001b[36m(HTTPProxyActor pid=850784)\u001b[0m INFO 2023-09-17 22:48:55,890 http_proxy 10.0.35.174 http_proxy.py:1626 - Starting HTTP server on node: c268d87a05f14889a7bdc3c259e78ced37c574c65ab440657e85be5a listening on port 8000\n", + "\u001b[2m\u001b[36m(HTTPProxyActor pid=850784)\u001b[0m INFO: Started server process [850784]\n", + "\u001b[2m\u001b[36m(ServeController pid=850735)\u001b[0m INFO 2023-09-17 22:48:56,036 controller 850735 deployment_state.py:1390 - Deploying new version of deployment ModelDeploymentRobust in application 'default'.\n", + "\u001b[2m\u001b[36m(ServeController pid=850735)\u001b[0m INFO 2023-09-17 22:48:56,138 controller 850735 deployment_state.py:1679 - Adding 1 replica to deployment ModelDeploymentRobust in application 'default'.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Deployment 'default_ModelDeploymentRobust:nmDnEU' is ready at `http://127.0.0.1:8000/`. component=serve deployment=default_ModelDeploymentRobust\n" + "Deployment 'ModelDeploymentRobust:tMjDvR' is ready at `http://127.0.0.1:8000/`. component=serve deployment=ModelDeploymentRobust\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2023-09-14 15:09:43,112\tINFO router.py:853 -- Using PowerOfTwoChoicesReplicaScheduler.\n", - "2023-09-14 15:09:43,117\tINFO router.py:329 -- Got updated replicas for deployment default_ModelDeploymentRobust: {'default_ModelDeploymentRobust#VLnRHd'}.\n" + "2023-09-17 22:49:02,011\tINFO router.py:1226 -- Using router .\n", + "2023-09-17 22:49:02,015\tINFO router.py:537 -- Got updated replicas for deployment 'ModelDeploymentRobust' in application 'default': {'default#ModelDeploymentRobust#YziEno'}.\n" ] }, { "data": { "text/plain": [ - "RayServeSyncHandle(deployment='default_ModelDeploymentRobust')" + "RayServeSyncHandle(deployment='ModelDeploymentRobust')" ] }, - "execution_count": 159, + "execution_count": 163, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Run service\n", - "serve.run(ModelDeploymentRobust.bind(run_id=run_id, threshold=0.9))" + "serve.run(ModelDeploymentRobust.bind(run_id=run_id, threshold=0.9), route_prefix=\"/\")" ] }, { "cell_type": "code", - "execution_count": 160, + "execution_count": 167, "metadata": { "tags": [] }, @@ -47575,28 +48875,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "(HTTPProxyActor pid=52887, ip=10.0.50.151) INFO 2023-09-14 15:09:43,082 http_proxy 10.0.50.151 http_proxy.py:314 - Setting draining flag on node 08c7b80ad4cca7d0486399f7e6cef170caf13128856ce8fe7a8ce7f4 to False.\n", - "(HTTPProxyActor pid=52887, ip=10.0.50.151) INFO 2023-09-14 15:09:43,082 http_proxy 10.0.50.151 http_proxy.py:314 - Setting draining flag on node 08c7b80ad4cca7d0486399f7e6cef170caf13128856ce8fe7a8ce7f4 to False.\n" + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeploymentRobust pid=850829)\u001b[0m Executing DAG InputDataBuffer[Input] -> TaskPoolMapOperator[MapBatches(preprocess)->MapBatches(TorchPredictor.predict_proba)]\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeploymentRobust pid=850829)\u001b[0m Execution config: ExecutionOptions(resource_limits=ExecutionResources(cpu=None, gpu=None, object_store_memory=None), locality_with_output=False, preserve_order=False, actor_locality_enabled=True, verbose_progress=False)\n", + "\u001b[2m\u001b[36m(ServeReplica:default:ModelDeploymentRobust pid=850829)\u001b[0m Tip: For detailed progress reporting, run `ray.data.DataContext.get_current().execution_options.verbose_progress = True`\n" ] }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "(pid=850829) Running 0: 0%| | 0/1 [00:00