def __deploy_model(self): service_name = self.__args.service_name model = Model(self.__ws, self.__args.model_name) explainer_model = Model(self.__ws, self.__args.explainer_model_name) myenv = Environment.from_conda_specification( name=self.__config.get('DEPLOY', 'ENV_NAME'), file_path=self.__config.get('DEPLOY', 'ENV_FILE_PATH')) inference_config = InferenceConfig( entry_script=self.__config.get('DEPLOY', 'SCORE_PATH'), environment=myenv, source_directory=self.__config.get('DEPLOY', 'DEPENDENCIES_DIRECTORY')) if not self.__args.update_deployment: deployment_config = AciWebservice.deploy_configuration( cpu_cores=self.__config.getint('DEPLOY', 'ACI_CPU'), memory_gb=self.__config.getint('DEPLOY', 'ACI_MEM'), collect_model_data=True, enable_app_insights=True) service = Model.deploy(self.__ws, service_name, [model, explainer_model], inference_config, deployment_config) else: service = AciWebservice(self.__ws, service_name) service.update(models=[model, explainer_model], inference_config=inference_config) service.wait_for_deployment(show_output=True) print(service.state) print(service.get_logs())
def get_environment(name="deploy", file_path="environment.yml"): """ Return an environment """ environment = Environment.from_conda_specification( name=name, file_path=file_path, ) environment.python.user_managed_dependencies = False environment.docker.enabled = True environment.docker.base_image = ( "mcr.microsoft.com/azureml/intelmpi2018.3-ubuntu16.04:20200821.v1" ) return environment
def main(): ws = Workspace.get(name=WORKSPACE_NAME, subscription_id=SUBSCRIPTION_ID, resource_group=RESOURCE_GROUP) print("connect") model = Model.register(model_path=os.path.join( os.getcwd(), "retailai_recommendation_model.zip"), model_name="retailai_recommendation_model", description="Retail.AI Item-Based Recommender", workspace=ws) print("model registered") myenv = Environment.from_conda_specification(name='myenv', file_path="environment.yml") myenv.docker.base_image = "mcr.microsoft.com/mmlspark/release" myenv.inferencing_stack_version = 'latest' print("Environment Configured") inference_config = InferenceConfig(entry_script='score.py', environment=myenv) aks_target_name = AKS_CLUSTER_NAME try: aks_target = AksCompute(ws, aks_target_name) print(aks_target) except ComputeTargetException as err: aks_target = attachAksComputeToWorkspace(ws, RESOURCE_GROUP, AKS_CLUSTER_NAME, aks_target_name, True) print(aks_target) except Exception as err: print(err) sys.exit() try: deployToAks(ws, aks_target, "retail-ai-item-recommender", model, inference_config, True) except Exception as err: print(err) sys.exit()
from azureml.core.model import InferenceConfig from azureml.core.environment import Environment from azureml.core import Workspace from azureml.core.model import Model from azureml.core.webservice import AciWebservice ws = Workspace.from_config(path='./.azureml', _file_name='config.json') model = Model(ws, name='titanic_model', version=2) env = Environment.from_conda_specification( name='sklearn-aml-env', file_path='./.azureml/sklearn-env-aml.yml') inference_config = InferenceConfig(entry_script="./src/score.py", environment=env) deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1) aci_service = Model.deploy(workspace=ws, name='titanic-model-2', models=[model], inference_config=inference_config, deployment_config=deployment_config) aci_service.wait_for_deployment(show_output=True) print(aci_service.state)
print("Creating new gpu-cluster") # Specify the configuration for the new cluster compute_config = AksCompute.provisioning_configuration( cluster_purpose=AksCompute.ClusterPurpose.DEV_TEST, agent_count=1, vm_size="Standard_NC6") # Create the cluster with the specified name and configuration aks_gpu_cluster = ComputeTarget.create(ws, gpu_cluster_name, compute_config) # Wait for the cluster to complete, show the output log aks_gpu_cluster.wait_for_completion(show_output=True) ######################################################################################################### deployment_env = Environment.from_conda_specification( name="deployment_env", file_path="./configuration/deployment_env.yml") inference_config = InferenceConfig(entry_script="./scripts/score/score.py", environment=deployment_env) # 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'
from azureml.core.webservice import Webservice from azureml.core.model import InferenceConfig from azureml.core.environment import Environment from azureml.core import Workspace from azureml.core.model import Model from azureml.core.webservice import LocalWebservice ws = Workspace.from_config(path='./.azureml', _file_name='config.json') model = Model(ws, name='mic_model.h5', version=2) env = Environment.from_conda_specification( name='mic-env', file_path='./.azureml/multiclass-image-classification.yml') inference_config = InferenceConfig(entry_script="./src/score.py", environment=env) deployment_config = LocalWebservice.deploy_configuration(port=6789) local_service = Model.deploy(workspace=ws, name='mic-model-local', models=[model], inference_config=inference_config, deployment_config=deployment_config) local_service.wait_for_deployment(show_output=True) print(f"Scoring URI is : {local_service.scoring_uri}")
default="onnx-demo", help='the web service name') args = parser.parse_args() print("Model name: ", args.name) print("Model version: ", args.version) # Load the AML Workspace and Model ws = Workspace.from_config(auth=AzureCliAuthentication()) model = Model(workspace=ws, name=args.name, version=args.version) # Configure Scoring App Environment scoringenv = Environment.from_conda_specification( name="scoringenv", file_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../environments/', 'scoring/conda_dependencies.yml')) inference_config = InferenceConfig(entry_script=os.path.join( os.path.dirname(os.path.realpath(__file__)), '../modeling/score.py'), environment=scoringenv) # Configure Deployment Compute compute_config = AciWebservice.deploy_configuration( cpu_cores=1, memory_gb=1, tags={'demo': 'onnx'}, description='ONNX for text') # Run the deployment
def deploy_custom(): subscription_id = request.json['subscription_id'] resource_group = request.json['resource_group'] workspace_name = request.json['workspace_name'] location = request.json['location'] deploy_mode = request.json['deploy_mode'] # AKS or ACI exp_name = request.json['exp_name'] #Model file Path reg_model_name = request.json['reg_model_name'] #Model name description = request.json['description'] score_path = request.json['score_path'] #Python scoring file conda_en_path = request.json['conda_en_path'] #yml file service_name = request.json['service_name'] if (deploy_mode == "AKS"): cluster_name = request.json['cluster_name'] flg = 1 if (flg == 1): import logging from matplotlib import pyplot as plt import numpy as np import pandas as pd from sklearn import datasets from azureml.core import Workspace import azureml.core from azureml.core.experiment import Experiment from azureml.core.workspace import Workspace from azureml.train.automl import AutoMLConfig from azureml.core.compute import AmlCompute from azureml.core.compute import ComputeTarget from azureml.core.runconfig import RunConfiguration from azureml.core.conda_dependencies import CondaDependencies #ws = Workspace.from_config() #!pip install azure.cli from azureml.core.authentication import AzureCliAuthentication import azure.cli.core #cli_auth = AzureCliAuthentication() ws = Workspace(subscription_id=subscription_id, resource_group=resource_group, workspace_name=workspace_name) print("Found workspace {} at location {}".format(ws.name, ws.location)) print('Found existing Workspace.') cwd = 'D:\\DCSAIAUTOML\\BestModels\\Custom' model_path = cwd + '\\' + exp_name + '\\best_model.pkl' #model_path = os.path.join(cwd, exp_name) from azureml.core.model import Model # Tip: When model_path is set to a directory, you can use the child_paths parameter to include # only some of the files from the directory model = Model.register(model_path=model_path, model_name=reg_model_name, description=description, workspace=ws) model = Model(ws, name=reg_model_name) print(model.name, model.id, model.version, sep='\t') from azureml.core.model import InferenceConfig from azureml.core.webservice import AciWebservice from azureml.core.webservice import Webservice from azureml.core.model import Model from azureml.core.environment import Environment script_file_name = score_path conda_env_file_name = conda_en_path myenv = Environment.from_conda_specification( name="myenv", file_path=conda_env_file_name) inference_config = InferenceConfig(entry_script=script_file_name, environment=myenv) print(inference_config) service_name = service_name if (deploy_mode == "ACI"): # ACI deploment with-out DOCKER from azureml.core.model import Model model = Model(ws, id=model.id) try: deployment_config = AciWebservice.deploy_configuration( cpu_cores=1, memory_gb=2) service = Model.deploy(ws, service_name, [model], inference_config, deployment_config) service.wait_for_deployment(show_output=True) print(service.state) compute_type = service.compute_type state = service.state url = service.scoring_uri s_url = service.swagger_uri #created_time = service.created_time #updated_time = service.updated_time v1 = "@" v2 = "Deployed Successfully" print(v2) return '{} {} {} {} {} {} {} {} {}'.format( v2, v1, compute_type, v1, state, v1, url, v1, s_url) except Exception as e: error_statement = str(e) print("Error statement: ", error_statement) return error_statement else: #AKS deployment from azureml.core.model import InferenceConfig from azureml.core.webservice import AciWebservice from azureml.core.model import Model from azureml.core.environment import Environment from azureml.core.webservice import AksWebservice, Webservice model = Model(ws, id=model.id) from azureml.core.compute import AksCompute, ComputeTarget service_name = service_name aks_target = AksCompute(ws, cluster_name) # If deploying to a cluster configured for dev/test, ensure that it was created with enough # cores and memory to handle this deployment configuration. Note that memory is also used by # things such as dependencies and AML components. try: deployment_config = AksWebservice.deploy_configuration( cpu_cores=1, memory_gb=2, enable_app_insights=True, collect_model_data=True, ) service = Model.deploy(ws, service_name, [model], inference_config, deployment_config, aks_target) service.wait_for_deployment(show_output=True) print(service.state) compute_type = service.compute_type state = service.state url = service.scoring_uri s_url = service.swagger_uri #created_time = service.created_time #updated_time = service.updated_time v1 = "@" v2 = "Deployed Successfully" print(v2) return '{} {} {} {} {} {} {} {} {}'.format( v2, v1, compute_type, v1, state, v1, url, v1, s_url) except Exception as e: error_statement = str(e) print("Error statement: ", error_statement) return error_statement
from azureml.core.environment import Environment from azureml.core.model import InferenceConfig, Model from azureml.core.webservice import LocalWebservice # Create inference configuration based on the environment definition and the entry script myenv = Environment.from_conda_specification(name="ml", file_path="C:\\Users\\rbenn\\AppData\\Local\\Packages\\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\\LocalState\\rootfs\\home\\rbennett\\mlenvironment.yml") inference_config = InferenceConfig(entry_script="EntryScript.py", environment=myenv) # Create a local deployment, using port 8890 for the web service endpoint deployment_config = LocalWebservice.deploy_configuration(port=8890) # Deploy the service service = Model.deploy( ws, "mymodel", [model], inference_config, deployment_config) # Wait for the deployment to complete service.wait_for_deployment(True) # Display the port that the web service is available on print(service.port)
# %% from azureml.core.conda_dependencies import CondaDependencies myenv = CondaDependencies.create(pip_packages=["numpy","onnxruntime","azureml-core", "azureml-defaults"]) with open("myenv.yml","w") as f: f.write(myenv.serialize_to_string()) # %% # from azureml.core.model import InferenceConfig from azureml.core.environment import Environment myenv = Environment.from_conda_specification(name="myenv", file_path="myenv.yml") inference_config = InferenceConfig(entry_script="score.py", environment=myenv) # %% from azureml.core.webservice import AciWebservice aciconfig = AciWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1, tags = {'demo': 'onnx'}, description = 'web service for MNIST ONNX model') #%% from azureml.core.model import Model from random import randint aci_service_name = 'onnx-demo-mnist'+str(randint(0,100)) print("Service", aci_service_name)
primary_metric='normalized_root_mean_squared_error', training_data=dataset, compute_target=compute_target, label_column_name=dataset_label_column) #Execute the AutoML run experiment = Experiment(ws, experiment_name) run = experiment.submit(automl_config, show_output=True) run.wait_for_completion() #Get the best model from the AutoML run and register it best_run = run.get_best_child() best_run.download_files(prefix='outputs', append_prefix=False) model = Model.register(model_path='outputs/model.pkl', model_name=model_name, workspace=ws) #Prepare an environment for the model myenv = Environment.from_conda_specification(name='project_environment', file_path='outputs/conda_env_v_1_0_0.yml') myenv.docker.enabled = True inference_config = InferenceConfig(entry_script='outputs/scoring_file_v_1_0_0.py', environment=myenv) #Create Docker container for the model package = Model.package(ws, [model], inference_config, image_name=docker_image_name, image_label=docker_image_label) package.wait_for_creation(show_output=True) #Update web app with the latest container requests.post(docker_webhook_url)
with open(script_file_name, 'w') as cefw: content = content.replace('<<groups>>', args.group_column_names.rstrip()) cefw.write( content.replace('<<time_colname>>', args.time_column_name.rstrip())) with open(script_file_name, 'r') as cefr1: content1 = cefr1.read() print(content1) model_list = json.loads(args.model_names) print(model_list) run = Run.get_context() ws = run.experiment.workspace myenv = Environment.from_conda_specification(name="env", file_path=conda_env_file_name) deployment_config = AciWebservice.deploy_configuration( cpu_cores=1, memory_gb=2, tags={"method": "grouping"}, description='grouping demo aci deployment') inference_config = InferenceConfig(entry_script=script_file_name, environment=myenv) models = [] for model_name in model_list: models.append(Model(ws, name=model_name)) service = Model.deploy(ws,
from azureml.core.model import InferenceConfig from azureml.core.environment import Environment from azureml.core import Workspace from azureml.core.model import Model from azureml.core.webservice import AciWebservice ws = Workspace.from_config(path='./.azureml', _file_name='config.json') model = Model(ws, name='model', version=4) env = Environment.from_conda_specification( name='remote-env', file_path='./.azureml/remote-env.yml') inference_config = InferenceConfig(entry_script="./src/score.py", environment=env) deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1) aci_service = Model.deploy(workspace=ws, name='model-service', models=[model], inference_config=inference_config, deployment_config=deployment_config) aci_service.wait_for_deployment(show_output=True) print(aci_service.state)
# 07-deploy-azure-model-local.py from azureml.core.webservice import Webservice from azureml.core.model import InferenceConfig from azureml.core.environment import Environment from azureml.core import Workspace from azureml.core.model import Model from azureml.core.webservice import LocalWebservice ws = Workspace.from_config(path='./.azureml', _file_name='config.json') model = Model(ws, name='mon_rcv_model', version=1) env = Environment.from_conda_specification( name='rcv-aml-env', file_path='./.azureml/rcv-local-env.yml') inference_config = InferenceConfig(entry_script="./src/score.py", environment=env) deployment_config = LocalWebservice.deploy_configuration(port=6789) local_service = Model.deploy(workspace=ws, name='rcv-local', models=[model], inference_config=inference_config, deployment_config=deployment_config) local_service.wait_for_deployment(show_output=True) print(f"Scoring URI is : {local_service.scoring_uri}")
def register_enviroment(workspace, name, file_path): myenv = Environment.from_conda_specification(name=name, file_path=file_path) myenv = myenv.register(workspace=workspace) return myenv
Returns ------- CondaDependencies collection of conda dependencies """ return CondaDependencies().create(conda_packages=pkg_list) # Initialise variables ENV_NAME = 'heart-failure' run_pkg = ['pip', 'joblib', 'pandas', 'numpy', 'pyodbc', 'scikit-learn'] test_pkg = run_pkg + ['pytest', 'pylint', 'requests'] workspace = Workspace.from_config() # Create dependencies for running run_dependencies = dep_from_pkg_list(run_pkg) run_dependencies.save('./conda_env.yaml') # Push to environment env = Environment.from_conda_specification(ENV_NAME, './conda_env.yaml') env.python.conda_dependencies=run_dependencies env.register(workspace=workspace) # Create dependencies for testing test_dependencies = dep_from_pkg_list(test_pkg) test_dependencies.save('./conda_env_test.yaml') # Initialise metadata with open('./metadata.json', 'w') as f: json.dump({'env_name': ENV_NAME}, f)
aks_target = ComputeTarget.create(workspace=ws, name=aks_name, provisioning_configuration=prov_config) aks_target.wait_for_completion(show_output=True) # Define the deployment configuration gpu_aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False, num_replicas=3, cpu_cores=2, memory_gb=4) # Define the inference configuration myenv = Environment.from_conda_specification( name="testEnv", file_path= "C:/Users/Danilo.Bento/Icon Dropbox/DEVDATA/RO/DEVELOPMENT/SIB2/tutorials/model5/mod5_deploy/deploy_env.yaml" ) myenv.docker.base_image = DEFAULT_GPU_IMAGE inference_config = InferenceConfig( #entry_script=os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'yolov5','score.py'), #entry_script="./yolov5/score.py", entry_script="score.py", environment=myenv, source_directory= "C:/Users/Danilo.Bento/Icon Dropbox/DEVDATA/RO/DEVELOPMENT/SIB2/tutorials/model5/mod5_deploy/deployassets" ) # Name of the web service that is deployed aks_service_name = 'aks-mod5-test' # Get the registerd model
def DeployAzureAKS(): subscription_id = request.json['subscription_id'] resource_group = request.json['resource_group'] workspace_name = request.json['workspace_name'] location = request.json['location'] best_model = request.json['best_model'] Model_path = request.json['Model_path'] cluster_name = request.json['cluster_name'] service_name = request.json['service_name'] Reg_model_name = request.json['Reg_model_name'] ws = Workspace(subscription_id=subscription_id, resource_group=resource_group, workspace_name=workspace_name) print("Found workspace {} at location {}".format(ws.name, ws.location)) print('Found existing Workspace.') from azureml.core.model import Model model = Model(ws, name=Reg_model_name) print(model) from azureml.core.model import InferenceConfig from azureml.core.webservice import AciWebservice from azureml.core.webservice import Webservice from azureml.core.model import Model from azureml.core.environment import Environment from sklearn.externals import joblib cwd = 'D:\\DCSAIAUTOML\\BestModels\\Azure' model_path = os.path.join(cwd, Model_path, best_model, "outputs") #model_path1 = os.path.join(model_path, "outputs", "model.pkl") print(model_path) os.chdir(model_path) #import importlib script_file_name = 'scoring_file_v_1_0_0.py' conda_env_file_name = 'conda_env_v_1_0_0.yml' #importlib.import_module('scoring_file_v_1_0_0.py') #script_file_name = joblib.load('scoring_file_v_1_0_0.py') #import yaml #conda_env_file_name = yaml.load(open('conda_env_v_1_0_0.yml')) #conda_env_file_name = joblib.load('conda_env_v_1_0_0.yml') myenv = Environment.from_conda_specification(name="myenv", file_path=conda_env_file_name) inference_config = InferenceConfig(entry_script=script_file_name, environment=myenv) aks_target = AksCompute(ws, cluster_name) # If deploying to a cluster configured for dev/test, ensure that it was created with enough # cores and memory to handle this deployment configuration. Note that memory is also used by # things such as dependencies and AML components. try: deployment_config = AksWebservice.deploy_configuration( cpu_cores=2, memory_gb=16, enable_app_insights=True, collect_model_data=True, ) service = Model.deploy(ws, service_name, [model], inference_config, deployment_config, aks_target) service.wait_for_deployment(show_output=True) print(service.state) compute_type = service.compute_type state = service.state url = service.scoring_uri s_url = service.swagger_uri #created_time = service.created_time #updated_time = service.updated_time v1 = "@" v2 = "Deployed Successfully" print(v2) return '{} {} {} {} {} {} {} {} {}'.format(v2, v1, compute_type, v1, state, v1, url, v1, s_url) except Exception as e: error_statement = str(e) print("Error statement: ", error_statement) return error_statement
def DeployAzureACI(): subscription_id = request.json['subscription_id'] resource_group = request.json['resource_group'] workspace_name = request.json['workspace_name'] location = request.json['location'] best_model = request.json['best_model'] Model_path = request.json['Model_path'] #cluster_name = request.json['cluster_name'] service_name = request.json['service_name'] Reg_model_name = request.json['Reg_model_name'] ws = Workspace(subscription_id=subscription_id, resource_group=resource_group, workspace_name=workspace_name) print("Found workspace {} at location {}".format(ws.name, ws.location)) print('Found existing Workspace.') from azureml.core.model import Model model = Model(ws, name=Reg_model_name) print(model) from azureml.core.model import InferenceConfig from azureml.core.webservice import AciWebservice from azureml.core.webservice import Webservice from azureml.core.model import Model from azureml.core.environment import Environment cwd = 'D:\\DCSAIAUTOML\\BestModels\\Azure' model_path = os.path.join(cwd, Model_path, best_model, "outputs") #model_path1 = os.path.join(model_path, "outputs", "model.pkl") print(model_path) os.chdir(model_path) #import importlib script_file_name = 'scoring_file_v_1_0_0.py' conda_env_file_name = 'conda_env_v_1_0_0.yml' #importlib.import_module('scoring_file_v_1_0_0.py') #script_file_name = joblib.load('scoring_file_v_1_0_0.py') #import yaml #conda_env_file_name = yaml.load(open('conda_env_v_1_0_0.yml')) #conda_env_file_name = joblib.load('conda_env_v_1_0_0.yml') myenv = Environment.from_conda_specification(name="myenv", file_path=conda_env_file_name) inference_config = InferenceConfig(entry_script=script_file_name, environment=myenv) try: deployment_config = AciWebservice.deploy_configuration(cpu_cores=2, memory_gb=8) service = Model.deploy(ws, service_name, [model], inference_config, deployment_config) service.wait_for_deployment(show_output=True) print(service.state) compute_type = service.compute_type state = service.state url = service.scoring_uri s_url = service.swagger_uri #created_time = service.created_time #updated_time = service.updated_time v1 = "@" v2 = "Deployed Successfully" print(v2) return '{} {} {} {} {} {} {} {} {}'.format(v2, v1, compute_type, v1, state, v1, url, v1, s_url) except Exception as e: error_statement = str(e) print("Error statement: ", error_statement) return error_statement
) args = parser.parse_args() sources_directory_train = e.sources_directory_train # model_names = ["nyc_energy_model", "diabetes_model"] model_names = get_model_names(os.path.join(sources_directory_train, "pipeline_config.json")) print("models:") print(model_names) models = [] for model_name in model_names: models.append(Model(ws, name=model_name)) # Conda environment myenv = Environment.from_conda_specification( "myenv", os.path.join(sources_directory_train, "conda_dependencies.yml")) # Enable Docker based environment myenv.docker.enabled = True inference_config = InferenceConfig( source_directory=sources_directory_train, entry_script="scoring/score.py", environment=myenv) package = Model.package(ws, models, inference_config) package.wait_for_creation(show_output=True) # Display the package location/ACR path # print(package.location) # location = get_location(package) location = package.location
args = parser.parse_args() model = Model(ws, name=e.model_name, version=e.model_version) sources_dir = e.sources_directory_train if (sources_dir is None): sources_dir = 'londonboiler' score_script = os.path.join(".", sources_dir, e.score_script) score_file = os.path.basename(score_script) path_to_scoring = os.path.dirname(score_script) cwd = os.getcwd() # Copy conda_dependencies.yml into scoring as this method does not accept relative paths. # NOQA: E501 shutil.copy(os.path.join(".", sources_dir, "conda_dependencies.yml"), path_to_scoring) os.chdir(path_to_scoring) scoring_env = Environment.from_conda_specification( name="scoringenv", file_path="conda_dependencies.yml") # NOQA: E501 inference_config = InferenceConfig(entry_script=score_file, environment=scoring_env) package = Model.package(ws, [model], inference_config) package.wait_for_creation(show_output=True) # Display the package location/ACR path print(package.location) os.chdir(cwd) if package.state != "Succeeded": raise Exception("Image creation status: {package.creation_state}") print("Package stored at {} with build log {}".format( package.location, package.package_build_log_uri)) # NOQA: E501
# This code saves training environment # Environment file 'environment.yml' is uploaded to GitHub for future trainings # from azureml.core.environment import Environment from azureml.automl.core.shared import constants best_run.download_file(constants.CONDA_ENV_FILE_PATH, 'environment.yml') environment = Environment.from_conda_specification(name="environment", file_path="environment.yml")