aimodelshare 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

aimodelshare/aimsonnx.py

@@ -3,25 +3,36 @@ import pandas as pd
 import numpy as np
 
 # ml frameworks
-
 try:
     import sklearn
     from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
 except:
-    pass
+    print("Warning: Please install sklearn to enable sklearn features")
+
 try:
     import torch
 except:
-    pass
+    print("Warning: Please install pytorch to enable pytorch features")
+
 try:
     import xgboost
 except:
-    pass
+    print("Warning: Please install xgboost to enable xgboost features")
+
 try:
     import tensorflow as tf
     import keras
 except:
-    pass
+    print("Warning: Please install tensorflow/keras to enable tensorflow/keras features")
+
+try:
+    import pyspark
+    from pyspark.sql import SparkSession
+    from pyspark.ml import PipelineModel, Model
+    from pyspark.ml.tuning import CrossValidatorModel, TrainValidationSplitModel
+    from onnxmltools import convert_sparkml
+except:
+    print("Warning: Please install pyspark to enable pyspark features")
 
 
 # onnx modules
@@ -1184,7 +1195,6 @@ def onnx_to_image(model):
     return pydot_graph
 
 
-
 def inspect_model(apiurl, version=None, naming_convention = None, submission_type="competition"):
     if all(["username" in os.environ, 
            "password" in os.environ]):
@@ -1582,9 +1592,9 @@ def model_from_string(model_type):
 def _get_pyspark_modules():
     try:
         if pyspark is None:
-            raise("Error: Please install pyspark to enable pyspark features")
+            raise Exception("Error: Please install pyspark to enable pyspark features")
     except:
-        raise("Error: Please install pyspark to enable pyspark features")
+        raise Exception("Error: Please install pyspark to enable pyspark features")
 
     pyspark_modules = ['ml', 'ml.feature', 'ml.classification', 'ml.clustering', 'ml.regression']
 
@@ -1603,9 +1613,9 @@ def _get_pyspark_modules():
 def pyspark_model_from_string(model_type):
     try:
         if pyspark is None:
-            raise("Error: Please install pyspark to enable pyspark features")
+            raise Exception("Error: Please install pyspark to enable pyspark features")
     except:
-        raise("Error: Please install pyspark to enable pyspark features")
+        raise Exception("Error: Please install pyspark to enable pyspark features")
 
     models_modules_dict = _get_pyspark_modules()
     module = models_modules_dict[model_type]

aimodelshare/api.py

@@ -211,7 +211,8 @@ class create_prediction_api_class():
         ###
         api_key = str(shortuuid.uuid())
 
-        t = Template(pkg_resources.read_text(main, 'eval_lambda.txt').replace("$apikey",api_key))
+        t = Template(pkg_resources.read_text(main, 'eval_lambda.txt').replace("$apikey",api_key).replace("$task_type",self.task_type))
+        
         data = t.substitute(bucket_name = self.bucket_name, unique_model_id = self.unique_model_id, task_type = self.task_type)
         with open(os.path.join(self.temp_dir, 'main.py'), 'w') as file:
             file.write(data)

aimodelshare/main/eval_lambda.txt

@@ -33,6 +33,20 @@ def handler(event, context):
         if value == "None":
             body[key]=None
 
+
+    if body.get("return_task_type","ALL")  == "True" or body.get("return_task_type", "ALL") == "TRUE":
+        task_type="$task_type"
+        task_type_dict = {"statusCode": 200,
+        "headers": {
+        "Access-Control-Allow-Origin" : "*",
+        "Access-Control-Allow-Credentials": True,
+        "Allow" : "GET, OPTIONS, POST",
+        "Access-Control-Allow-Methods" : "GET, OPTIONS, POST",
+        "Access-Control-Allow-Headers" : "*"},
+        "body": json.dumps({"task_type":task_type})
+        }
+        return task_type_dict
+
     if body.get("exampledata", "ALL") == "True" or body.get("exampledata", "ALL") == "TRUE":
 
         exampledata=get_exampledata(example_data_filename = "exampledata.json")

aimodelshare/playground.py

@@ -50,6 +50,13 @@ class ModelPlayground:
 
         self.model_type = input_type
 
+        if task_type == None:
+            post_dict = {"return_task_type": "TRUE"}
+            headers = { 'Content-Type':'application/json', 'authorizationToken': os.environ.get("AWS_TOKEN"),} 
+            playground_url_eval=playground_url[:-1]+"eval"
+            response = requests.post(playground_url_eval,headers=headers,data=json.dumps(post_dict))
+            task_type = json.loads(response.text)['task_type']
+        
         if task_type == "classification":
             self.categorical = True
         elif task_type == "regression":
