def show_environment( workspace=None, environment_name=None, environment_version=None, # We should enforce a logger logger=None): return Environment._serialize_to_dict(Environment.get(workspace, environment_name, environment_version))
def get_inference_config(aml_interface): aml_env = Environment.get(workspace=aml_interface.workspace, name=AML_ENVIRONMENT_NAME) scoring_script_path = os.path.join(__here__, 'score.py') inference_config = InferenceConfig(entry_script=scoring_script_path, environment=aml_env) return inference_config
def download_environment( workspace=None, environment_name=None, environment_version=None, environment_directory=None, environment_overwrite=None, # We should enforce a logger logger=None): definition = Environment.get(workspace, environment_name, environment_version) definition.save_to_directory(environment_directory, environment_overwrite)
def main(): try: ws = connectToWorkspace(TENANT_ID, APP_ID, SP_PASSWORD, SUBSCRIPTION_ID, RESOURCE_GROUP, WORKSPACE_NAME) except ProjectSystemException as err: print('Authentication did not work.') return json.dumps('ProjectSystemException') except Exception as err: print(err) sys.exit() 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.get(ws, name='AzureML-PySpark-MmlSpark-0.15') myenv.name = "myenv" conda_dep = CondaDependencies() conda_dep.add_pip_package("azureml-defaults") conda_dep.add_pip_package("azure-storage") conda_dep.add_pip_package("azure-storage-file-datalake") myenv.python.conda_dependencies = conda_dep print("Environment Configured") inference_config = InferenceConfig(entry_script='score.py', environment=myenv) aks_target_name = "raiaks" 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()
def main(): workspace_name = os.environ['AML_WORKSPACE_NAME'] resource_group = os.environ['RESOURCE_GROUP'] subscription_id = os.environ['SUBSCRIPTION_ID'] spn_credentials = { 'tenant_id': os.environ['TENANT_ID'], 'service_principal_id': os.environ['SPN_ID'], 'service_principal_password': os.environ['SPN_PASSWORD'], } aml_interface = AMLInterface(spn_credentials, subscription_id, workspace_name, resource_group) scoring_script_path = os.path.join(__here__, 'score.py') aml_env = Environment.get(workspace=aml_interface.workspace, name=AML_ENV_NAME) service_name = 'aml-pipeline-deploy-3' inference_config = InferenceConfig(entry_script=scoring_script_path, environment=aml_env) deploy(aml_interface, inference_config, service_name)
def deploy_models(): aciconfig = AciWebservice.deploy_configuration( cpu_cores=1, memory_gb=1, tags={ "data": "Earthquake", "method": "sklearn" }, description='Predict aftershock situation ' 'using linear models in sklearn') # env = Environment('aftershock-env') # cd = CondaDependencies.create(pip_packages=['azureml-dataset-runtime[pandas,fuse]', # 'azureml-defaults'], # conda_packages=['scikit-learn==0.24.2']) # env.python.conda_dependencies = cd env = Environment.get(workspace=ws, name='aftershock-env') inference_config = InferenceConfig(entry_script="predict.py", environment=env) model = Model(ws, "aftershock_model") # service_name = 'sklearn-aftershock-svc-' + str(uuid.uuid4())[:4] service_name = "sklearn-aftershock-svc-f41b" service = Model.deploy(workspace=ws, name=service_name, models=[model], overwrite=True, inference_config=inference_config, deployment_config=aciconfig) service.wait_for_deployment(show_output=True) print(service.get_logs()) print(service.scoring_uri) print("service keys") print(service.get_keys()) print("service token") print(service.get_token())
def file_to_inference_config(workspace, inference_config_file, description): with open(inference_config_file) as inference_file_stream: inference_config_obj = file_stream_to_object(inference_file_stream) # Retrieve Environment object from the name in the InferenceConfig file if 'environment' not in inference_config_obj: raise OMLException("need to specify environment in --deploy-config-file") environment_name = inference_config_obj.get('environment')["name"] environment = Environment.get(workspace, name=environment_name) inference_config = InferenceConfig( entry_script=inference_config_obj.get('entryScript'), runtime=inference_config_obj.get('runtime'), conda_file=inference_config_obj.get('condaFile'), extra_docker_file_steps=inference_config_obj.get('extraDockerfileSteps'), source_directory=inference_config_obj.get('sourceDirectory'), enable_gpu=inference_config_obj.get('enableGpu'), base_image=inference_config_obj.get('baseImage'), base_image_registry=inference_config_obj.get('baseImageRegistry'), cuda_version=inference_config_obj.get('cudaVersion'), environment=environment, description=description) return inference_config
print(args) # Load the stored workspace ws = Workspace.from_config() # Get the registered training dataset from azure if args.data_subset.endswith('npy'): train_dataset = Dataset.get_by_name(ws, name='birdsongs_npy') else: train_dataset = Dataset.get_by_name(ws, name='birdsongs_10sec') # get the validation dataset val_test_dataset = Dataset.get_by_name(ws, name='birdsongs_10sec') ## Get saved enviornment env = Environment.get(workspace=ws, name="birdsong-env-gpu") # set the expiriment name if args.test: experiment_name = 'test' else: experiment_name = 'birdsongs_2' exp = Experiment(workspace=ws, name=experiment_name) # get the compute cluster if args.gpus == 1: compute_name = "gpu-cluster-NC6" elif args.gpus == 2: compute_name = "gpu-cluster-NC12" elif args.gpus == 4: compute_name = "gpu-cluster-NC24"
# # You should have received a copy of the GNU General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. # Deploy an existing model from the model repository, in this case to a local # service (ie a local docker container) from azureml.core.environment import Environment from azureml.core.model import InferenceConfig from azureml.core import Model from azureml.core.webservice import LocalWebservice from workspace import get_workspace workspace = get_workspace() # Create an environment based on the AzureML-Minimal environment env = Environment.get(workspace=workspace, name="AzureML-Minimal").clone("TestEnv") # Add packages manually. This can also be done automatically from either a # conda dependencies export or a pip requirements file for pip_package in ["scikit-learn"]: env.python.conda_dependencies.add_pip_package(pip_package) # Create the inverence config from the deploy/ folder inference_config = InferenceConfig( entry_script='deploy/main.py', environment=env) # Use the following model from the repository model = Model(workspace, 'model_from_test_experiment_1') service = Model.deploy(
from azureml.data import OutputFileDatasetConfig from azureml.pipeline.core import Pipeline from azureml.pipeline.steps import PythonScriptStep COMPUTE_TARGET_NAME = 'learnml-big' ENV_NAME = 'gensim-environment' print("Azure ML SDK Version: ", azureml.core.VERSION) workspace = Workspace.from_config() print(workspace.name, workspace.location, workspace.resource_group, sep='\t') # Re-use pre-defined Compute Target and Environment compute_target = workspace.compute_targets[COMPUTE_TARGET_NAME] env = Environment.get(workspace=workspace, name=ENV_NAME) # Step 1: data preparation ds_20news_source = Dataset.File.from_files( path='http://qwone.com/~jason/20Newsgroups/20news-bydate.tar.gz') train_ds = OutputFileDatasetConfig().read_delimited_files(separator='\t').register_on_complete(name='20news-train') dataprep_step = PythonScriptStep( script_name="dataprep.py", source_directory="./topicmodel", compute_target=compute_target, arguments=[ '--input', ds_20news_source.as_named_input('source').as_download(), '--output', train_ds
def deploy(ws_name,model_name,path_to_model, environment_name,register_environment,pip_packages,conda_packages, cpu_cores , memory_gb, path_to_entry_script,service_name): ''' Get Workspace ''' ws = Workspace.from_config() print("Got Workspace {}".format(ws_name)) ''' Register Model ''' model = Model.register(workspace = ws, model_path =path_to_model, model_name = model_name, ) print("Registered Model {}".format(model_name)) ''' Register Environment ''' # to install required packages if register_environment: env = Environment(environment_name) cd = CondaDependencies.create(pip_packages=pip_packages, conda_packages = conda_packages) env.python.conda_dependencies = cd # Register environment to re-use later env.register(workspace = ws) print("Registered Environment") myenv = Environment.get(workspace=ws, name=environment_name) # Uncomment to save environment # myenv.save_to_directory('./environ', overwrite=True) ''' Config Objects ''' aciconfig = AciWebservice.deploy_configuration( cpu_cores=cpu_cores, memory_gb=memory_gb, ) inference_config = InferenceConfig(entry_script=path_to_entry_script, environment=myenv) ''' Deploying ''' print("Deploying....... This may take a few mins, check the status in MLS after the function finishes executing") service = Model.deploy(workspace=ws, name=ws_name, models=[model], inference_config=inference_config, deployment_config=aciconfig, overwrite = True) service.wait_for_deployment(show_output=True) url = service.scoring_uri print(url) service = Webservice(ws,ws_name) print(service.get_logs()) return url
from azureml.core.environment import Environment from azureml.core.model import InferenceConfig from azureml.core import Workspace from azureml.core.authentication import AzureCliAuthentication interactive_auth = AzureCliAuthentication(cloud="AzureCloud") ws = Workspace.get(name="Machine-Learning", subscription_id="ecadfaca-baf6-4554-b903-5d4de6dea911", resource_group="Projekt-Azure", auth=interactive_auth) env = Environment.get(ws, "AzureML-Minimal").clone("test_env") for pip_package in ["sentence-transformers"]: env.python.conda_dependencies.add_pip_package(pip_package) m_inference_config = InferenceConfig(entry_script="./entry_script.py", environment=env)
def get_env(workspace, name, version='1'): env = Environment.get(workspace=workspace, name=name, version=version) return env
model.fit(X_train, Y_train) filename = 'dummy.pkl' pickle.dump(model, open(filename, 'wb')) # register the dummy model ws = Workspace.from_config() registration_params = { 'model_path': "dummy.pkl", 'model_name': "dummy-model", 'description': "mock test deployment", 'workspace': ws } model = register_model(**registration_params) myenv = Environment(name='my_env') myenv.get(workspace=ws, name='ls-ds-ml-env') conda_dep = CondaDependencies() conda_dep.add_pip_package("azureml-defaults==1.3.0") conda_dep.add_pip_package("joblib") conda_dep.add_pip_package("json") myenv.python.conda_dependencies = conda_dep inference_config = InferenceConfig(entry_script="src/dummy_score.py", environment=myenv) aci_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1) service_name = 'dummy-service' try: service = Model.deploy(ws, service_name, [model], inference_config, deployment_config=aci_config)
# COMMAND ---------- from azureml.core.webservice import AciWebservice, Webservice from azureml.exceptions import WebserviceException from azureml.core.model import InferenceConfig from azureml.core.environment import Environment from azureml.core.conda_dependencies import CondaDependencies # Remove any existing service under the same name. try: Webservice(ws, webservice_name).delete() except WebserviceException: pass env = Environment.get(ws, name='AzureML-PySpark-MmlSpark-0.15') inference_config = InferenceConfig(entry_script="score_sparkml.py", environment=env) deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1, auth_enabled=True) #image_config = ContainerImage.image_configuration(execution_script = "score_sparkml.py", # runtime = "spark-py", # conda_file = "mydeployenv.yml") myservice = Model.deploy(ws, webservice_name, [mymodel], inference_config, deployment_config)
#retrieve workspace #get experiment name ws = utils.retrieve_workspace() experiment = Experiment(workspace=ws, name='myexp') #get compute target try: compute_name = os.environ.get("AML_COMPUTE_CLUSTER_NAME", "cpucluster") compute_target = ws.compute_targets[compute_name] except ComputeTargetException as e: print('Error while retrieving compute', e) sys.exit(-1) env = None try: env = Environment.get(workspace=ws, name=os.environ.get('AML_ENVIRONMENT', 'myenv')) except Exception as e: print('Environment not found in workspace') print('Trying to retrieve from local config') if env is None: try: dir_path = Path(__file__).resolve().parent.parent env_path = dir_path / '< folder to use >' env = Environment.load_from_directory(path=env_path) except Exception as e: print('Environment folder not found') print('Shutting everything down !') sys.exit(-1) src = ScriptRunConfig(source_directory='./src', script='/train.py')
uniform) experiment_name = 'tm-gensim-20news' compute_target_name = 'learnml-big' env_name = 'gensim-environment' print("Azure ML SDK Version: ", azureml.core.VERSION) ws = Workspace.from_config() print(ws.name, ws.location, ws.resource_group, sep='\t') # Prepare experiment exp = Experiment(workspace=ws, name=experiment_name) compute_target = ws.compute_targets[compute_target_name] env = Environment.get(workspace=ws, name=env_name) ds = Dataset.get_by_name(workspace=ws, name='20news-train', version=2) args = [ '--input-data', ds.as_named_input('train_data'), #'--num-topics', 10, '--chunksize', 2000, '--passes', 20, '--iterations', 400 ] src = ScriptRunConfig(source_directory="./topicmodel", script='train.py', arguments=args, compute_target=compute_target, environment=env)
subscription_id=subscription_id, resource_group=resource_group) aciconfig = AciWebservice.deploy_configuration( cpu_cores=1, memory_gb=1, tags={ "data": "Titanic", "method": "sklearn" }, description='Predict Titanic with sklearn', auth_enabled=True) model = Model(ws, 'decision_tree_model') env = Environment.get(workspace=ws, name="sklearn-env") inference_config = InferenceConfig(entry_script="src/score.py", environment=env) service = Model.deploy(workspace=ws, name='sklearn-titanic', models=[model], inference_config=inference_config, deployment_config=aciconfig, overwrite=True) service.wait_for_deployment(show_output=True) ######### Lets test the web service df = pd.read_csv(