def main():
# Setup container manager.
# k8 = KubernetesContainerManager(kubernetes_proxy_addr="127.0.0.1:8080",
# useInternalIP=True)
# clipper_conn = ClipperConnection(k8)
swarm = DockerContainerManager()
clipper_conn = ClipperConnection(swarm)
clipper_conn.stop_all()
clipper_conn.start_clipper()
# Register application.
clipper_conn.register_application(name="sum-app",
input_type="doubles",
default_output="-1.0",
slo_micros=10000000)
# Model deployement.
python_deployer.deploy_python_closure(clipper_conn,
name="sum-model",
version=1,
input_type="doubles",
func=sum)
# Link application to model.
clipper_conn.link_model_to_app(app_name="sum-app",
model_name="sum-model")
# Test
headers = {"Content-type": "application/json"}
response = requests.post("http://localhost:1337/sum-app/predict",
headers=headers,
data=json.dumps({"input": list(np.random.random(10))})).json()
print(response)
def setup_clipper():
app_name = 'inceptionv3-app'
model_name = 'inceptionv3-model'
clipper_conn = ClipperConnection(DockerContainerManager())
clipper_conn.connect()
pytorch_deployer.deploy_pytorch_model(
clipper_conn=clipper_conn,
name=model_name,
version='1',
input_type='bytes',
func=incept_predict,
pytorch_model=incept,
num_replicas=10,
batch_size=1,
pkgs_to_install=['pillow', 'pyarrow', 'torch', 'torchvision'])
clipper_conn.register_application(name=app_name,
input_type="bytes",
default_output="-1.0",
slo_micros=10000000) # 10s
clipper_conn.link_model_to_app(app_name=app_name, model_name=model_name)
print(
"url: ", "http://{addr}/{app_name}/predict".format(addr="",
app_name=app_name))
class Clip(object):
def __init__(self, sleep_time):
from clipper_admin import ClipperConnection, DockerContainerManager
#from clipper_admin.deployers import python as python_deployer
from clipper_admin.deployers import pytorch as pt_deployer
self.clipper_conn = ClipperConnection(DockerContainerManager())
try:
self.clipper_conn.connect()
self.clipper_conn.stop_all()
except Exception:
pass
self.clipper_conn.start_clipper()
self.clipper_conn.register_application(name="hello-world",
input_type="strings",
default_output="-1.0",
slo_micros=10**8)
model = Model()
def policy(ptmodel, x):
batch = (len(x))
arr = []
for j in x:
xs, masks = j.split("###")
res = np.frombuffer(base64.decodestring(xs), dtype=np.float32)
res = res.reshape((64, 19, 19, 3))
res = np.frombuffer(base64.decodestring(masks),
dtype=np.float32)
res = res.reshape((64, 362))
for i in x:
time.sleep(sleep_time)
return [
np.random.rand(64).astype(np.float32) for i in range(batch)
]
pt_deployer.deploy_pytorch_model(self.clipper_conn,
name="policy",
version=1,
input_type="strings",
func=policy,
pytorch_model=model)
self.clipper_conn.link_model_to_app(app_name="hello-world",
model_name="policy")
class Clip(object):
def __init__(self, shape, model_name):
from clipper_admin import ClipperConnection, DockerContainerManager
from clipper_admin.deployers import python as python_deployer
from clipper_admin.deployers import pytorch as pytorch_deployer
self.clipper_conn = ClipperConnection(DockerContainerManager())
try:
self.clipper_conn.connect()
self.clipper_conn.stop_all()
except Exception:
pass
self.clipper_conn.start_clipper()
self.clipper_conn.register_application(name="hello-world",
input_type="strings",
default_output="-1.0",
slo_micros=10**8)
ptmodel = get_model(model_name)
def policy(model, x):
print(len(x))
batch = (len(x))
arr = []
for j in x:
print(type(j), len(j))
res = np.frombuffer(base64.decodestring(j), dtype=np.float32)
print(res.shape)
arr += [res]
x = np.array(arr)
x = x.reshape((-1, ) + shape[1:])
print("new shape", x.shape)
return evaluate_model(model, x).reshape((batch, shape[0]))
pytorch_deployer.deploy_pytorch_model(self.clipper_conn,
name="policy",
version=1,
input_type="strings",
func=policy,
pytorch_model=ptmodel)
self.clipper_conn.link_model_to_app(app_name="hello-world",
model_name="policy")
def deployModelToClipper():
"""Deploy model to clipper and replace its entry."""
global app_name, model_name, model_version
print('Deploying model to clipper, model_name={}, model_version={}'.format(
model_name, model_version))
# Setup clipper and deploy model
clipper_conn = ClipperConnection(DockerContainerManager(redis_port=6380))
try:
clipper_conn.start_clipper()
except:
clipper_conn.connect()
try:
# input_type must be bytes as inputs will be serialized into bytes with pickle
clipper_conn.register_application(name=app_name,
input_type="bytes",
default_output="-1.0",
slo_micros=1000000)
except Exception as e:
print(e)
try:
deploy_python_closure(clipper_conn,
name=model_name,
version=model_version,
input_type="bytes",
batch_size=1,
func=predict,
base_image='hysia-clipper-base-container-gpu')
except Exception as e:
print(e)
try:
clipper_conn.link_model_to_app(app_name=app_name,
model_name=model_name)
except Exception as e:
print(e)
replaceDefaultEntry()
print('{} deployed to clipper!'.format(model_name))
def setup_clipper():
app_name = 'predict-app'
model_name = "predict-model"
clipper_conn = ClipperConnection(DockerContainerManager())
clipper_conn.connect()
deploy_python_closure(clipper_conn,
name="predict-model",
version='1',
input_type="bytes",
func=join_predict)
clipper_conn.register_application(name=app_name,
input_type="bytes",
default_output="-1.0",
slo_micros=10000000) # 10s
clipper_conn.link_model_to_app(app_name=app_name, model_name=model_name)
print(
"url: ", "http://{addr}/{app_name}/predict".format(addr="",
app_name=app_name))
def setup_clipper():
app_name = 'resnet101-app'
model_name = 'resnet101-model'
clipper_conn = ClipperConnection(DockerContainerManager())
clipper_conn.connect()
pytorch_deployer.deploy_pytorch_model(clipper_conn=clipper_conn,
name=model_name,
version='1',
input_type='bytes',
func=resnet_predict,
pytorch_model=resnet101,
pkgs_to_install=['pillow', 'torch', 'torchvision'])
clipper_conn.register_application(name=app_name,
input_type="bytes",
default_output="-1.0",
slo_micros=10000000) # 10s
clipper_conn.link_model_to_app(app_name=app_name, model_name=model_name)
print("query_adress: ", clipper_conn.get_query_addr())
print("app_name: ", )
print("model_name: ", )
print("url: ", "http://{addr}/{app_name}/predict".format(addr=clipper_conn.get_query_addr(),app_name=app_name))
elif sys.argv[2] == "sess-frozen":
sess = load_from_frozen()
deploy_tensorflow_model(clipper_conn,
model_name,
version=1,
input_type="integers",
func=predict,
tf_sess_or_saved_model_path=sess)
elif sys.argv[2] == "checkpoint":
deploy_tensorflow_model(
clipper_conn,
model_name,
version=1,
input_type="integers",
func=predict,
tf_sess_or_saved_model_path=CHECKPOINT_PATH.split('/')[0])
elif sys.argv[2] == "frozen":
deploy_tensorflow_model(clipper_conn,
model_name,
version=1,
input_type="integers",
func=predict,
tf_sess_or_saved_model_path=FROZEN_GRAPH_PATH)
else:
print("invalid usage")
print(
"usage: python deploy.py --mode checkpoint|frozen|checkpoint|sess-frozen"
)
exit(1)
clipper_conn.link_model_to_app(app_name, model_name)
global model
pred = model.predict(inputs)
return [str(p) for p in pred]
# Point to the gradient boosting model
model = model
# Deploy the 'predict' function as a model
deploy_python_closure(
clipper_conn,
name="gb-model",
version=1,
input_type="doubles",
func=predict,
pkgs_to_install=['scikit-learn', 'pandas', 'numpy', 'scipy'],
registry="gkip")
# Routes requests for the application 'kddtutorial' to the model 'gb-model'
clipper_conn.link_model_to_app(app_name="kddtutorial", model_name="gb-model")
inputs = X.loc[200, X.columns != 'classification'] # use random data point
headers = {"Content-type": "application/json"}
addr = clipper_conn.get_query_addr()
response = requests.post("http://%s/%s/predict" % (addr, 'kddtutorial'),
headers=headers,
data=json.dumps({"input": list(inputs)})).json()
print(response)
clipper_conn.stop_all()
# In[ ]:
from clipper_admin.deployers import python as python_deployer
# We specify which packages to install in the pkgs_to_install arg.
# For example, if we wanted to install xgboost and psycopg2, we would use
# pkgs_to_install = ['xgboost', 'psycopg2']
python_deployer.deploy_python_closure(clipper_conn, name='xgboost-model', version=1,
input_type="integers", func=predict, pkgs_to_install=['xgboost'])
# In[ ]:
clipper_conn.link_model_to_app('xgboost-test', 'xgboost-model')
# In[ ]:
import requests, json
# Get Address
addr = clipper_conn.get_query_addr()
# Post Query
response = requests.post(
"http://%s/%s/predict" % (addr, 'xgboost-test'),
headers={"Content-type": "application/json"},
data=json.dumps({
'input': get_test_point()
}))
KubernetesContainerManager(useInternalIP=True))
# clipper_conn = ClipperConnection(DockerContainerManager())
clipper_conn.start_clipper()
#Deploy lin_model_1
clipper_conn.register_application(name="linear1",
input_type="doubles",
default_output="-1.0",
slo_micros=100000)
deploy_python_closure(clipper_conn,
name="lin-model-1",
version=1,
input_type="doubles",
func=lin_model_1,
registry="hsubbaraj")
clipper_conn.link_model_to_app(app_name="linear1", model_name="lin-model-1")
print("deployed model 1")
#Deploy lin_model_2
clipper_conn.register_application(name="linear2",
input_type="doubles",
default_output="-1.0",
slo_micros=100000)
deploy_python_closure(clipper_conn,
name="lin-model-2",
version=1,
input_type="doubles",
func=lin_model_2,
registry="hsubbaraj")
clipper_conn.link_model_to_app(app_name="linear2", model_name="lin-model-2")
print("deployed model 2")
def predict(delay):
#delay = eval(delay)
future_r = model_r.make_future_dataframe(periods=30, freq='D')
forecast_r = model_r.predict(future_r)
#forecast_r.index = forecast_r['ds']
#forecast
#pred_r = pd.DataFrame(forecast_r['yhat'][len(forecast_r)-delay:len(forecast_r)])
#pred_r=pred_r.reset_index()
#pred_r = pred_r.to_json()
return forecast_r.to_json()
from clipper_admin.deployers import python as python_deployer
python_deployer.deploy_python_closure(
clipper_conn,
name="p1model",
version=1,
input_type="strings",
func=predict,
pkgs_to_install=['pandas', 'fbprophet==0.4'])
clipper_conn.link_model_to_app(app_name="p1app", model_name="p1model")
#import requests, json, numpy as np
#headers = {"Content-type": "application/json"}
#datas = json.dumps({"input": list(np.random.random(10))})
#requests.post("http://10.65.47.80:1337/p1app/predict", headers=headers, data=datas).json()
# Setup clipper and deploy pytorch model
clipper_conn = ClipperConnection(DockerContainerManager(redis_port=6380))
try:
clipper_conn.start_clipper()
clipper_conn.register_application(name=APP_NAME,
input_type="doubles",
default_output="-1.0",
slo_micros=1000000)
deploy_pytorch_model(clipper_conn,
name=MODEL_NAME,
version="1",
input_type="doubles",
func=predict,
pytorch_model=model,
pkgs_to_install=pip_deps)
clipper_conn.link_model_to_app(app_name=APP_NAME, model_name=MODEL_NAME)
except:
clipper_conn.connect()
# Check all apps
print(clipper_conn.get_all_apps())
# Test inference
# inputs = np.array([[1., 2., 3.], [2., 3., 4.], [3., 4., 5.]])
# print(predict(model, inputs))
inputs = np.array([1., 2., 3.]).tolist(
) # Inputs can only be one-dimensional or there will be json serialization error
headers = {"Content-type": "aplication/json"}
result = requests.post("http://localhost:1337/" + APP_NAME + "/predict",
headers=headers,
data=json.dumps({"input": inputs})).json()
return results
#################################################
#################################################
#################################################
from clipper_admin.deployers import python as python_deployer
python_deployer.deploy_python_closure(clipper_conn,
name="query-agent-model",
input_type="doubles",
func=query_agent_function,
version=9)
clipper_conn.link_model_to_app(app_name="query_agent",
model_name="query-agent-model")
# Debugging
clipper_conn.set_model_version(name="query-agent-model", version="3")
import requests, json, time, sys, numpy as np
headers = {"Content-type": "application/json"}
clipper_url = "192.168.56.101" # default: "localhost"
app_name = "query_agent"
# data_input = json.dumps({"input": list(np.random.random(input_size))})
data_input = json.dumps(
{"input": list(np.random.randint(0, 16, 64).astype(float))})
print requests.post("http://" + clipper_url + ":1337/" + app_name + "/predict",
headers=headers,
data=data_input).json()
TESTDATA = StringIO(inputs[0])
data = spark.createDataFrame(read_csv(TESTDATA, header=None, names=['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']))
feature_cols = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width']
assembler = pyspark.ml.feature.VectorAssembler(inputCols=feature_cols, outputCol='features')
data = assembler.transform(data)
data = data.select(['features', 'class'])
label_indexer = pyspark.ml.feature.StringIndexer(inputCol='class', outputCol='label').fit(data)
data = label_indexer.transform(data)
data = data.select(['features', 'label'])
output = model.transform(data).select("prediction").rdd.flatMap(lambda x: x).collect()
return output
deploy_pyspark_model(
clipper_conn,
name="iris-output",
version=1,
input_type="string",
func=predict,
pyspark_model=model,
sc=sc,
pkgs_to_install=["pandas"])
clipper_conn.register_application(
name="iris-app",
input_type="strings",
default_output="-1",
slo_micros=9000000) #will return default value in 9 seconds
clipper_conn.link_model_to_app(app_name="iris-app", model_name="iris-output")
# )
deploy_pytorch_model(
clipper_conn,
name="superresolution-model",
version=1,
input_type="bytes",
func=image_enhance,
pytorch_model=model,
base_image='custom-model-image',
pkgs_to_install=['opencv-python','numpy','six', 'Pillow','wheel',]
)
print("linking model to app...")
clipper_conn.link_model_to_app(app_name="superresolution", model_name="superresolution-model")
def query(addr, filename):
url = "http://%s/superresolution/predict" % addr
req_json = json.dumps({
"input":
base64.b64encode(open(filename, "rb").read()).decode() # bytes to unicode
})
headers = {'Content-type': 'application/json'}
r = requests.post(url, headers=headers, data=req_json)
print(r.json())
print("deployed... do a query")
query(clipper_conn.get_query_addr(),'LR/baboon.png')
######### Define Own Prediction Function ######## ################################################# import sklearn import numpy as np from sklearn.neural_network import MLPClassifier from sklearn.externals import joblib model_path = "../../models/sklearn/" model_name = "nn_model.sav" clf = joblib.load(model_path + model_name) def clf_predict(xs): return clf.predict(xs) ################################################# ################################################# ################################################# from clipper_admin.deployers import python as python_deployer python_deployer.deploy_python_closure( clipper_conn, name="nn-model", version=1, input_type="doubles", func=clf_predict) clipper_conn.link_model_to_app(app_name="breast-cancer", model_name="nn-model") # clipper_conn.stop_all()
cols = ['age','workclass','fnlwgt','education','education-num','marital-status', \
'occupation','relationship','race','sex','capital-gain', \
'capital-loss','hours-per-week','native-country','label']
TESTDATA = StringIO(inputs[0])
data = spark.createDataFrame(read_csv(TESTDATA, header=None, names=cols))
feature_cols = cols[:-1]
assembler = pyspark.ml.feature.VectorAssembler(inputCols=feature_cols, outputCol='features')
data = assembler.transform(data)
data = data.select(['features', 'label'])
output = model.transform(data).select("prediction").rdd.flatMap(lambda x: x).collect()
return output
deploy_pyspark_model(
clipper_conn,
name="pyspark-test",
version=1,
input_type="string",
func=predict,
pyspark_model=model,
sc=sc,
pkgs_to_install=["pandas"])
clipper_conn.register_application(
name="pyspark-app",
input_type="strings",
default_output="-1",
slo_micros=9000000) #will return default value in 9 seconds
clipper_conn.link_model_to_app(app_name="pyspark-app", model_name="pyspark-test")
# For example, if we wanted to install xgboost and psycopg2, we would use
# pkgs_to_install = ['xgboost', 'psycopg2']
print("Deploy predict function closure using Clipper...")
python_deployer.deploy_python_closure(clipper_conn,
name='xgboost-model',
version=1,
input_type="doubles",
func=predict,
pkgs_to_install=['xgboost'])
time.sleep(5)
# In[8]:
print("Link Clipper connection to model application...")
clipper_conn.link_model_to_app('xgboost-airlines', 'xgboost-model')
# In[22]:
import requests, json
# Get Address
addr = clipper_conn.get_query_addr()
print(
"Model predict for a single instance via Python requests POST request & parse response..."
)
# Post Query
response = requests.post("http://%s/%s/predict" % (addr, 'xgboost-airlines'),
headers={"Content-type": "application/json"},
data=json.dumps({'input': get_test_point(0)}))
result = response.json()
clipper_conn = ClipperConnection(DockerContainerManager())
clipper_conn.start_clipper()
clipper_addr = clipper_conn.get_query_addr()
def preprocess(inputs):
inputArr = (inputs[0]).split(",")
floats = inputArr[:-1]
rounded = [round(float(i),1) for i in floats]
rounded.append(inputArr[-1])
output = [(str(rounded))[1:-1]]
return output
python_deployer.deploy_python_closure(
clipper_conn,
name="process-iris", # The name of the model in Clipper
version=1, # A unique identifier to assign to this model.
input_type="string", # The type of data the model function expects as input
func=preprocess # The model function to deploy
)
clipper_conn.register_application(
name="process-app",
input_type="strings",
default_output="-1",
slo_micros=9000000) #will return default value in 9 seconds
clipper_conn.link_model_to_app(app_name="process-app", model_name="process-iris")
response = apply_forecast_impl(parameters[0].decode("utf-8").split(','))
code = '202'
except Exception as e:
response = str(e)
code = '500'
return [str(code+', '+response) for _ in parameters]
if __name__ == '__main__':
# setup logging format
format = "%(asctime)-15s %(message)s"
logging.basicConfig(
filename='./timeseries/log.log', level=logging.DEBUG, format=format)
# set up logging to console
console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.ERROR)
logging.getLogger().addHandler(console)
signal.signal(signal.SIGINT, signal_handler)
conn = ClipperConnection(DockerContainerManager())
conn.start_clipper()
try:
conn.register_application(name="forecast",input_type="strings",default_output="500, Error executing call.",slo_micros=100000000)
python_deployer.deploy_python_closure(conn, name="do-forecast", version=1, input_type="strings", func=do_forecast, base_image='wamsiv/timeseries:latest')
conn.link_model_to_app(app_name="forecast", model_name='do-forecast')
print(subprocess.getoutput(["docker update --restart=on-failure $(docker ps -a | grep 'clipper/query_frontend:0.3.0' | awk '{ print $1 }')"]))
input("Server started. Press ctrl+c to stop server.\n")
except Exception as e:
logging.error("Encountered {}. Stopping server...".format(e))
conn.stop_all()
conn.stop_all()
clipper_query_port=1337 + node_id,
clipper_management_port=2337 + node_id,
clipper_rpc_port=7000 + node_id,
redis_ip=None,
redis_port=6379 + node_id,
prometheus_port=9090 + node_id,
# WARING: DO NOT CHANGE THE RULE OF NETWORK NAMES
docker_network='clipper_network_{}'.format(node_id),
# SINCE THIS IS USED BY reset.sh TO IDENTIFY CLIPPER CONTAINERS
extra_container_kwargs={})
) # for node_id in range(args.num_nodes)]
try:
clipper_conn.start_clipper()
clipper_conn.register_application(name="default",
input_type="string",
default_output="",
slo_micros=100000)
python_deployer.deploy_python_closure(clipper_conn,
name="echo-model",
version=1,
input_type="string",
func=echo_model)
clipper_conn.link_model_to_app(app_name="default",
model_name="echo-model")
except:
exit(1)
exit(0)
oY = graph.get_tensor_by_name('Placeholder_1:0')
def predict(X):
print("inputs {}".format(X))
result = sess.run(load_infer_op, feed_dict={oX: X})
ret = [str(i) for i in result]
print("return is {}".format(ret))
return ret
manager = KubernetesContainerManager(kubernetes_proxy_addr=K8S_ADDR,
namespace=K8S_NS)
clipper_conn = ClipperConnection(manager)
clipper_conn.connect()
# clipper_conn.delete_application(APP_NAME)
# clipper_conn.register_application(
# name = APP_NAME, input_type = 'doubles', default_output = '0', slo_micros = 100000000)
deploy_tensorflow_model(clipper_conn,
name=PREDICT_NAME,
version=VERSION,
input_type="doubles",
func=predict,
tf_sess_or_saved_model_path=sess,
registry=REGISTRY,
pkgs_to_install=['tensorflow'])
clipper_conn.link_model_to_app(app_name=APP_NAME, model_name=PREDICT_NAME)
res = []
for x in xs:
x = x.reshape(1, -1)
res.append(str(model.predict(x)))
print("res: ", res)
return res
# In[43]:
from clipper_admin.deployers import python as python_deployer
# We specify which packages to install in the pkgs_to_install arg.
# For example, if we wanted to install xgboost and psycopg2, we would use
# pkgs_to_install = ['xgboost', 'psycopg2']
python_deployer.deploy_python_closure(clipper_conn,
name='simple-model',
version=1,
input_type="floats",
pkgs_to_install=['sklearn'],
func=predict)
# In[44]:
try:
clipper_conn.link_model_to_app('simple_model', 'simple-model')
except ClipperException as e:
print(e)
addr = clipper_conn.get_query_addr()
print(addr)
args = json.loads(param)
zone = args['zone']
date = str(args['date'])
schedule = args['schedule']
temps, actions = execute_schedule(date, schedule, models[zone], 65)
ret.append(temps)
return ret
from clipper_admin.deployers import python as python_deployer
python_deployer.deploy_python_closure(clipper_conn,
name='thermal-model-ciee',
version=1,
input_type='strings',
func=execute_thermal_model,
base_image="xbospy")
clipper_conn.link_model_to_app(app_name="ciee_thermal",
model_name="thermal-model-ciee")
except:
clipper_conn.connect()
import time
import requests
time.sleep(10)
inp = json.dumps({
'zone': 'http://buildsys.org/ontologies/ciee#CentralZone',
'date': '2018-02-06 00:00:00 UTC',
'schedule': normal_schedule
})
print inp
resp = requests.post('http://localhost:1337/ciee_thermal/predict',
data=json.dumps({'input': inp}))
# clipper_start from clipper_admin import ClipperConnection, DockerContainerManager clipper_conn = ClipperConnection(DockerContainerManager()) clipper_conn.start_clipper() clipper_conn.connect() clipper_conn.register_application( name="hello-world", input_type="doubles", default_output="-1.0", slo_micros=100000) clipper_conn.get_all_apps() def feature_sum(xs): return [str(sum(x)) for x in xs] from clipper_admin.deployers import python as python_deployer python_deployer.deploy_python_closure( clipper_conn, name="sum-model", version=1, input_type="doubles", func=feature_sum) clipper_conn.link_model_to_app(app_name="hello-world", model_name="sum-model") # clipper_conn.stop_all()
clipper_conn.start_clipper()
clipper_conn.register_application(name="pytorch-example-2", input_type="doubles", default_output="-1.0", slo_micros=100000)
# model = nn.Linear(1, 1)
# Define a shift function to normalize prediction inputs
def pred(model, inputs):
preds = []
for i in inputs:
preds.append(np.random.rand(1,10))
return preds
# return [model(torch.FloatTensor(np.reshape(i, (-1, 3, 32, 32))).data.numpy()) for i in inputs]
# return [str(model(torch.FloatTensor(np.reshape(i, (1, 3, 32, 32)))).data.numpy()) for i in inputs]
deploy_pytorch_model(
clipper_conn,
name="pytorch-nn",
version=1,
input_type="doubles",
func=pred,
pytorch_model=net,
registry="hsubbaraj"
)
clipper_conn.link_model_to_app(app_name="pytorch-example-2", model_name="pytorch-nn")
time.sleep(2)
print("deployed model")
def predict(model, inputs):
trans = shift(inputs)
pred = model(trans)
# print(pred)
pred = pred.data.numpy()
# print(pred)
# print(pred.shape)
# pred = pred.flatten()
# print(pred)
# print(pred.shape)
#Fix bug, append str(pred.shape) tuple as string, and append dtype
return pred.astype(np.str).tolist()
# return [np.array2string(x, precision=8,separator=",") for x in pred]
# res = pred.tostring().encode('base64')
# print(res)
# return [res]
# return [np.array_str(pred)]
deploy_pytorch_model(clipper_conn,
name="example",
version=1,
input_type="doubles",
func=predict,
pytorch_model=model)
clipper_conn.link_model_to_app(app_name="Shoe", model_name="example")
slo_micros=10000000) # 10,000,000 micros == 10 sec
clipper_conn.get_all_apps()
#################################################
######### Define Own Prediction Function ########
#################################################
import sklearn
import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.externals import joblib
from clipper_admin.deployers import python as python_deployer
for version_postfix in ["10x1k", "10x2k", "20x1k", "15x2k"]:
model_path = "../../models/sklearn/"
model_name = "dig_nn_model_" + version_postfix + ".sav"
clf = joblib.load(model_path + model_name)
def clf_predict(xs):
return clf.predict(xs)
python_deployer.deploy_python_closure(clipper_conn,
name="digit-nn-model",
version=version_postfix,
input_type="doubles",
func=clf_predict)
clipper_conn.link_model_to_app(app_name="digit", model_name="digit-nn-model")
# clipper_conn.stop_all()
data_transforms = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(train_mean, train_std)])
image = get_image(data_transforms, image_url)
pred = np.argmax(model(image).detach().numpy())
return CLASSES[pred]
model = get_model()
clipper_conn.stop_models(model_names='logo-detector')
deploy_pytorch_model(
clipper_conn,
name="logo-detector",
version=1,
input_type="strings",
func=predict,
pytorch_model=model,
pkgs_to_install=['Pillow', 'torchvision', 'torch', 'numpy', 'requests']
)
clipper_conn.get_clipper_logs()
clipper_conn.link_model_to_app(app_name="logo-detector", model_name="logo-detector")
clipper_conn.get_linked_models(app_name="logo-detector")
clipper_conn.cm.get_num_replicas(name="logo-detector", version="1")
clipper_conn.get_clipper_logs()