@@ -786,7 +793,7 @@ class ModelPlayground:
                               eval_metric_filepath=eval_metric_filepath,
                               email_list=email_list,
                               public=public,
-                              public_private_split=public_private_split,
+                              public_private_split=0, #set to 0 because its an experiment
                               input_dict=exp_input_dict,
                               print_output=False)
 

{aimodelshare-0.1.4.dist-info → aimodelshare-0.1.5.dist-info}/METADATA

@@ -1,43 +1,41 @@
 Metadata-Version: 2.1
 Name: aimodelshare
-Version: 0.1.4
+Version: 0.1.5
 Summary: Deploy locally saved machine learning models to a live rest API and web-dashboard.  Share it with the world via modelshare.org
 Home-page: https://www.modelshare.org
 Author: Michael Parrott
 Author-email: mikedparrott@modelshare.org
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: boto3 (==1.26.69)
-Requires-Dist: botocore (==1.29.82)
-Requires-Dist: scikit-learn (==1.2.2)
-Requires-Dist: onnx (==1.13.1)
-Requires-Dist: onnxconverter-common (>=1.7.0)
+Requires-Dist: boto3 ==1.26.69
+Requires-Dist: botocore ==1.29.82
+Requires-Dist: scikit-learn ==1.2.2
+Requires-Dist: onnx ==1.13.1
+Requires-Dist: onnxconverter-common >=1.7.0
 Requires-Dist: regex
-Requires-Dist: keras2onnx (>=1.7.0)
-Requires-Dist: tensorflow (>=2.12)
+Requires-Dist: keras2onnx >=1.7.0
+Requires-Dist: tensorflow >=2.12
 Requires-Dist: tf2onnx
-Requires-Dist: skl2onnx (>=1.14.0)
-Requires-Dist: onnxruntime (>=1.7.0)
-Requires-Dist: torch (>=1.8.1)
-Requires-Dist: pydot (==1.3.0)
-Requires-Dist: importlib-resources (==5.10.0)
-Requires-Dist: onnxmltools (>=1.6.1)
-Requires-Dist: Pympler (==0.9)
-Requires-Dist: docker (==5.0.0)
-Requires-Dist: wget (==3.2)
-Requires-Dist: PyJWT (>=2.4.0)
-Requires-Dist: seaborn (>=0.11.2)
-Requires-Dist: astunparse (==1.6.3)
-Requires-Dist: shortuuid (>=1.0.8)
-Requires-Dist: psutil (>=5.9.1)
-Requires-Dist: pathlib (>=1.0.1)
-Requires-Dist: protobuf (>=3.20.1)
+Requires-Dist: skl2onnx >=1.14.0
+Requires-Dist: onnxruntime >=1.7.0
+Requires-Dist: torch >=1.8.1
+Requires-Dist: pydot ==1.3.0
+Requires-Dist: importlib-resources ==5.10.0
+Requires-Dist: onnxmltools >=1.6.1
+Requires-Dist: Pympler ==0.9
+Requires-Dist: docker ==5.0.0
+Requires-Dist: wget ==3.2
+Requires-Dist: PyJWT >=2.4.0
+Requires-Dist: seaborn >=0.11.2
+Requires-Dist: astunparse ==1.6.3
+Requires-Dist: shortuuid >=1.0.8
+Requires-Dist: psutil >=5.9.1
+Requires-Dist: pathlib >=1.0.1
+Requires-Dist: protobuf >=3.20.1
 Requires-Dist: dill
 
 

