def predict(self, deployment_name, df): """ Predict on the specified deployment using the provided dataframe. Compute predictions on the pandas DataFrame ``df`` using the specified deployment. Note that the input/output types of this method matches that of `mlflow pyfunc predict` (we accept a pandas DataFrame as input and return either a pandas DataFrame, pandas Series, or numpy array as output). :param deployment_name: Name of deployment to predict against :param df: Pandas DataFrame to use for inference :return: A pandas DataFrame, pandas Series, or numpy array """ try: service = Webservice(self.workspace, deployment_name) except Exception as e: raise MlflowException( 'Failure retrieving deployment to predict against') from e # Take in DF, parse to json using split orient input_data = _get_jsonable_obj(df, pandas_orient='split') if not service.scoring_uri: raise MlflowException( 'Error attempting to call webservice, scoring_uri unavailable. ' 'This could be due to a failed deployment, or the service is not ready yet.\n' 'Current State: {}\n' 'Errors: {}'.format(service.state, service.error)) # Pass split orient json to webservice # Take records orient json from webservice resp = ClientBase._execute_func(service._webservice_session.post, service.scoring_uri, data=json.dumps( {'input_data': input_data})) if resp.status_code == 401: if service.auth_enabled: service_keys = service.get_keys() service._session.headers.update( {'Authorization': 'Bearer ' + service_keys[0]}) elif service.token_auth_enabled: service_token, refresh_token_time = service.get_access_token() service._refresh_token_time = refresh_token_time service._session.headers.update( {'Authorization': 'Bearer ' + service_token}) resp = ClientBase._execute_func(service._webservice_session.post, service.scoring_uri, data=input_data) if resp.status_code == 200: # Parse records orient json to df return parse_json_input(json.dumps(resp.json()), orient='records') else: raise MlflowException('Failure during prediction:\n' 'Response Code: {}\n' 'Headers: {}\n' 'Content: {}'.format(resp.status_code, resp.headers, resp.content))
def update_deployed_model(ws, aci_service_name, model_name, mlapp_env, entry_script): inference_config = InferenceConfig(source_directory=os.getcwd(), entry_script=entry_script, environment=mlapp_env) model = Model(ws, name=model_name) service = Webservice(name=aci_service_name, workspace=ws) service.update(models=[model], inference_config=inference_config) print(service.state) print(service.get_logs())
def get_deployment(self, name): """ Retrieve details for the specified deployment. Returns a dictionary describing the specified deployment. The dict is guaranteed to contain an 'name' key containing the deployment name. :param name: Name of deployment to retrieve """ try: service = Webservice(self.workspace, name) return service.serialize() except WebserviceException as e: raise MlflowException( 'There was an error retrieving the deployment: \n{}'.format( e.message)) from e
def test_deployed_model_service(): service = Webservice(ws, deployment_name) assert service is not None key1, key2 = service.get_keys() uri = service.scoring_uri assert key1 is not None assert uri.startswith('http') headers = { 'Content-Type': 'application/json', 'Authorization': f'Bearer {key1}' } response = requests.post(uri, test_sample, headers=headers) assert response.status_code is 200 assert abs(1 - sum(response.json()['predict_proba'][0])) < 0.01
def delete_deployment(self, name): """ Delete the deployment with name ``name``. :param name: Name of deployment to delete :return: None """ try: service = Webservice(self.workspace, name) service.delete() except WebserviceException as e: if 'WebserviceNotFound' not in e.message: _logger.info( 'Deployment with name {} not found, no service to delete'. format(name)) return raise MlflowException( 'There was an error deleting the deployment: \n{}'.format( e.message)) from e
def list_deployments(self): """ List deployments. :return: A list of dicts corresponding to deployments. """ try: service_list = [] services = Webservice.list(self.workspace) for service in services: service_list.append(service.serialize()) return service_list except WebserviceException as e: raise MlflowException( 'There was an error listing deployments: \n{}'.format( e.message)) from e
def create_aks_service(name: str, image_config: ImageConfig, models: List[Model], target: ComputeTarget, ws: Workspace) -> Webservice: print("Loading AKS deploy config from deployconfig_aks.yml") deploy_conf = AksWebservice.deploy_configuration() print(models) service = Webservice.deploy_from_model(workspace=ws, name=name, deployment_target=target, models=models, deployment_config=deploy_conf, image_config=image_config) service.wait_for_deployment(show_output=True) return service
def __init__(self, CONTAINER_NAME, BLOB_NAME, REQUEST_ID): """ First, we will initialize different variables that we will use in the code below """ self.CONTAINER_NAME = CONTAINER_NAME self.BLOB_NAME = BLOB_NAME self.REQUEST_ID = REQUEST_ID # "container042021" self.blob_service_client = BlobServiceClient.from_connection_string( conn_str=conf.AZURE_STORAGE_CONNECTION_STRING) self.container_client = self.blob_service_client.get_container_client( self.CONTAINER_NAME) interactive_auth = InteractiveLoginAuthentication( tenant_id=conf.TENANT_ID) self.ws = Workspace.from_config('resources', auth=interactive_auth) self.service = Webservice(workspace=self.ws, name='mynewservice')
def main(args, ws): dir = os.path.dirname(os.path.abspath(__file__)) ic = InferenceConfig(runtime='python', source_directory=dir, entry_script='score.py', conda_file='environment.yml') dc = AciWebservice.deploy_configuration(cpu_cores=args.cores, memory_gb=args.memory) m = ws.models[args.model_name] # Remove any existing service under the same name. try: Webservice(ws, args.service_name).delete() print(f'Deleted webservice with name {args.service_name}.') except WebserviceException: pass service = Model.deploy(ws, args.service_name, [m], ic, dc) service.wait_for_deployment(True) print(service.state) print(service.get_logs())
# Get environment workspace = Workspace.from_config() environment = Environment.get(workspace=workspace, name=METADATA['env_name']) # Deploy container inference_config = InferenceConfig( entry_script='./src/score.py', environment=environment, ) aci_config = AciWebservice.deploy_configuration( cpu_cores=CPU_CORES, memory_gb=MEMORY_GB, description=SERVICE_DESCRIPTION) # Deploy as web service try: # Remove any existing service under the same name. Webservice(workspace, SERVICE_NAME).delete() except WebserviceException: pass model = Model(workspace, METADATA['model_name']) webservice = Model.deploy(workspace=workspace, name=SERVICE_NAME, models=[model], inference_config=inference_config, deployment_config=aci_config, overwrite=True) webservice.wait_for_deployment(show_output=True) webservice.get_logs()
# Authentication via service principle ws = Workspace.get( args.ws, ServicePrincipalAuthentication( tenant_id=os.getenv('tenant_id'), service_principal_id=os.getenv('service_principal_id'), service_principal_password=os.getenv('service_principal_password')), subscription_id=os.getenv('subscription_id'), resource_group=args.rg) model = Model(ws, "new_model") deployment_target = ComputeTarget(ws, args.aksname) img = create_image_config("score.py", "scoringenv.yml") servicename = args.servicename try: service = Webservice(ws, servicename) except Exception as e: print(e) service = None if service: print("Updating existing service with new image...") try: # create new image service = update_service(service, [model], img, ws) except Exception as e: print("Unable to link existing service.\n {}".format(e)) else: create_aks_service(servicename, img, [model], deployment_target, ws)
) parser.add_argument( "--webservicename", type=str, default="freezerchain-prediction-v0-2", help="Name of the deployed Webservice", ) args = parser.parse_args() run = Run.get_context() ws = run.experiment.workspace freezer_environment = ws.environments["sktime_freezer_environment"] try: service = Webservice(ws, args.webservicename) except WebserviceException: service = None if args.redeploy: if service is not None: service.delete() print("deleted existing Webservice.") model = Model(ws, "sktime_freezer_classifier") inference_config = InferenceConfig( entry_script="score.py", source_directory="./", environment=freezer_environment ) aci_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)
memory_gb = 1, auth_enabled=False, #passer à True pour enclencher la sécurité par clés tags = {"data": "New York citibike", "method": "sklearn regression"}, description = "Trip duration regression") # COMMAND ---------- from azureml.core import Webservice from azureml.core.webservice import AciWebservice from azureml.exceptions import WebserviceException service_name = 'dbx-tripduration-service' # Remove any existing service under the same name. try: Webservice(ws, service_name).delete() except WebserviceException: pass service = Model.deploy(workspace=ws, name=service_name, models=[model], inference_config=inference_config, deployment_config=aciconfig) service.wait_for_deployment(show_output=True) # COMMAND ---------- from azureml.core.image import ContainerImage
import json import requests from azureml.core import Webservice, Workspace from config_deepensemble_1 import CONFIG from cgmml.common.data_utilities import mlpipeline_utils if __name__ == "__main__": if CONFIG.LOCALTEST: uri = 'http://localhost:6789/' else: workspace = Workspace.from_config() service = Webservice(workspace=workspace, name=CONFIG.ENDPOINT_NAME) uri = service.scoring_uri requests.get(uri) depthmap = mlpipeline_utils.get_depthmaps( CONFIG.TEST_FILES).tolist() # Make JSON serializable headers = {"Content-Type": "application/json"} data = { "data": depthmap, } data = json.dumps(data) response = requests.post(uri, data=data, headers=headers) print(response.json())
from azureml.core import Workspace ws = Workspace.from_config() print(ws) # ## Find Web Service by Name and get Connection Details # We select the web service by the name and this will provide us information on the URLs such as scoring and [swagger](https://swagger.io/) calls # In[ ]: from azureml.core import Webservice service = Webservice(workspace=ws, name='<insert web service name here>') print("Score URI: " + str(service.scoring_uri)) print("Swagger URI: " + str(service.swagger_uri)) primary, secondary = service.get_keys() print(primary) # ## Data Input to REST API Schema # Now we need to understand the schema of the data to be input into the REST call. # # You can get this sample input information from the auto-generated scoring script that was created in the Azure Portal # In[ ]:
import requests import json from azureml.core import Webservice from azureml.core import Workspace # URL for the web service scoring_uri = 'http://97d4b24f-8f41-46e7-b875-32d30bfb8deb.westus2.azurecontainer.io/score' ws = Workspace.get('Mohith_workspace', auth=None, subscription_id='c229fecc-7c30-489c-b79f-1de37cd2de58', resource_group='Mohith_group') print(ws) services = Webservice.list(ws) print(services) print(services[0].scoring_uri) print(services[0].swagger_uri) service = services[0] print(service) # Set the content type headers = {'Content-Type': 'application/json'} if service.auth_enabled: headers['Authorization'] = 'Bearer ' + service.get_keys()[0] elif service.token_auth_enabled: headers['Authorization'] = 'Bearer ' + service.get_token()[0] # If the service is authenticated, set the key or token key = service.get_keys()[0]
memory_gb = 1, auth_enabled=False, #passer à True pour enclencher la sécurité par clés tags = {"data": "New York citibike", "method": "sklearn ridge regression"}, description = "Trip duration regression") # COMMAND ---------- from azureml.core import Webservice from azureml.exceptions import WebserviceException service_name = 'tripduration-service' # Remove any existing service under the same name. try: Webservice(ws, service_name).delete() except WebserviceException: pass service = Model.deploy(workspace=ws, name=service_name, models=[model], inference_config=inference_config, deployment_config=aci_config) service.wait_for_deployment(show_output=True) # COMMAND ---------- print(service.get_logs())
def deploy_model(ws, aci_service_name, experiment_name, asset_name, asset_label, run_id, cpu_cores, memory_gb, entry_script): env = create_env_from_requirements(endpoint=True) inference_config = InferenceConfig(source_directory=os.getcwd(), entry_script=entry_script, environment=env) deployment_config = AciWebservice.deploy_configuration(cpu_cores=cpu_cores, memory_gb=memory_gb) # model name model_name = get_model_register_name(run_id) try: model = Model(ws, name=model_name) except: # creating directory for download Model files for Model register tmp_path = create_tempdir(name='download_tmp') register_path = create_directory(AML_MLAPP_FOLDER, path=tmp_path) # getting RUN context experiment = Experiment(workspace=ws, name=experiment_name) tags = {"run_id": run_id, "asset_name": asset_name} if asset_label is not None: tags["asset_label"] = asset_label selected_run_id = None for run in Run.list(experiment, tags=tags, include_children=True, status='Completed'): run_metrics = run.get_metrics() exp_saved_run_id = run_metrics.get("run_id") if exp_saved_run_id == run_id: selected_run_id = run.id break if selected_run_id is None: raise Exception( 'ERROR: there is no matching Run object that associated with the run id %s in this experiment.' % str(run_id)) current_run = Run(experiment=experiment, run_id=selected_run_id) # download files from run object current_run.download_files(output_directory=register_path) # register model model = Model.register(ws, model_path=register_path, model_name=model_name, tags=tags, description=asset_name) # deletes tmp dir and all content delete_directory_with_all_contents(tmp_path) # deploy model service = None try: service = Webservice(ws, name=aci_service_name) service.update(models=[model], inference_config=inference_config) except WebserviceException as e: if service: service.delete() service = Model.deploy(ws, aci_service_name, [model], inference_config, deployment_config) service.wait_for_deployment(True)
def update_deployment(self, name, model_uri=None, flavor=None, config=None): """ Update the deployment specified by name. Update the deployment with the specified name. You can update the URI of the model, the flavor of the deployed model (in which case the model URI must also be specified), and/or any target-specific attributes of the deployment (via `config`). By default, this method should block until deployment completes (i.e. until it's possible to perform inference with the updated deployment). See target-specific plugin documentation for additional detail on support for asynchronous deployment and other configuration. :param name: Unique name of deployment to update :param model_uri: URI of a new model to deploy. :param flavor: (optional) new model flavor to use for deployment. If provided, ``model_uri`` must also be specified. If ``flavor`` is unspecified but ``model_uri`` is specified, a default flavor will be chosen and the deployment will be updated using that flavor. :param config: (optional) dict containing updated target-specific configuration for the deployment :return: None """ try: service = Webservice(self.workspace, name) except Exception as e: raise MlflowException( 'Error retrieving deployment to update') from e models = None inference_config = None with TempDir(chdr=True) as tmp_dir: if model_uri: model_name, model_version = handle_model_uri(model_uri, name) try: aml_model = Model(self.workspace, id='{}:{}'.format( model_name, model_version)) except Exception as e: raise MlflowException( 'Failed to retrieve model to deploy') from e models = [aml_model] inference_config = create_inference_config( tmp_dir, model_name, model_version, name) deploy_config = None if 'deploy-config-file' in config: try: # TODO: Tags, properties, and description are not in the config file for some reason? with open(config['deploy-config-file'], 'r') as deploy_file_stream: deploy_config_obj = file_stream_to_object( deploy_file_stream) deploy_config = deploy_config_dict_to_obj( deploy_config_obj, None, None, None) except Exception as e: raise MlflowException( 'Failed to parse provided deployment config file' ) from e aks_endpoint_version_config = None # TODO deployment or version/service? Talk to PMs if 'aks-endpoint-deployment-config' in config: aks_endpoint_version_config = config[ 'aks-endpoint-deployment-config'] try: submit_update_call(service, models, inference_config, deploy_config, aks_endpoint_version_config) if 'async' in config and config['async']: _logger.info( 'AzureML deployment in progress, you can use get_deployment to check on the current ' 'deployment status.') else: service.wait_for_deployment(show_output=True) except Exception as e: raise MlflowException( 'Error submitting deployment update') from e
# In[ ]: from azureml.core import Workspace ws = Workspace.from_config() print(ws) # ## Find Web Service by Name and get Connection Details # We select the web service by the name and this will provide us information on the URLs such as scoring and [swagger](https://swagger.io/) calls # In[ ]: from azureml.core import Webservice service = Webservice(workspace=ws, name='<insert web service name here>') print("Score URI: " + str(service.scoring_uri)) print("Swagger URI: " + str(service.swagger_uri)) # ## Data Input to REST API Schema # Now we need to understand the schema of the data to be input into the REST call. # # You can get this sample input information from the auto-generated scoring script that was created in the Azure Portal # In[ ]: import pandas as pd input_sample = pd.DataFrame(data=[{ 'Escalated': 0,
# Set the web service configuration (using default here) aks_config = AksWebservice.deploy_configuration( cpu_cores=2, auth_enabled=True, # this flag generates API keys to secure access memory_gb=8, #tags={'name': 'mnist', 'framework': 'Keras'}, #max_request_wait_time=300000,scoring_timeout_ms=300000, description='X-Ray ML Estimator AKS endpoint') ######################################################################################################### service_name = 'mlops-estimator-model-aks' # Remove any existing service under the same name. try: Webservice(ws, service_name).delete() except WebserviceException: pass aks_service = Model.deploy(workspace=ws, name=service_name, models=[model], inference_config=inference_config, deployment_config=aks_config, deployment_target=aks_gpu_cluster) ######################################################################################################### aks_service.wait_for_deployment(show_output=True) print(aks_service.state)
from azureml.core import Workspace from azureml.core.authentication import AzureCliAuthentication from azureml.core import Webservice from azureml.core.model import InferenceConfig from azureml.core.webservice import AciWebservice from azureml.exceptions import WebserviceException import json import numpy # load Azure ML workspace azureml_workspace = Workspace.from_config(auth=AzureCliAuthentication()) # the name of the scoring service service_name = 'comments-clf-westeurope' service = Webservice(azureml_workspace, service_name) input_payload = json.dumps({"data": "this is some text about gaming"}) request = json.loads(input_payload)["data"] output = service.run(input_payload) print(output)
from azureml.core import Workspace from azureml.core import Webservice ws = Workspace.from_config() service = Webservice(ws, 'lpr') scoring_uri = service.scoring_ui primary, secondary = service.get_keys() print(primary) print(service.get_logs())
}, properties=None, description= "Sktime classifier to predict if freezer chain was interrupted.", datasets=[("training_data", dataset)], resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5), ) logger.info("Model registered") # DEPLOY logger.info("Starting deployment") freezer_environment = ws.environments["sktime_freezer_environment"] try: Webservice(ws, SERVICENAME).delete() print("deleted existing Webservice.") except WebserviceException: pass service = Model.deploy( workspace=ws, name=SERVICENAME, models=[model], inference_config=InferenceConfig( entry_script="score.py", source_directory="deployment", environment=freezer_environment, ), deployment_config=AciWebservice.deploy_configuration( cpu_cores=1,
from azureml.core import Run, Webservice run = Run.get_context() ws = run.experiment.workspace parser = argparse.ArgumentParser() parser.add_argument( "--webservicename", type=str, default="freezerchain-prediction-v0-2", help="Name of the deployed Webservice", ) args = parser.parse_args() service = Webservice(ws, args.webservicename) service.update_deployment_state() retries = 0 max_wait_time_minutes = 5 polling_frequency_seconds = 15 max_retries = int(max_wait_time_minutes * 60 / polling_frequency_seconds) assert max_retries > 0 while service.state == "Transitioning" and retries <= max_retries: retries += 1 print("Service still transitioning") time.sleep(polling_frequency_seconds)