def setUp(self):
new_name = "admin-test-cluster-{}".format(random.randint(0, 5000))
self.clipper_conn = create_docker_connection(cleanup=False,
start_clipper=True,
new_name=new_name,
use_centralized_log=False)
self.name = new_name
def test_invalid_clipper_conn_old_connection_not_use_log_centralization(
self):
# Raise a ClipperException when new connection uses log-centralization, although
# the original connection does not use log-centralization.
# Recreate a cluster with
self.clipper_conn = create_docker_connection(
cleanup=True, start_clipper=False, cleanup_name=self.cluster_name)
self.start_clipper(self.cluster_name, use_centralized_log=False)
new_conn = get_new_connection_instance(self.cluster_name, True)
self.assertRaises(ClipperException, new_conn.connect)
def create(name, use_kubernetes=False):
if use_kubernetes:
conn = create_kubernetes_connection(cleanup=False,
start_clipper=True,
new_name=name)
else:
conn = create_docker_connection(cleanup=False,
start_clipper=True,
new_name=name)
return conn
def setUpClass(self):
self.clipper_conn = create_docker_connection(cleanup=True,
start_clipper=True)
self.app_name_1 = "app3"
self.app_name_2 = "app4"
self.app_name_3 = "app5"
self.app_name_4 = "app6"
self.app_name_5 = "app7"
self.model_name_1 = "m4"
self.model_name_2 = "m5"
self.model_name_3 = "m6"
self.model_name_4 = "m7"
self.model_name_5 = "m8"
self.input_type = "doubles"
self.default_output = "DEFAULT"
self.latency_slo_micros = 30000
self.clipper_conn.register_application(self.app_name_1,
self.input_type,
self.default_output,
self.latency_slo_micros)
self.clipper_conn.register_application(self.app_name_2,
self.input_type,
self.default_output,
self.latency_slo_micros)
self.clipper_conn.register_application(self.app_name_3,
self.input_type,
self.default_output,
self.latency_slo_micros)
self.clipper_conn.register_application(self.app_name_4,
self.input_type,
self.default_output,
slo_micros=30000000)
self.clipper_conn.register_application(self.app_name_5,
self.input_type,
self.default_output,
self.latency_slo_micros)
def start_clipper(self, cluster_name, use_centralized_log=True):
self.clipper_conn = create_docker_connection(
cleanup=False,
start_clipper=True,
new_name=cluster_name,
use_centralized_log=use_centralized_log)
# Make sure all the containers are on.
timeout_count = 0
while True:
containers = get_containers(self.clipper_conn)
if self.all_containers_found(containers):
break
timeout_count += 1
if timeout_count == 5:
self.logger.info("Running containers: {}".format(containers))
raise TimeoutError(
"Containers haven't been created within 10 seconds. "
"It means that every instance haven't been initialized.")
time.sleep(2)
self.logger.info("All the containers are found")
raise BenchmarkException("Error querying APP %s, MODEL %s:%d" %
(app, model_name, version))
def get_test_point():
return [np.random.randint(255) for _ in range(784)]
if __name__ == "__main__":
pos_label = 3
import random
cluster_name = "xg-{}".format(random.randint(0, 5000))
try:
clipper_conn = create_docker_connection(cleanup=False,
start_clipper=True,
new_name=cluster_name)
try:
clipper_conn.register_application(app_name, "integers",
"default_pred", 100000)
time.sleep(1)
addr = clipper_conn.get_query_addr()
response = requests.post("http://%s/%s/predict" % (addr, app_name),
headers=headers,
data=json.dumps(
{'input': get_test_point()}))
result = response.json()
if response.status_code != requests.codes.ok:
print("Error: %s" % response.text)
def doCleanups(self):
self.clipper_conn = create_docker_connection(
cleanup=True, start_clipper=False, cleanup_name=self.cluster_name)
class TrainingDataset(data.Dataset):
def __init__(self, data, label):
self.imgs = data
self.classes = label
def __getitem__(self, index):
img = self.imgs[index]
label = self.classes[index]
img = torch.Tensor(img)
return img, torch.Tensor(label)
if __name__ == "__main__":
pos_label = 3
try:
clipper_conn = create_docker_connection(cleanup=True,
start_clipper=True)
train_path = os.path.join(cur_dir, "data/train.data")
train_x, train_y = parsedata(train_path, pos_label)
train_x = normalize(train_x)
train_loader = TrainingDataset(train_x, train_y)
try:
clipper_conn.register_application(app_name, "integers",
"default_pred", 100000)
time.sleep(1)
addr = clipper_conn.get_query_addr()
response = requests.post("http://%s/%s/predict" % (addr, app_name),
headers=headers,
data=json.dumps(
def tearDownClass(self):
self.clipper_conn = create_docker_connection(cleanup=True,
start_clipper=False)
def setUp(self):
self.clipper_conn = create_docker_connection(cleanup=True,
start_clipper=True)
def tearDown(self):
self.clipper_conn = create_docker_connection(cleanup=True,
start_clipper=False,
cleanup_name=self.name)
def run_test():
spark = SparkSession\
.builder\
.appName("clipper-pyspark")\
.getOrCreate()
training = spark.createDataFrame([(0, "a b c d e spark", 1.0),
(1, "b d", 0.0), (2, "spark f g h", 1.0),
(3, "hadoop mapreduce", 0.0)],
columns + ["label"])
# Configure an ML pipeline, which consists of three stages: tokenizer, hashingTF, and lr.
tokenizer = Tokenizer(inputCol="text", outputCol="words")
hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(),
outputCol="features")
lr = LogisticRegression(maxIter=10, regParam=0.001)
pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])
# Fit the pipeline to training documents.
model = pipeline.fit(training)
# Prepare test documents, which are unlabeled (id, text) tuples.
test = spark.createDataFrame([(4, "spark i j k"), (5, "l m n"),
(6, "spark hadoop spark"),
(7, "apache hadoop")], columns)
# Make predictions on test documents and print columns of interest.
prediction = model.transform(test)
selected = prediction.select("id", "text", "probability", "prediction")
for row in selected.collect():
rid, text, prob, prediction = row
print("(%d, %s) --> prob=%s, prediction=%f" %
(rid, text, str(prob), prediction))
# test predict function
print(
predict(spark, model,
[json.dumps((np.random.randint(1000), "spark abcd"))]))
try:
clipper_conn = create_docker_connection(cleanup=True,
start_clipper=True)
try:
clipper_conn.register_application(app_name, "strings",
"default_pred", 10000000)
time.sleep(1)
addr = clipper_conn.get_query_addr()
response = requests.post("http://%s/%s/predict" % (addr, app_name),
headers=headers,
data=json.dumps({
'input':
json.dumps((np.random.randint(1000),
"spark abcd"))
}))
result = response.json()
if response.status_code != requests.codes.ok:
print("Error: %s" % response.text)
raise BenchmarkException("Error creating app %s" % app_name)
version = 1
deploy_pyspark_model(clipper_conn, model_name, version, "strings",
predict, model, spark.sparkContext)
clipper_conn.link_model_to_app(app_name, model_name)
time.sleep(30)
num_preds = 25
num_defaults = 0
addr = clipper_conn.get_query_addr()
for i in range(num_preds):
response = requests.post(
"http://%s/%s/predict" % (addr, app_name),
headers=headers,
data=json.dumps({
'input':
json.dumps((np.random.randint(1000), "spark abcd"))
}))
result = response.json()
if response.status_code == requests.codes.ok and result[
"default"]:
num_defaults += 1
if num_defaults > 0:
print("Error: %d/%d predictions were default" %
(num_defaults, num_preds))
if num_defaults > num_preds / 2:
raise BenchmarkException("Error querying APP %s, MODEL %s:%d" %
(app_name, model_name, version))
version += 1
deploy_pyspark_model(clipper_conn, model_name, version, "strings",
predict, model, spark.sparkContext)
time.sleep(30)
num_preds = 25
num_defaults = 0
addr = clipper_conn.get_query_addr()
for i in range(num_preds):
response = requests.post(
"http://%s/%s/predict" % (addr, app_name),
headers=headers,
data=json.dumps({
'input':
json.dumps((np.random.randint(1000), "spark abcd"))
}))
result = response.json()
if response.status_code == requests.codes.ok and result[
"default"]:
num_defaults += 1
if num_defaults > 0:
print("Error: %d/%d predictions were default" %
(num_defaults, num_preds))
if num_defaults > num_preds / 2:
raise BenchmarkException("Error querying APP %s, MODEL %s:%d" %
(app_name, model_name, version))
except BenchmarkException as e:
log_docker(clipper_conn)
log_clipper_state(clipper_conn)
logger.exception("BenchmarkException")
clipper_conn = create_docker_connection(cleanup=True,
start_clipper=False)
sys.exit(1)
else:
spark.stop()
clipper_conn = create_docker_connection(cleanup=True,
start_clipper=False)
logger.info("ALL TESTS PASSED")
except Exception as e:
log_docker(clipper_conn)
logger.exception("Exception")
clipper_conn = create_docker_connection(cleanup=True,
start_clipper=False)
sys.exit(1)