{aimodelshare-0.1.4.dist-info → aimodelshare-0.1.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
 aimodelshare/README.md,sha256=_OMdUIeIYZnpFlKdafM1KNWaANO2nWdx0QpLE_ZC-Qs,2014
 aimodelshare/__init__.py,sha256=CS0iFxgAic21gBcQE6NSZ-D_ElHw80_A3OWrEYo9Dks,539
-aimodelshare/aimsonnx.py,sha256=venOx0_k8mEvDhXLZSL2Heeu04CRSIxrXHk4nf84pTY,68708
-aimodelshare/api.py,sha256=WvJnp6cdYaSycv4gpDOjstxfS3M3IANzvWli54Pcg-k,34889
+aimodelshare/aimsonnx.py,sha256=CPZ_OZu909Tcq7x_Q5db_Oh-7vTbfV3bbRgSc7U6YgM,69338
+aimodelshare/api.py,sha256=XgFu30Cabh1G5MxU2ToALt4qp69XjwXJ4KZvIWtF3Zw,34935
 aimodelshare/aws.py,sha256=Ujhqgc1tpqdBVj5RCB_udTBt1lth4EZeLYgLU-dmu78,15188
 aimodelshare/aws_client.py,sha256=Ce19iwf69BwpuyyJlVN8z1da3c5jf93svsTgx1OWhaA,6784
 aimodelshare/base_image.py,sha256=itaQmX_q5GmgQrL3VNCBJpDGhl4PGA-nLTCbuyNDCCc,4825
@@ -15,7 +15,7 @@ aimodelshare/generatemodelapi.py,sha256=KNIWd8_g7auZi-UC-dCVmazGHJQvs9_68aGaUS47
 aimodelshare/leaderboard.py,sha256=xtKJcNCsZjy2IoK1fUTAFyM_I-eLCMS1WJRfwgsT5AA,5216
 aimodelshare/model.py,sha256=03TPnazX2s-6wjkzYl1sSpvzLOmpYW5k_2cIHZGmPgg,49899
 aimodelshare/modeluser.py,sha256=kW1zG4lFcwA0-ZLEyYaD8diJOF8PVhB-RGpPZQB07V4,4311
-aimodelshare/playground.py,sha256=iIPv7Na4V6Ux65xelPEsq1fdwu1SgiqGtJ2ZVhOC8oc,88269
+aimodelshare/playground.py,sha256=0qRaJ8pn5e2uDrWqdsue199sTfYgYkfi19A29oGahO4,88713
 aimodelshare/postprocessormodules.py,sha256=L87fM2mywlInOrgaMETi-7zdHBGbIMRcrXKttQthyQ4,4992
 aimodelshare/preprocessormodules.py,sha256=ujkIdGWeMEyyc6eTaZi9kZRpfP-JEGzse89fL80ShHY,10912
 aimodelshare/readme.md,sha256=_OMdUIeIYZnpFlKdafM1KNWaANO2nWdx0QpLE_ZC-Qs,2014
@@ -107,7 +107,7 @@ aimodelshare/main/8.txt,sha256=MfcEQe9Gv6RSmWL3kd7oYkRkdDdkN4bPxEG43QVs7ms,4513
 aimodelshare/main/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 aimodelshare/main/authorization.txt,sha256=lBWFZ1pyNuYFSEEWQbfEAZFDspcVE1guzlfpES7HNxk,10942
 aimodelshare/main/eval_classification.txt,sha256=gCBU71rbXRlkBwefVN3WhwVJX9fXh6bwOCa7ofLMdnA,3081
-aimodelshare/main/eval_lambda.txt,sha256=gj4QwSFufOrAY8hNDtlF6Zf-OI7D1hSKWLofb4Q8Tjk,59775
+aimodelshare/main/eval_lambda.txt,sha256=FZirZ_jrIdJQ90sChz30oBikUJG4eCVqlYg3z4MRS8o,60314
 aimodelshare/main/eval_regression.txt,sha256=iQeE9mbOkg-BDF9TnoQmglo86jBJitJQCvaf1eELzrs,3111
 aimodelshare/main/lambda_function.txt,sha256=-XkuD2YUOWNryNT7rBPjlts588UAeE949TUqeVGCRlQ,150
 aimodelshare/main/nst.txt,sha256=8kTsR18kDEcaQbv6091XDq1tRiqqFxdqfCteslR_udk,4941
@@ -141,10 +141,10 @@ aimodelshare/sam/codepipeline_trust_relationship.txt,sha256=yfPYvZlN3fnaIHs7I3EN
 aimodelshare/sam/spark-class.txt,sha256=chyJBxDzCzlUKXzVQYTzuJ2PXCTwg8_gd1yfnI-xbRw,217
 aimodelshare/sam/template.txt,sha256=JKSvEOZNaaLalHSx7r9psJg_6LLCb0XLAYi1-jYPu3M,1195
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_aimsonnx.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_playground.py,sha256=fG1WSGjKkyHffHAN4vsnQ99FJqo5lreInjsN7OygGKA,12210
-aimodelshare-0.1.4.dist-info/LICENSE,sha256=JXBYLriXYgTloZs-9CJPZY76dqkuDT5df_HghMnljx8,1134
-aimodelshare-0.1.4.dist-info/METADATA,sha256=NYxgo80tz-iujRfjSQqagdbW8IFq0h1maBDddFTMMN4,3364
-aimodelshare-0.1.4.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-aimodelshare-0.1.4.dist-info/top_level.txt,sha256=2KJgeHQ0BmZuilB75J203i7W4vri6CON2kdbwk9BNpU,19
-aimodelshare-0.1.4.dist-info/RECORD,,
+tests/test_aimsonnx.py,sha256=-GOF1_qXGQaMxHyqK0GPg7dD1meE-S7CZea4pLmBDTk,3906
+tests/test_playground.py,sha256=vdFWPRrZNQ2poiBOoN3l7HsXB5yc3p3rrrclNYJHnaw,24574
+aimodelshare-0.1.5.dist-info/LICENSE,sha256=JXBYLriXYgTloZs-9CJPZY76dqkuDT5df_HghMnljx8,1134
+aimodelshare-0.1.5.dist-info/METADATA,sha256=QDwwbkLuz2D27SYGrhX4lJkzUS9OtJY9ZIxXO84UpOE,3283
+aimodelshare-0.1.5.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+aimodelshare-0.1.5.dist-info/top_level.txt,sha256=2KJgeHQ0BmZuilB75J203i7W4vri6CON2kdbwk9BNpU,19
+aimodelshare-0.1.5.dist-info/RECORD,,

{aimodelshare-0.1.4.dist-info → aimodelshare-0.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.41.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/test_aimsonnx.py

@@ -0,0 +1,135 @@
+from aimodelshare.aimsonnx import _get_layer_names
+from aimodelshare.aimsonnx import _get_layer_names_pytorch
+from aimodelshare.aimsonnx import _get_sklearn_modules
+from aimodelshare.aimsonnx import model_from_string
+from aimodelshare.aimsonnx import _get_pyspark_modules
+from aimodelshare.aimsonnx import pyspark_model_from_string
+from aimodelshare.aimsonnx import layer_mapping
+from aimodelshare.aimsonnx import _sklearn_to_onnx
+from aimodelshare.aimsonnx import _pyspark_to_onnx
+from aimodelshare.aimsonnx import _keras_to_onnx
+from aimodelshare.aimsonnx import _pytorch_to_onnx
+from aimodelshare.aimsonnx import _misc_to_onnx
+from sklearn.linear_model import LogisticRegression
+from sklearn.neural_network import MLPClassifier
+import onnx
+from xgboost import XGBClassifier
+from pyspark.ml.classification import RandomForestClassifier, MultilayerPerceptronClassifier
+from keras.models import Sequential
+from torch import nn
+import torch
+from tensorflow.keras.layers import Dense
+
+def test_sklearn_to_onnx():
+
+    from sklearn.datasets import load_iris
+    data = load_iris()
+    X = data.data
+    y = data.target
+
+    model = LogisticRegression(C=10, penalty='l1', solver='liblinear')
+    model.fit(X, y)
+    onnx_model = _sklearn_to_onnx(model)
+    assert isinstance(onnx_model, onnx.ModelProto)
+
+    # model = MLPClassifier()
+    # model.fit(X, y)
+    # onnx_model = _sklearn_to_onnx(model)
+    # assert isinstance(onnx_model, onnx.ModelProto)
+
+
+# def test_misc_to_onnx():
+#
+#     model = XGBClassifier()
+#     onnx_model = _misc_to_onnx(model)
+#     assert isinstance(onnx_model, onnx.ModelProto)
+
+
+# def test_pyspark_to_onnx():
+#
+#     model =RandomForestClassifier(labelCol="indexedLabel", featuresCol="indexedFeatures", numTrees=10)
+#     onnx_model = _pyspark_to_onnx(model)
+#     assert isinstance(onnx_model, onnx.ModelProto)
+#
+#     model = MultilayerPerceptronClassifier()
+#     onnx_model = _pyspark_to_onnx(model)
+#     assert isinstance(onnx_model, onnx.ModelProto)
+
+def test_keras_to_onnx():
+
+    model = Sequential()
+    model.add(Dense(12, input_shape=(8,), activation='relu'))
+    model.add(Dense(8, activation='relu'))
+    model.add(Dense(1, activation='sigmoid'))
+    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+
+    onnx_model = _keras_to_onnx(model)
+    assert isinstance(onnx_model, onnx.ModelProto)
+
+
+def test_pytorch_to_onnx():
+
+    model = nn.Sequential(nn.Linear(3, 3),
+                          nn.ReLU(),
+                          nn.Linear(3, 1),
+                          nn.Sigmoid())
+
+    onnx_model = _pytorch_to_onnx(model, torch.randn(1, 3))
+    assert isinstance(onnx_model, onnx.ModelProto)
+
+
+def test_get_layer_names():
+
+    layers = _get_layer_names()
+
+    assert isinstance(layers, tuple)
+
+
+def test_get_layer_names_pytorch():
+
+        layers = _get_layer_names_pytorch()
+
+        assert isinstance(layers, tuple)
+
+
+def test_get_sklearn_modules():
+
+        modules = _get_sklearn_modules()
+
+        assert isinstance(modules, dict)
+
+def test_model_from_string():
+
+    model_class = model_from_string("RandomForestClassifier")
+
+    assert model_class.__name__ == "RandomForestClassifier"
+
+
+def test_get_pyspark_modules():
+
+    modules = _get_pyspark_modules()
+
+    assert isinstance(modules, dict)
+
+
+def test_pyspark_model_from_string():
+
+    model_class = pyspark_model_from_string("RandomForestClassifier")
+
+    assert model_class.__name__ == "RandomForestClassifier"
+
+
+def test_layer_mapping():
+
+    layer_map = layer_mapping(direction="torch_to_keras")
+    assert isinstance(layer_map, dict)
+
+    layer_map = layer_mapping(direction="keras_to_torch")
+    assert isinstance(layer_map, dict)
+
+    layer_map = layer_mapping(direction="torch_to_keras", activation=True)
+    assert isinstance(layer_map, dict)
+
+    layer_map = layer_mapping(direction="keras_to_torch", activation=True)
+    assert isinstance(layer_map, dict)
+

tests/test_playground.py

@@ -17,25 +17,18 @@ import os
 
 
 
+def test_configure_credentials():
 
-# def test_set_credentials():
-
-#	set_credentials(credential_file="../../credentials.txt", type="deploy_model")
-
-
-# def test_quickstart_sklearn():
-
-# 	X_train, X_test, y_train, y_test, example_data, y_test_labels = ai.import_quickstart_data("titanic")
-
-# 	assert isinstance(X_train, pd.DataFrame)
-# 	assert isinstance(X_test, pd.DataFrame)
-# 	assert isinstance(y_train, pd.Series)
-# 	assert isinstance(y_test, pd.Series)
-# 	assert isinstance(example_data, pd.DataFrame)
-# 	assert isinstance(y_test_labels, list)
-
+	# when testing locally, we can set credentials from file
+	try:
+		set_credentials(credential_file="../../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
 
-def test_configure_credentials():
+	try:
+		set_credentials(credential_file="../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
 
 	# mock user input
 	inputs = [os.environ.get('USERNAME'),
@@ -44,6 +37,7 @@ def test_configure_credentials():
 			  os.environ.get('AWS_SECRET_ACCESS_KEY'),
 			  os.environ.get('AWS_REGION')]
 
+
 	with patch("getpass.getpass", side_effect=inputs):
 		from aimodelshare.aws import configure_credentials
 		configure_credentials()
@@ -54,6 +48,17 @@ def test_configure_credentials():
 
 def test_playground_sklearn():
 
+	# when testing locally, we can set credentials from file
+	try:
+		set_credentials(credential_file="../../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
+
+	try:
+		set_credentials(credential_file="../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
+
 	# mock user input
 	inputs = [os.environ.get('USERNAME'),
 			  os.environ.get('PASSWORD'),
@@ -192,6 +197,17 @@ def test_playground_sklearn():
 
 def test_playground_keras():
 
+	# when testing locally, we can set credentials from file
+	try:
+		set_credentials(credential_file="../../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
+
+	try:
+		set_credentials(credential_file="../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
+
 	# mock user input
 	inputs = [os.environ.get('USERNAME'),
 			  os.environ.get('PASSWORD'),
@@ -288,7 +304,6 @@ def test_playground_keras():
 	# example url from deployed playground: apiurl= "https://123456.execute-api.us-east-1.amazonaws.com/prod/m
 	apiurl=myplayground.playground_url 
 
-
 	# Submit Model 2
 	# Generate predicted y values (Model 2)
 	prediction_column_index=keras_model_2.predict(X_test).argmax(axis=1)
@@ -343,3 +358,364 @@ def test_playground_keras():
 	shutil.rmtree("flower_competition_data", onerror=redo_with_write)
 	shutil.rmtree("quickstart_materials", onerror=redo_with_write)
 	shutil.rmtree("quickstart_flowers_competition", onerror=redo_with_write)
+
+
+def test_playground_pytorch():
+
+	# when testing locally, we can set credentials from file
+	try:
+		set_credentials(credential_file="../../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
+
+	try:
+		set_credentials(credential_file="../../credentials.txt", type="deploy_model")
+	except Exception as e:
+		print(e)
+
+	# mock user input
+	inputs = [os.environ.get('USERNAME'),
+			  os.environ.get('PASSWORD'),
+			  os.environ.get('AWS_ACCESS_KEY_ID'),
+			  os.environ.get('AWS_SECRET_ACCESS_KEY'),
+			  os.environ.get('AWS_REGION')]
+
+	with patch("getpass.getpass", side_effect=inputs):
+		from aimodelshare.aws import configure_credentials
+		configure_credentials()
+
+	# set credentials
+	set_credentials(credential_file="credentials.txt", type="deploy_model")
+	# os.environ["AWS_TOKEN"]=get_aws_token()
+
+	# clean up credentials file
+	os.remove("credentials.txt")
+
+	# # Download flower image data # Download flower image file (jpg) dataset
+	import aimodelshare as ai
+	ai.download_data("public.ecr.aws/y2e2a1d6/flower-competition-data-repository:latest")
+
+	# Extract filepaths to use to import and preprocess image files...
+	base_path = 'flower-competition-data/train_images'
+	categories = ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']
+
+	# Load file paths to fnames list object...
+	fnames = []
+
+	for category in categories:
+		flower_folder = os.path.join(base_path, category)
+		file_names = os.listdir(flower_folder)
+		full_path = [os.path.join(flower_folder, file_name) for file_name in file_names]
+		fnames.append(full_path)
+
+	# Here is a pre-designed preprocessor, but you could also build your own to prepare the data differently
+
+	def preprocessor(data, shape=(128, 128)):
+		"""
+        This function preprocesses reads in images, resizes them to a fixed shape and
+        min/max transforms them before converting feature values to float32 numeric values
+        required by onnx files.
+
+        params:
+            data
+                list of unprocessed images
+
+        returns:
+            X
+                numpy array of preprocessed image data
+
+        """
+
+		import cv2
+		import numpy as np
+
+		"Resize a color image and min/max transform the image"
+		img = cv2.imread(data)  # Read in image from filepath.
+		img = cv2.cvtColor(img,
+						   cv2.COLOR_BGR2RGB)  # cv2 reads in images in order of blue green and red, we reverse the order for ML.
+		img = cv2.resize(img, shape)  # Change height and width of image.
+		img = img / 255.0  # Min-max transform.
+
+		# Resize all the images...
+		X = np.array(img)
+		X = np.expand_dims(X, axis=0)  # Expand dims to add "1" to object shape [1, h, w, channels].
+		X = np.array(X, dtype=np.float32)  # Final shape for onnx runtime.
+
+		# transpose image to pytorch format
+		X = np.transpose(X, (0, 3, 1, 2))
+
+		return X
+
+	# Import image, load to array of shape height, width, channels, then min/max transform...
+
+	# Read in all images from filenames...
+	preprocessed_image_data = [preprocessor(x) for x in fnames[0] + fnames[1] + fnames[2] + fnames[3] + fnames[4]]
+
+	# models require object to be an array rather than a list. (vstack converts above list to array object.)
+	import numpy as np
+	X = np.vstack(
+		preprocessed_image_data)  # Assigning to X to highlight that this represents feature input data for our model.
+
+	# Create y training label data made up of correctly ordered labels from file folders...
+	from itertools import repeat
+
+	daisy = list(repeat("daisy", 507))  # i.e.: 507 filenames in daisy folder
+	dandelion = list(repeat("dandelion", 718))
+	roses = list(repeat("roses", 513))
+	sunflowers = list(repeat("sunflowers", 559))
+	tulips = list(repeat("tulips", 639))
+
+	# Combine into single list of y labels...
+	y_labels = daisy + dandelion + roses + sunflowers + tulips
+
+	# Check length, same as X above...
+	len(y_labels)
+
+	# get numerical representation of y labels
+	import pandas as pd
+	y_labels_num = pd.DataFrame(y_labels)[0].map(
+		{'daisy': 4, 'dandelion': 1,  # `data_paths` has 'daisy', 'dandelion', 'sunflowers', 'roses', 'tulips'...
+		 'sunflowers': 2, 'roses': 3, 'tulips': 0})  # ...but `image_paths` has 'tulips' first, and 'daisy' last.
+
+	y_labels_num = list(y_labels_num)
+
+	# train_test_split resized images...
+	from sklearn.model_selection import train_test_split
+
+	X_train, X_test, y_train, y_test = train_test_split(X, y_labels_num,
+														stratify=y_labels_num,
+														test_size=0.20,
+														random_state=1987)
+
+	import torch
+
+	# Get cpu or gpu device for training.
+	device = "cuda" if torch.cuda.is_available() else "cpu"
+	print(f"Using {device} device")
+
+	from torch.utils.data import DataLoader, TensorDataset
+
+	# prepare datasets for pytorch dataloader
+	tensor_X_train = torch.Tensor(X_train)
+	tensor_y_train = torch.tensor(y_train, dtype=torch.long)
+	train_ds = TensorDataset(tensor_X_train, tensor_y_train)
+
+	tensor_X_test = torch.Tensor(X_test)
+	tensor_y_test = torch.tensor(y_test, dtype=torch.long)
+	test_ds = TensorDataset(tensor_X_test, tensor_y_test)
+
+	# set up dataloaders
+	batch_size = 50
+	train_dataloader = DataLoader(train_ds, batch_size=batch_size, shuffle=False)
+	test_dataloader = DataLoader(test_ds, batch_size=batch_size, shuffle=False)
+
+	from torch import nn
+
+	# Define pytorch model
+	class NeuralNetwork(nn.Module):
+		def __init__(self):
+			super(NeuralNetwork, self).__init__()
+			self.flatten = nn.Flatten()
+			self.linear_relu_stack = nn.Sequential(
+				nn.Linear(128 * 128 * 3, 512),
+				nn.ReLU(),
+				nn.Linear(512, 512),
+				nn.ReLU(),
+				nn.Linear(512, 5)
+			)
+
+		def forward(self, x):
+			x = self.flatten(x)
+			logits = self.linear_relu_stack(x)
+			return logits
+
+	model = NeuralNetwork().to(device)
+	print(model)
+
+	# set up loss function and optimizer
+	loss_fn = nn.CrossEntropyLoss()
+	optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
+
+	# define training function
+	def train(dataloader, model, loss_fn, optimizer):
+		size = len(dataloader.dataset)
+		model.train()
+		for batch, (X, y) in enumerate(dataloader):
+			X, y = X.to(device), y.to(device)
+
+			# Compute prediction error
+			pred = model(X)
+			loss = loss_fn(pred, y)
+
+			# Backpropagation
+			optimizer.zero_grad()
+			loss.backward()
+			optimizer.step()
+
+			if batch % 100 == 0:
+				loss, current = loss.item(), batch * len(X)
+				print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
+
+	# define testing function
+	def test(dataloader, model, loss_fn):
+		size = len(dataloader.dataset)
+		num_batches = len(dataloader)
+		model.eval()
+		test_loss, correct = 0, 0
+		with torch.no_grad():
+			for X, y in dataloader:
+				X, y = X.to(device), y.to(device)
+				pred = model(X)
+				test_loss += loss_fn(pred, y).item()
+				correct += (pred.argmax(1) == y).type(torch.float).sum().item()
+		test_loss /= num_batches
+		correct /= size
+		print(f"Test Error: \n Accuracy: {(100 * correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
+
+	epochs = 2
+	for t in range(epochs):
+		print(f"Epoch {t + 1}\n-------------------------------")
+		train(train_dataloader, model, loss_fn, optimizer)
+		test(test_dataloader, model, loss_fn)
+	print("Done!")
+
+	# -- Generate predicted y values (Model 1)
+	# Note: returns the predicted column index location for classification models
+	if torch.cuda.is_available():
+		prediction_column_index = model(tensor_X_test.cuda()).argmax(axis=1)
+	else:
+		prediction_column_index = model(tensor_X_test).argmax(axis=1)
+
+	# extract correct prediction labels
+	prediction_labels = [['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips'][i] for i in prediction_column_index]
+
+	# Create labels for y_test
+	y_test_labels = [['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips'][i] for i in y_test]
+
+	# Create labels for y_train
+	y_train_labels = [['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips'][i] for i in y_train]
+
+	# Instantiate Model Playground object
+	from aimodelshare.playground import ModelPlayground
+	myplayground = ModelPlayground(input_type="image", task_type="classification", private=False)
+
+	# Create Model Playground Page on modelshare.ai website
+	myplayground.create(eval_data=y_test_labels)
+
+	if torch.cuda.is_available():
+		example_input = torch.randn(1, 3, 128, 128, requires_grad=True).cuda()
+	else:
+		example_input = torch.randn(1, 3, 128, 128, requires_grad=True)
+
+
+	# Submit Model to Experiment Leaderboard
+	myplayground.submit_model(model=model,
+							  preprocessor=preprocessor,
+							  prediction_submission=prediction_labels,
+							  input_dict={"description": "", "tags": ""},
+							  submission_type="all",
+							  model_input = example_input)
+
+
+	# Create example data folder to provide on model playground page
+	#     for users to test prediction REST API
+	import shutil
+	os.mkdir('example_data')
+	example_images = ["flower-competition-data/train_images/daisy/100080576_f52e8ee070_n.jpg",
+					  "flower-competition-data/train_images/dandelion/10200780773_c6051a7d71_n.jpg",
+					  "flower-competition-data/train_images/roses/10503217854_e66a804309.jpg",
+					  "flower-competition-data/train_images/sunflowers/1022552002_2b93faf9e7_n.jpg",
+					  "flower-competition-data/train_images/tulips/100930342_92e8746431_n.jpg"]
+
+	for image in example_images:
+		shutil.copy(image, 'example_data')
+
+	# Deploy model by version number
+	myplayground.deploy_model(model_version=1, example_data="example_data", y_train=y_train)
+
+	# example url from deployed playground: apiurl= "https://123456.execute-api.us-east-1.amazonaws.com/prod/m
+	apiurl = myplayground.playground_url
+
+	# Submit Model 2
+	# Define model
+	class NeuralNetwork(nn.Module):
+		def __init__(self):
+			super(NeuralNetwork, self).__init__()
+			self.flatten = nn.Flatten()
+			self.linear_relu_stack = nn.Sequential(
+				nn.Linear(128 * 128 * 3, 512),
+				nn.ReLU(),
+				nn.Linear(512, 512),
+				nn.ReLU(),
+				nn.Linear(512, 256),
+				nn.ReLU(),
+				nn.Linear(256, 5)
+			)
+
+		def forward(self, x):
+			x = self.flatten(x)
+			logits = self.linear_relu_stack(x)
+			return logits
+
+	model2 = NeuralNetwork().to(device)
+	print(model2)
+
+	# set up loss function and optimizer
+	loss_fn = nn.CrossEntropyLoss()
+	optimizer = torch.optim.SGD(model2.parameters(), lr=1e-3)
+
+	# train model
+	epochs = 2
+	for t in range(epochs):
+		print(f"Epoch {t + 1}\n-------------------------------")
+		train(train_dataloader, model2, loss_fn, optimizer)
+		test(test_dataloader, model2, loss_fn)
+	print("Done!")
+
+	# Submit Model 2 to Experiment Leaderboard
+	myplayground.submit_model(model=model2,
+							  preprocessor=preprocessor,
+							  prediction_submission=prediction_labels,
+							  input_dict={"description": "", "tags": ""},
+							  submission_type="all",
+							  model_input = example_input)
+
+	# submit model through competition
+	mycompetition = ai.playground.Competition(myplayground.playground_url)
+	mycompetition.submit_model(model=model2,
+							   preprocessor=preprocessor,
+							   prediction_submission=prediction_labels,
+							   input_dict={"description": "", "tags": ""},
+							   model_input=example_input)
+
+	# submit model through experiment
+	myexperiment = ai.playground.Experiment(myplayground.playground_url)
+	myexperiment.submit_model(model=model2,
+							  preprocessor=preprocessor,
+							  prediction_submission=prediction_labels,
+							  input_dict={"description": "", "tags": ""},
+							  model_input=example_input)
+
+	# Check experiment leaderboard
+	data = myplayground.get_leaderboard()
+	myplayground.stylize_leaderboard(data)
+	assert isinstance(data, pd.DataFrame)
+
+	# Compare two or more models
+	data = myplayground.compare_models([1, 2], verbose=1)
+	myplayground.stylize_compare(data)
+	assert isinstance(data, (pd.DataFrame, dict))
+
+	# Check structure of evaluation data
+	data = myplayground.inspect_eval_data()
+	assert isinstance(data, dict)
+
+	# Update runtime model
+	myplayground.update_runtime_model(model_version=2)
+
+	# delete
+	myplayground.delete_deployment(confirmation=False)
+
+	# local cleanup
+	shutil.rmtree("flower-competition-data", onerror=redo_with_write)
+	shutil.rmtree("example_data", onerror=redo_with_write)