def test_service(service: AksWebservice, container: str, blob: str, write_logs: bool = True) -> None: if write_logs: logs = service.get_logs() with open("logs.txt", "w") as fp: fp.write(logs) data = {"container": container, "blob": blob} data_raw = bytes(json.dumps({"data": data}), encoding="utf8") print("Testing service: {0}".format(service.name)) print("Container: {0}, blob: {1}".format(container, blob)) ping = time.time() response = service.run(input_data=data_raw) print("Elapsed time: {0:.5f}".format(time.time() - ping)) print("Response: {0}".format(response))
deployment_target=aks_test_cluster) # Show output of the deployment on stdout test_service.wait_for_deployment(show_output=True) print(test_service.state) # Checking status of test web service print("Checking status of AKS Test Deployment") if test_service.state != "Healthy": raise Exception( "Test Deployment on AKS failed with the following status: {} and logs: \n{}" .format(test_service.state, test_service.get_logs())) # Testing AKS web service print("Testing AKS test web service") test_sample = test_functions.get_test_data_sample() print("Test Sample: ", test_sample) test_sample_encoded = bytes(test_sample, encoding='utf8') try: prediction = test_service.run(input_data=test_sample) print(prediction) except Exception as e: result = str(e) logs = test_service.get_logs() test_service.delete() raise Exception( "AKS Test web service is not working as expected: \n{} \nLogs: \n{}". format(result, logs)) # Delete test AKS service after test print("Deleting AKS Test web service after successful test") test_service.delete()
# Check its state print(service.state) #review service logs print(service.get_logs()) #deploy to local container to diagnose probs from azureml.core.webservice import LocalWebservice deployment_config = LocalWebservice.deploy_configuration(port=8890) service = Model.deploy(ws, 'test-svc', [model], inference_config, deployment_config) #test deployed service print(service.run(input_data = json_data)) #troubleshoot issues by changing scoring file #then reload wo having to redeploy service.reload() print(service.run(input_data = json_data)) ##EXERCISE #connect to ws import azureml.core from azureml.core import Workspace # Load the workspace from the saved config file
for f in fnames: file_name = os.path.join(dirpath, f) # load image print("Loading image", file_name) data = read_tensor_from_image_file(file_name, input_height=input_height, input_width=input_width, input_mean=input_mean, input_std=input_std) raw_data = str(data.tolist()) # predict using the deployed model print("Sending image", f, "to service") response = service.run(input_data=raw_data) print("Service response:", response) print() print("Testings web service via HTTP call...") api_keys = service.get_keys() headers = { 'Content-Type': 'application/json', 'Authorization': ('Bearer ' + api_keys[0]) } file_name = "./resources/test-images/Daisy1.jpg" data = read_tensor_from_image_file(file_name, input_height=input_height, input_width=input_width, input_mean=input_mean,
import json import pickle import numpy as np import pandas as pd from azureml.core.workspace import Workspace import azureml.train.automl from sklearn.externals import joblib from azureml.core.model import Model ws = Workspace.from_config('./config.json') from azureml.core.webservice import Webservice, AciWebservice, AksWebservice # service = AciWebservice(ws, "sentiment-scorer-korean") # service = AksWebservice(ws, "sentiment-scorer-korean-aks") service = AksWebservice(ws, "sentiment-scorer-korean-aks-pr") # input_sample = pd.DataFrame({'id': pd.Series(['6471903'], dtype='int64'), 'document': pd.Series(['진짜 별로다 헐 ㅡ'], dtype='object')}) from load_dataset import testdata as input_sample import json test = json.dumps({"data": input_sample.values.tolist()}) result = service.run(input_data=bytes(test, encoding="utf8")) # input_sample['predicted'] = list(json.loads(result).values())[0] # print(input_sample) print(json.loads(result).values()) with open('./output.json', 'w') as f: f.write(result) ## Remember to open the output with proper encoding (for example UTF-8)
def main(): # Parse command line arguments args = parse_args(sys.argv[1:]) # Retreive workspace workspace = Workspace.get( subscription_id=args.subscription_id, resource_group=args.resource_group, name=args.workspace_name, ) # Retreive compute cluster compute_target = workspace.compute_targets[args.compute_target] # Get baseline dataset baseline_dataset = Dataset.get_by_name(workspace, args.baseline_dataset_name) # Get model id and version model_name, model_version = args.model_id.split(":") # Get AKS Endpoint aks_endpoint = AksWebservice(workspace, args.endpoint_name) # Make call to endpoint with sample data and wait for the data to arrive in the storage account # [Note: this step is required to ensure a data sample is present for validation when # registering a new target dataset below - this can take up to 10 mins to appear] input_record = ( baseline_dataset.take(1) .to_pandas_dataframe() .drop(["cardiovascular_disease", "datetime"], axis=1) .to_dict("records") ) input_data = json.dumps({"data": input_record}) print("Variable [input_data]:", input_data) aks_endpoint.run(input_data) time.sleep(600) # Define target dataset target_dataset_name = ( f"inference-data-{model_name}-{model_version}-{args.endpoint_name}" ) # Get current registered target dataset definition current_target_dataset = Dataset.get_by_name(workspace, name=target_dataset_name) current_target_dataset_definition = json.loads(current_target_dataset._definition) # Get current registered target dataset datasetore definition current_target_dataset_datastore_definition = current_target_dataset_definition[ "blocks" ][0]["arguments"]["datastores"][0] # Define current registered target dataset datasetore target_dataset_datastore = Datastore( workspace, current_target_dataset_datastore_definition["datastoreName"] ) # Define current registered target dataset datasetore path target_dataset_datastore_path = current_target_dataset_datastore_definition["path"] # Create updated target dataset with non-string feature data types target_dataset = Dataset.Tabular.from_delimited_files( path=(target_dataset_datastore, target_dataset_datastore_path), validate=False, infer_column_types=False, set_column_types={ "age": DataType.to_float(decimal_mark="."), "height": DataType.to_float(decimal_mark="."), "weight": DataType.to_float(decimal_mark="."), "systolic": DataType.to_float(decimal_mark="."), "diastolic": DataType.to_float(decimal_mark="."), "gender": DataType.to_string(), "cholesterol": DataType.to_string(), "glucose": DataType.to_string(), "smoker": DataType.to_string(), "alcoholic": DataType.to_string(), "active": DataType.to_string(), "datetime": DataType.to_datetime(), }, ) # Assign timestamp column for Tabular Dataset to activate time series related APIs target_dataset = target_dataset.with_timestamp_columns( timestamp=target_dataset_timestamp_column ) # Register updated dataset version target_dataset.register( workspace, name=target_dataset_name, create_new_version=True ) print("Variable [target_dataset]:", target_dataset) print("Variable [baseline_dataset]:", baseline_dataset) # Define features to monitor feature_list = args.feature_list.split(",") print("Variable [feature_list]:", args.feature_list) # List data drift detectors drift_detector_list = DataDriftDetector.list(workspace) # Delete existing data drift detector for drift_monitor in drift_detector_list: if drift_monitor.name == args.data_drift_monitor_name: print("Deleteing existing data drift monitor...") drift_monitor.delete() # Define data drift detector monitor = DataDriftDetector.create_from_datasets( workspace, args.data_drift_monitor_name, baseline_dataset, target_dataset, compute_target=compute_target, frequency=args.frequency, feature_list=feature_list, ) print("Variable [monitor]:", monitor) # Enable the pipeline schedule for the data drift detector monitor.enable_schedule()
ws = Workspace.from_config(auth=auth) service = AksWebservice(ws, "videoanom-service") # load the dataset X_test_file = os.path.join('.', 'deployment', 'test_data', 'X_test.hkl') y_test_file = os.path.join('.', 'deployment', 'test_data', 'y_test.hkl') X_test = hkl.load(X_test_file) y_test = hkl.load(y_test_file) json_data = json.dumps({"data": X_test.tolist(), "id": "UCSDped1"}) json_data = bytes(json_data, encoding='utf8') print("Service URL:", service.scoring_uri) try: prediction = service.run(json_data) except Exception as e: result = str(e) print(result) raise Exception('web service is not working as expected') cm = confusion_matrix(y_test.tolist(), prediction) acc = accuracy_score(y_test.tolist(), prediction) print("Accuracy:", acc) print("Confusion Matrix:\n", cm) if acc < .80: raise Exception("The accuracy of this service is pretty low!")