def __init__(self): print "init dualcross" self.gateway_channel = implementations.insecure_channel('localhost', 50051) self.gateway = beta_create_BfGatewayService_stub(self.gateway_channel) self.datafeed_channel = implementations.insecure_channel('localhost',50052) self.datafeed = beta_create_BfDatafeedService_stub(self.datafeed_channel) self.connectivity = interfaces.ChannelConnectivity.IDLE
def main(): print("Testing namenode...") port = 5000 ip = "127.0.0.1" channel = implementations.insecure_channel(str(ip),int(port)) stub = namenode_pb2.beta_create_NameNode_stub(channel) #parameters required for request pfn = "./test.txt" file_size = 1337 ts = "123121234" f = open(pfn, 'r') d = f.read() f.close() #req =namenode_pb2.StoreRequest(file_path=pfn,file_size=file_size,timestamp=ts) #response = stub.Store(req,10) req = namenode_pb2.ReadRequest(file_path=pfn,timestamp=ts) response = stub.Read(req,10) datanodes = json.loads(response.datanodes) c = (datanodes) dn_channel = implementations.insecure_channel('localhost',5000) dn_stub = datanode_pb2.beta_create_DataNode_stub(dn_channel) pathy = hashlib.sha1(pfn).hexdigest() dn_req = datanode_pb2.ReadRequest(blockname=pathy,timestamp=ts) response = dn_stub.Read(dn_req,10) print(response.data)
def __init__(self): print "init datarecorder" self.gateway_channel = implementations.insecure_channel('localhost', 50051) self.gateway = beta_create_BfGatewayService_stub(self.gateway_channel) self.datafeed_channel = implementations.insecure_channel('localhost',50052) self.datafeed = beta_create_BfDatafeedService_stub(self.datafeed_channel) self._service = beta_create_BfProxyService_server(self) self._service.add_insecure_port('[::]:50060')
def __init__(self): print "init robot" self.gateway_channel = implementations.insecure_channel('localhost', 50051) self.gateway = bfgateway_pb2.beta_create_BfGatewayService_stub(self.gateway_channel) self.datafeed_channel = implementations.insecure_channel('localhost', 50052) self.datafeed = bfdatafeed_pb2.beta_create_BfDatafeedService_stub(self.datafeed_channel) self._service = bfrobot_pb2.beta_create_BfRobotService_server(self) self._service.add_insecure_port('[::]:50053')
def __init__(self): print "init datarecorder" self.gateway_channel = implementations.insecure_channel('localhost', 50051) self.gateway = beta_create_BfGatewayService_stub(self.gateway_channel) self.datafeed_channel = implementations.insecure_channel('localhost',50052) self.datafeed = beta_create_BfDatafeedService_stub(self.datafeed_channel) self.connectivity = interfaces.ChannelConnectivity.IDLE # -------------------------------------------------- # 1Min Bar的时间戳 self.last_dt_bar = dt.datetime.now() # 当前累积的Bar self.CntBar = BfBarData() self.last_volume = 1
def run(): channel = implementations.insecure_channel('localhost', 50051) stub = ss_pb2.beta_create_ImageAnalysis_stub(channel) img_region = ss_pb2.ImageRegion() # img_file = open("/home/mythxcq/source_codes/caffe/examples/images/cat.jpg", "rb") img_file = open("/home/mythxcq/2.jpg", "rb") img_region.img = img_file.read() # img_region.x = 0 # img_region.w = 1000 # img_region.y = 0 # img_region.h = 1000 img_file.close() # string_buffer = StringIO.StringIO(img_region.img) # img = caffe.io.load_image(string_buffer) # inputs = [img] # model_def = "/home/mythxcq/caffe_person_classification_models/google_net/deploy_112.prototxt" # pretrained_model = "/home/mythxcq/caffe_person_classification_models/google_net/finetune_person_googlenet_112.caffemodel" # mean_file = "" # mean = np.load(mean_file) # mean = np.empty((3,112,112),dtype=np.float32) # mean[0] = 104 # mean[1] = 117 # mean[2] = 123 # global classifier # mean = np.array([104,117,123]) # classifier = caffe.Classifier(model_def, pretrained_model) # predictions = classifier.predict(inputs, False) # print(predictions) response = [stub.ImageClassify.future(img_region, _TIMEOUT_SECONDS) for i in range(5) ] print("send all tasks") for res in response: print(res.result().type)
def __init__(self, server, config, hist): # Create the stub host, port = server.split(':') port = int(port) if config.HasField('security_params'): creds = implementations.ssl_channel_credentials( resources.test_root_certificates()) channel = test_utilities.not_really_secure_channel( host, port, creds, config.security_params.server_host_override) else: channel = implementations.insecure_channel(host, port) connected_event = threading.Event() def wait_for_ready(connectivity): if connectivity == grpc.ChannelConnectivity.READY: connected_event.set() channel.subscribe(wait_for_ready, try_to_connect=True) connected_event.wait() if config.payload_config.WhichOneof('payload') == 'simple_params': self._generic = False self._stub = services_pb2.beta_create_BenchmarkService_stub(channel) payload = messages_pb2.Payload( body='\0' * config.payload_config.simple_params.req_size) self._request = messages_pb2.SimpleRequest( payload=payload, response_size=config.payload_config.simple_params.resp_size) else: self._generic = True self._stub = implementations.generic_stub(channel) self._request = '\0' * config.payload_config.bytebuf_params.req_size self._hist = hist self._response_callbacks = []
def main(): host = "0.0.0.0" port = 8502 model_name = "default" model_version = -1 signature_name = "" request_timeout = 10.0 # Generate inference data image_b64_string = base64.urlsafe_b64encode(open("./0.jpg", "rb").read()) images_tensor_proto = tf.contrib.util.make_tensor_proto( [image_b64_string], dtype=tf.string) # Create gRPC client channel = implementations.insecure_channel(host, port) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = model_name if model_version > 0: request.model_spec.version.value = model_version if signature_name != "": request.model_spec.signature_name = signature_name request.inputs["images"].CopyFrom(images_tensor_proto) # Send request start_time = time.time() for i in range(10): result = stub.Predict(request, request_timeout) end_time = time.time() print("Cost time: {}".format(end_time - start_time)) print(result)
def testRegress(self): """Test PredictionService.Regress implementation.""" model_path = self._GetSavedModelBundlePath() atexit.register(self.TerminateProcs) model_server_address = self.RunServer(PickUnusedPort(), 'default', model_path) print 'Sending Regress request...' # Prepare request request = regression_pb2.RegressionRequest() request.model_spec.name = 'default' request.model_spec.signature_name = 'regress_x_to_y' example = request.input.example_list.examples.add() example.features.feature['x'].float_list.value.extend([2.0]) # Send request host, port = model_server_address.split(':') channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) result = stub.Regress(request, RPC_TIMEOUT) # 5 secs timeout # Verify response self.assertEquals(1, len(result.result.regressions)) expected_output = 3.0 self.assertEquals(expected_output, result.result.regressions[0].value) self._VerifyModelSpec(result.model_spec, request.model_spec.name, request.model_spec.signature_name, self._GetModelVersion(model_path))
def run(gobgpd_addr, vrf_name, route_dist, import_rt, export_rt): channel = implementations.insecure_channel(gobgpd_addr, 50051) with gobgp_pb2.beta_create_GobgpApi_stub(channel) as stub: bin_rd = str_to_bin_for_rd(route_dist) import_rts = [] bin_import_rt = str_to_bin_for_rt(import_rt) import_rts.append(str(bin_import_rt)) export_rts = [] bin_export_rt = str_to_bin_for_rt(export_rt) export_rts.append(str(bin_export_rt)) vrf = {} vrf['name'] = vrf_name vrf['rd'] = str(bin_rd) vrf['import_rt'] = import_rts vrf['export_rt'] = export_rts ret = stub.ModVrf(gobgp_pb2.ModVrfArguments(operation=Operation_ADD, vrf=vrf), _TIMEOUT_SECONDS) if ret.code == 0: print "Success!" else: print "Error!"
def test_immediately_connectable_channel_connectivity(self): server = implementations.server({}) port = server.add_insecure_port('[::]:0') server.start() channel = implementations.insecure_channel('localhost', port) callback = _Callback() try: ready_future = utilities.channel_ready_future(channel) ready_future.add_done_callback(callback.accept_value) self.assertIsNone( ready_future.result(timeout=test_constants.LONG_TIMEOUT)) value_passed_to_callback = callback.block_until_called() self.assertIs(ready_future, value_passed_to_callback) self.assertFalse(ready_future.cancelled()) self.assertTrue(ready_future.done()) self.assertFalse(ready_future.running()) # Cancellation after maturity has no effect. ready_future.cancel() self.assertFalse(ready_future.cancelled()) self.assertTrue(ready_future.done()) self.assertFalse(ready_future.running()) finally: ready_future.cancel() server.stop(0)
def run(gobgpd_addr, vrf_name, prefix, nexthop): channel = implementations.insecure_channel(gobgpd_addr, 50051) with gobgp_pb2.beta_create_GobgpApi_stub(channel) as stub: subnet = IPNetwork(prefix) ipaddr = subnet.ip masklen = subnet.prefixlen nlri = IPAddrPrefix(addr=ipaddr, length=masklen) bin_nlri = nlri.serialize() nexthop = BGPPathAttributeNextHop(value=nexthop) bin_nexthop = nexthop.serialize() origin = BGPPathAttributeOrigin(value=2) bin_origin = origin.serialize() pattrs = [] pattrs.append(str(bin_nexthop)) pattrs.append(str(bin_origin)) path = {} path['nlri'] = str(bin_nlri) path['pattrs'] = pattrs uuid = stub.ModPath(gobgp_pb2.ModPathArguments(resource=Resource_VRF, name=vrf_name, path=path), _TIMEOUT_SECONDS) if uuid: print "Success!" else: print "Error!"
def _get_service(service_url, service_class): channel = implementations.insecure_channel(service_url, api_settings.DEFAULT_GRPC_PORT) stub = import_class(_PROTO_GENERATED_PATH + service_class) service = stub(channel) return service
def main(): host = FLAGS.host port = FLAGS.port model_name = FLAGS.model_name model_version = FLAGS.model_version request_timeout = FLAGS.request_timeout # Create gRPC client and request channel = implementations.insecure_channel(host, port) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = model_name if model_version > 0: request.model_spec.version.value = model_version inputs_np = numpy.asarray([sys.argv[1]]) inputs_tensor_proto = tf.contrib.util.make_tensor_proto(inputs_np, dtype=tf.float32) request.inputs['x_observed'].CopyFrom(inputs_tensor_proto) # Send request result = stub.Predict(request, request_timeout) print(result) result_np = tf.contrib.util.make_ndarray(result.outputs['y_pred']) print('\n%s\n' % result_np)
def test_connect(self): channel = implementations.insecure_channel('localhost', 9713) print "Connected" stub = agro_pb2.beta_create_Scheduler_stub(channel) task_ids = [] for i in range(5): task = agro_pb2.Task() task_id = str(uuid.uuid4()) task.id = task_id task_ids.append(task_id) task.command = "/bin/echo" task.args.add( arg="Testing" ) task.args.add( arg="Hello" ) task.args.add( arg="World" ) task.args.add( arg="%s" % (i) ) task.container = "ubuntu" task.tags.extend( ['testing'] ) print "Adding task" stub.AddTask(task, 10) for a in stub.SearchTasks(agro_pb2.TagArray(tags=[]), 10): print "Found", a count = 0 c = pyagro.wait(stub, task_ids) assert(c == 0) print "Quiting" channel = None stub = None #import pdb; pdb.set_trace()
def run(gobgpd_addr): channel = implementations.insecure_channel(gobgpd_addr, 50051) with gobgp_pb2.beta_create_GobgpApi_stub(channel) as stub: vrfs = stub.GetVrfs(gobgp_pb2.Arguments(), _TIMEOUT_SECONDS) for vrf in vrfs: print(" Vrf.name : %s" % ( vrf.name)) routeDist = _RouteDistinguisher.parser(vrf.rd) if routeDist.type == 0: print(" Vrf.rd : %s:%s" % ( routeDist.admin, routeDist.assigned)) else: print(" Vrf.rd : ???") import_rt = vrf.import_rt for import_route_target in import_rt: import_rt_tmp = _ExtendedCommunity.parse(import_route_target) import_rt = import_rt_tmp[0] if isinstance(import_rt, BGPTwoOctetAsSpecificExtendedCommunity): print(" Vrf.import_rt : %s:%s" % ( import_rt.as_number, import_rt.local_administrator)) else: print(" Vrf.import_rt : ???") export_rt = vrf.export_rt for export_route_target in export_rt: export_rt_tmp = _ExtendedCommunity.parse(export_route_target) export_rt = export_rt_tmp[0] if isinstance(export_rt, BGPTwoOctetAsSpecificExtendedCommunity): print(" Vrf.export_rt : %s:%s" % ( export_rt.as_number, export_rt.local_administrator)) else: print(" Vrf.export_rt : ???") print "----------------------------"
def run(gobgpd_addr, vrf_name): channel = implementations.insecure_channel(gobgpd_addr, 50051) with gobgp_pb2.beta_create_GobgpApi_stub(channel) as stub: rib = stub.GetRib(gobgp_pb2.Table(type=Resource_VRF, family=RF_IPv4_UC, name=vrf_name), _TIMEOUT_SECONDS) destinations_target = rib.destinations for destination_target in destinations_target: paths_target = destination_target.paths for path_target in paths_target: nlri = LabelledVPNIPAddrPrefix.parser(path_target.nlri) print (" Rib.prefix : %s" % nlri[0].prefix) print (" Rib.route_dist : %s" % nlri[0].route_dist) print (" Rib.label_list : %s" % nlri[0].label_list) for pattr in path_target.pattrs: path_attr = _PathAttribute.parser(pattr) if isinstance(path_attr[0], BGPPathAttributeOrigin): print (" Rib.origin : %s" % path_attr[0].value) elif isinstance(path_attr[0], BGPPathAttributeAsPath): if path_attr[0].type == 2: print(" Rib.aspath : %s" % path_attr[0].value) else: print(" Rib.aspath : ???") elif isinstance(path_attr[0], BGPPathAttributeMultiExitDisc): print (" Rib.med : %s" % path_attr[0].value) elif isinstance(path_attr[0], BGPPathAttributeExtendedCommunities): for community in path_attr[0].communities: if isinstance(community, BGPTwoOctetAsSpecificExtendedCommunity): print(" Rib.community : %s:%s" % ( community.as_number, community.local_administrator)) else: print(" Rib.community : ???") elif isinstance(path_attr[0], BGPPathAttributeMpReachNLRI): print (" Rib.nexthop : %s" % path_attr[0].next_hop) print "----------------------------"
def main(argv): filename = argv[0] img = Image.open(filename) width, height = img.size # crop out the center 300x300 crop_h = (width - image_size)/2 crop_v = (height - image_size)/2 img = img.crop((crop_h, crop_v, width-crop_h, height-crop_v)) # resize the resulting image to 150x150 img = img.resize((image_size, image_size)) # convert to grayscale img = img.convert('L') arr = array(img).reshape(image_size * image_size).astype(float) print(arr) #debug # build the request request = tf_convnet_inference_pb2.BoxImageRequest() for pixel in arr: request.image_data.append(pixel) # call the gRPC server channel = implementations.insecure_channel(host, port) stub = tf_convnet_inference_pb2.beta_create_BoxImageService_stub(channel) result = stub.Classify(request, 8.0) print(result.value)
def test_immediately_connectable_channel_connectivity(self): server_completion_queue = _low.CompletionQueue() server = _low.Server(server_completion_queue, []) port = server.add_http2_port('[::]:0') server.start() server_completion_queue_thread = threading.Thread( target=_drive_completion_queue, args=(server_completion_queue,)) server_completion_queue_thread.start() channel = implementations.insecure_channel('localhost', port) callback = _Callback() try: ready_future = utilities.channel_ready_future(channel) ready_future.add_done_callback(callback.accept_value) self.assertIsNone( ready_future.result(test_constants.SHORT_TIMEOUT)) value_passed_to_callback = callback.block_until_called() self.assertIs(ready_future, value_passed_to_callback) self.assertFalse(ready_future.cancelled()) self.assertTrue(ready_future.done()) self.assertFalse(ready_future.running()) # Cancellation after maturity has no effect. ready_future.cancel() self.assertFalse(ready_future.cancelled()) self.assertTrue(ready_future.done()) self.assertFalse(ready_future.running()) finally: ready_future.cancel() server.shutdown() server_completion_queue.shutdown() server_completion_queue_thread.join()
def main(): host = "0.0.0.0" port = 8502 model_name = "default" model_version = -1 signature_name = "" request_timeout = 10.0 # Generate inference data keys = numpy.asarray([[1]]) keys_tensor_proto = tf.contrib.util.make_tensor_proto(keys, dtype=tf.int32) features = numpy.asarray([[1, 2, 3, 4, 5, 6, 7, 8, 9]]) features_tensor_proto = tf.contrib.util.make_tensor_proto( features, dtype=tf.float32) # Create gRPC client channel = implementations.insecure_channel(host, port) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = model_name if model_version > 0: request.model_spec.version.value = model_version if signature_name != "": request.model_spec.signature_name = signature_name request.inputs["keys"].CopyFrom(keys_tensor_proto) request.inputs["features"].CopyFrom(features_tensor_proto) # Send request start_time = time.time() for i in range(100): result = stub.Predict(request, request_timeout) end_time = time.time() print("Cost time: {}".format(end_time - start_time)) print(result)
def run(gobgpd_addr, neighbor_address, local_as, peer_as): channel = implementations.insecure_channel(gobgpd_addr, 50051) with gobgp_pb2.beta_create_GobgpApi_stub(channel) as stub: conf = {} if local_as == peer_as: conf['peer_type'] = PEER_TYPE_INTERNAL else: conf['peer_type'] = PEER_TYPE_EXTERNAL conf['neighbor_address'] = neighbor_address conf['local_as'] = local_as conf['peer_as'] = peer_as families = [] families.append(RF_IPv4_UC) peer = {} peer['conf'] = conf peer['families'] = families uuid = stub.ModNeighbor(gobgp_pb2.ModNeighborArguments(operation=Operation_ADD, peer=peer), _TIMEOUT_SECONDS) if uuid: print "Success!" else: print "Error!"
def _stub(args): if args.oauth_scope: if args.test_case == "oauth2_auth_token": # TODO(jtattermusch): This testcase sets the auth metadata key-value # manually, which also means that the user would need to do the same # thing every time he/she would like to use and out of band oauth token. # The transformer function that produces the metadata key-value from # the access token should be provided by gRPC auth library. access_token = _oauth_access_token(args) metadata_transformer = lambda x: [("authorization", "Bearer %s" % access_token)] else: metadata_transformer = lambda x: [("authorization", "Bearer %s" % _oauth_access_token(args))] else: metadata_transformer = lambda x: [] if args.use_tls: if args.use_test_ca: root_certificates = resources.test_root_certificates() else: root_certificates = None # will load default roots. channel = test_utilities.not_really_secure_channel( args.server_host, args.server_port, implementations.ssl_channel_credentials(root_certificates), args.server_host_override, ) stub = test_pb2.beta_create_TestService_stub(channel, metadata_transformer=metadata_transformer) else: channel = implementations.insecure_channel(args.server_host, args.server_port) stub = test_pb2.beta_create_TestService_stub(channel) return stub
def VerifyPredictRequest(self, model_server_address, expected_output, model_name='default', specify_output=True): """Send PredictionService.Predict request and verify output.""" print 'Sending Predict request...' # Prepare request request = predict_pb2.PredictRequest() request.model_spec.name = model_name request.inputs['x'].dtype = types_pb2.DT_FLOAT request.inputs['x'].float_val.append(2.0) dim = request.inputs['x'].tensor_shape.dim.add() dim.size = 1 if specify_output: request.output_filter.append('y') # Send request host, port = model_server_address.split(':') channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) result = stub.Predict(request, 5.0) # 5 secs timeout # Verify response self.assertTrue('y' in result.outputs) self.assertIs(types_pb2.DT_FLOAT, result.outputs['y'].dtype) self.assertEquals(1, len(result.outputs['y'].float_val)) self.assertEquals(expected_output, result.outputs['y'].float_val[0])
def dial(self): if self.stub: self.stub.close() p = urlparse('http://' + self.addr) channel = implementations.insecure_channel(p.hostname, p.port) self.stub = vtgateservice_pb2.beta_create_Vitess_stub(channel)
def _stub(args): if args.test_case == 'oauth2_auth_token': creds = oauth2client_client.GoogleCredentials.get_application_default() scoped_creds = creds.create_scoped([args.oauth_scope]) access_token = scoped_creds.get_access_token().access_token call_creds = implementations.access_token_call_credentials(access_token) elif args.test_case == 'compute_engine_creds': creds = oauth2client_client.GoogleCredentials.get_application_default() scoped_creds = creds.create_scoped([args.oauth_scope]) call_creds = implementations.google_call_credentials(scoped_creds) elif args.test_case == 'jwt_token_creds': creds = oauth2client_client.GoogleCredentials.get_application_default() call_creds = implementations.google_call_credentials(creds) else: call_creds = None if args.use_tls: if args.use_test_ca: root_certificates = resources.test_root_certificates() else: root_certificates = None # will load default roots. channel_creds = implementations.ssl_channel_credentials(root_certificates) if call_creds is not None: channel_creds = implementations.composite_channel_credentials( channel_creds, call_creds) channel = test_utilities.not_really_secure_channel( args.server_host, args.server_port, channel_creds, args.server_host_override) stub = test_pb2.beta_create_TestService_stub(channel) else: channel = implementations.insecure_channel( args.server_host, args.server_port) stub = test_pb2.beta_create_TestService_stub(channel) return stub
def main(): logging.basicConfig(stream=sys.stderr, level=logging.INFO) try: master = subprocess.Popen(['python', 'typhoon/master.py']) time.sleep(1) worker = subprocess.Popen(['./build/latest/typhoon_worker'], env={ 'MASTER_ADDRESS': '127.0.0.1:29999' }) graph = test_kmer() channel = implementations.insecure_channel('localhost', 29999) time.sleep(1) stub = typhoon_pb2.beta_create_TyphoonMaster_stub(channel) response = stub.execute(graph, 3600) logging.info('Response: %s', response) ready = False while not ready: ready = True empty = typhoon_pb2.EmptyMessage() status = stub.status(empty, 100) # logging.info('Status: %s', status) job = status.job[0] for t in job.task: if t.status != typhoon_pb2.SUCCESS: ready = False time.sleep(1) logging.info('Success!') except: logging.info('Error.', exc_info=1) finally: master.kill() worker.kill() os._exit(1)
def connect(): # create a channel channel = implementations.insecure_channel('localhost', 50051) # crete a stub stub = structure_pb2.beta_create_StructService_stub(channel) return stub, channel
def do_inference(hostport, input): """Tests mnist_inference service with concurrent requests. Args: hostport: Host:port address of the mnist_inference service. work_dir: The full path of working directory for test data set. concurrency: Maximum number of concurrent requests. num_tests: Number of test images to use. Returns: The classification error rate. Raises: IOError: An error occurred processing test data set. """ host, port = hostport.split(':') channel = implementations.insecure_channel(host, int(port)) stub = mnist_inference_pb2.beta_create_MnistService_stub(channel) result = {'active': 0, 'error': 0, 'done': 0} request = inference_pb2.VerifyRequest() for pixel in data.flatten(): request.image_data.append(pixel.item()) result_future = stub.Classify(request, 5.0) exception = result_future.exception() if exception: print exception else: sys.stdout.write('.') sys.stdout.flush() response = numpy.array(result_future.message) print(response)
def __init__(self, host, port, timeout, user, password, creds=None, options=None): """This class creates grpc calls using python. :param username: Username for device login :param password: Password for device login :param host: The ip address for the device :param port: The port for the device :param timeout: how long before the rpc call timesout :param creds: Input of the pem file :param options: TLS server name :type password: str :type username: str :type server: str :type port: int :type timeout:int :type creds: str :type options: str """ if creds != None: self._target = '%s:%d' % (host, port) self._creds = implementations.ssl_channel_credentials(creds) self._options = options channel = grpc.secure_channel( self._target, self._creds, (('grpc.ssl_target_name_override', self._options,),)) self._channel = implementations.Channel(channel) else: self._host = host self._port = port self._channel = implementations.insecure_channel(self._host, self._port) self._stub = ems_grpc_pb2.beta_create_gRPCConfigOper_stub(self._channel) self._timeout = int(timeout) self._metadata = [('username', user), ('password', password)]
def main(): parser = argparse.ArgumentParser(description="Translation client example") parser.add_argument("--model_name", required=True, help="model name") parser.add_argument("--host", default="localhost", help="model server host") parser.add_argument("--port", type=int, default=9000, help="model server port") parser.add_argument("--timeout", type=float, default=10.0, help="request timeout") parser.add_argument("--concurrency", type=int, default=10, help="number of concurrent requests") parser.add_argument('--spm_model', type=str, help="sentencepiece model file") parser.add_argument('input', type=str, help="string to split") args = parser.parse_args() channel = implementations.insecure_channel(args.host, args.port) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) sp = spm.SentencePieceProcessor() sp.Load(args.spm_model) future = translate(stub, args.model_name, sp, args.input, timeout=args.timeout) output = parse_translation_result(future.result(), sp) print("Input:", args.input) print("Split:", output)
def predict_from_tf_serving(self, line): from grpc.beta import implementations from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_service_pb2_grpc # def pretty_print(line, preds): # words = line.strip().split() # lengths = [max(len(w), len(p)) for w, p in zip(words, preds)] # padded_words = [w + (l - len(w)) * ' ' for w, l in zip(words, lengths)] # padded_preds = [p.decode() + (l - len(p)) * ' ' for p, l in zip(preds, lengths)] # # print('words: {}'.format(' '.join(padded_words))) # # print('preds: {}'.format(' '.join(padded_preds))) # # res1 = 'words: {}'.format(' '.join(padded_words)) # # res2 = 'preds: {}'.format(' '.join(padded_preds)) # res1 = ' '.join(padded_words) # res2 = ' '.join(padded_preds) # return res1, res2 # # def predict_input_fn(line): # # Words # words = [w.encode() for w in line.strip().split()] # nwords = len(words) # # # Wrapping in Tensors # # words = tf.constant([words], dtype=tf.string) # # nwords = tf.constant([nwords], dtype=tf.int32) # # # return (words, nwords), None # return words, nwords def pretty_print(line, preds): line = repr(line).replace('\\', '/')[1:-1] line = list(line.replace(' ', '')) words = [w for w in line] lengths = [max(len(w), len(p)) for w, p in zip(words, preds)] padded_words = [w + (l - len(w)) * ' ' for w, l in zip(words, lengths)] padded_preds = [p + (l - len(p)) * ' ' for p, l in zip(preds, lengths)] print('words: {}'.format('\t'.join(padded_words))) print('preds: {}'.format('\t'.join(padded_preds))) def predict_input_fn(line): # Words # line = ''.join([' ' + c + ' ' if len(c.encode()) > 1 else c for c in line]).split() line = repr(line).replace('\\', '/')[1:-1] line = list(line.replace(' ', '')) words = [w.encode() for w in line] nwords = len(words) # Wrapping in Tensors # words = tf.constant(words, shape=(1, nwords), dtype = tf.string) # nwords = tf.constant([nwords], shape=(1,), dtype=tf.int32) # return (words, nwords), None return words, nwords def build_sentence(data, tags): res = '' sub_res = [] for word, tag in zip(data.strip().split(), tags.strip().split()): if tag == 'B': if sub_res: sub_str = ''.join(sub_res) res = res + sub_str + ' ' # idx = i sub_res = [] else: # idx = i sub_res.append(word) elif tag == 'S': # res[i] = word # ' '.join(res, word) res = res + word + ' ' # idx = -1 elif tag == 'M': sub_res.append(word) # idx = -1 elif tag == 'E': if len(sub_res) > 0: sub_res.append(word) sub_str = ''.join(sub_res) res = res + sub_str + ' ' sub_res = [] else: # res[idx] = word res = res + word + ' ' return res.strip() # @timecost # def predict(testStr): host = '43.247.185.201' # port='8031' port = '8036' # port='30000' channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2_grpc.PredictionServiceStub(channel._channel) request = predict_pb2.PredictRequest() request.model_spec.name = "saved_model" words, nwords = predict_input_fn(line) request.inputs['words'].CopyFrom( tf.contrib.util.make_tensor_proto(words, shape=(1, nwords), dtype=tf.string)) # tf.contrib.util.make_tensor_proto(words, shape=words.shape, dtype=tf.string)) request.inputs['nwords'].CopyFrom( tf.contrib.util.make_tensor_proto([nwords], shape=(1,), dtype=tf.int32)) future = stub.Predict.future(request, 10.0) result = future.result() result_list = tf.make_ndarray(result.outputs["pred_ids"]).tolist() tags_id = [self.tags_from_table[id] for id in result_list[0]] pretty_print(line, tags_id)
def _create_stub(server): host, port = server.split(":") channel = implementations.insecure_channel(host, int(port)) # TODO(bgb): Migrate to GA API. return prediction_service_pb2.beta_create_PredictionService_stub(channel)
import sys from grpc.beta import implementations import numpy import tensorflow as tf from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_service_pb2 import threading hostport = "0.0.0.0:8500" host, port = hostport.split(':') print(host, port) # 创建 python grpc 代码调用。全局变量。不能每次都创建。 channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) # 调用 grpc 代码,将图片转换成数组,让后放到 grpc 调用。 def do_inference(hostport, img_obj): request = predict_pb2.PredictRequest() request.model_spec.name = 'mnist' request.model_spec.signature_name = 'predict_images' # image, label = test_data_set.next_batch(1) label = np.array([1], dtype=np.uint8) img_array = np.array(img_obj, dtype=np.float32) img_array = img_array.reshape(img_array.size) # 新方法。很接近原始数据。
for s in sentence_words: print(s) for i, w in enumerate(words): if w.strip() == s.strip(): bow[i] = 1 return (np.array(bow)) query = "hello this is a new query" x = get_tf_record(query) print(x) channel = implementations.insecure_channel(TF_MODEL_SERVER_HOST, TF_MODEL_SERVER_PORT) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = "helix" request.model_spec.signature_name = "predict_class" request.inputs['query'].CopyFrom( tf.contrib.util.make_tensor_proto(x, shape=[1, len(words)])) #request.inputs['classes'].CopyFrom( # tf.contrib.util.make_tensor_proto(np.array(1,2,3), shape=[3])) result = stub.Predict(request, 10.0) # 10 secs timeout print(result) arr = tf.contrib.util.make_ndarray(result.outputs["classes"])[0] print(arr)
def application(environ, start_response): request_method = environ['REQUEST_METHOD'].upper() response_body = dict() if request_method == 'GET': response_body.update( { 'service': 'slim-unified-client-rest', 'message': 'No support on GET, please use POST.', 'usage': { 'endpoint': 'POST /', 'payload': { 'format': 'application/json', 'body': { 'host': 'optional, host for tensorflow serving model server, default "127.0.0.1"', 'port': 'optional, port for tensorflow serving model server, default "9000"', 'model_name': 'optional, tensorflow serving model name, default "slim_inception_resnet_v2", ' + 'all available models: slim_inception_resnet_v2 at port 9000, and slim_inception_v4 at port 9090', 'image_urls': 'required, image urls in list' } }, 'returns': { 'classes': 'top 5 classes of each input image_urls, in shape `n x 5`', 'scores': 'top 5 classes scores (probabilities) of each input image_urls, in shape `n x 5`', 'prelogits': 'a numeric vector of 1536 of each input image_urls, in shape `n x 1536`, ' + 'this vector can be viewed as features of each input image_urls for transfer learning or etc.' } } } ) if request_method == 'POST': # the environment variable CONTENT_LENGTH may be empty or missing try: request_body_size = int(environ.get('CONTENT_LENGTH', 0)) # the request body is expected to be json request_body = json.loads( environ['wsgi.input'].read(request_body_size) ) # connect to tfs-slim host = request_body.get('host', '127.0.0.1') port = request_body.get('port', '9000') model_name = request_body.get('model_name', 'slim_inception_resnet_v2') image_urls = request_body.get('image_urls', []) # print('channel:', host+':'+port) # print('model_name:', model_name) # print('image_urls:', image_urls) assert len(image_urls) > 0, "payload should contains a image_urls as a list of image urls." assert len(image_urls) <= 128, "payload should contains a image_urls as a list of image urls, " + \ "with length less than or equal to 128." # fetch image urls into bytes, in parallel # multiprocessing.pool.ThreadPool is undocumented, as its implementation has never been completed # and in modern computer architecture, starting a process has a similar cost as starting a thread # as a result, often it is preferred to use multiprocessing.Pool, with the following exception: # CPU bound jobs -> multiprocessing.Pool # IO bound jobs -> multiprocessing.pool.ThreadPool _thread_pool = ThreadPool(len(image_urls)) image_fetch_results = _thread_pool.map(fetch_url, image_urls) _thread_pool.close() # close the thread pool explicitly to avoid `can't start new thread` image_bytes = [ result[1] for result in image_fetch_results if result[2] is None ] # for result in image_fetch_results: # if result[2] is not None: # print('Error in Fetch URL: {}'.format(result[2])) # establish a stub with tensorflow serving service channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = model_name request.model_spec.signature_name = 'predict_images' request.inputs['images'].CopyFrom( tf.contrib.util.make_tensor_proto( image_bytes, shape=[len(image_bytes)] ) ) result = stub.Predict(request, 60.0) # 60 secs timeout # post-processing the result protobuf into json # stringVal have to go the hard way result_classes_tensorproto = text_format.MessageToString( result.outputs['classes'] ) result_classes_tensorproto = result_classes_tensorproto.strip().split('\n') result_classes_value = [ x.split(": ")[1][1:-1] for x in result_classes_tensorproto if 'string_val' in x ] # use ...[1:-1] to remove double qoute around synset names # assume in classes are in 2 dims result_classes_shape = [ int(x.split(": ")[1]) for x in result_classes_tensorproto if 'size' in x ] assert len(result_classes_shape) == 2 result_classes = [ result_classes_value[i:i+result_classes_shape[1]] for i in range( 0, len(result_classes_value), result_classes_shape[1] ) ] # floatVal is able to go the easy way result_scores_tensorproto = json_format.MessageToDict( result.outputs['scores'] ) result_scores_value = result_scores_tensorproto['floatVal'] result_scores_shape = [ int(x['size']) for x in result_scores_tensorproto['tensorShape']['dim'] ] result_scores = np.reshape( result_scores_value, result_scores_shape ).tolist() # prelogits as image feature for further development result_prelogits_tensorproto = json_format.MessageToDict( result.outputs['prelogits'] ) result_prelogits_value = result_prelogits_tensorproto['floatVal'] result_prelogits_shape = [ int(x['size']) for x in result_prelogits_tensorproto['tensorShape']['dim'] ] result_prelogits = np.reshape( result_prelogits_value, result_prelogits_shape ).tolist() response_body.update( { 'data': { 'image_urls': [ x for x, y in zip(image_urls, image_fetch_results) if y[2] is None ], 'classes': result_classes, 'scores': result_scores, 'prelogits': result_prelogits }, 'message': { 'image_urls_fetch_failed': [ x for x, y in zip(image_urls, image_fetch_results) if y[2] is not None ] } } ) except Exception as e: response_body.update( { 'error': { 'type': str(type(e)), 'args': str(e.args) } } ) # convert response body into str response_body = json.dumps(response_body) # construct start_response with status, and response headers status = '200 OK' response_headers = [ ('Content-Type', 'application/json'), ('Content-Length', str(len(response_body))) ] start_response(status, response_headers) # return: wrap response body into a list return [response_body]
def web_client_serving(): args_batch_size = 10 args_model_name = "aver_ende" args_host = "localhost" args_tf_port= 9000 args_redis_port = 6379 args_timeout = 100 args_src = None args_tgt = None # Redis red0 = redis.Redis(host=args_host, port=args_redis_port, db=0) # for hash caching red1 = redis.Redis(host=args_host, port=args_redis_port, db=1) # for message queue # TensorFlow Serving channel = implementations.insecure_channel(args_host, args_tf_port) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) # Fast Execution fast_execution = 0 fast_model_name = "toy_ende" fast_timeout = 100000 # Looping User Serving while True: try: if red1.get("timeout_exist"): print("Fast Execution for Timeout user !") fast_execution = 1 user_to_serve = red1.lpop("timeout_user_list") if user_to_serve == None: print("Well.. False Alarm. No user there.") fast_execution = 0 red1.delete("timeout_exist") print("Waiting for new users ...") while not red1.get("timeout_exist"): user_to_serve = red1.blpop('web_user_list', 100)[1] # pick the first user, if none then wait print("Serving: "+user_to_serve) else: print("Waiting for new users ...") while not red1.get("timeout_exist"): user_to_serve = red1.blpop('web_user_list', 100)[1] # pick the first user, if none then wait print("Serving: "+user_to_serve) src_list_id = user_to_serve + "_src" # e.g. "web_1_src" tgt_list_id = user_to_serve + "_tgt" # e.g. "web_1_tgt" #: retrieve all queries of this user queries = red1.lrange(src_list_id, 0, -1) #: try caching first length_of_queries = len(queries) queries_for_loop = queries[:] for item in queries_for_loop: # print(str(length_of_queries)+repr(item)) result = red0.hget(item, args_model_name) if result == None: # print(str(length_of_queries)) break # no hope, go to TensorFlow Serving :( else: red1.rpush(tgt_list_id, result) # for users to retrieve from list queries.remove(item) length_of_queries = length_of_queries - 1 if length_of_queries > 0: batch_tokens = [] for query in queries: batch_token = [str(item) for item in query.split()] batch_tokens.append(batch_token) # red1.rpush(tgt_list_id, str(batch_token)) # too good to be true :) # batch_tokens = [ # ["Hello", "world", "!"], # ["My", "name", "is", "John", "."], # ["I", "live", "on", "the", "West", "coast", "."]] #: ready for TensorFlow Serving tf_start_time = time.time() futures = [] for tokens in batch_tokens: if 0 == len(tokens): continue if fast_execution: future = translate(stub, fast_model_name, tokens, timeout=fast_timeout) futures.append(future) else: future = translate(stub, args_model_name, tokens, timeout=args_timeout) futures.append(future) for tokens, future in zip(batch_tokens, futures): result_tokens = parse_translation_result(future.result()) #: get results from tensorflow serving #: result_tokens = ["Hallo", "Welt", "!"] query = ' '.join(tokens) result = ' '.join(result_tokens) if not fast_execution: # only store full execution red0.hset(query, args_model_name, result) # cache result red0.expire(query, 1200) # key expires after 20 minutes red1.rpush(tgt_list_id, result) # return to users if not fast_execution: print(tgt_list_id + '||' + result + "|| Latency: " + str(time.time() - tf_start_time)) else: print("Fast Execution "+tgt_list_id + '||' + result + "|| Latency: " + str(time.time() - tf_start_time)) fast_execution = 0 red1.delete("timeout_exist") print("Well served: "+user_to_serve) except: red1.lpush('web_user_list', user_to_serve) print("Fail to serve: "+ str(user_to_serve))
result[n_sample] = dest pool.add_task(work, src, n_sample, counter) n_sample += 1 if n_sample % 100 == 0: bleu, _ = counter.get() print '%d %.3f' % (n_sample, (0. + bleu) / n_sample) if n_sample == total: break pool.wait_completion() bleu, _ = counter.get() print '%d %.3f' % (n_sample, (0. + bleu) / n_sample) if __name__ == '__main__': argparser = argparse.ArgumentParser(sys.argv[0]) argparser.add_argument('--port', type=int, default=30031) argparser.add_argument('--host', type=str, default='localhost') argparser.add_argument('--num_thread', type=int, default=1) argparser.add_argument('--test_file', type=str) argparser.add_argument('--num_sample', type=int, default=100) argparser.add_argument('--verbose', type=int, default=1) argparser.add_argument('--num_skip', type=int, default=0) args = argparser.parse_args() global channel global results channel = implementations.insecure_channel(args.host, args.port) test()
def predict(self, sents): _, self.sents, self.segs, self.tags = self.sents2id(sents) # hostport = '192.168.31.186:6000' # host, port = hostport.split(':') # channel = implementations.insecure_channel(host, int(port)) channel = implementations.insecure_channel(TF_SERVING_HOST, TF_SERVING_PORT) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel) # build request request = predict_pb2.PredictRequest() request.model_spec.name = self.model_name request.model_spec.signature_name = self.signature_name request.inputs['input_w'].CopyFrom( tf.contrib.util.make_tensor_proto(self.sents, dtype=tf.int32)) request.inputs['input_seg'].CopyFrom( tf.contrib.util.make_tensor_proto(self.segs, dtype=tf.int32)) request.inputs['target'].CopyFrom( tf.contrib.util.make_tensor_proto(self.tags, dtype=tf.int32)) request.inputs['dropout'].CopyFrom( tf.contrib.util.make_tensor_proto(1.0, dtype=tf.float32)) model_results = stub.Predict(request, 60.0) trans = tensor_util.MakeNdarray(model_results.outputs["trans"]) scores = tensor_util.MakeNdarray(model_results.outputs["scores"]) lengths = tensor_util.MakeNdarray(model_results.outputs["lengths"]) batch_paths = self.decode(scores, lengths, trans) tags = [self.id_to_tag[idx] for idx in batch_paths[0]] item = self.result_to_json(sents, tags) lbl_list = ["O"] * len(sents) for lbldict in item["entities"]: start, end, lbl = lbldict["start"], lbldict["end"], lbldict["type"] lbl_list[start:end] = [lbl] * (end - start) ner_str = "" for c, lbl in zip(sents, lbl_list): ner_str += c + "/" + lbl + " " ner_str = ner_str.rstrip() year_dict = {"YEAR": 1} year_str = self.str_spec(sents, lbl_list, year_dict) # print("year_str:{}".format(year_str)) month_dict = {"MONTH": 1} month_str = self.str_spec(sents, lbl_list, month_dict) # print("month_str:{}".format(month_str)) day_dict = {"DAY": 1} day_str = self.str_spec(sents, lbl_list, day_dict) # print("day_str:{}".format(day_str)) part_dict = {"PART": 1} part_str = self.str_spec(sents, lbl_list, part_dict) # print("part_str:{}".format(part_str)) speed_dict = {"SPEED": 1} speed_str = self.str_spec(sents, lbl_list, speed_dict) # print("speed_str:{}".format(speed_str)) type_dict = {"TYPE": 1} type_str = self.str_spec(sents, lbl_list, type_dict) # print("type_str:{}".format(type_str)) loc_dict = {"SLOC": 1, "ELOC": 2} loc_str = self.str_spec(sents, lbl_list, loc_dict) # print("loc_str:{}".format(loc_str)) time_dict = {"STIME": 1, "ETIME": 2} time_str = self.str_spec(sents, lbl_list, time_dict) # print("time_str:{}".format(time_str)) return loc_str, time_str, year_str, month_str, day_str, part_str, speed_str, type_str
def index(): #host, port, image = parse_args() try: host = "localhost" port = 9000 channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel) # dataset = input_data.read_data_sets('/tmp/Mnist', one_hot=True) # batch = dataset.train.next_batch(1) # print(batch[1]) if (request.method == 'GET'): #img = [[0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]] numpyarray = np.array(img, np.float32) print("Expected result: %d" % (2)) if (request.method == 'POST'): modelUrl = request.form.get('modelUrl') imgUrl = request.form.get('imageUrl') modelName = request.form.get('modelName') imageSize = request.form.get('imageSize') checkClearModelPath = 1 modelFolder = "/home/ubuntu/model" if (os.listdir(modelFolder) != []): #checkClearModelPath = subprocess.check_call(["sudo", "rm", "-r", "/home/ubuntu/model/*"]) for the_file in os.listdir(modelFolder): file_path = os.path.join(modelFolder, the_file) try: if os.path.isfile(file_path): os.unlink(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path) except Exception as e: raise Exception(str(e)) #if(checkClearModelPath == 0): downloadModel = subprocess.check_call( ["wget", "-O", "/home/ubuntu/model/model.zip", modelUrl]) if (downloadModel == 0): unzipModel = subprocess.check_call([ "unzip", "/home/ubuntu/model/model.zip", "-d", "/home/ubuntu/model/" ]) if (unzipModel == 0): try: thread.start_new_thread(runServingService, (modelName, )) except Exception as e: raise Exception(str(e)) checkRunningProcess = "" while ("tensorflow_model_server" not in checkRunningProcess): checkRunningProcess = subprocess.check_output(['ps', '-au']) print(checkRunningProcess) time.sleep(1.5) downloadImg = subprocess.check_call( ["wget", "-O", "/home/ubuntu/serveimg/img.jpg", imgUrl]) if (downloadImg == 0): print("downloaded image") img = cv2.imread('/home/ubuntu/serveimg/img.jpg') imgarray = [] for i in range(0, len(img)): for j in range(0, len(img[i])): tmp = img[i][j] px = 0 for item in tmp: if (item > 5): px = 1 break imgarray.append(px) numpyarray = np.array(imgarray, np.float32) else: raise Exception("cannot download image") start = time.time() servingrequest = predict_pb2.PredictRequest() servingrequest.model_spec.name = modelName servingrequest.model_spec.signature_name = 'predict_images' #servingrequest.inputs['images'].CopyFrom(make_tensor_proto(numpyarray, shape=[1, 784])) servingrequest.inputs['images'].CopyFrom( make_tensor_proto(numpyarray, shape=[1, imageSize])) result = stub.Predict(servingrequest, 60.0) # 60 secs timeout end = time.time() time_diff = end - start print(result.outputs['scores'].float_val) print(result) print('time elapased: {}'.format(time_diff)) result_list = result.outputs['scores'].float_val max_val = max(result_list) num_result = 0 for i in range(0, len(result_list)): if (result_list[i] == max_val): num_result = i return str(num_result) except Exception as e: with open('/home/ubuntu/myproject/log.txt', 'a+') as f: error = "\n\n Internal Server Error \n" + str( traceback.format_exc()) f.write(error) f.close()
def getGRPCChannel(host='localhost', port=7050): channel = implementations.insecure_channel(host, port) print("Returning GRPC for address: {0}:{1}".format(host,port)) return channel
def __init__(self, host, port): channel = implementations.insecure_channel(host, port) self.client = Transactor_pb2.beta_create_TransactorService_stub(channel)
def get_stub(hostport): host, port = hostport.split(':') channel = implementations.insecure_channel(host, int(port)) return prediction_service_pb2.beta_create_PredictionService_stub(channel)
def main(_): host, port = FLAGS.server.split(':') channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = FLAGS.model request.model_spec.signature_name = 'serving_default' # true label value, this is taken from the eval.py portion label = 1 # hard coded inputs, however, the hard coded inputs can be easily converted into flexible inputs as well # these inputs are derived from observing the signature definition using the saved_model_cli show command request.inputs['C1'].CopyFrom( tf.contrib.util.make_tensor_proto("68fd1e64", shape=[1])) request.inputs['C10'].CopyFrom( tf.contrib.util.make_tensor_proto("547c0ffe", shape=[1])) request.inputs['C11'].CopyFrom( tf.contrib.util.make_tensor_proto("bc8c9f21", shape=[1])) request.inputs['C12'].CopyFrom( tf.contrib.util.make_tensor_proto("60ab2f07", shape=[1])) request.inputs['C13'].CopyFrom( tf.contrib.util.make_tensor_proto("46f42a63", shape=[1])) request.inputs['C14'].CopyFrom( tf.contrib.util.make_tensor_proto("07d13a8f", shape=[1])) request.inputs['C15'].CopyFrom( tf.contrib.util.make_tensor_proto("18231224", shape=[1])) request.inputs['C16'].CopyFrom( tf.contrib.util.make_tensor_proto("e6b6bdc7", shape=[1])) request.inputs['C17'].CopyFrom( tf.contrib.util.make_tensor_proto("e5ba7672", shape=[1])) request.inputs['C18'].CopyFrom( tf.contrib.util.make_tensor_proto("74ef3502", shape=[1])) request.inputs['C19'].CopyFrom( tf.contrib.util.make_tensor_proto("0", shape=[1])) request.inputs['C2'].CopyFrom( tf.contrib.util.make_tensor_proto("2c16a946", shape=[1])) request.inputs['C20'].CopyFrom( tf.contrib.util.make_tensor_proto("0", shape=[1])) request.inputs['C21'].CopyFrom( tf.contrib.util.make_tensor_proto("5316a17f", shape=[1])) request.inputs['C22'].CopyFrom( tf.contrib.util.make_tensor_proto("0", shape=[1])) request.inputs['C23'].CopyFrom( tf.contrib.util.make_tensor_proto("32c7478e", shape=[1])) request.inputs['C24'].CopyFrom( tf.contrib.util.make_tensor_proto("9117a34a", shape=[1])) request.inputs['C25'].CopyFrom( tf.contrib.util.make_tensor_proto("0", shape=[1])) request.inputs['C26'].CopyFrom( tf.contrib.util.make_tensor_proto("", shape=[1])) request.inputs['C3'].CopyFrom( tf.contrib.util.make_tensor_proto("503b9dbc", shape=[1])) request.inputs['C4'].CopyFrom( tf.contrib.util.make_tensor_proto("e4dbea90", shape=[1])) request.inputs['C5'].CopyFrom( tf.contrib.util.make_tensor_proto("f3474129", shape=[1])) request.inputs['C6'].CopyFrom( tf.contrib.util.make_tensor_proto("13718bbd", shape=[1])) request.inputs['C7'].CopyFrom( tf.contrib.util.make_tensor_proto("38eb9cf4", shape=[1])) request.inputs['C8'].CopyFrom( tf.contrib.util.make_tensor_proto("1f89b562", shape=[1])) request.inputs['C9'].CopyFrom( tf.contrib.util.make_tensor_proto("a73ee510", shape=[1])) request.inputs['I1'].CopyFrom( tf.contrib.util.make_tensor_proto(1.0, shape=[1])) request.inputs['I10'].CopyFrom( tf.contrib.util.make_tensor_proto(1.0, shape=[1])) request.inputs['I11'].CopyFrom( tf.contrib.util.make_tensor_proto(1.0, shape=[1])) request.inputs['I12'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) request.inputs['I13'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) request.inputs['I2'].CopyFrom( tf.contrib.util.make_tensor_proto(4.0, shape=[1])) request.inputs['I3'].CopyFrom( tf.contrib.util.make_tensor_proto(2.0, shape=[1])) request.inputs['I4'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) request.inputs['I5'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) request.inputs['I6'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) request.inputs['I7'].CopyFrom( tf.contrib.util.make_tensor_proto(1.0, shape=[1])) request.inputs['I8'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) request.inputs['I9'].CopyFrom( tf.contrib.util.make_tensor_proto(0.0, shape=[1])) result_future = stub.Predict.future(request, 5.0) prediction = result_future.result().outputs # Uncomment this if you want to see the output of the entire TensorProto # print('Prediction: ' + str(prediction)) # True label value print('True label: ' + str(label)) # converting the tensorproto to an Ndarray for extracting output probList = tensor_util.MakeNdarray(prediction['probabilities'])[0] if probList[0] < probList[1]: print("Prediction: 1") else: print("Prediction: 0")
def __init__(self, host, port): self.channel = implementations.insecure_channel(host, port) self.stub = graphresponse_pb2.beta_create_Dgraph_stub(self.channel)
def main(_): host, port = FLAGS.server.split(':') channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) # Send request #with open(FLAGS.image, 'rb') as f: # See prediction_service.proto for gRPC request/response details. #data = f.read() request = predict_pb2.PredictRequest() images = load_and_align_data(['images/12.jpg'], 160, 44, 0.9) # Call Facenet model to make prediction on the image request.model_spec.name = 'face128' request.model_spec.signature_name = 'calculate_embeddings' request.inputs['images'].CopyFrom( tf.contrib.util.make_tensor_proto(images, dtype=tf.float32)) request.inputs['phase'].CopyFrom( tf.contrib.util.make_tensor_proto(False, dtype=tf.bool)) start_time = time.time() result = stub.Predict(request, 60.0) # 60 secs timeout # Convert to friendly python object results_dict = {} for key in result.outputs: tensor_proto = result.outputs[key] nd_array = tf.contrib.util.make_ndarray(tensor_proto) results_dict[key] = nd_array #storing embeddings emb = results_dict.get("embeddings") feature_time = time.time() - start_time # calculate distance between images nrof_embeds = labels.size dist_array = np.zeros((nrof_embeds, 1)) for i in range(nrof_embeds): tmp = embeds[i, :] - emb[0, :] sum_squared = np.dot(tmp.T, tmp) dist = math.sqrt(sum_squared) # AVGTIME = 0.09sec dist_array[i][0] = dist # arranging distance in ascending order pred_array = dist_array.argmin(0) # threshold distance to 0.8 if dist_array[pred_array[0]][0] < 0.8: pred_label = labels[pred_array[0]] pred_face = class_names[int(pred_label)] else: pred_face = 'Unknown' print('Face name: {}'.format(pred_face)) print('Face Dist: {}'.format(dist_array[pred_array[0]][0])) print(' ') distance_time = time.time() - start_time - feature_time print('Feature Calculation time: {}'.format(feature_time)) print('Distance Calculation time: {}'.format(distance_time)) print('Image Recognition time: {}'.format(time.time() - start_time)) print(' ')
def create_channel_for_batching_server(): channel = implementations.insecure_channel('localhost', 9003) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) return stub
def main(): # Connect to server client = InfluxDBClient(host=HOST, port=PORT, username=USER, password=PASSWORD, database=DBNAME) print("connect to Influxdb", DBNAME, HOST, PORT) # Time dt1 = datetime.now() dt1 = dt1 - timedelta(hours=6) dt = dt1.isoformat() # Query to database query = 'SELECT "value_gasflow", "value_eta_a", "value_ngp", "value_npt" FROM "example"."autogen"."unit3" WHERE time > now() - 4h' data = DataFrameClient(host=HOST, \ username=USER, \ password=PASSWORD, \ database=DBNAME) dict_query = data.query(query) df = pandas.DataFrame(data=dict_query['unit3']) index = df.index empty_df = pandas.DataFrame( columns=['gas_fuel_flow', 'hpc_eta', 'ngp', 'npt', 'prediction'], index=index) empty_df.gas_fuel_flow = df['value_gasflow'] empty_df.hpc_eta = df['value_eta_a'] empty_df.ngp = df['value_ngp'] empty_df.npt = df['value_npt'] strafe = numpy.array(empty_df.values[:, 0:3]) out_pp = numpy.float32(strafe) # Prepare request request = predict_pb2.PredictRequest() request.model_spec.name = 'deka' request.inputs['inputs'].dtype = types_pb2.DT_FLOAT request.inputs['inputs'].CopyFrom( tf.contrib.util.make_tensor_proto(out_pp)) request.output_filter.append('outputs') # Send request host, port = FLAGS.server.split(':') channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) prediction = stub.Predict(request, 5.0) # 5 secs timeout floats = prediction.outputs['outputs'].float_val predicted_array = numpy.array(floats) empty_df.prediction = predicted_array #print(empty_df) json_body = [{ "measurement": "prediction", "tags": { "type": "npt predict" }, "time": dt, "fields": { "gas_fuel_flow": empty_df.gas_fuel_flow[-1], "hpc_eta": empty_df.hpc_eta[-1], "ngp": empty_df.ngp[-1], "npt": empty_df.npt[-1], "prediction": empty_df.prediction[-1] } }] client.write_points(json_body, database="example") #print(json_body) client.close()
pass_flag = 1 else: if eval(test_condition): pass_count += 1 logger.info("\nRESULT ===>\n{0} -> PASS\n".format(log_str)) else: fail_count += 1 logger.info("\nRESULT ===>\n{0} -> FAIL\n".format(log_str)) pass_flag = 1 try: # Channel Creation and Authentication channel = implementations.insecure_channel(host=device, port=port) stub = authentication_service_pb2.beta_create_Login_stub(channel) login_response = stub.LoginCheck( authentication_service_pb2.LoginRequest(user_name=APP_USER, password=APP_PASSWORD, client_id=client_id), login_timeout) # Service stub creation AclService_stub = beta_create_AclService_stub(channel) # All the valid combinations logger.info('All the valid combinations') api_request = AccessList(ace_list=[
import tensorflow as tf from grpc.beta import implementations from tensorflow_serving.apis import predict_pb2, prediction_service_pb2 import os channel = implementations.insecure_channel("10.100.51.111", 8877) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) model_name = "deepseg_test" def serving(source): inputs = source inputs_length = len(source) req = predict_pb2.PredictRequest() req.model_spec.name = model_name req.inputs["inputs"].CopyFrom( tf.make_tensor_proto([source], shape=[1, inputs_length])) req.inputs["inputs_length"].CopyFrom( tf.make_tensor_proto([inputs_length], shape=[1])) response = stub.Predict.future(req, 10) res = response.result() outputs = tf.make_ndarray(res.outputs["predict_tags"])[0] outputs = [b.decode("utf-8") for b in outputs] return translate(inputs, outputs) def translate(src_list, tag_list): if not src_list or not tag_list: return False, None if len(src_list) != len(tag_list): return False, None
from grpc.beta import implementations import tensorflow as tf from tensorflow_serving.apis import predict_pb2, prediction_service_pb2_grpc # 获取stub channel = implementations.insecure_channel('localhost', 8500) stub = prediction_service_pb2_grpc.PredictionServiceStub(channel._channel) # 模型签名 request = predict_pb2.PredictRequest() request.model_spec.name = 'ner' # request.model_spec.version = 'latest' request.model_spec.signature_name = 'predict' # 构造入参 x_data = [[ 13, 45, 13, 13, 49, 1, 49, 196, 594, 905, 48, 231, 318, 712, 1003, 477, 259, 291, 287, 161, 65, 62, 82, 68, 2, 10 ]] drop_out = 1 sequence_length = [26] request.inputs['input'].CopyFrom(tf.make_tensor_proto(x_data, dtype=tf.int32)) request.inputs['sequence_length'].CopyFrom( tf.make_tensor_proto(sequence_length, dtype=tf.int32)) request.inputs['drop_out'].CopyFrom( tf.make_tensor_proto(drop_out, dtype=tf.float32)) result = stub.Predict(request, 10.0) # 10 secs timeout print(result)
class ModelHandler(tornado.web.RequestHandler): __metaclass__ = abc.ABCMeta serverlg.info( '[ModelServer] [Initialization: service %s, schedule %d] [%s]' % (options.service, options.schedule, time.strftime('%Y-%m-%d %H:%M:%S'))) for conf_name in schedule: #may be deprecated graph = create(conf_name) graph.apply_deploy_conf(schedule[conf_name]) host, port = schedule[conf_name]["tf_server"].split(":") channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel) schedule[conf_name]["graph_stub"] = (graph, stub) @abc.abstractmethod def handle(self): query = self.get_argument('query', None) if not query: ret = {} ret["status"] = "missing params" serverlg.info( '[chatbot] [ERROR: missing params] [REQUEST] [%s] [%s]' % (time.strftime('%Y-%m-%d %H:%M:%S'), self.request.uri)) self.write(json.dumps(ret, ensure_ascii=False)) self.finish() results = [] debug_infos = [] graph_stubs = [schedule[name]["graph_stub"] for name in schedule] # Multi model compatible, but here just one model exists multi_models = [] for graph, stub in graph_stubs: multi_models.append( self.run_model(graph, stub, [query.encode("utf-8")])) outs = yield multi(multi_models) serverlg.info(outs) raise gen.Return(None) @abc.abstractmethod def form_multi_results(self, model_name, model_out): return def set_default_header(self): self.set_header('Access-Control-Allow-Origin', "*") @tornado.gen.coroutine def run_model(self, graph, stub, records, use_seg=True): # Use model specific preprocess feed_data = graph.preproc(records, use_seg=use_seg, for_deploy=True) # make request request = predict_pb2.PredictRequest() request.model_spec.name = graph.name values = feed_data.values() N = len(values[0]) if len(values[0]) < 2 else 2 see_feed = {k: v[0:N] for k, v in feed_data.items()} serverlg.info('[DispatcherServer] [sample %d/%d] %s' % (N, len(values), str(see_feed))) for key, value in feed_data.items(): v = np.array(value) value_tensor = tensor_util.make_tensor_proto(value, shape=v.shape) # For compatibility to the old placeholder key request.inputs[key].CopyFrom(value_tensor) # query the model #result = stub.Predict(request, 4.0) result = yield fwrap(stub.Predict.future(request, 3.0)) out = {} for key, value in result.outputs.items(): out[key] = tensor_util.MakeNdarray(value) model_results = graph.after_proc(out) raise gen.Return(model_results) @tornado.web.asynchronous @tornado.gen.coroutine def post(self): serverlg.info('[DispatcherServer] [BEGIN] [REQUEST] [%s] [%s]' % (time.strftime('%Y-%m-%d %H:%M:%S'), self.request.uri)) gc.disable() # prepare locks, events, and results container for coroutine #self.results = [None] * len(deployments) #self.model_results = [] #self.evt = Event() #self.lock = locks.Lock() # query all models #for name in self.servings: model_results, debug_infos, desc = yield self.handle() results = self.form_multi_results(model_results, debug_infos) # wait until told to proceed #yield self.evt.wait() #self.run() # form response ret = {"status": "ok", "result": results} #self.write(json.dumps(ret)) self.write(ret) #self.finish() @tornado.web.asynchronous @tornado.gen.coroutine def get(self): gc.disable() serverlg.info('[DispatcherServer] [BEGIN] [REQUEST] [%s] [%s]' % (time.strftime('%Y-%m-%d %H:%M:%S'), self.request.uri)) # preproc model_results, debug_infos, desc = yield self.handle() results = self.form_multi_results(model_results, debug_infos) # form response ret = {"status": "ok", "result": results, "desc": desc} self.write(json.dumps(ret, ensure_ascii=False))
def run(): channel = implementations.insecure_channel('localhost', 50051) stub = helloworld_pb2.beta_create_Greeter_stub(channel) response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'), _TIMEOUT_SECONDS) print("Greeter client received: " + response.message)
def main(unused_argv): test_file_path = FLAGS.test_file_path id_data_dir = FLAGS.id_data_dir batch_size = FLAGS.batch_size seed_num = FLAGS.seed_num max_timesteps = FLAGS.max_timesteps vocab_size = FLAGS.vocab_size test_size = FLAGS.test_size use_local = FLAGS.use_local DR_path = os.path.join(id_data_dir, 'DataReader.pkl') with open(DR_path, 'rb') as f: DR = pickle.load(f) input_pinyin_data, input_word_data, target_data = DR.make_data_from_dataframe( file_path=test_file_path, build_dictionary=False, max_rows=test_size) np.random.seed(seed_num) np.random.shuffle(input_pinyin_data) np.random.seed(seed_num) np.random.shuffle(input_word_data) np.random.seed(seed_num) np.random.shuffle(target_data) test_data_full = batch_generator_triple_with_length( input_pinyin_data, input_word_data, target_data, batch_size, max_timesteps, DR.word2id, DR.pinyin2id) n_iter_per_epoch = len(input_pinyin_data) // (batch_size) for t in range(1, n_iter_per_epoch + 1): batch_full = next(test_data_full) src_pinyin_list, src_word_list, src_length_list, tgt_list, tgt_length_list = batch_full src_pinyin_list = np.asarray(src_pinyin_list, dtype=np.int32) src_word_list = np.asarray(src_word_list, dtype=np.int32) src_length_list = np.asarray(src_length_list, dtype=np.int32) tgt_list = np.asarray(tgt_list, dtype=np.int32) hostport = '0.0.0.0:9012' host, port = hostport.split(':') channel = implementations.insecure_channel(host, int(port)) #channel = insecure_channel(host,int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub( channel) request = predict_pb2.PredictRequest() request.model_spec.name = 'spell' request.model_spec.signature_name = "predict" request.inputs['pinyin_ids'].CopyFrom( tf.contrib.util.make_tensor_proto( src_pinyin_list, shape=[src_pinyin_list.shape[0], src_pinyin_list.shape[1]])) request.inputs['word_ids'].CopyFrom( tf.contrib.util.make_tensor_proto( src_word_list, shape=[src_word_list.shape[0], src_word_list.shape[1]])) request.inputs['input_lengths'].CopyFrom( tf.contrib.util.make_tensor_proto(src_length_list)) request.inputs['keep_ratio'].CopyFrom( tf.contrib.util.make_tensor_proto(FLAGS.keep_ratio)) print('Predict:') proba = stub.Predict(request, 50.0) results = {} for key in proba.outputs: tensor_proto = proba.outputs[key] nd_array = tf.contrib.util.make_ndarray(tensor_proto) results[key] = nd_array #import pdb #pdb.set_trace() predict_ids = np.argmax(results['predict'], axis=1) print(predict_ids)
def getGRPCChannel(ipAddress): channel = implementations.insecure_channel(ipAddress, 5005) print("Returning GRPC for address: {0}".format(ipAddress)) return channel
except: LOG.debug("SocketIO: Write failed") requestQ.task_done() try: CONNECTION_LIST = list() for i in range(1): t = Thread(target=allRouteApis) t.setDaemon(True) t.start() dispatch_thread = Thread(target=sendtoPS) dispatch_thread.setDaemon(True) dispatch_thread.start() channel = implementations.insecure_channel(host=HOST, port=GRPC_PORT) stub = authentication_service_pb2.beta_create_Login_stub(channel) login_response = stub.LoginCheck( authentication_service_pb2.LoginRequest(user_name=USER, password=PASSWORD, client_id=CLIENT_ID), TIMEOUT) LOG.info("Connected to the JET GRPC request response server") bgp = bgp_route_service_pb2.beta_create_BgpRoute_stub(channel) prpd = prpd_service_pb2.beta_create_Base_stub(channel) purgeTime = 30 # Variables for RouteGet Operation eod = 0 count = 0 getroutelist = []
from grpc.beta import implementations import tensorflow as tf # TensorFlow serving stuff to send messages from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_service_pb2 from tensorflow.contrib.util import make_tensor_proto app = Flask(__name__) crash_vocab = [ 'Crash', 'Earthquake', 'Explosion', 'Fire', 'Floods', 'Terrorism', 'Typhoon', 'None' ] vector_channel = implementations.insecure_channel('35.184.14.40', 80) disaster_channel = implementations.insecure_channel('0.0.0.0', 8500) vector_stub = prediction_service_pb2.beta_create_PredictionService_stub( vector_channel) disaster_stub = prediction_service_pb2.beta_create_PredictionService_stub( disaster_channel) def sendVectorRequest(sents): req = predict_pb2.PredictRequest() req.model_spec.name = 'serving_saved_model' req.model_spec.signature_name = 'serving_default' req.inputs['text'].CopyFrom( make_tensor_proto(sents, shape=[len(sents)], dtype=tf.string)) result = vector_stub.Predict(req, 60.0)
str(ipaddress.ip_address(result.Prefix)), result.PrefixLen, result.ErrStatus.Status) os._exit(0) # # Setup the GRPC channel with the server, and issue RPCs # if __name__ == '__main__': from util import util server_ip, server_port = util.get_server_ip_port() print "Using GRPC Server IP(%s) Port(%s)" % (server_ip, server_port) # Create the channel for gRPC. channel = implementations.insecure_channel(server_ip, server_port) # Spawn a thread to Initialize the client and listen on notifications # The thread will run in the background client_init.global_init(channel) # Create another channel for gRPC requests. channel = implementations.insecure_channel(server_ip, server_port) # Send an RPC for VRF registrations vrf.vrf_operation(channel, sl_common_types_pb2.SL_REGOP_REGISTER) # RPC EOF to cleanup any previous stale routes vrf.vrf_operation(channel, sl_common_types_pb2.SL_REGOP_EOF) # RPC route operations
def __init__(self): print "init GatewayClient" self.gateway_channel = implementations.insecure_channel( 'localhost', 50051) self.gateway = beta_create_BfGatewayService_stub(self.gateway_channel) self.connectivity = interfaces.ChannelConnectivity.IDLE
def setUp(self): self._server = implementations.server({}) port = self._server.add_insecure_port('[::]:0') channel = implementations.insecure_channel('localhost', port) self._generic_stub = implementations.generic_stub(channel) self._server.start()
'image': tf.train.Feature(bytes_list=tf.train.BytesList(value=[data])) } example = tf.train.Example(features=tf.train.Features( feature=feature_dict)) serialized = example.SerializeToString() request.inputs['images'].CopyFrom( tf.contrib.util.make_tensor_proto(serialized, shape=[1], dtype=tf.string)) result_future = stub.Predict.future(request, 10.0) prediction = result_future.result() # print(prediction.outputs['classes'].int64_val) # print(prediction.outputs['probabilities'].float_val) pred_class = (prediction.outputs['classes'].int64_val)[0] pred_probs = prediction.outputs['probabilities'].float_val pred_class_prob = pred_probs[pred_class] return pred_class, pred_class_prob channel = implementations.insecure_channel(IP_ADDR, PORT) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) dog_path = os.path.expanduser(IMAGE_PATH) output = make_request(stub, dog_path, MODEL_NAME) print(output)