aimodelshare 0.3.7__py3-none-any.whl

aimodelshare/main/1.txt

@@ -0,0 +1,132 @@
+#Text Classification Prediction Runtime Code
+
+import boto3
+import pandas as pd
+import os
+from io import BytesIO
+import pickle
+import numpy as np
+import json
+import onnxruntime as rt
+import warnings
+import six
+
+
+def get_model_onnx(runtimemodel_s3_filename="runtime_model.onnx"):
+    s3 = boto3.resource('s3')
+    obj = s3.Object("$bucket_name", "$unique_model_id" +
+                    "/runtime_model.onnx")
+    model = rt.InferenceSession(obj.get()['Body'].read())
+    return model
+
+
+
+def get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip"):
+    import pickle
+    from zipfile import ZipFile
+    from io import BytesIO
+    import os
+    s3 = boto3.resource("s3")
+    bucket = s3.Bucket("$bucket_name")
+    
+    zip_obj = s3.Object(bucket_name="$bucket_name", key="$unique_model_id/runtime_preprocessor.zip")
+    buffer = BytesIO(zip_obj.get()["Body"].read())
+    z = ZipFile(buffer)
+    # Extract all the contents of zip file in current directory
+    z.extractall("/tmp/")
+    
+    folderpath=os.path.dirname(os.path.abspath("/tmp/preprocessor.py"))
+    file_name=os.path.basename("/tmp/preprocessor.py")
+
+    #Then import all pkl files you want from bucket (need to generate this list from...
+    # function globals)
+    import os
+    pickle_file_list=[]
+    for file in os.listdir(folderpath):
+          if file.endswith(".pkl"):
+              pickle_file_list.append(os.path.join(folderpath, file))
+
+    for i in pickle_file_list: 
+          objectname=str(os.path.basename(i)).replace(".pkl","")
+          objects={objectname:""}
+          globals()[objectname]=pickle.load(open(str(i), "rb" ) )
+      # First import preprocessor function to session from preprocessor.py
+    exec(open(os.path.join(folderpath,'preprocessor.py')).read(),globals())
+    return preprocessor
+
+def get_runtimedata(runtimedata_s3_filename="runtime_data.json"):
+
+      s3 = boto3.resource('s3')
+      obj = s3.Object("$bucket_name", "$unique_model_id"+"/"+runtimedata_s3_filename)
+      runtime_data = json.load(obj.get()['Body'])
+
+      return runtime_data
+
+
+runtime_data=get_runtimedata(runtimedata_s3_filename="runtime_data.json")
+
+preprocessor_type=runtime_data["runtime_preprocessor"]
+
+runtime_model=runtime_data["runtime_model"]["name"]
+
+# Load model
+model=get_model_onnx(runtimemodel_s3_filename='runtime_model.onnx')
+
+# Load preprocessor
+preprocessor=get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip")
+
+
+def predict(event,model,preprocessor):
+    body = event["body"]
+    if isinstance(event["body"], six.string_types):
+        body = json.loads(event["body"])
+        print(body["data"])
+        bodynew = pd.Series(body["data"])
+    else:
+        print(body["data"])
+        bodynew = pd.Series(body["data"])
+        print(bodynew)
+        
+    sess=model
+    def predict_classes(x): # adjusted from keras github code
+            proba=x
+            if proba.shape[-1] > 1:
+              return proba.argmax(axis=-1)
+            else:
+              return (proba > 0.5).astype("int32")
+    input_name = sess.get_inputs()[0].name
+
+    input_data = preprocessor(bodynew).astype(np.float32) #needs to be float32
+
+    res = sess.run(None,  {input_name: input_data})
+    prob = res[0]
+    print(prob)
+    try:
+        prediction_index=predict_classes(prob)
+        def index_to_label(labels,index_n):
+            return labels[index_n]
+
+        # load class labels
+        try: 
+            s3 = boto3.resource('s3')
+            obj = s3.Object("$bucket_name", "$unique_model_id" + "/labels.json")
+            labels = json.loads(obj.get()['Body'].read())
+        except:
+            labels=$labels
+            
+        result=list(map(lambda x: labels[x], prediction_index))
+    except:
+        result=prob.tolist() 
+    return result
+
+def handler(event, context):
+    result = predict(event,model,preprocessor)
+    return {"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(result)}

aimodelshare/main/1B.txt

@@ -0,0 +1,112 @@
+#Text Regression Prediction Runtime Code
+
+import boto3
+import pandas as pd
+import os
+from io import BytesIO
+import pickle
+import numpy as np
+import json
+import onnxruntime as rt
+import warnings
+import six
+
+def get_model_onnx(runtimemodel_s3_filename="runtime_model.onnx"):
+    s3 = boto3.resource('s3')
+    obj = s3.Object("$bucket_name", "$unique_model_id" +
+                    "/runtime_model.onnx")
+    model = rt.InferenceSession(obj.get()['Body'].read())
+    return model
+
+def get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip"):
+    import pickle
+    from zipfile import ZipFile
+    from io import BytesIO
+    import os
+    s3 = boto3.resource("s3")
+    bucket = s3.Bucket("$bucket_name")
+    
+    zip_obj = s3.Object(bucket_name="$bucket_name", key="$unique_model_id/runtime_preprocessor.zip")
+    buffer = BytesIO(zip_obj.get()["Body"].read())
+    z = ZipFile(buffer)
+    # Extract all the contents of zip file in current directory
+    z.extractall("/tmp/")
+    
+    folderpath=os.path.dirname(os.path.abspath("/tmp/preprocessor.py"))
+    file_name=os.path.basename("/tmp/preprocessor.py")
+
+    #Then import all pkl files you want from bucket (need to generate this list from...
+    # function globals)
+    import os
+    pickle_file_list=[]
+    for file in os.listdir(folderpath):
+          if file.endswith(".pkl"):
+              pickle_file_list.append(os.path.join(folderpath, file))
+
+    for i in pickle_file_list: 
+          objectname=str(os.path.basename(i)).replace(".pkl","")
+          objects={objectname:""}
+          globals()[objectname]=pickle.load(open(str(i), "rb" ) )
+      # First import preprocessor function to session from preprocessor.py
+    exec(open(os.path.join(folderpath,'preprocessor.py')).read(),globals())
+    return preprocessor
+
+def get_runtimedata(runtimedata_s3_filename="runtime_data.json"):
+
+      s3 = boto3.resource('s3')
+      obj = s3.Object("$bucket_name", "$unique_model_id"+"/"+runtimedata_s3_filename)
+      runtime_data = json.load(obj.get()['Body'])
+
+      return runtime_data
+
+
+runtime_data=get_runtimedata(runtimedata_s3_filename="runtime_data.json")
+
+preprocessor_type=runtime_data["runtime_preprocessor"]
+
+runtime_model=runtime_data["runtime_model"]["name"]
+
+# Load model
+model=get_model_onnx(runtimemodel_s3_filename='runtime_model.onnx')
+
+# Load preprocessor
+preprocessor=get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip")
+
+
+def predict(event,model,preprocessor):
+    body = event["body"]
+    if isinstance(event["body"], six.string_types):
+        body = json.loads(event["body"])
+        print(body["data"])
+        bodynew = pd.Series(body["data"])
+    else:
+        print(body["data"])
+        bodynew = pd.Series(body["data"])
+        print(bodynew)
+        
+    sess=model
+    def predict_classes(x): # adjusted from keras github code
+            proba=x
+            if proba.shape[-1] > 1:
+              return proba.argmax(axis=-1)
+            else:
+              return (proba > 0.5).astype("int32")
+    input_name = sess.get_inputs()[0].name
+
+    input_data = preprocessor(bodynew).astype(np.float32) #needs to be float32
+
+    res = sess.run(None,  {input_name: input_data})
+    prob = res[0]
+    return prob.tolist()[0]
+
+def handler(event, context):
+    result = predict(event,model,preprocessor)
+    return {"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(result)}

aimodelshare/main/2.txt

@@ -0,0 +1,153 @@
+#Image Classification Prediction Runtime Code
+
+import boto3
+import cv2
+import os
+import numpy as np
+import json
+import onnxruntime as rt
+import base64
+import imghdr
+import six
+from functools import partial
+import os.path
+from os import path
+
+def get_model_onnx(runtimemodel_s3_filename="runtime_model.onnx"):
+    s3 = boto3.resource('s3')
+    obj = s3.Object("$bucket_name", "$unique_model_id" +
+                    "/runtime_model.onnx")
+    model = rt.InferenceSession(obj.get()['Body'].read())
+    return model
+
+def get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip"):
+    import pickle
+    from zipfile import ZipFile
+    from io import BytesIO
+    import os
+    s3 = boto3.resource("s3")
+    bucket = s3.Bucket("$bucket_name")
+    
+    zip_obj = s3.Object(bucket_name="$bucket_name", key="$unique_model_id/runtime_preprocessor.zip")
+    buffer = BytesIO(zip_obj.get()["Body"].read())
+    z = ZipFile(buffer)
+    # Extract all the contents of zip file in current directory
+    z.extractall("/tmp/")
+    
+    folderpath=os.path.dirname(os.path.abspath("/tmp/preprocessor.py"))
+    file_name=os.path.basename("/tmp/preprocessor.py")
+
+    #Then import all pkl files you want from bucket (need to generate this list from...
+    # function globals)
+    import os
+    pickle_file_list=[]
+    for file in os.listdir(folderpath):
+          if file.endswith(".pkl"):
+              pickle_file_list.append(os.path.join(folderpath, file))
+
+    for i in pickle_file_list: 
+          objectname=str(os.path.basename(i)).replace(".pkl","")
+          objects={objectname:""}
+          globals()[objectname]=pickle.load(open(str(i), "rb" ) )
+      # First import preprocessor function to session from preprocessor.py
+    exec(open(os.path.join(folderpath,'preprocessor.py')).read(),globals())
+    return preprocessor
+
+
+def get_runtimedata(runtimedata_s3_filename="runtime_data.json"):
+
+      s3 = boto3.resource('s3')
+      obj = s3.Object("$bucket_name", "$unique_model_id"+"/"+runtimedata_s3_filename)
+      runtime_data = json.load(obj.get()['Body'])
+
+      return runtime_data
+
+
+runtime_data=get_runtimedata(runtimedata_s3_filename="runtime_data.json")
+
+preprocessor_type=runtime_data["runtime_preprocessor"]
+
+runtime_model=runtime_data["runtime_model"]["name"]
+
+model=get_model_onnx(runtimemodel_s3_filename='runtime_model.onnx')
+
+# Load preprocessor
+
+preprocessor=get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip")
+
+
+def predict(event,model,preprocessor):
+
+  # load class labels
+  try: 
+    s3 = boto3.resource('s3')
+    obj = s3.Object("$bucket_name", "$unique_model_id" + "/labels.json")
+    labels = json.loads(obj.get()['Body'].read())
+  except:
+    labels=$labels
+
+
+# Load base64 encoded image stored within "data" key of event dictionary
+  print(event["body"])
+  body = event["body"]
+  if isinstance(event["body"], six.string_types):
+        body = json.loads(event["body"])
+        
+  bodydata=body["data"]
+
+# Extract image file extension (e.g.-jpg, png, etc.)
+  sample = base64.decodebytes(bytearray(bodydata, "utf-8"))
+
+  for tf in imghdr.tests:
+    image_file_type = tf(sample, None)
+    if image_file_type:
+      break;
+  image_file_type=image_file_type
+ 
+  if(image_file_type==None):
+    print("This file is not an image, please submit an image base64 encoded image file.")
+
+# Save image to local file, read into session, and preprocess image with preprocessor function
+
+  with open("/tmp/imagetopredict."+image_file_type, "wb") as fh:
+    fh.write(base64.b64decode(bodydata))
+
+  input_data = preprocessor("/tmp/imagetopredict."+image_file_type)
+  
+
+# Generate prediction using preprocessed input data
+  print("The model expects input shape:", model.get_inputs()[0].shape)
+  
+  input_name = model.get_inputs()[0].name
+
+  res = model.run(None, {input_name: input_data})
+ 
+  #extract predicted probability for all classes, extract predicted label
+  
+  prob = res[0]
+
+  def predict_classes(x): # adjusted from keras github code
+    if len(x.shape)==2:
+        index = x.argmax(axis=-1)
+        return list(map(lambda x: labels[x], index))
+    else:
+        return list(x)
+      
+  result=predict_classes(prob)
+
+  os.remove("/tmp/imagetopredict."+image_file_type)
+
+  return result
+
+def handler(event, context):
+
+    result = predict(event,model,preprocessor)
+    return {"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(result)}

aimodelshare/main/3.txt

@@ -0,0 +1,134 @@
+#Image Regression Prediction Runtime Code
+
+import boto3
+import cv2
+import os
+import numpy as np
+import json
+import onnxruntime as rt
+import base64
+import imghdr
+import six
+from functools import partial
+import os.path
+from os import path
+
+
+def get_model_onnx(runtimemodel_s3_filename="runtime_model.onnx"):
+    s3 = boto3.resource('s3')
+    obj = s3.Object("$bucket_name", "$unique_model_id" +
+                    "/runtime_model.onnx")
+    model = rt.InferenceSession(obj.get()['Body'].read())
+    return model
+
+def get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip"):
+    import pickle
+    from zipfile import ZipFile
+    from io import BytesIO
+    import os
+    s3 = boto3.resource("s3")
+    bucket = s3.Bucket("$bucket_name")
+    
+    zip_obj = s3.Object(bucket_name="$bucket_name", key="$unique_model_id/runtime_preprocessor.zip")
+    buffer = BytesIO(zip_obj.get()["Body"].read())
+    z = ZipFile(buffer)
+    # Extract all the contents of zip file in current directory
+    z.extractall("/tmp/")
+    
+    folderpath=os.path.dirname(os.path.abspath("/tmp/preprocessor.py"))
+    file_name=os.path.basename("/tmp/preprocessor.py")
+
+    #Then import all pkl files you want from bucket (need to generate this list from...
+    # function globals)
+    import os
+    pickle_file_list=[]
+    for file in os.listdir(folderpath):
+          if file.endswith(".pkl"):
+              pickle_file_list.append(os.path.join(folderpath, file))
+
+    for i in pickle_file_list: 
+          objectname=str(os.path.basename(i)).replace(".pkl","")
+          objects={objectname:""}
+          globals()[objectname]=pickle.load(open(str(i), "rb" ) )
+      # First import preprocessor function to session from preprocessor.py
+    exec(open(os.path.join(folderpath,'preprocessor.py')).read(),globals())
+    return preprocessor
+
+
+def get_runtimedata(runtimedata_s3_filename="runtime_data.json"):
+
+      s3 = boto3.resource('s3')
+      obj = s3.Object("$bucket_name", "$unique_model_id"+"/"+runtimedata_s3_filename)
+      runtime_data = json.load(obj.get()['Body'])
+
+      return runtime_data
+
+
+runtime_data=get_runtimedata(runtimedata_s3_filename="runtime_data.json")
+
+preprocessor_type=runtime_data["runtime_preprocessor"]
+
+runtime_model=runtime_data["runtime_model"]["name"]
+
+model=get_model_onnx(runtimemodel_s3_filename='runtime_model.onnx')
+
+# Load preprocessor
+
+preprocessor=get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip")
+
+
+def predict(event,model,preprocessor):
+
+# Load base64 encoded image stored within "data" key of event dictionary
+  print(event["body"])
+  body = event["body"]
+  if isinstance(event["body"], six.string_types):
+        body = json.loads(event["body"])
+        
+  bodydata=body["data"]
+
+# Extract image file extension (e.g.-jpg, png, etc.)
+  sample = base64.decodebytes(bytearray(bodydata, "utf-8"))
+
+  for tf in imghdr.tests:
+    image_file_type = tf(sample, None)
+    if image_file_type:
+      break;
+  image_file_type=image_file_type
+ 
+  if(image_file_type==None):
+    print("This file is not an image, please submit an image base64 encoded image file.")
+
+# Save image to local file, read into session, and preprocess image with preprocessor function
+
+  with open("/tmp/imagetopredict."+image_file_type, "wb") as fh:
+    fh.write(base64.b64decode(bodydata))
+
+  input_data = preprocessor("/tmp/imagetopredict."+image_file_type)
+
+# Generate prediction using preprocessed input data
+  print("The model expects input shape:", model.get_inputs()[0].shape)
+  input_name = model.get_inputs()[0].name
+
+  res = model.run(None, {input_name: input_data})
+ 
+  #extract predicted value
+  
+  result = res[0].tolist()[0]
+
+  os.remove("/tmp/imagetopredict."+image_file_type)
+
+  return result
+
+def handler(event, context):
+
+    result = predict(event,model,preprocessor)
+    return {"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(result)}

aimodelshare/main/4.txt

@@ -0,0 +1,128 @@
+#Tabular Classification Prediction Runtime Code
+
+import boto3
+import pandas as pd
+import os
+import numpy as np
+import onnxruntime as rt
+import json
+
+class NpEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super(NpEncoder, self).default(obj)
+
+def get_model_onnx(runtimemodel_s3_filename="runtime_model.onnx"):
+    s3 = boto3.resource('s3')
+    obj = s3.Object("$bucket_name", "$unique_model_id" +
+                    "/runtime_model.onnx")
+    model = rt.InferenceSession(obj.get()['Body'].read())
+    return model
+    
+def get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip"):
+    import pickle
+    from zipfile import ZipFile
+    from io import BytesIO
+    import os
+    s3 = boto3.resource("s3")
+    bucket = s3.Bucket("$bucket_name")
+    
+    zip_obj = s3.Object(bucket_name="$bucket_name", key="$unique_model_id/runtime_preprocessor.zip")
+    buffer = BytesIO(zip_obj.get()["Body"].read())
+    z = ZipFile(buffer)
+    # Extract all the contents of zip file in current directory
+    z.extractall("/tmp/")
+    
+    folderpath=os.path.dirname(os.path.abspath("/tmp/preprocessor.py"))
+    file_name=os.path.basename("/tmp/preprocessor.py")
+
+    #Then import all pkl files you want from bucket (need to generate this list from...
+    # function globals)
+    import os
+    pickle_file_list=[]
+    for file in os.listdir(folderpath):
+          if file.endswith(".pkl"):
+              pickle_file_list.append(os.path.join(folderpath, file))
+
+    for i in pickle_file_list: 
+          objectname=str(os.path.basename(i)).replace(".pkl","")
+          objects={objectname:""}
+          globals()[objectname]=pickle.load(open(str(i), "rb" ) )
+      # First import preprocessor function to session from preprocessor.py
+    exec(open(os.path.join(folderpath,'preprocessor.py')).read(),globals())
+    return preprocessor
+
+def get_runtimedata(runtimedata_s3_filename="runtime_data.json"):
+
+      s3 = boto3.resource('s3')
+      obj = s3.Object("$bucket_name", "$unique_model_id"+"/"+runtimedata_s3_filename)
+      runtime_data = json.load(obj.get()['Body'])
+
+      return runtime_data
+
+
+runtime_data=get_runtimedata(runtimedata_s3_filename="runtime_data.json")
+
+preprocessor_type=runtime_data["runtime_preprocessor"]
+
+runtime_model=runtime_data["runtime_model"]["name"]
+
+# Load model
+model=get_model_onnx(runtimemodel_s3_filename='runtime_model.onnx')
+
+# Load preprocessor
+preprocessor=get_preprocessor(preprocessor_s3_filename="runtime_preprocessor.zip")
+
+
+def predict(event,model,preprocessor):
+    body = event["body"]
+
+    # load class labels
+    try: 
+        s3 = boto3.resource('s3')
+        obj = s3.Object("$bucket_name", "$unique_model_id" + "/labels.json")
+        labels = json.loads(obj.get()['Body'].read())
+    except:
+        labels=$labels
+
+    import six
+    if isinstance(event["body"], six.string_types):
+        body = json.loads(event["body"])
+        print(body["data"])
+        bodydata = pd.DataFrame.from_dict(body["data"])
+    else:
+        print(body["data"])
+        bodydata = pd.DataFrame.from_dict(body["data"])
+        print(bodydata)
+
+    def predict_classes(x): # adjusted from keras github code
+        if len(x.shape)==2:
+            index = x.argmax(axis=-1)
+            return list(map(lambda x: labels[x], index))
+        else:
+            return list(x)
+    input_name = model.get_inputs()[0].name
+    print(input_name)
+    input_data = preprocessor(bodydata).astype('float32') #needs to be float32
+    print(input_data)
+    res=model.run(None,  {input_name: input_data})
+    prob = res[0]
+    print(prob)
+    return predict_classes(prob)
+
+def handler(event, context):
+        result = predict(event,model,preprocessor)
+        return {"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(result, cls=NpEncoder)}