diff --git a/components/alibi-detect-server/Dockerfile b/components/alibi-detect-server/Dockerfile index b91c09c4fc..ca7f15b7d2 100644 --- a/components/alibi-detect-server/Dockerfile +++ b/components/alibi-detect-server/Dockerfile @@ -1,4 +1,4 @@ -# TODO: Add to release script +# TODO: Add to release script FROM docker.io/seldonio/seldon-core-s2i-python37-ubi8:1.8.0-dev LABEL name="Seldon Alibi Detect Server" \ vendor="Seldon Technologies" \ @@ -7,6 +7,13 @@ LABEL name="Seldon Alibi Detect Server" \ summary="Alibi Detect Server for Seldon Core" \ description="The Alibi Detect Server provides outlier, drift and adversarial detection services for Seldon Core" +# Install Rclone Binary to be present in the image +RUN yum install -y unzip +RUN wget https://downloads.rclone.org/v1.55.1/rclone-v1.55.1-linux-amd64.zip && \ + unzip rclone-v1.55.1-linux-amd64.zip && \ + mv rclone-v1.55.1-linux-amd64/rclone /usr/bin/rclone && \ + rm -rf rclone-v1.55.1-linux-amd64.zip rclone-v1.55.1-linux-amd64 + ADD requirements_server.txt . RUN pip install pip -U diff --git a/components/alibi-detect-server/adserver/ad_model.py b/components/alibi-detect-server/adserver/ad_model.py index fc8ed3fa88..0f88660cda 100644 --- a/components/alibi-detect-server/adserver/ad_model.py +++ b/components/alibi-detect-server/adserver/ad_model.py @@ -1,12 +1,12 @@ import json from typing import List, Dict, Optional import logging -import kfserving import numpy as np from adserver.constants import HEADER_RETURN_INSTANCE_SCORE from .numpy_encoder import NumpyEncoder from alibi_detect.utils.saving import load_detector, Data from adserver.base import CEModel +from adserver.base.storage import download_model class AlibiDetectAdversarialDetectionModel( @@ -34,7 +34,7 @@ def load(self): Load the model from storage """ - model_folder = kfserving.Storage.download(self.storage_uri) + model_folder = download_model(self.storage_uri) self.model: Data = load_detector(model_folder) self.ready = True diff --git a/components/alibi-detect-server/adserver/base/alibi_model.py b/components/alibi-detect-server/adserver/base/alibi_model.py index f770d5d6e8..514d8160b2 100644 --- a/components/alibi-detect-server/adserver/base/alibi_model.py +++ b/components/alibi-detect-server/adserver/base/alibi_model.py @@ -1,6 +1,6 @@ -import kfserving from typing import Optional from adserver.base.model import CEModel +from adserver.base.storage import download_model from alibi_detect.utils.saving import load_detector, Data @@ -27,6 +27,6 @@ def load(self): Load the model from storage """ - model_folder = kfserving.Storage.download(self.storage_uri) + model_folder = download_model(self.storage_uri) self.model: Data = load_detector(model_folder) self.ready = True diff --git a/components/alibi-detect-server/adserver/base/storage.py b/components/alibi-detect-server/adserver/base/storage.py new file mode 100644 index 0000000000..cd84d2f168 --- /dev/null +++ b/components/alibi-detect-server/adserver/base/storage.py @@ -0,0 +1,63 @@ +import os +import sys +import kfserving +import logging +import tempfile +from distutils.util import strtobool + + +logger = logging.getLogger(__name__) + +try: + from sh import rclone +except ImportError: + logger.warning( + "rclone-based storage funcionality not available without rclone binary" + ) + rclone = None + + +def _rclone_enabled(): + # IF RCLONE_ENABLED variable set explicitly we read from it + enabled = os.environ.get("RCLONE_ENABLED", None) + if enabled is not None: + return strtobool(enabled) + + # Otherwise we determine if Rclone config is provided + for key in os.environ.keys(): + if "RCLONE_CONFIG" in key: + return True + else: + return False + + +RCLONE_ENABLED = _rclone_enabled() + + +class Rclone: + def __init__(self, cfg_file: str = None): + self.cfg_file = cfg_file + + def copy(self, src: str, dest: str = None): + if rclone is None: + raise RuntimeError( + "rclone binary not found - rclone-based storage funcionality disabled" + ) + + if dest is None: + dest = tempfile.mkdtemp() + + args = ["-v"] + kwargs = {} + if self.cfg_file is not None: + kwargs["config"] = os.path.abspath(os.path.expanduser(self.cfg_file)) + + rclone.copy(src, dest, *args, **kwargs, _out=sys.stdout, _err_to_out=True) + return dest + + +def download_model(storage_uri) -> str: + if RCLONE_ENABLED: + return Rclone().copy(storage_uri) + else: + return kfserving.Storage.download(storage_uri) diff --git a/components/alibi-detect-server/adserver/cd_model.py b/components/alibi-detect-server/adserver/cd_model.py index a2b0dc7edb..46522527fd 100644 --- a/components/alibi-detect-server/adserver/cd_model.py +++ b/components/alibi-detect-server/adserver/cd_model.py @@ -6,7 +6,6 @@ from alibi_detect.utils.saving import load_detector, Data from adserver.base import AlibiDetectModel from seldon_core.user_model import SeldonResponse -import kfserving import tensorflow as tf from transformers import AutoTokenizer diff --git a/components/alibi-detect-server/adserver/cm_model.py b/components/alibi-detect-server/adserver/cm_model.py index e89d1e3725..6e83b03858 100644 --- a/components/alibi-detect-server/adserver/cm_model.py +++ b/components/alibi-detect-server/adserver/cm_model.py @@ -3,7 +3,6 @@ import logging import numpy as np from enum import Enum -import kfserving import importlib import pickle import os @@ -14,6 +13,7 @@ ) from .numpy_encoder import NumpyEncoder from adserver.base import CEModel +from adserver.base.storage import download_model from seldon_core.user_model import SeldonResponse from seldon_core.flask_utils import SeldonMicroserviceException from seldon_core.metrics import DEFAULT_LABELS, NONIMPLEMENTED_MSG @@ -73,7 +73,7 @@ def load(self): """ if "/" in self.storage_uri: - model_folder = kfserving.Storage.download(self.storage_uri) + model_folder = download_model(self.storage_uri) self.model = pickle.load( open(os.path.join(model_folder, "meta.pickle"), "rb") ) diff --git a/components/alibi-detect-server/adserver/od_model.py b/components/alibi-detect-server/adserver/od_model.py index 092decec63..dc1c3b19f7 100644 --- a/components/alibi-detect-server/adserver/od_model.py +++ b/components/alibi-detect-server/adserver/od_model.py @@ -2,12 +2,13 @@ from typing import List, Dict, Optional, Union import os import logging -import kfserving import numpy as np from .numpy_encoder import NumpyEncoder from adserver.base import CEModel +from adserver.base.storage import download_model from alibi_detect.utils.saving import load_detector, Data from seldon_core.user_model import SeldonResponse +from adserver.base.storage import download_model from adserver.constants import ( HEADER_RETURN_INSTANCE_SCORE, HEADER_RETURN_FEATURE_SCORE, @@ -62,7 +63,7 @@ def load(self): Load the model from storage """ - model_folder = kfserving.Storage.download(self.storage_uri) + model_folder = download_model(self.storage_uri) self.model: Data = load_detector(model_folder) self.ready = True diff --git a/components/alibi-detect-server/setup.py b/components/alibi-detect-server/setup.py index ffe43c4f48..efb26d1b09 100644 --- a/components/alibi-detect-server/setup.py +++ b/components/alibi-detect-server/setup.py @@ -17,6 +17,7 @@ "numpy >= 1.8.2", "cloudevents == 1.2.0", "elasticsearch==7.9.1", + "sh<2.0.0", # Fixes #2533 "google-cloud-core==1.4.1", "google-cloud-storage==1.31.2", diff --git a/components/drift-detection/cifar10/cifar10_drift.ipynb b/components/drift-detection/cifar10/cifar10_drift.ipynb index 2968253b88..b3faf5dfbd 100644 --- a/components/drift-detection/cifar10/cifar10_drift.ipynb +++ b/components/drift-detection/cifar10/cifar10_drift.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -37,14 +37,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "gateway.networking.istio.io/seldon-gateway created\r\n" + "gateway.networking.istio.io/seldon-gateway unchanged\n" ] } ], @@ -61,14 +61,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "namespace/cifar10drift created\r\n" + "Error from server (AlreadyExists): namespaces \"cifar10drift\" already exists\n" ] } ], @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -100,14 +100,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "broker.eventing.knative.dev/default created\r\n" + "Error from server (AlreadyExists): error when creating \"broker.yaml\": brokers.eventing.knative.dev \"default\" already exists\n" ] } ], @@ -117,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -166,15 +166,15 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "deployment.apps/hello-display created\n", - "service/hello-display created\n" + "deployment.apps/hello-display unchanged\n", + "service/hello-display unchanged\n" ] } ], @@ -191,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -241,14 +241,14 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "seldondeployment.machinelearning.seldon.io/tfserving-cifar10 created\r\n" + "seldondeployment.machinelearning.seldon.io/tfserving-cifar10 unchanged\n" ] } ], @@ -263,9 +263,18 @@ "Create the pretrained Drift Detector. We forward replies to the message-dumper we started. Notice the `drift_batch_size`. The drift detector will wait until `drify_batch_size` number of requests are received before making a drift prediction." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we configure `seldonio/alibi-detect-server` to use rclone for downloading the artifact. \n", + "If `RCLONE_ENABLED=true` environmental variable is set or any of the enviromental variables contain `RCLONE_CONFIG` in their name then rclone\n", + "will be used to download the artifacts. If `RCLONE_ENABLED=false` or no `RCLONE_CONFIG` variables are present then kfserving storage.py logic will be used to download the artifacts." + ] + }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -278,6 +287,20 @@ ], "source": [ "%%writefile cifar10cd.yaml\n", + "\n", + "apiVersion: v1\n", + "kind: Secret\n", + "metadata:\n", + " name: seldon-rclone-secret\n", + " namespace: cifar10drift \n", + "type: Opaque\n", + "stringData:\n", + " RCLONE_CONFIG_GS_TYPE: google cloud storage\n", + " RCLONE_CONFIG_GS_ANONYMOUS: \"true\"\n", + "\n", + "--- \n", + "\n", + "\n", "apiVersion: serving.knative.dev/v1\n", "kind: Service\n", "metadata:\n", @@ -290,7 +313,7 @@ " autoscaling.knative.dev/minScale: \"1\"\n", " spec:\n", " containers:\n", - " - image: seldonio/alibi-detect-server:1.6.0-dev\n", + " - image: seldonio/alibi-detect-server:1.8.0-dev\n", " imagePullPolicy: IfNotPresent\n", " args:\n", " - --model_name\n", @@ -309,19 +332,23 @@ " - io.seldon.serving.cifar10cd\n", " - DriftDetector\n", " - --drift_batch_size\n", - " - '5000'\n" + " - '5000'\n", + " envFrom:\n", + " - secretRef:\n", + " name: seldon-rclone-secret " ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "service.serving.knative.dev/drift-detector created\r\n" + "secret/seldon-rclone-secret configured\n", + "service.serving.knative.dev/drift-detector configured\n" ] } ], @@ -338,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -371,14 +398,14 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "trigger.eventing.knative.dev/drift-trigger created\r\n" + "trigger.eventing.knative.dev/drift-trigger unchanged\n" ] } ], @@ -395,14 +422,14 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "35.205.124.31\n" + "172.18.255.1\n" ] } ], @@ -421,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -430,14 +457,14 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "drift-detector.cifar10drift.35.205.124.31.xip.io\n" + "drift-detector.cifar10drift.example.com\n" ] } ], @@ -449,7 +476,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -523,14 +550,14 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 50, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -546,7 +573,7 @@ "'truck'" ] }, - "execution_count": 38, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -574,9 +601,56 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 51, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "☁️ cloudevents.Event\n", + "Validation: valid\n", + "Context Attributes,\n", + " specversion: 1.0\n", + " type: io.seldon.serving.inference.drift\n", + " source: io.seldon.serving.cifar10cd\n", + " id: 2c10fbe2-f43d-4ca9-a13e-2fce016f0f76\n", + " datacontenttype: application/json\n", + "Extensions,\n", + " datacontenttype: application/json\n", + " endpoint: model\n", + " inferenceservicename: tfserving-cifar10\n", + " knativearrivaltime: 2021-05-12T13:16:58.651766746Z\n", + " knativehistory: default-kne-trigger-kn-channel.cifar10drift.svc.cluster.local\n", + " modelid: resnet32\n", + " namespace: cifar10drift\n", + " requestid: 8ffc70d5-a672-4c93-bc14-25d2685a4407\n", + " traceparent: 00-c20604528630c8d71db5d6edde6075a3-e003ccb52bdfa884-00\n", + "Data,\n", + " \"{\\\"data\\\": {\\\"is_drift\\\": 0, \\\"distance\\\": [0.02034001238644123, 0.015247910283505917, 0.01797136664390564, 0.020757608115673065, 0.015546650625765324, 0.020235512405633926, 0.0174444317817688, 0.02709726057946682, 0.017980124801397324, 0.01426214724779129, 0.021082984283566475, 0.02285262942314148, 0.02567242458462715, 0.02408074401319027, 0.012295660562813282, 0.01230973843485117, 0.01437152549624443, 0.023169726133346558, 0.019348571076989174, 0.019863108173012733, 0.020116576924920082, 0.02951645664870739, 0.013265427201986313, 0.013755128718912601, 0.020870545879006386, 0.021712416782975197, 0.014476824551820755, 0.018704859539866447, 0.022685622796416283, 0.02446802705526352, 0.017233233898878098, 0.022092580795288086], \\\"p_val\\\": [0.2488422989845276, 0.6008104085922241, 0.3901328146457672, 0.2284145951271057, 0.5759391784667969, 0.25415995717048645, 0.42737877368927, 0.04996078461408615, 0.38953083753585815, 0.6837745308876038, 0.21339522302150726, 0.14460472762584686, 0.07283377647399902, 0.108327716588974, 0.8394819498062134, 0.8384828567504883, 0.6745736002922058, 0.13440917432308197, 0.3026794493198395, 0.2737903594970703, 0.26031363010406494, 0.025144921615719795, 0.765920102596283, 0.7260689735412598, 0.22311334311962128, 0.1865001916885376, 0.6657025814056396, 0.34173062443733215, 0.15022000670433044, 0.0985845997929573, 0.44285809993743896, 0.17158570885658264], \\\"threshold\\\": 0.0015625}, \\\"meta\\\": {\\\"name\\\": \\\"KSDrift\\\", \\\"detector_type\\\": \\\"offline\\\", \\\"data_type\\\": null}}\"\n", + "☁️ cloudevents.Event\n", + "Validation: valid\n", + "Context Attributes,\n", + " specversion: 1.0\n", + " type: io.seldon.serving.inference.drift\n", + " source: io.seldon.serving.cifar10cd\n", + " id: 78c8c780-5314-4602-ad95-08ec56950241\n", + " datacontenttype: application/json\n", + "Extensions,\n", + " datacontenttype: application/json\n", + " endpoint: model\n", + " inferenceservicename: tfserving-cifar10\n", + " knativearrivaltime: 2021-05-12T13:19:58.146586917Z\n", + " knativehistory: default-kne-trigger-kn-channel.cifar10drift.svc.cluster.local\n", + " modelid: resnet32\n", + " namespace: cifar10drift\n", + " requestid: fd258cd0-addb-48e7-a262-5117eca90605\n", + " traceparent: 00-9adc8d40ccb026d81bf9f7b56e26731d-8ca43007e2ea438f-00\n", + "Data,\n", + " \"{\\\"data\\\": {\\\"is_drift\\\": 0, \\\"distance\\\": [0.02534129098057747, 0.019455349072813988, 0.018564486876130104, 0.017164727672934532, 0.018880784511566162, 0.017182564362883568, 0.018239112570881844, 0.019043751060962677, 0.02446526661515236, 0.0168598685413599, 0.03348050266504288, 0.02682587504386902, 0.022839592769742012, 0.02329082228243351, 0.016494980081915855, 0.014509297907352448, 0.014447270892560482, 0.017970765009522438, 0.01854313164949417, 0.016967127099633217, 0.020245671272277832, 0.018110457807779312, 0.017264626920223236, 0.02135360985994339, 0.0264295544475317, 0.024911778047680855, 0.019677504897117615, 0.025282783433794975, 0.03149370104074478, 0.022254828363656998, 0.020830754190683365, 0.020097261294722557], \\\"p_val\\\": [0.07927045226097107, 0.2965146601200104, 0.3506747782230377, 0.44794410467147827, 0.33073702454566956, 0.44661688804626465, 0.37199002504348755, 0.3207682967185974, 0.09865134954452515, 0.47094887495040894, 0.007191904820501804, 0.053763918578624725, 0.14503692090511322, 0.13067291676998138, 0.4992358088493347, 0.6629649996757507, 0.6681933999061584, 0.3901740610599518, 0.3520488739013672, 0.4627872109413147, 0.2536394000053406, 0.38064056634902954, 0.4405378997325897, 0.20148807764053345, 0.05976467579603195, 0.08832921087741852, 0.2839736342430115, 0.08045630156993866, 0.013735480606555939, 0.16551445424556732, 0.22497043013572693, 0.2613232433795929], \\\"threshold\\\": 0.0015625}, \\\"meta\\\": {\\\"name\\\": \\\"KSDrift\\\", \\\"detector_type\\\": \\\"offline\\\", \\\"data_type\\\": null}}\"\n" + ] + } + ], "source": [ "!kubectl logs -n cifar10drift $(kubectl get pod -n cifar10drift -l app=hello-display -o jsonpath='{.items[0].metadata.name}') " ] @@ -590,33 +664,19 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 52, "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "22a5f0ced72f4c2d97e75d4d9a92a758", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=50.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "\n" + "100%|██████████| 50/50 [00:36<00:00, 1.35it/s]\n" ] } ], "source": [ - "from tqdm.notebook import tqdm\n", + "from tqdm import tqdm\n", "for i in tqdm(range(0,5000,100)):\n", " X = X_train[i:i+100]\n", " predict(X)" @@ -631,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 53, "metadata": {}, "outputs": [ { @@ -661,18 +721,9 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 61, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Logging before flag parsing goes to stderr.\n", - "E1224 13:55:57.815184 140147866126080 plot.py:39] Importing plotly failed. Interactive plots will not work.\n" - ] - } - ], + "outputs": [], "source": [ "from alibi_detect.datasets import fetch_cifar10c, corruption_types_cifar10c\n", "corruption = ['motion_blur']\n", @@ -682,12 +733,12 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 62, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -699,7 +750,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -711,7 +762,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -737,28 +788,14 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 63, "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0cda5e7e94984e3d91ff6910c8637955", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=50.0), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "\n" + "100%|██████████| 50/50 [00:37<00:00, 1.35it/s]\n" ] } ], @@ -777,7 +814,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 64, "metadata": {}, "outputs": [ { @@ -807,27 +844,20 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "namespace \"cifar10drift\" deleted\r\n" + "namespace \"cifar10drift\" deleted\n" ] } ], "source": [ "!kubectl delete ns cifar10drift" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -846,9 +876,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.10" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/components/outlier-detection/cifar10/cifar10_outlier.ipynb b/components/outlier-detection/cifar10/cifar10_outlier.ipynb index c758f91202..6832ae7ad2 100644 --- a/components/outlier-detection/cifar10/cifar10_outlier.ipynb +++ b/components/outlier-detection/cifar10/cifar10_outlier.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -45,7 +45,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "gateway.networking.istio.io/seldon-gateway unchanged\r\n" + "gateway.networking.istio.io/seldon-gateway unchanged\n" ] } ], @@ -53,6 +53,37 @@ "!kubectl apply -f ../../../notebooks/resources/seldon-gateway.yaml" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apiVersion: networking.istio.io/v1alpha3\n", + "kind: Gateway\n", + "metadata:\n", + " name: seldon-gateway\n", + " namespace: istio-system\n", + "spec:\n", + " selector:\n", + " istio: ingressgateway # use istio default controller\n", + " servers:\n", + " - port:\n", + " number: 80\n", + " name: http\n", + " protocol: HTTP\n", + " hosts:\n", + " - \"*\"\n" + ] + } + ], + "source": [ + "!cat ../../../notebooks/resources/seldon-gateway.yaml" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -62,14 +93,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "namespace/cifar10 created\r\n" + "Error from server (AlreadyExists): namespaces \"cifar10\" already exists\n" ] } ], @@ -79,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -101,14 +132,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "broker.eventing.knative.dev/default created\r\n" + "Error from server (AlreadyExists): error when creating \"broker.yaml\": brokers.eventing.knative.dev \"default\" already exists\n" ] } ], @@ -118,14 +149,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Writing event-display.yaml\n" + "Overwriting event-display.yaml\n" ] } ], @@ -167,15 +198,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "deployment.apps/hello-display created\n", - "service/hello-display created\n" + "deployment.apps/hello-display unchanged\n", + "service/hello-display unchanged\n" ] } ], @@ -192,14 +223,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Writing cifar10.yaml\n" + "Overwriting cifar10.yaml\n" ] } ], @@ -242,14 +273,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "seldondeployment.machinelearning.seldon.io/tfserving-cifar10 created\r\n" + "seldondeployment.machinelearning.seldon.io/tfserving-cifar10 unchanged\n" ] } ], @@ -264,21 +295,43 @@ "Create the pretrained VAE Cifar10 Outlier Detector. We forward replies to the message-dumper we started." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we configure `seldonio/alibi-detect-server` to use rclone for downloading the artifact. \n", + "If `RCLONE_ENABLED=true` environmental variable is set or any of the enviromental variables contain `RCLONE_CONFIG` in their name then rclone\n", + "will be used to download the artifacts. If `RCLONE_ENABLED=false` or no `RCLONE_CONFIG` variables are present then kfserving storage.py logic will be used to download the artifacts." + ] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Writing cifar10od.yaml\n" + "Overwriting cifar10od.yaml\n" ] } ], "source": [ "%%writefile cifar10od.yaml\n", + "\n", + "apiVersion: v1\n", + "kind: Secret\n", + "metadata:\n", + " name: seldon-rclone-secret\n", + " namespace: cifar10 \n", + "type: Opaque\n", + "stringData:\n", + " RCLONE_CONFIG_GS_TYPE: google cloud storage\n", + " RCLONE_CONFIG_GS_ANONYMOUS: \"true\"\n", + "\n", + "--- \n", + "\n", "apiVersion: serving.knative.dev/v1\n", "kind: Service\n", "metadata:\n", @@ -291,7 +344,7 @@ " autoscaling.knative.dev/minScale: \"1\"\n", " spec:\n", " containers:\n", - " - image: seldonio/alibi-detect-server:1.5.0\n", + " - image: seldonio/alibi-detect-server:1.8.0-dev\n", " imagePullPolicy: IfNotPresent\n", " args:\n", " - --model_name\n", @@ -308,19 +361,23 @@ " - io.seldon.serving.inference.outlier\n", " - --event_source\n", " - io.seldon.serving.cifar10od\n", - " - OutlierDetector\n" + " - OutlierDetector\n", + " envFrom:\n", + " - secretRef:\n", + " name: seldon-rclone-secret" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "service.serving.knative.dev/vae-outlier created\r\n" + "secret/seldon-rclone-secret configured\n", + "service.serving.knative.dev/vae-outlier configured\n" ] } ], @@ -337,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": { "scrolled": true }, @@ -346,7 +403,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Writing trigger.yaml\n" + "Overwriting trigger.yaml\n" ] } ], @@ -372,14 +429,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "trigger.eventing.knative.dev/vaeoutlier-trigger created\r\n" + "trigger.eventing.knative.dev/vaeoutlier-trigger unchanged\n" ] } ], @@ -396,14 +453,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "34.77.158.93\n" + "172.18.255.1\n" ] } ], @@ -422,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -438,7 +495,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -447,14 +504,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "vae-outlier.cifar10.34.77.158.93.xip.io\n" + "vae-outlier.cifar10.example.com\n" ] } ], @@ -466,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -545,14 +602,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -568,7 +625,7 @@ "'truck'" ] }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -589,7 +646,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -619,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -635,12 +692,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -656,7 +713,7 @@ "'truck'" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -675,7 +732,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -705,7 +762,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -721,12 +778,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABGoAAAERCAYAAAAjakGjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3debxld1nn++e39t5nHmseqcpQlQSSEAiEAEG4IAZUGidanFulr7fbsa/j1dYL0o6tdmvrFYXWtqHbiVZEASEyY4gxQOahklRVUpWazzyfvdf69R/70Lc65vn+KnvVyVnn1Of9etXrBXnqWeNvPeu3f2fXeUKM0QAAAAAAALD2srU+AAAAAAAAALSxUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARLNRscCGEnw4hvOdi/90L2FYMIVx5MbYFQAsh7F955uor//8jIYTvWuvjWkshhNeEEI6v9XE8XQjh7SGE9631cQCrgVr0T1GLgOceteifohatPyzUrDMhhH8RQrgvhDAfQjgVQvjdEMKI9/djjL8YY3zbhWz72fxdAJ17ts/xM+QfDSF8pRePMb4xxvhHF+dozUII3xtCeDiEMBNCOB1C+HAIYfBibb/Ecd20ciyTIYTxEMKdIYTvXuvjKiOE8LqVaz0fQvhkCGHfWh8TNi5q0UU7rg1Vi0IIXSGE96/c3xhCeM1aHxM2NmrRRTuujVaLbg4h3LZyLmdDCH8eQti51sf1XGGhZh0JIfyomf2Kmf24mQ2b2c1mts/MbgshdD3D368/t0cIIOXZPsfP8bH9k5oRQni1mf2imX1LjHHQzK4xsz9d7f1eQM7LzewTZvZpM7vSzDab2b8yszdezGN7LoUQtpjZX5jZz5rZJjO7yy7ytQa+jFp0Yfu9gJwNV4tWfM7Mvt3MTq31gWBjoxZd2H4vIGcj1qJRM/t9M9tv7TExY2Z/uJYH9JyKMfJnHfwxsyEzmzWzf/60/z5gZmfN7HvM7O1m9n4ze5+ZTZvZ21b+2/vO+/vfaWZPmNmYtT8MHDWzr1yJ/a+/a+0HIprZd5nZk2Z2zsx+5rzt3GRmnzezSTM7aWa/bWZd58WjmV251teNP/yp0p8LeY5X/v9/MbN/d178NWZ2fOV/v9fMCjNbWNnWT5z3vNZX/s6nzOxt5+V/j5k9ZGYTZvZRM9t3Xiya2feb2aNmduQZjvnHzOwD4px6zezXV+rKlLUn970rsX9mZg+s1IlPmdk15+UdNbOfNLN7zWzJzOpmtsvM/sfKtThiZj8k9vs5M/sdEX+NmR03sx81szMrdeq7z4t/jZl9aaVWHjOzt58XS9W/t5vZn5nZf7X2pOEBM3vJeXH3POxpNflpx/x/mtnt5/3//pX7fPVaj13+bKw/1CJqkapFTzv+42b2mrUes/zZmH+oRdSiC61FK3/3xWY2s9bj9rn6wzdq1o9XmFmPtX/a+r/EGGfN7MNm9vqV//Rmay/WjJjZfzv/74YQnm9m/5+ZfZuZ7bT2qvXuxH5vMbOrzOx1ZvZzIYRrVv57bmb/xsy2mNnLV+L/uoPzAi4lF/ocu2KM32Htl+SbYowDMcZfVX8/hPBmM/tpM/sGM9tqZp81sz9+2l/7OjN7mZk9/xk28Q9mdmsI4R0hhFeGELqfFv81M7tx5dw2WXuCVIQQDq7s50dW9vthM/vrp/107FusPTEYsfYk66/N7B5r16XXmdmPhBBufYZz6rN23Xm/Oncz22H/f537XjP7nRDC6EpsztoL1yMrx/CvQghf97R8r/6ZtSdbf7KS/0FrL1ZbCCG70PN4Bi9YyTMzsxjjnJk9vvLfgYuJWkQtAqqAWkQteja+wtqLQJcEFmrWjy1mdi7G2HqG2MmVuJnZ52OMH4gxFjHGhaf9vW8ys7+OMX4uxrhsZj9n7dVR5R0xxoUY4z3WfsBeaGYWY/xCjPGOGGMrxnjUzH7PzF7d2akBl4wLfY4vpv/LzH4pxvjQyn5/0cxueNrvPvmlGOP4M9QMizF+1tqTmReb2YfMbCyE8BshhNrKy/d7zOyHY4xPxRjzGOPtMcYlM/tmM/tQjPG2GGPT2hOXXmtPXL7st2KMx1b2+1Iz2xpj/PkY43KM8bCZvdvM3voM5zRq7ffXycS5N83s52OMzRjjh639k7arVs7rUzHG+1Zq5b3Wnjw9vYY9Y/1b8bkY44djjLm1f5r35dizOY+nG7D2T9/ON2Vma/7v3rHhUIuoRUAVUIuoRRckhHC9tT+7/vizyVvP+B0m68c5M9sSQqg/QzHbuRI3a39VzbPr/HiMcT6EMJbY7/n/Nnne2h8kbGVV+DfM7CVm1mftsfSF1EkAl7gLfY4vpn1m9pshhF8/778Fa/9U44mV/6/qhsUYP2JmH1mZgPwfZvbnZvaImf2ltX8S9vgzpO06b/sWYyxCCMfsf/8W3/n73Wdmu0IIk+f9t5q1f9L1dBPW/knTTjN7WBz62NOu8/k17GVm9stmdq2ZdZlZ98p5ne8Z658T61n5N+XP5jyebtbaXwM/35C1v0YMXEzUImoRUAXUImpRUmh3Ev6ItRfALpkaxjdq1o/PW/vfK37D+f8xhDBg7V8S9fGV/6S+IXPSzPacl9tr7V801YnftXYhOBBjHLL2VwhDh9sCLhUX+hzPWXsB9Mt2PG07qW/Cne+YmX1fjHHkvD+9Mcbbn+32Vn7K8nFr/7K6a609gVo0syue4a+fsPbL2czMQgjBzPaa2VPOfo9Z+9+Cn3+cgzHGr36G45i39rX8xgs5bsd/t/ZXc/fGGIfN7F12cWrYBZ/HM3jAzvvpVAih39rX9pL5mi+eM9QiahFQBdQiapG08k2nvzOzd8YY33sRjmfdYKFmnYgxTpnZO8zsP4UQ3hBCaIQQ9lv7Fzcdt/ZXzFLeb2ZvCiG8YuXfQ77dOn8AB639y6ZmQwhXW/u3igMQnsVzfLeZfXUIYVMIYYe1/z3z+U6b2eUXuNt3mdn/E0J4gZlZCGE4hPCWCz3mEMKbQwhvDSGMhrabrP1V2DtijIWZ/YGZ/UYIYdfK135fvvLvtf/MzL4mtNtNN6z9y+uWzOx2Z1d3mtlMCOEnQwi9K9u6NoTwUufv/4SZ/YsQwo+HEDavHOsLQwh/coGnNmhm4zHGxZVz+tYLzEt5tudxvr80s2tDCN8YQuix9ld8740xqp+OAc8atYhalBJC6F6pQ2ZmXSGEnpUPlsBFQy2iFikhhN3WXgT77Rjjuy7S8awbLNSsI7H9y7F+2tr/pnHa2r/M6piZvW7l3z6m8h8wsx+09i96Omntr9mfsXaReLZ+zNoP8Iy1/50hLWSBC3CBz/F7rf1vf4+a2cfsnz5fv2Rm/zaEMBlC+LHE/v7S2m0v/ySEMG1m99uza9U4YWb/0trdD6at3VXu38cYv/zLyn/MzO4zs380s/GVfWUxxkes3dr1P1n7J0xvsvYv+lt2jjM3s681sxus3RHgnJm9x9q/9O6Z/v7tZvbalT+HQwjj1m7h+OELPK9/bWY/H0KYsfaCyJ9dYJ70bM/jablnrf3TsF+w9nV/mfH7JLBKqEXUooRHrN1FZ7e1u+Is2HnfBgAuFmoRtUh4m7UX4N4eQpj98p+LcVzrQYjx2XxTDBtJaH+tcNLa/3zpyFofDwAAAAAAlzq+UXOJCSG8KYTQF9q/++DXrL3ie3RtjwoAAAAAAJixUHMperO1f5nVCTM7YGZvjXytCgAAAACASuCfPgEAAAAAAFQE36gBAAAAAACoCBZqAAAAAAAAKqKugu/+4N/Jfxd1/OEvuLGzRx6SO85zf9e/9/vvkblrJYQg46l/Rnbra1/jxnbt3S1zf+nf/7ob++J9D8rcKw9e7cYWp8Zl7gP3f0nGi+IZO8qZmdlyc1HmPvjAfW5sevKczF1a1h3Fm8s1NzY+Ni9zZ+f9427ler9bt26S8dFNA24sjzMyt9X0Y4sLeux94C8+qgdvxb2+9s/1CYpnLxsclKlhzw4/NqnvSZzTY8ky/7LHvNDH1dVwY++/529l7ltu/noZn7p5jxvrP74gc7O7D8m4UiyKmpCor/VdO2U8zs25sXxySuZWlromIfFzliLX8cyvkcncEm4r/nxd16Kv6v12WYvikv+OqG3ZLLdd7PNrUXb0pMyNC/p9K8dSpsdSqPvztfff91GZ+5ZXvUXGz92yy40NP67ra+3uR91YbLZkbmz6cxf5bJhZfed2ve0Zv3NsPj0tc9fquUwSxxXEe87MLLb0vUjVfr3xzn99w3qvRWZmtw5/j7wAxYw/h6nv9ecBZmb5Nr9zcnb4hMxVdbB9YGL+k6pH3d1u7GWfOi1z/+GtL5Dxxb3+OXedTcyNjvrXJJ+clLlyHJedGy37Hx7yc/qzVpnjKvNsllLV40rw6hHfqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAiqir4PTEuEzePLLJjcWt22VurA+5sdtuv1fmvv4V18u4cu/jx2X84H7/uD/7uds63q+Z2dUHr3Zjv/mud8nckPl94Scn9X1qNLrdWGukT+bu3bNDxlutZTe2uLggcycnZt3YuXP6nOpdPTJuoeaGRjf718PMrKffP+6p6QmZ290jHykrYsuNNer6uKanJt3Y8lKUueteTJxf5t/vYtYfZ2ZmtadOu7HW9LTOHfLrmJlZbPr3u5ibk7lZf78b+/o9N8nc+mV6HA7fddKNNXeNytzrP7/oxu55qd6vBb+Ope5x66kTHW+7NqrPKZ8Qz7U6ZrP02CxDbTvmJbdd+LG1POeqyxPXXdSifEy/17Il/32az8zo3MFBfVziuIsS207Wov16rGz+wpgba272a6CZ2Wvv9Gv3x2/Qz7wc44W+x6laFOp+Haxt2Sxz83P+9UhazedWXJMYE/vFmgndYv5/TH8eys6ec2P5oj8PMNPzl5Rifl5vW8Ruf2GXzK1do/fde59/TeZfuFfmxl8ZdmM9b9LnFJf92r+qc6NhPYfNJ6f8YNl5QIn54KWEb9QAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFaF7qTabMry85Mfn50WrMTPbf3C3G/uqV75Q5sYSbbteeOW+xLb9FoSvuuX1MvfEU7rV3dd+wzfLuBIL/5zn5nRrzdDyWwQvzOnWxUuJMdDX67f3Hh3ZJnOvuPz5buyhhx6RuRb0cS0t+a3whod0286G6O43Ne23AzUzi6bHfSHu48SEbte8ML/k7/dS72SnWg0n5KIF95N/fp3MvezndIvK2OMPpl2/+6TMPfONfkvcDx76jMz9Zwf859JMt79cfv52mXvXj97oxrr7HpW5+awY42XbTSs1/TMJ1U43ptoxr5WyrXgv+aLRGfUuLku1yS4+rlvD1n6gR2+732/T+9L33CNzv/Qmv+3snzz0MZn71oOd16LZb71Z5n74x17rxnoHDsncfMqv+2WVqhnquQ6Jn60m2oqvllDzW9KbmUUxB23/BWpRxxJzdCnxDilEC+7xvzkoc7f+aGJOJt7JU7+mczf/gD+eXvNXD8jcT3+F33LczKxYWHBjM7svk7mNP9zhxvpH/e2ambVOn5HxUtTzJeY+Zrq9e1zyP5NckNV67lN1cjXnmquAb9QAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEXIBuqtRd33PbT8XuTdXb0yd+qc38v+E5/7osxNCSF0nPtTv/Qrbmw60fN9MLHtnbt2u7HXvvXbZe74qRNu7J0/+VMy9ytueqkbi4lzmp6ekvEnn/CPq6vRI3O7uobc2Jat/rUyM3vy2KN62z19bmx2YU7mTk/7Y7Pe0GNraMjfr5nZwsK8G8tbMtVarcKNdXd36eSNLjGOO3X5T87I+KHv2ynj+/52yY099qvPl7n95+52Y2++4Q0yNxttyHhx7RX+fu95SuaaGGut6WmdW6I2p3JDrebG8nNjnW87NbZS57RKY9NC6ucsfr0ws9U7ro2u8Oc9ZlZuLAmN75PTNXv8u7fI+O5PLruxv/+pm2Vu17F/dGPfess3y9xssx6HrRuvcmMjH7hXb3t0xN/uVKIWlbGatUiJibG3RmJe4pkwoxaVEFuJiaNM7vzdtvln9Rzj0Nv8+b2Z2ZV/6s+thn5B17rWYX9u9OlvfpHMDaN+HTQzW3rR5W5s8x/cIXNrmze5sdbYuMyV7/PUc5/59SYlVY9CYx1+toiJuc86wzdqAAAAAAAAKoKFGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKoKFGgAAAAAAgIqQPdCW5nUb44Fev/3y0KatMvfFL7zBjb32lhfL3DJS7ah7L7vajf3H9/yBzF06fKjjfX/yT/+bzDXzW+Hd/TUPy8xXv/wWf6uNpszdsWOXPqzot7KenNCtjb/4Jb/1Zr3RLXP7B3Xrv1buX+vl2UmZWxPLl1u3+u33zMzyXLf+Gxv3r1dmurV3ve4/riMjwzJ33Uu1H0y1zBVqV13pxhb36Ot68PdOyng857dk/LuHPyNzXz/23W7s0Dfo5+Oml+hadPw/+GOtt1e3xgwt/9kKRxJta+t+HYtN/eykWonKNqWJ9rC1Eb/Nbz4xIXPXrLVsmTbRq6lEq9B1YRVrUf2yfW5s9ho9p7ryPydq0bg/jj/84Kdl7te8/E1u7OQbdsvcga8/JePFu/32r+HW62Ruz7hfM7KnTsjcIN6nyZbHq1mLNo26sTzV4hf/u41ei+wCxmqJ90Dtiv1ubHFrr8y96rePy3gh5kYfe/TvZe4br3qVG5u73H+Xm5md/PZFGR/+qF+PRm7xP7eamYUF8Xkq0QY76/bnRsVi4p1S4p2TtJqtrtXYLDOvKjsnW63j6rAe8Y0aAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKiIugp2i77uZmbN2qAbW+gdkLlHphdkXDk0ofuYHxztcWNB9Uc3s+/6kXe4sR/6Nz8sc3/v3f9Zxv/+8XMyrjXdyMzktMw8dOSIG9u5c4vMbTTkELGde3e4sV0iZmb25KljbuyR+/yYmdm2nVtl/OiT4lo3C5lbLPvxvJ7L3J6ubhnvrvvP1MKi3vbQ0JAbq9f1fuErjvpjLdvm1zgzs0feOSrjB773lBt745WvkLl1e8SN7d50ncyd+OFxGW+8wR/jjVMzMjdMz7qxVtS1OTaXZbwUVduD/plEPiVqaOKdkZS4Jh1LHVfinC2KepPVdG7h54as5PWquqjfH6U2Pe0/e93jutYMv3dKxide788h3njglTI3G/Jzl0b1/d56qz//MDOb+rbtbmzT3RMyN8wvurFW4vmIrZaMlyKen1DTz1Y+Ls45cU6pba/aOadqXKqeqFqUqnNi3xu+FpWVuC+h6Y+X2rweSz/88b+V8d+4+oVu7I2X36yPa59fM45/pX7vHfiOh2X8xA++xI01TukaGxb9+U2qHhVLSzJeith3EJ9JzMrN2bIe/7O4mVmx7L9XZE1IKTtnWyWd1iO+UQMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFVFXwb4+v1e9mdmZyZYbe+zYMZn74AP3y7hycM+exN/ovB/95k1+3/cb9410vF0zs6/66ld1nPs93/8TfrCl+9z//Wc/5cb2XXaZzD141UEZ37x52I1198jhZcND3W4sa03J3Lklvca4MO+PgYXJGZmb54turKe3IXNnp/W2hwaH3Fh3T03mLi833dj8/LzMXfeKvOPU0OiS8dj061jIC5l71b+dlPGiIcZLobcddm5zY0NfPCFz48ErZHx+m/9s9t5xVm+7Wzy3g4Myt5iddWOhpsd/bPn3KSVkofNtZ/q4UmMziOuVEpc6f5eVeWbK5Ja5T+tCjJ3nBj0O87FxN9YcuFzmTn2THmdBhFP3rNg26sb2//FxmRuvOSDjU1f47/JNHz0nc63Hn69lfX0ytRDvzFDX7/nY1HMui6K2Z3pepMZXqpYk64WoZaGhjysuJ85ZKVOLSjxvG74WmVmo6/sWuvz5T7GwIHNbT/if44or/fmJmdl/eNHNMp6N+McVl/RYy0f9Z/vq3zolc+OB/TLeHBDBCf25JI76n4dqiblRPuN/dkjd41LjXNWqhNRxFYv+Z6n0xvW7UtaFMu/oVRTzzuog36gBAAAAAACoCBZqAAAAAAAAKoKFGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKkL21hrZtEUmP3bskBs7efSIzO1r+G0EZxKttb7tW79Dxv/qv7/XjYVEy69aI9GKtYRvesVNbmzgutfK3ANXX+fG7vnsR2VuLfit7pqJdmFnz43J+HXXXePGrjyg24nu3bnVjQ3c/CKZe+/DT8r40qLftnOpodvRFea30C6iboN36pRum9wl2msOj+p2h2ZzbmQh0WZxvctEG1azRBvAVPtB0Tr0sW/T+z3wg7o17am/8Nvb7/p/9WHFw/62mzdcKXNrs7q95ZbP+uM0Br1+H/r91pj56TMyV29Y7zfZ+lu0t4xFol2jeC8k29YulWg922G7RrOL0EIYHSnT9jk1xi364+HoW3TqwdvOyvih9/jv1Cv/UI/DxoNPuLH5l+j3fGNWvzMve7/fgjsfn5S52XV+fS2OPyVzy6gN+XMEM7N8etqNxWbnrXTL5JqZhZqY36ZqpGobvprtgyHVturPacWUPxbLtDE+9jq/vbaZ2eWf1nPSx37mWje263O6HvV94n43Nvs6f7tmZl3TTRnf/0G/5uSJz0Pxqr1uLDx6WOZaJp5N9dyaWdbbK+PF7KwbS86NhFV9rkuMzcrWow7PiW/UAAAAAAAAVAQLNQAAAAAAABXBQg0AAAAAAEBFsFADAAAAAABQESzUAAAAAAAAVAQLNQAAAAAAABXBQg0AAAAAAEBFyGbjjz9+p0x++PHH3NiJk4/L3Hxmzo0NhiBzY6IX+WKz8/7rv/pTP9pR7EJ8x8/8jht73y/+gMz9qR/4uBt75fveLXPPTo65sWueL1Pt9QevkfG52QU3VuR623F52Y09cMfnZe6Bq26Q8e27R9zYHXd+RuaeOj3txprNlsxdXPDPycxsYmLGjfUO+MdsZlbEwo3NzfvP00ZQLC6u2rZDd7cb2/u3upYsvOlGGd/5Dv++PPGzus7t+P2r/GCRqIFbBmR88LOn3NjJb00887v9fV/5y+Myt1hacmOqHpiZxRkdD3X/dRbzRDFS+xXHbGaW9fXJeLHg18hQb3R0TGZmsdXsOLe9b3G9WrrOXcqK+flV27YaS5v/QY+V4pXXy/jz/905N/YVf/WAzP3Ut7/EjXWP6dqc9yeO+/En3NjhX75J5vae8mvonqc26/3OzLqxVC3Kp0vUokTtltut1WQ8tWVVB7MufZ+iKDdl6mt75+K8UhPJS1zrpP8uL0vNjbrH9fyl9rw9Mn7wN4+4se/6tJ7//9HrXuXGBh44I3Nb24ZkvLjnITf26G+9TOZuvtv/7sO2J/X1KMYn/FjinZOao6zW3Cg194mJz0uW+WMoVYNNrAOUrUdVmxvxjRoAAAAAAICKYKEGAAAAAACgIlioAQAAAAAAqAgWagAAAAAAACqChRoAAAAAAICKYKEGAAAAAACgImR77js+c5tO3u63j73imutkbu+y32p4SrRNvBCPHTrtxlKtvf/2zkk39oabdPvkd777kzL+3l/4fjd27Q23yNzDx/32a61cn9OTZ/y2bz0DT8nc4aFRGb/8iv1uLCbWARcm/ZZzD//D3TI3Lvjjx8zs2lvf4Mauu/5yfVx3+e25H3/sqMzt69NtkYdHVMtQ3VJuetq/j0tLq9cytgpCo0vGYzPRyk8Rrfwas7oVX0i0Wo33POzG9r3zoMwt7rnLjWXXXy1ze+46qbd94HlubPvv+/s1M4s3+vtOtlSUG9bXMuvpkfFSLdyD3yYyNfZU+20zs9Dl55dqq1myTWSpfHG9UvdxvSvTjj3r8dvdmuk2rPUFfV27jo/LeOuI3wb7M29M1KLjfsva+p7dMjeb1fO5sGuHG7v8J3Sb3toL/DlokmrhmhjDq/o+Emq7/WtlZtZ6Us/nVAvuZP1czRbatODuWDY4KOPFnF9Tsv5ELRPP7tCTeg4ep2dkPB/z69Uf3ni93vbyWTeWqs8m6qCZWW3bVjd24IfvlLnN19/oxlJzo2JBPH+peiTaqJsl5hnqXZ5yuT+PNDOLDzwi42pulJxHrOIcZNXmRh3iGzUAAAAAAAAVwUINAAAAAABARbBQAwAAAAAAUBEs1AAAAAAAAFQECzUAAAAAAAAVwUINAAAAAABARbBQAwAAAAAAUBF1FTxz7JxMftELv8aNdXf7vejNzDbV/Njrbn29zP2P7/pjGT/22LgbWy50v/mZuODG/uKDvTJ3x55dMv6OP/q0G3vq2EmZ+3t3f8qNDQxvkbljs3NuLOvql7lFsh+9iBc6c6BnyI3t37VX5vbU9HFlNuvGrrv2Mpk7MjLixj648DGZe+rkhIzv3uaPkTwsytxGw39cp6enZe56lw0NyHgx5Z9/1tenN97t14TGnY/o/c75z5aZWRDbjg88KnOznh4/eOiozM2XmzIevvSQv9/Nm/S277jXjSUeeS0EHe7q0vmL+vmR26433FhsJa5l4rhis9XRMbX3LXIz8RK9EEXeeW7yvbBxhT07dfzIMT/Wr9+3WeE/QcPvu0PmthLjob5ntxuLiWenNjrqxoqJSZlbzM/LuInaXRsZlqn5A6I+p54PNf5TubFUpetY/tQp/RcSz3RsiRpb5pwTtTupTD0pu+91LtvsP5tmZkFdnz07ZG59fMqNDf7FXTI3L/Q9rQ378/9CfCbj3JwAACAASURBVGYxMwt1fy5czMzI3NRYy0+fETvWY63xMf+a5CXqkZwLmpnV9Lbj0pIIJp49cdzx0SM6N0EeVzJZHHeqJpQ45+S8aRXmRnyjBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqwm9Gb2Z9A5tkckO0C5+cFL3ozax704gbm28VMndxUYatd3TQ32+R6K++6PdIj/JqmS0252W8p9ffQBaWZW6R+bkDm3fJ3K447sZqvaMyN3aJfvJmVgT/nEPeL3Ozmn9Ojf4umds7oOOtpRk3NvbUaZm7uX+rG3vzV98qc++656iMzy7493lx6azMXVpYcGMjg/7ztCEE/dzGVsuN5dPTetMNfyyFRuKhz/TzEZeWVic3iuJ7AaIosXFKX6/VEmqJ6yHu8WpKHVfW3S3jubqPiXEt77O6ianc1L5D4mc4hf+e3OhCU4/D2PRrfH5W1/hSEvek9dQJP1iynqyWuNzUf0GN4RJjNPXMJ5+9VRJbJa6HmcW8xHMrxkio6/fkqtZuNXYT79gNYVG8X8ysmPfn6PGhR2Vu6PLnRrFI1IzE85dPTul8odR4So2J1Xq2E9cjiHlE6O/Tm56d0/tWdSFV+8X1iIl3YZn3StaXOGcxrpNzyVQdXK0xkJrvOfhGDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARsqfezuddJpND5q/zLC7qFq+np/1dd41skbnNlm7NHBoNN7YwO6u3Hf1zqtd1G9ZWTcf7hobc2LbNkzI3jvutmZcTLdJC4Z9Tb2+vzE11siuiaIucaIGWNfyNx5peQ5yd89tvm5mFwm+v1i3GrZnZ9Fm/fXdvn25Z/xUvv17GH3n8CTd2/4OnZO7stN+Cr6vRI3PXu2JK3+8yVDvdZDvUMm1t17LFcYdtAldzv6mWm6Vay6aoFpSJNqTFwqLedplrrQpwqt1niZa5Wbf/DjUzi7mo3eJ52giK0yVabJdpx76W214jqWc+2UZbbVuM/2TdXysh8bPV1DulTJveErU76++X8WJOtBcu02J7Ld+xz5F8bELGy7Syjkui9XfZOUSJd1spq9V6uSxR62KiBbu8T2arNt8Lmd5umUudav2t5jepMV8bGZbxfEqsX5R5z3b4DuYbNQAAAAAAABXBQg0AAAAAAEBFsFADAAAAAABQESzUAAAAAAAAVAQLNQAAAAAAABXBQg0AAAAAAEBFsFADAAAAAABQEX4jcjOLQfS5N7Om6HM+PzMjc7t7e93YzPS4zF1O9JSfn/b33Ui0QB/s73ZjW0c3ydyhTf0yvnXEP+e8rvu6L3T713p83y6Zu5Sf9IPNeZmbt5ZlvCj8C5pnhcwNDX98jWwa1fvNE8ctxubwsH8fzMy6gt/rfnJmUubG5qyM33DNDjc2MuiPPTOzv/mbj7mxs6fPydz1LuZ5x7mhLsucxZY/Viz6Y8HMLHTre2aFnx9bTZ2b2LeU6dotd6uuR1lB/GwgUZutSIyBIDaQuJZlxlds6TpX6j7GMseVuI9ijBRL+h2bqXGfJZ6JdS4u63eiErq61mzbKl7M6fepRTHGy4zvlMRzWea5lfVC1SmzdC0qQx1X2f2WqkWd5xZzczKu3qPJZ0Lcq9DQz8RGUOoZSM0T1Hgr+9yrmrKayhy3ejZT8dQcRLyvS8/JSp2z/3wljyt1vcRxxWbn78KUfHJKxsvUjeS8vgN8owYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKoKFGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoCN23NtGauV748eEeveO9w37brqsvH5G5Az26vXJNtBObm9btlRfn/bZdvf267dZVB3T77r379rixrLFP5s5O+se9d+dOfVxHzrixoU36Rm0aHZLxel20/Ex0hIuiM2BPf5/MbS3qtnCZ2Hcj0+uTi+a3pt28ZUDmzs7rNqdzk6fc2O6tW2Xu173pq9zYBz70dzJ33Uu0JVUtuMu0EJRtiM0s5okW9D0if0HnyuNOtT1MXS/VfjDT2w6qHWpNP1uy7XPpdp+r04Iy2UZ0NdsTryY1RhLjS41N9SxuBMl2uOLaxUTb8063a5ZuYxybop6UaPusWiubpc9ZjpdUm+zgP3shUcfkfVzN9tspshat4XEpJdrwmukxkqwnNTGRLNO6er1YzblRVYnxFrp0a+VkDU61LO9QqKVae3c+B1m397GiVGvwVOtu9ZmhWO6sdTffqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAiqir4KtffqNMvvz5L3RjJ556Subu3rXJjR08cIXM3bF1m4zXot+vfmZmUuYuNefdWMj87ZqZDfT36/hAjxurdfXK3Ebh93VfmDsrc1987T43tv/gfpnbLHTf9yjW+lpFS+fW/OtZa8ihac3FKONF0993Vtfrk6FH3OdE7lJTX696reHG8mU9NrduGXBjt7zqpTJ3vcsGB2U87PRrQn7ocb3x6I+lYnFR77eux2lc9p/bmOf6uOSG9fhPprfEOA2J9fvCP+7Qo++TiesZGl0yNTb9a1laLESs3LVeM1lNx8V9TJ2zGruxpev+ehfqfg03M6ttHnVjrVOn9cbVPVP3y8ws6PnJaolLS+Xy1XhJnZMYp9nQsEzNJ6f83XZ3692WPGcl1PwxEFNjoNSOO7/Wq1kjk/WkEPtezetVFYn7lo369Sg/qz87ZD3+Z5bU3GitqDnXBVmlMZMN+/fBzCyfmHBjqbnRaipVj9Zq7lSmliWk5qGxJfbd4X75Rg0AAAAAAEBFsFADAAAAAABQESzUAAAAAAAAVAQLNQAAAAAAABXBQg0AAAAAAEBFsFADAAAAAABQEbK37I3XXy2TX/Aivz33wrW6xXb/8JAbE41SzcwsptrRiRbIm/p36G2LpavUqlZR6CNviZbRlmjrvLS04MauuPJ5Mre3y28bvjDnt6g0M4uZbj9swY/HkGihLVqV5Yl7XKiWjGa2vOBfr7zQbdSzur/vLDEKZsb89u5mZk8cOebGXnnLi2TufHPGjfWpluIbQDE7K+PZ8bVpw5lsHVrVVsWy1WrnbYDLtMZMtt8u03441RZxvbbgFkKmr1dtu/8ubJ08pTe+Aa/XhUqN09aZc51vvExr2OQYX4etilPnJGpCsZBoH6zq2Cq2306JLT0XXDOq/oZyP/OtbRpxY/nYuE6+FFpwK4lnJD/XeT1a1RbcZd4hVX3/ZKKVdWpupHLXsCbEXDxf4pjNrNyzWabFdqoeJd6FWb//GbGYm0ts++KPTb5RAwAAAAAAUBEs1AAAAAAAAFQECzUAAAAAAAAVwUINAAAAAABARbBQAwAAAAAAUBEs1AAAAAAAAFQECzUAAAAAAAAVUVfBXtFL3MxsoKfbjfX3yU2b1f3+60WiDXlI9FfPRLyIhcwtmn68SPRHD5le92qZv+0s1TJe9IUfGNmk95v7+80L/z6YmVmhDyya348+S51U7sfzeiOx38QgaS27oVD4x2xm1i2uSSPX97h/UV/PeHrBjZ09fFrm7rlqjxs7l83K3HUv8ezFZf9+41lK1Fd1L+LS0kU+mAvbr5mlj7tTJa7HqkocV2y1dHxuvvNd1/33e2q/G17i/YKLaK1q0WpS9aSitSgk5nqpmhAaYr6XOqdMzLkuhWdRnb/ZpXENqkJc62Ju7jk8kOdGqCU+75QZeyXme6Gh1x/ikj6uUnMYVaM7rM98owYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKoKFGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKkI2Gx8c3iSTY63hxuaXlnXu0pIbW0rkzs3qfvTLTT9/aakpc1utwo01mzq3KfZrZjY/P+/H5mb0cRX+cQ1uGpa5g8MjbmxkcIvM7enqkvG8EOccdC/6zPz44GCPzB07o6/14sKsGyuKUZkbzD/nIvfHrZnZ0GC3jO973nY3tjCvx3Us/Os1PNgvc9e9rCbDobfXDy4s6G0Hf7065rlOrenjUvkhCzq35d/v0NDPZZLYd6jL14KFHn+Mhx793JqoY3E58c5YWNSbXhTPZtT3cV2KUccTz0w+Pd35vsUzY0GP640u6+tzY3KMmq4Jqh60k0tcd3U/zcwK8fwkxlly1w1db2SumJ9kA52/E2PiPlnivVCI+W2S2HZqDKRqt8xP1RO13cT1SGmdPNVxrnoHx+i/bzYM9WyaWej239epd+56FOr+59LS2651/t0GOUc1k3OypEI/u4X47JmqZVFtO/V8pd4NKj9Vj0Q8Na6TdbJM/S5RRz18owYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKoKFGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoCNmj6gMf/IhMzhufdWMTE6dl7uzUOTeWJbpbpdp3nz7t7ztPtDHbtHWbGxvdslnmdtd0y6+58Uk3dujRh2Tu9KzfbnrvZftkbq3ht6sbGtTndNllz5PxPXt3+LmX75a5m7r9dnSDPbrFXjE8JOMmWjY2c93islb31y9r4pjNzLbvT7Q7H/JbJTYTLYRroiPzpk2J67HOZb267XOynarKbXbeojLZiE+0zoyx83aMsdXsOHdl536omWgBu+zvO46Nd3xIq6pM6+JVaLd4wdRxJ44r1TpetQNNtQGW7XjX8no9B2ojwzJezM75wUQ709jq/Nql7rduzdx5e+X0fnWtUq1QU21UrfCvZ5mWz6WJtrRZV2JuU6LVdbKFexmq1W6JFtFmVqoleel34TpXS3wuKaZm3Fjy2S1T51OtmRNjpuNtJ9pcp+Y38riirkeqXuUTE3q/q0nMI5LzBHU9Gonnuui8HqVqf+jyPxDJduRmZiHxHZUStW418I0aAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgI2aj8tk/eLpNH9lzlxmI+K3O/dPsn3di+PXtk7pbNm2X8qeOn3Fgr0QO9b9OIG1vOCpl7+vgxGX/dTS93Yzdc/wKZO7+06Mayhu43f+TJJ9zYoUcfl7n33f8lGR8ZHnBj3/hNXy9zX/mCg26sK+o1xD0798r4cq3mxkIWZG4Roxtrmh4/WV3Hu0d63Fhvps+5qC27sYbMXP9aL/HHiplZ435/jOfjEzK3Njrq507o3KTMH4e1zZtkaiH2HXM9zuo7tst466RfIy1RI2MiroTubjdW27ZV5uY7/PtkZpbN+89H/uChxIGJZy8mrvXuXTIe5xfcWGp8hbr/ZKfGQGz616O0EmNgvVu86YCMd//9Q24szs3J3NrIsBvLJ6f0gaWoWjTQL1Pz6Wk3lhpnqeejdeKkv+3CfxebmdnSkh8L+j2vnq3a7h0ytxjq09teELXo0cMytwz1LjMzMzH3ycfGO9+xGFtmZlHdp7LEfO1SMP+yy2W85+/udWNxqSVza0NDbkzVhAsins/Q1SVT1XiKS/rdpGqsma6zqXoUl5syrmQ9/meDbLueG8UBXY9MHFeZehSbevyExGdTdZ+LmRmZmw0O+jGZaVYs+HMyMytVU9QcN3W9PHyjBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgI2TvrLd/ynTK5e5vfpnJ+RrR/NbNH77vHje3coVsvZ4k2xr09fku55UK35Tp4rX9Oozu3ydz5Lbo14te+8SvdWN9gr8ydE+25C92F0lrRbyu+2PK3a2Z25oxu2fjEkRNurK/Pvw9mZqeOj7mxow88KnOzRX3ch0+dcWM3fdVLZO6+/X470Wau26tlPbqtoDX81oGhSLRuC35uV9Ct49e77DN3y3gh2vzV9+l6kp887QcTLV5NPFtmugWsbC1r6fbLMnduXsZV201LtFSMi/5xp9pqqvaw1ko8W4/4LdjNSrYLTbTglql9fltNM7PinF/nQj1xrVezxTY60vjYXTIetmx2Y9mVz5O5hXrvJWpRsl6IFvSp3KxftO9OtDLNz5zThyVqRpZoG67qXOjVc6pQE/PIPFHXT5yV8VKtruWOy72P8olZN6baA5uZFYk5F9ZG94f+UcZre3a7sXz7iMzNv/igH0y0ZA/qXW9msSXqRqINtmrNrOYnZmbFgh7H8jmo6XM2WUfFXDChOJeoJ4m4POdkTfHvRUhcj1S8mPXrUeq48okJP7WRmIemqH2L96iZWdbnt0ovZuc6Ohy+UQMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFVFXwe4uvY5z6OH73dj01CmZG0Vv9ubyssydTfQiD6IHek+37mXfnJ9xY1Nn/WM2Mzv95DEZ/8hHP+LGJmb8/ZqZTc1OubHBoSGZOzy6yY31D3XL3OPHT8j4ti273VjP0DaZ+9kP+ddj/NF7ZW6+3JTxx06ddmPH5/S1PnDNATc2PNQnc4dHh2W8t6/Hz+3XY7PRU3NjfX36Pq57ol6YmcWlJTdWnDmnc5stPxgSa9lFnti2X8tyETMzq23Z7O92ZlYflrgeZvp6maifZmZZtz/W8okJmau2nfX2ytRiYUEf1+Cg2K0+J3W95LUyMzudGF+p/NWS+fXCzCxk+poosaWemc63uxEUk/67Oqvpe1Lkop6UrEUW/Xgxp+dU9cv2+cHEu7gYG9fxxUU3lqvabGah4U9hY2JOJbe74B+TmVlMzFGzPjFPyPR9DHUxLVfjw8xyMfZSisXE+FESz3zo6tJx8VzI97Ppd2yqBl4KinH/nVxLzKtaIh7q+trGlq4LMjc5N/I/0xRFkdi4Pudift6NyWfTzIKYw8TE/EW+U0vKevzPHWGgX+bGef+4g5gLml3AfHCVpMZPsi5EMYYS79l8arrjXA/fqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAipBN4WfGTsnkT/zVh9zYsVPHZW7W9Huz33uv6ENuZhaCDLdUP/og+qOb2W1/8wk31tXQPeNveNGLZXy5a9CNTS/Ny9zDT55xY2NjD+n9LvrnfOLUUZl75Kje9ktedKMb+6Hv/79l7p13fN6NtabGZO700pKML1h0Y4fvOiZzP/uFk26sv96UuY2umozXuv0xNNjfkLl79u13Y2/+xrfKXP8ubQy1oSE3FvNc5oaauGdR1wvLZAmVYuGPUTOz/Jz/DGT9/Xrby3qc6mR9XMXi4qpsOzZF3Taz+o7tMt466b+v8tfo2tz4x0dkXMmnE+8rIdT1+AmiXhTz+p1hhR73qaGtyONWz9MlIPT2urFickrn1sU7oGQtStUbpXXkCX+3qVqk5mMpqTG8JOKJeWKqzin13btkvHX8KT9403V626cn/WDinMKCrs2x5b8X5HvQzCz4P9dV2zUzi4n5Wud3wuQ1yXp7ymx5w8tP+58rzMws88dE6p4nqbGceDbVuz40umRu8rjFcaXmknFmpqPtpmSD/mdHM7Owc5uM548e9nOvuULm1k6Jz2KpmjGVmBuVmYSUkXivrBb1OUXhGzUAAAAAAAAVwUINAAAAAABARbBQAwAAAAAAUBEs1AAAAAAAAFQECzUAAAAAAAAVwUINAAAAAABARch+jju375TJB/Zf5sai6bZb9cyP1xJtzLKaXl9SbSi7enQrSWv47fx27dotU19z660yPtjX58aGe0Zl7oP33+PGDj32uMzdsXu/G1uM+lrWev1jNjO7/9DDbuzBQ4dkbt/+a9zYiRP6eoyO6Pi2Lr9FX9+A3z7VzGz8lN+KdOypx2Tu2XOnZXwx98dms9Dj/uSk/7i+4nWdt/5bD1JtjFWLZNXi2Mxki8Bkbopq55jrGhl6xL6zRA1sLsu4bGkq6pSZWTE3p7etdivuY+qYW6fPJjbun1NtUbcIVueUuh6lWssmlLnWayWI2rshiJa1ZmbF7KyfmqgnMYp6kWiFGlLtX0W9SbWdlc/tcqI1c6I9t9p2aiwlW9Sr/Yo2vql20q0Tfnvg5H6buu63njjmxrIe3W66TN1Pja+4LLZdotV5UqoluTjuDV+LzJLXp1hY8FNT7ZXVbku0czdL1BxVBxNSz0BqTqfGTEg8f/lZMUdJPCOqDhaq7beZZcn63fBjTZ2rWqGn3oWp9tvqfRh69ee0XLX+XqP222amP08M054bAAAAAABgXWOhBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIv3G7mY2fHZfJN7/sFW7sFa9+tczt7vb7r9drev0oy3S8EH3Ma6b7vjeX/f7rC8vzMnfs+BEZH19s+rFz+loffuxxN3bijOhzb2YD23b5we4emRu6+mR8ubXkxm779Odk7r4rrnNjezftlrk9mRy61tfodmNLizMy9/D0A25sYHBI5uaxJeOnJmbd2JYt+2XufNMf15/49J0y923/8jtlvOpiS1/XUPfHg4qZmYVuf6yk9psSY/T3m6hzcXnZjyWOK+vRz3Wx7NeiYl7XOQvBD3V1yVR1Tqsp3PWgjMfMfy8kr0cJyfEljsvEe87MLNT0u67U2A7+2I2L/jthQyj8OYJZohYlno/QI2qReGYvRCa2bYVfp8zMioVFNxab+pkOjcQ5izqYfPbE8xEyv06ZWfL5kRJjQLrvERlW46dY9O9DWXEp8dzKWlTiepQlalE+MfEcHsgaEXMMMz2/yQYH9LbVOyRVjxLzGyUk5i9xzq8L+eSkzk3MQeRzMOvP380Sc83E+9jyzp+h5Dmp+v7wYzI36/M/AxYLCzI31Bs6Lt93iblimRpcQurzhJpXtY4d72iffKMGAAAAAACgIlioAQAAAAAAqAgWagAAAAAAACqChRoAAAAAAICKYKEGAAAAAACgIlioAQAAAAAAqAjZZ6q/T7RzNLOxab9V4Jfu/YLM3bZt1I1t37ZF5jabui3cxIRoz5Zob1gv/G3vvky0uTazvaODMv7UoZNubG5Wt0bctn2HG+vbPCJzaz1+S+l50XbTzGznzufJ+KkTfruxc2NTetu75txYSLQcnF1KtAas+2O3mWjr1t3b78dEa2Izs+Wxs/q4Mr9d3fbd+/W2l0S7Zn251r/EdVftB+OcP85S21atCc3SLXNV69pStyxxPYpUq9VVGjCxmWijLlpUJttFp9oxivaxyW0nrmen+zWzUm0k5fVq6u2Wab+dbkHpj/tUS86NLoo2q/n0tE5Wtai3V+830c50NdvMK6n23Wa6fbcknq1o+rkMDTHGy7SuN1uzWpR8bmUbdt2uXNaiVWyVmxr3clynavMlQL2T83NjOllcv6xfz41sSY+JYlHMUaIei6s54Q0Nvx6lapl8thPtt9XzlZKqKaoupHJlzUjch9T1yidT7wZB1clVHB/ZoP6cn09MXPx9XvQtAgAAAAAAoCMs1AAAAAAAAFQECzUAAAAAAAAVwUINAAAAAABARbBQAwAAAAAAUBEs1AAAAAAAAFQECzUAAAAAAAAV4TdXN7Puhu5lv7Q46cZuv/3jMjc2F93YUF+vzG02dd/3xYUFN1ZPrE3t27/XjV178/Nl7hXP2yXjk8eOu7FTE+dkbldvt7/fzTtk7tmzs27suquulbkvuO4qGf+T9/1XN1a3LpnbnPPHwPKyHzMzi61cxq3HHyO1bv9ampntv+xyN3bm2CN6v1lNhnv7/X1fc81Bmbs479/HvTu36eNa50JNX9fYEvf7ysv0tmfn3Vgx58fMzLLhQb3tRkMk61pUTM/4wWZT5mYjwzLeOn3GD8Yoc5XaQL+M5zPinBLqO3Wdy8/6NTTGoDde4pxXU2wur8l+s82bZDw/O+bGYkuPzQ1PjKX65ft17rJ/7aKY15il71ns9mtRyPVcL8747564oN/VyTo362/bQufPbdbfp/dbphbt1nO9/IyoRamNF2Juk7oeq2jNatG2LTIej5/wY0U16/pzSoyn2sErZGpYWHJjqXok5z5mlm0Sc7rEOI+L/nHlY+P6uLLEttX7q0w96kvUo3k911Rq2/X8v0hcE52c+KyllLheSWVySxxXGBnSm1b3Me/sWvKNGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoCBZqAAAAAAAAKoKFGgAAAAAAgIpgoQYAAAAAAKAiWKgBAAAAAACoiLoKzi8k+rpn/jrPrW/8WplaLM+5sVqzpXPzQsZjreZvu94lc3v6/V73pyYXZO7M5CEZH1/wzyv09MjcR+4+7MbGPn9W5l5+2VVu7KVXHpC5ywuLMt7b1e3GYrMpc+fFtrOaHJpWBBm2hcIfI/Vcj699ey53Y4uzYzL3+UP9Mn7nF77kxk488YjMXZjzn5k4PyFz17vY0vdMyR870vmOQ2KgzcTOt11m31Hvtziln9vkeQmZqlUN/dxaED8biLlMzccTY1zUfSsS9ymxb6kokZuQ9fv1pEjU5qxXv1OKef/9np/R7xQpMTYvZa3DR1dv42Pjq7ftMhK1JtQbbiw2l2Vu1ufP11JzqrC45O+3pecu+ekzetvd/rwo5Prno8WiqCeJZ6vMezKlNjLsxvKpaZmr7rGZWcz9c249cUwf2KUu9S4XYyY/9PhFPpjqiybmCVayHomaExLv47Ak6pF4PszMikTtV/VIzskscc4l5pFlZYODbqyYndXJiXMOdX+MtI4+GKs5RgAABhhJREFUqbe9CvhGDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARspdq/4BuZT0sOgUObj0oc5dEK7KexPpRV9DHFXt73Vh3n84tFv22XjMzugVhrW9IxrddMeLGrug7J3MfPSLa6AXdbq7R57dme+qkbjW2ectox/HlBb+dtJnZ0tKUG5ub061nl+Z1+7Xmkt96tt7jt/Q0M9u+a6sbe+LkaZl7+knd7nBx1j/nxx+4W+Zu3uwfVxzdJHPXvRItKC1LtGPM/G1nA7rdumwJbSbbQseFBZ26KJ6BxDklW0aL6xUaqRrpH1dItYct08o60aJStqZNtgj2X4Wp1phr1o46cS1T7btTLXOlWPihVWwRvN6pcZaKhy79XCZrUZe434l7lo9P6G0rqZbSov2rbCtrusV8WNatdOVznXqmE+1dizk995FUbS9TP8sS77KyNbA27M+dY+I+qn0nczeCEtc+WY9Um/ke/WyGPj3PlvdNzX3MLB+f9IOpZyQRjyKeul5yzrbclLllnu2onk0ziyXqUeqc5X5Tc6cSgnqfJZ6JrDcxdvvFvD/xroxibaNIzPk9fKMGAAAAAACgIlioAQAAAAAAqAgWagAAAAAAACqChRoAAAAAAICKYKEGAAAAAACgIlioAQAAAAAAqAgWagAAAAAAACpCNkifnzmkswt/nacRBmTq6dNTbuzRB4/K3J56r4x3DY+4sS3bRmXuri3Dbqye6XWtzcObZTwv/NjiwoTM3bZtyI3t3rVJ5p48dcqNHTr0kMzdv3yZjC+JnvEzM/49NjObnz/txqanpvV+52dlPF/2+9XXuvtl7gP3b3Fjy0vLMnfbtu0yvvv6a/3crTp3y9YdbqwncU7rXowdp4aGLHMWl/17mk/qMbxmilyGQ12fczbi17m4sNjRIZmZZf26NufquU7c49Q5WRD1OYria2YxF9czNfZCSMT948p6umVqMTfX+X4TYySqeGLbod4QscR9upTVajJciPepqZhZqRqZHEtl6m+qFg0O+kH1XJpZFMcdehO1aHJSxpVQS/2Ms8uNyFpjlnxupUyPr6zLf25TYzOfFrU7sd/UOecTev4rpcbuBlcb8j8bmOmaEhM1JbZafjA1Txgb13FlFetRattZX58fTD27nW7XEs9XQmqOa4X/fMZWU6bKMZCSutb9nX9uydX4StUjMec3Myvm5zs5pFXDN2oAAAAAAAAqgoUaAAAAAACAimChBgAAAAAAoCJYqAEAAAAAAKgIFmoAAAAAAAAqgoUaAAAAAACAipA9vYpl3X4tE+s89aZujzXU8NulfuGOT8vcU6fPyXho+C1Pb7rpRpl7y8tf4sampnSr3nu/+A8yPrfoX89DTx6TuYePHnVjC4lWYjH6LdJ6hrbK3OnpGRmfmfDvxdy0brmoGrfVa7qt2/CgbnW36zK/rfjo5p0yd9suvw32rhddJ3M3Del2c12iBWYt0R7TgojHDb7mWqLtaKpNq3WLFsmqnamZxR36+QminXtx5Em97RIto1MtFfNzYzIuiXtRzIp20ma6hbbpFtqFqJ9JZVq4lm0VGv37WCzq9qiqtbFsa2xmIdH6W7Xjjc1Ey875BT+YyN3wVMvoEq3Lazu2yXi+dVjGw7JfE+JDh2VuqoWrzC3081GqNbN6LywnjlnVIvHMmpWsRYl3mYqHTNeiVN0vFjtvL6zGbujy25GbmQX1jk1JtESWLe1LtFNeL1KthlfrGtQO+HNsM7PWlgEZD03/uLJ7H5W56vlL1lg5BynXmjmId6ocp2YWGv4zFJv6HqfarEupeiRKjjpfs8Qc1syKucR8UShTj9Tcx0x/Nk09T7EpanDUc1zPBv90BwAAAAAAsH6wUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFARLNQAAAAAAABURIgxrvUxAAAAAAAAwPhGDQAAAAAAQGWwUAMAAAAAAFARLNQAAAAAAABUBAs1AAAAAAAAFcFCDQAAAAAAQEWwUAMAAAAAAFAR/xOZsqCJI+qDbAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -752,27 +809,20 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "namespace \"cifar10\" deleted\r\n" + "namespace \"cifar10\" deleted\n" ] } ], "source": [ "!kubectl delete ns cifar10" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -791,7 +841,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/components/outlier-detection/nvidia-triton-cifar10/cifar10_outlier.ipynb b/components/outlier-detection/nvidia-triton-cifar10/cifar10_outlier.ipynb index 2d430d73aa..aeba566281 100644 --- a/components/outlier-detection/nvidia-triton-cifar10/cifar10_outlier.ipynb +++ b/components/outlier-detection/nvidia-triton-cifar10/cifar10_outlier.ipynb @@ -46,7 +46,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "gateway.networking.istio.io/seldon-gateway unchanged\r\n" + "gateway.networking.istio.io/seldon-gateway unchanged\n" ] } ], @@ -70,7 +70,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "namespace/cifar10 created\r\n" + "namespace/cifar10 created\n" ] } ], @@ -109,7 +109,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "broker.eventing.knative.dev/default created\r\n" + "broker.eventing.knative.dev/default created\n" ] } ], @@ -250,7 +250,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "seldondeployment.machinelearning.seldon.io/triton-cifar10 created\r\n" + "seldondeployment.machinelearning.seldon.io/triton-cifar10 created\n" ] } ], @@ -321,7 +321,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "service.serving.knative.dev/vae-outlier created\r\n" + "service.serving.knative.dev/vae-outlier created\n" ] } ], @@ -380,7 +380,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "trigger.eventing.knative.dev/vaeoutlier-trigger created\r\n" + "trigger.eventing.knative.dev/vaeoutlier-trigger created\n" ] } ], @@ -773,7 +773,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "namespace \"cifar10\" deleted\r\n" + "namespace \"cifar10\" deleted\n" ] } ], @@ -805,7 +805,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/components/rclone-storage-initializer/Dockerfile b/components/rclone-storage-initializer/Dockerfile index 7b98d0ee76..c1f33db292 100644 --- a/components/rclone-storage-initializer/Dockerfile +++ b/components/rclone-storage-initializer/Dockerfile @@ -10,4 +10,4 @@ LABEL name="Storage Initializer (rclone based)" \ ENV RCLONE_CONFIG_GS_TYPE google cloud storage ENV RCLONE_CONFIG_GS_ANONYMOUS true -ENTRYPOINT ["rclone", "copy"] +ENTRYPOINT ["rclone", "copy", "-v"] diff --git a/python/licenses/license.txt b/python/licenses/license.txt index 6109012775..55f2c558c7 100644 --- a/python/licenses/license.txt +++ b/python/licenses/license.txt @@ -75,7 +75,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Jinja2 -2.11.3 +3.0.0 BSD License Copyright 2007 Pallets @@ -181,7 +181,7 @@ POSSIBILITY OF SUCH DAMAGE. MarkupSafe -1.1.1 +2.0.0 BSD License Copyright 2010 Pallets @@ -239,7 +239,7 @@ SOFTWARE. Werkzeug -1.0.1 +2.0.0 BSD License Copyright 2007 Pallets @@ -548,7 +548,7 @@ Agreement. attrs -20.3.0 +21.2.0 MIT License The MIT License (MIT) @@ -573,12 +573,29 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +cached-property +1.5.2 +BSD License +Copyright (c) 2015, Daniel Greenfeld +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +* Neither the name of cached-property nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + cachetools -4.2.1 +4.2.2 MIT License The MIT License (MIT) -Copyright (c) 2014-2020 Thomas Kemmer +Copyright (c) 2014-2021 Thomas Kemmer Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in @@ -1165,7 +1182,7 @@ That's all there is to it! click -8.0.0rc1 +8.0.0 BSD License Copyright 2014 Pallets @@ -1214,7 +1231,7 @@ Apache Software License UNKNOWN gast -0.3.3 +0.4.0 BSD License Copyright (c) 2016, Serge Guelton All rights reserved. @@ -1248,7 +1265,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. google-auth -1.29.0 +1.30.0 Apache Software License Apache License Version 2.0, January 2004 @@ -1866,7 +1883,7 @@ Apache Software License grpcio -1.37.0 +1.34.1 Apache Software License Apache License @@ -2486,7 +2503,7 @@ Apache Software License gunicorn -20.0.4 +20.1.0 MIT License 2009-2018 (c) Benoît Chesneau 2009-2015 (c) Paul J. Davis @@ -2514,9 +2531,39 @@ OTHER DEALINGS IN THE SOFTWARE. h5py -2.10.0 +3.1.0 BSD License -UNKNOWN +Copyright (c) 2008 Andrew Collette and contributors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the + distribution. + +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + idna 2.10 @@ -2576,55 +2623,36 @@ limitations under the License. itsdangerous -1.1.0 +2.0.0 BSD License -`BSD 3-Clause `_ - -Copyright © 2011 by the Pallets team. - -Some rights reserved. +Copyright 2011 Pallets Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: -- Redistributions of source code must retain the above copyright +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. -- Redistributions in binary form must reproduce the above copyright +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -- Neither the name of the copyright holder nor the names of its +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. -We kindly ask you to use these themes in an unmodified manner only with -Pallets and Pallets-related projects, not for unrelated projects. If you -like the visual style and want to use it for your own projects, please -consider making some larger changes to the themes (such as changing font -faces, sizes, colors or margins). - -THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND -CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, -BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE -COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT -NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF -THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF -SUCH DAMAGE. - ----- - -The initial implementation of itsdangerous was inspired by Django's -signing module. - -Copyright © Django Software Foundation and individual contributors. -All rights reserved. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. jaeger-client @@ -2656,10 +2684,15 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +keras-nightly +2.5.0.dev2021032900 +Apache Software License +UNKNOWN + numpy -1.18.5 +1.19.5 BSD -Copyright (c) 2005-2019, NumPy Developers. +Copyright (c) 2005-2020, NumPy Developers. All rights reserved. Redistribution and use in source and binary forms, with or without @@ -4043,7 +4076,7 @@ Apache Software License protobuf -3.15.8 +3.17.0 3-Clause BSD License UNKNOWN @@ -4163,33 +4196,6 @@ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -redis -3.5.3 -MIT License -Copyright (c) 2012 Andy McCurdy - - Permission is hereby granted, free of charge, to any person - obtaining a copy of this software and associated documentation - files (the "Software"), to deal in the Software without - restriction, including without limitation the rights to use, - copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the - Software is furnished to do so, subject to the following - conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES - OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT - HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, - WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR - OTHER DEALINGS IN THE SOFTWARE. - - requests 2.25.1 Apache Software License @@ -5263,7 +5269,7 @@ THE SOFTWARE. tensorboard-data-server -0.6.0 +0.6.1 Apache Software License UNKNOWN @@ -5273,7 +5279,7 @@ Apache 2.0 UNKNOWN tensorflow -2.3.2 +2.5.0 Apache Software License Copyright 2019 The TensorFlow Authors. All rights reserved. @@ -5479,9 +5485,54 @@ Copyright 2019 The TensorFlow Authors. All rights reserved. See the License for the specific language governing permissions and limitations under the License. +MIT License + +Copyright (c) 2017-2021 Arm Limited + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +LICENSE + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + tensorflow-estimator -2.3.0 +2.5.0 Apache Software License UNKNOWN diff --git a/python/licenses/license_info.csv b/python/licenses/license_info.csv index 442b594703..670a913c82 100644 --- a/python/licenses/license_info.csv +++ b/python/licenses/license_info.csv @@ -2,42 +2,44 @@ "Flask","1.1.2","BSD License" "Flask-Cors","3.0.10","MIT License" "Flask-OpenTracing","1.1.0","BSD License" -"Jinja2","2.11.3","BSD License" +"Jinja2","3.0.0","BSD License" "Keras-Preprocessing","1.1.2","MIT License" "Markdown","3.3.4","BSD License" -"MarkupSafe","1.1.1","BSD License" +"MarkupSafe","2.0.0","BSD License" "PyYAML","5.4.1","MIT License" -"Werkzeug","1.0.1","BSD License" +"Werkzeug","2.0.0","BSD License" "absl-py","0.12.0","Apache Software License" "astunparse","1.6.3","BSD License" -"attrs","20.3.0","MIT License" -"cachetools","4.2.1","MIT License" +"attrs","21.2.0","MIT License" +"cached-property","1.5.2","BSD License" +"cachetools","4.2.2","MIT License" "certifi","2020.12.5","Mozilla Public License 2.0 (MPL 2.0)" "cffi","1.14.5","MIT License" "chardet","4.0.0","GNU Library or Lesser General Public License (LGPL)" -"click","8.0.0rc1","BSD License" +"click","8.0.0","BSD License" "cryptography","3.4","Apache Software License, BSD License" "flatbuffers","1.12","Apache Software License" -"gast","0.3.3","BSD License" -"google-auth","1.29.0","Apache Software License" +"gast","0.4.0","BSD License" +"google-auth","1.30.0","Apache Software License" "google-auth-oauthlib","0.4.4","Apache Software License" "google-pasta","0.2.0","Apache Software License" -"grpcio","1.37.0","Apache Software License" +"grpcio","1.34.1","Apache Software License" "grpcio-opentracing","1.1.4","Apache Software License" "grpcio-reflection","1.34.1","Apache Software License" -"gunicorn","20.0.4","MIT License" -"h5py","2.10.0","BSD License" +"gunicorn","20.1.0","MIT License" +"h5py","3.1.0","BSD License" "idna","2.10","BSD License" "importlib-metadata","4.0.1","Apache Software License" -"itsdangerous","1.1.0","BSD License" +"itsdangerous","2.0.0","BSD License" "jaeger-client","4.4.0","Apache Software License" "jsonschema","3.2.0","MIT License" -"numpy","1.18.5","BSD" +"keras-nightly","2.5.0.dev2021032900","Apache Software License" +"numpy","1.19.5","BSD" "oauthlib","3.1.0","BSD License" "opentracing","2.4.0","Apache Software License" "opt-einsum","3.3.0","MIT" "prometheus-client","0.8.0","Apache Software License" -"protobuf","3.15.8","3-Clause BSD License" +"protobuf","3.17.0","3-Clause BSD License" "pyasn1","0.4.8","BSD License" "pyasn1-modules","0.2.8","BSD License" "pycparser","2.20","BSD License" @@ -50,10 +52,10 @@ "setuptools-rust","0.12.1","MIT License" "six","1.15.0","MIT License" "tensorboard","2.5.0","Apache Software License" -"tensorboard-data-server","0.6.0","Apache Software License" +"tensorboard-data-server","0.6.1","Apache Software License" "tensorboard-plugin-wit","1.8.0","Apache 2.0" -"tensorflow","2.3.2","Apache Software License" -"tensorflow-estimator","2.3.0","Apache Software License" +"tensorflow","2.5.0","Apache Software License" +"tensorflow-estimator","2.5.0","Apache Software License" "termcolor","1.1.0","MIT License" "threadloop","1.0.2","MIT License" "thrift","0.13.0","Apache Software License" diff --git a/python/licenses/license_info.no_versions.csv b/python/licenses/license_info.no_versions.csv index 197ff87471..0a9465d421 100644 --- a/python/licenses/license_info.no_versions.csv +++ b/python/licenses/license_info.no_versions.csv @@ -11,6 +11,7 @@ "absl-py","Apache Software License" "astunparse","BSD License" "attrs","MIT License" +"cached-property","BSD License" "cachetools","MIT License" "certifi","Mozilla Public License 2.0 (MPL 2.0)" "cffi","MIT License" @@ -32,6 +33,7 @@ "itsdangerous","BSD License" "jaeger-client","Apache Software License" "jsonschema","MIT License" +"keras-nightly","Apache Software License" "numpy","BSD" "oauthlib","BSD License" "opentracing","Apache Software License" diff --git a/testing/resources/adserver-cifar10-od-rclone.yaml b/testing/resources/adserver-cifar10-od-rclone.yaml new file mode 100644 index 0000000000..7c8330c0a1 --- /dev/null +++ b/testing/resources/adserver-cifar10-od-rclone.yaml @@ -0,0 +1,86 @@ +apiVersion: v1 +kind: Secret +metadata: + name: seldon-rclone-secret +type: Opaque +stringData: + RCLONE_CONFIG_GS_TYPE: google cloud storage + RCLONE_CONFIG_GS_ANONYMOUS: "true" + +--- + +apiVersion: apps/v1 +kind: Deployment +metadata: + name: cifar10-od-server-rclone +spec: + selector: + matchLabels: + app: cifar10-od-server-rclone + replicas: 1 + template: + metadata: + labels: + app: cifar10-od-server-rclone + spec: + containers: + - name: server + image: seldonio/alibi-detect-server:1.8.0-dev + imagePullPolicy: IfNotPresent + args: + - --model_name + - cifar10od + - --http_port + - '8080' + - --protocol + - kfserving.http + - --event_type + - org.kubeflow.serving.inference.outlier + - --storage_uri + - gs://seldon-models/alibi-detect/od/OutlierVAE/cifar10 + - --event_source + - http://localhost:8080 + - OutlierDetector + envFrom: + - secretRef: + name: seldon-rclone-secret + +--- + +apiVersion: v1 +kind: Service +metadata: + name: cifar10-od-server-rclone + labels: + app: cifar10-od-server-rclone +spec: + type: ClusterIP + ports: + - protocol: TCP + port: 8080 + targetPort: 8080 + selector: + app: cifar10-od-server-rclone + +--- + +apiVersion: networking.istio.io/v1alpha3 +kind: VirtualService +metadata: + name: cifar10-od-server-rclone +spec: + gateways: + - istio-system/seldon-gateway + hosts: + - '*' + http: + - match: + - uri: + prefix: /cifar10-od-server-rclone/ + rewrite: + uri: / + route: + - destination: + host: cifar10-od-server-rclone + port: + number: 8080 diff --git a/testing/resources/adserver-cifar10-od.yaml b/testing/resources/adserver-cifar10-od.yaml new file mode 100644 index 0000000000..f28e10d590 --- /dev/null +++ b/testing/resources/adserver-cifar10-od.yaml @@ -0,0 +1,72 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: cifar10-od-server +spec: + selector: + matchLabels: + app: cifar10-od-server + replicas: 1 + template: + metadata: + labels: + app: cifar10-od-server + spec: + containers: + - name: server + image: seldonio/alibi-detect-server:1.8.0-dev + imagePullPolicy: IfNotPresent + args: + - --model_name + - cifar10od + - --http_port + - '8080' + - --protocol + - kfserving.http + - --event_type + - org.kubeflow.serving.inference.outlier + - --storage_uri + - gs://seldon-models/alibi-detect/od/OutlierVAE/cifar10 + - --event_source + - http://localhost:8080 + - OutlierDetector + +--- + +apiVersion: v1 +kind: Service +metadata: + name: cifar10-od-server + labels: + app: cifar10-od-server +spec: + type: ClusterIP + ports: + - protocol: TCP + port: 8080 + targetPort: 8080 + selector: + app: cifar10-od-server + +--- + +apiVersion: networking.istio.io/v1alpha3 +kind: VirtualService +metadata: + name: cifar10-od-server +spec: + gateways: + - istio-system/seldon-gateway + hosts: + - '*' + http: + - match: + - uri: + prefix: /cifar10-od-server/ + rewrite: + uri: / + route: + - destination: + host: cifar10-od-server + port: + number: 8080 diff --git a/testing/scripts/seldon_e2e_utils.py b/testing/scripts/seldon_e2e_utils.py index 61d272584a..3df7f956c1 100644 --- a/testing/scripts/seldon_e2e_utils.py +++ b/testing/scripts/seldon_e2e_utils.py @@ -120,6 +120,23 @@ def get_deployment_names(sdep_name, namespace, attempts=20, sleep=5): return deployment_names +def wait_for_deployment(deployment_name, namespace, attempts=50, sleep=5): + logging.info(f"Waiting for deployment {deployment_name}") + for _ in range(attempts): + ret = run( + f"kubectl rollout status -n {namespace} deploy/{deployment_name}", + shell=True, + ) + if ret.returncode == 0: + logging.info(f"Successfully waited for deployment {deployment_name}") + break + logging.warning(f"Unsuccessful wait command but retrying for {deployment_name}") + time.sleep(sleep) + assert ( + ret.returncode == 0 + ), f"Wait for rollout of {deployment_name} failed: non-zero return code" + + def wait_for_rollout( sdep_name, namespace, attempts=50, sleep=5, expected_deployments=1 ): @@ -138,22 +155,7 @@ def wait_for_rollout( assert len(deployment_names) == expected_deployments, error_msg for deployment_name in deployment_names: - logging.info(f"Waiting for deployment {deployment_name}") - for _ in range(attempts): - ret = run( - f"kubectl rollout status -n {namespace} deploy/{deployment_name}", - shell=True, - ) - if ret.returncode == 0: - logging.info(f"Successfully waited for deployment {deployment_name}") - break - logging.warning( - f"Unsuccessful wait command but retrying for {deployment_name}" - ) - time.sleep(sleep) - assert ( - ret.returncode == 0 - ), f"Wait for rollout of {deployment_name} failed: non-zero return code" + wait_for_deployment(deployment_name, namespace, attempts, sleep) def retry_run(cmd, attempts=10, sleep=5): diff --git a/testing/scripts/test_alibi_detect_server.py b/testing/scripts/test_alibi_detect_server.py new file mode 100644 index 0000000000..e7e0e98782 --- /dev/null +++ b/testing/scripts/test_alibi_detect_server.py @@ -0,0 +1,120 @@ +import json +import logging +import time +import uuid +from subprocess import run + +import requests +from tenacity import RetryError, Retrying, stop_after_attempt, wait_fixed + +from seldon_core.batch_processor import start_multithreaded_batch_worker +from seldon_e2e_utils import ( + API_ISTIO_GATEWAY, + create_random_data, + initial_rest_request, + rest_request, + rest_request_ambassador, + retry_run, + wait_for_deployment, + wait_for_rollout, + wait_for_status, +) + + +class TestADServer: + truck_json = "../../components/alibi-detect-server/cifar10-v2.json" + truck_json_outlier = "../../components/alibi-detect-server/cifar10-v2-outlier.json" + HEADERS = { + "ce-namespace": "default", + "ce-modelid": "cifar10", + "ce-type": "io.seldon.serving.inference.request", + "ce-id": "1234", + "ce-source": "localhost", + "ce-specversion": "1.0", + } + + def test_alibi_detect_cifar10(self, namespace): + spec = "../resources/adserver-cifar10-od.yaml" + name = "cifar10-od-server" + vs_prefix = name + + retry_run(f"kubectl apply -f {spec} -n {namespace}") + + wait_for_deployment(name, namespace) + + time.sleep(10) + + with open(self.truck_json) as f: + data = json.load(f) + + for attempt in Retrying(wait=wait_fixed(4), stop=stop_after_attempt(3)): + with attempt: + r = requests.post( + f"http://localhost:8004/{vs_prefix}/", + json=data, + headers=self.HEADERS, + ) + j = r.json() + + assert j["data"]["is_outlier"][0] == 0 + assert j["meta"]["name"] == "OutlierVAE" + assert j["meta"]["detector_type"] == "offline" + assert j["meta"]["data_type"] == "image" + + with open(self.truck_json_outlier) as f: + data = json.load(f) + + r = requests.post( + f"http://localhost:8004/{vs_prefix}/", json=data, headers=self.HEADERS + ) + j = r.json() + + assert j["data"]["is_outlier"][0] == 1 + assert j["meta"]["name"] == "OutlierVAE" + assert j["meta"]["detector_type"] == "offline" + assert j["meta"]["data_type"] == "image" + + run(f"kubectl delete -f {spec} -n {namespace}", shell=True) + + def test_alibi_detect_cifar10_rclone(self, namespace): + spec = "../resources/adserver-cifar10-od-rclone.yaml" + name = "cifar10-od-server-rclone" + vs_prefix = name + + retry_run(f"kubectl apply -f {spec} -n {namespace}") + + wait_for_deployment(name, namespace) + + time.sleep(10) + + with open(self.truck_json) as f: + data = json.load(f) + + for attempt in Retrying(wait=wait_fixed(4), stop=stop_after_attempt(3)): + with attempt: + r = requests.post( + f"http://localhost:8004/{vs_prefix}/", + json=data, + headers=self.HEADERS, + ) + j = r.json() + + assert j["data"]["is_outlier"][0] == 0 + assert j["meta"]["name"] == "OutlierVAE" + assert j["meta"]["detector_type"] == "offline" + assert j["meta"]["data_type"] == "image" + + with open(self.truck_json_outlier) as f: + data = json.load(f) + + r = requests.post( + f"http://localhost:8004/{vs_prefix}/", json=data, headers=self.HEADERS + ) + j = r.json() + + assert j["data"]["is_outlier"][0] == 1 + assert j["meta"]["name"] == "OutlierVAE" + assert j["meta"]["detector_type"] == "offline" + assert j["meta"]["data_type"] == "image" + + run(f"kubectl delete -f {spec} -n {namespace}", shell=True)