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)