azureml-snippets/snippets/snippets.md

title	description
VS Code Snippets	A collection of VS Code Snippets for working with Azure ML.

We have compiled a collection of useful templates in the form of VS code snippets.

To add these snippets to your VS Code: ctrl+shift+p > Type 'Configure user snippets' > Select python.json. All of these snippets are available here: python.json

Imports Group: Basic

Description: Import collection of basic Azure ML classes

Prefix: import-basic

from azureml.core import Workspace              # connect to workspace
from azureml.core import Experiment             # connect/create experiments
from azureml.core import ComputeTarget          # connect to compute
from azureml.core import Environment            # manage e.g. Python environments
from azureml.core import Datastore, Dataset     # work with data

Import Workspace

Description: Import Workspace class

Prefix: import-workspace

from azureml.core import Workspace

Import Compute Target

Description: Import ComputeTarget class

Prefix: import-compute-target

from azureml.core import ComputeTarget

Import Environment

Description: Import Environment class

Prefix: import-environment

from azureml.core import Environment

Import ScriptRunConfig

Description: Import ScriptRunConfig class

Prefixes: import-script-run-config, import-src

from azureml.core import ScriptRunConfig

Import Dataset

Description: Import Dataset class

Prefix: import-dataset

from azureml.core import Dataset

Import Datastore

Description: Import Datastore class

Prefix: import-datastore

from azureml.core import Datastore

Import Run

Description: Import Run class

Prefix: import-run

from azureml.core import Run

Import Conda Dependencies

Description: Import CondaDependencies class

Prefix: import-conda-dependencies

from azureml.core.conda_dependencies import CondaDependencies

Get Workspace From Config

Description: Get Azure ML Workspace from config

Prefixes: get-workspace-config, ws-config

from azureml.core import Workspace
ws = Workspace.from_config()

Get Workspace

Description: Get Azure ML Workspace

Prefixes: get-workspace, get-ws

from azureml.core import Workspace
ws = Workspace.get(
    name='${1:name}',
    subscription_id='${2:subscription_id}',
    resource_group='${3:resource_group}',
)

Get Compute

Description: Get Azure ML Compute Target

Prefix: get-compute

from azureml.core import ComputeTarget
target = ComputeTarget(${2:ws}, '${1:<compute_target_name>}')

Get Compute with SSH

Description: Get Azure ML Compute Target with SSH

Prefix: get-compute-ssh

from azureml.core.compute import AmlCompute
from azureml.core.compute_target import ComputeTargetException

ssh_public_key = 'public-key-here'
compute_config = AmlCompute.provisioning_configuration(
    vm_size='$2',
    min_nodes=$3,
    max_nodes=$4,
    admin_username='$5',
    admin_user_ssh_key=ssh_public_key,
    vm_priority='${6|lowpriority,dedicated|}',
    remote_login_port_public_access='Enabled',
    )

cluster = ComputeTarget.create(
    workspace=${7:workspace_name},
    name='${8:target_name}',
    compute_config=compute_config,
)

Get Environment

Description: Get Azure ML Environment

Prefix: get-environment

from azureml.core import Environment
${2:env} = Environment('${1:<env-name>}')

Get Environment From Pip

Description: Create environment from pip requirements.txt

Prefixes: get-environment-pip, env-pip

from azureml.core import Environment
env = Environment.from_pip_requirements(
    name='${1:env_name}',
    file_path='${2:requirements.txt}',
)

Get Environment From Conda

Description: Create environment from Conda env.yml file

Prefixes: get-environment-conda, env-conda

from azureml.core import Environment
env = Environment.from_conda_specification(
    name='${1:env_name}',
    file_path='${2:env.yml}',
)

Get Environment From SDK

Description: Create environment using CondaDependencies class

Prefixes: get-environment-sdk, env-sdk

from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies
env = Environment('${1:my-env}')

conda = CondaDependencies()

# add channels
conda.add_channel('$2')

# add conda packages
conda.add_conda_package('$3')

# add pip packages
conda.add_pip_package('$4')

# add conda dependencies to environment
env.python.conda_dependencies = conda

Get Environment From Custom image

Description: Create environment using Custom image

Prefixes: get-environment-custom-image, env-image

from azureml.core import Environment
env = Environment('${1:my-env}')

env.docker.enabled = True

# base image for DockerHub
env.docker.base_image = '${2}'

# if you are using base image from a Dockerfile
# env.docker.base_image = None
# env.docker.base_dockerfile = './Dockerfile'

# The user_managed_dependencies flag to True will use your custom image's built-in Python environment. 
env.python.user_managed_dependencies = True

Workspace Compute Targets

Description: Get compute target from workspace

Prefix: ws-compute-target

target = ws.compute_targets['${1:target-name}']

Workspace Environments

Description: Get environment from workspace

Prefix: ws-environment

env = ws.environments['${1:env-name}']

Workspace Datastores

Description: Get datastore from workspace

Prefix: ws-datastore

datastore = ws.datastores['${1:datastore-name}']

Workspace Datasets

Description: Get dataset from workspace

Prefix: ws-dataset

dataset = ws.datasets['${1:dataset-name}']

Workspace Experiment

Description: Get (existing) experiment from workspace

Prefix: ws-experiment

exp = ws.experiments['${1:experiment-name}']

Workspace Models

Description: Get model from workspace

Prefix: ws-model

model = ws.models['${1:model-name}']

Script Run Config

Description: Set up ScriptRunConfig including compute target, environment and experiment

Prefixes: script-run-config, src

from azureml.core import Workspace, Experiment, ScriptRunConfig

# get workspace
ws = Workspace.from_config()

# get compute target
target = ws.compute_targets['${1:target-name}']

# get registered environment
env = ws.environments['${2:env-name}']

# get/create experiment
exp = Experiment(ws, '${3:experiment_name}')

# set up script run configuration
config = ScriptRunConfig(
    source_directory='${4:.}',
    script='${5:script.py}',
    compute_target=target,
    environment=env,
    arguments=[${6:'--meaning', 42}],
)

# submit script to AML
run = exp.submit(config)
print(run.get_portal_url()) # link to ml.azure.com
run.wait_for_completion(show_output=True)

Script Run Config with Command

Description: Set up ScriptRunConfig using command argument

Prefixes: script-run-config-command, command-src, src-command

from azureml.core import Workspace, Experiment, ScriptRunConfig

# get workspace
ws = Workspace.from_config()

# get compute target
target = ws.compute_targets['${1:target-name}']

# get registered environment
env = ws.environments['${2:env-name}']

# get/create experiment
exp = Experiment(ws, '${3:experiment_name}')

# create command
command = 'python ${4:script.py} ${5:--argument value}'.split()

# set up script run configuration
config = ScriptRunConfig(
    source_directory='${6:.}',
    command=command,
    compute_target=target,
    environment=env,
)

# submit script to AML
run = exp.submit(config)
print(run.get_portal_url()) # link to ml.azure.com
run.wait_for_completion(show_output=True)

Script Run Config with Distributed Config

Description: Set up ScriptRunConfig for distributed training.

Prefixes: script-run-config-distributed, distributed-src, src-distributed

from azureml.core import Workspace, ScriptRunConfig, Environment, Experiment
from azureml.core.runconfig import MpiConfiguration

# get workspace
ws = Workspace.from_config()

# get compute target
target = ws.compute_targets['${1:target-name}']

# get curated environment
curated_env_name = '${2:AzureML-PyTorch-1.6-GPU}'
env = Environment.get(workspace=ws, name=curated_env_name)

# get/create experiment
exp = Experiment(ws, '${3:experiment_name}')

# distributed job configuration
distributed_job_config = MpiConfiguration(process_count_per_node=4, node_count=2)

# set up script run configuration
config = ScriptRunConfig(
    source_directory='${4:.}',
    script='${5:script.py}',
    compute_target=target,
    environment=env,
    distributed_job_config=distributed_job_config,
)

# submit script to AML
run = exp.submit(config)
print(run.get_portal_url()) # link to ml.azure.com
run.wait_for_completion(show_output=True)

Run Details Widget

Description: Represents a Jupyter notebook widget used to view the progress of model training.

Prefix: run-details-widget

from azureml.core import Workspace,Experiment,Run
from azureml.widgets import RunDetails

# get workspace
ws = Workspace.from_config()

# get/create experiment
exp = Experiment(ws, '${1:experiment_name}')

# get run
run = Run(exp,'${2:run_id}')

# submit script to AML
RunDetails(run).show()

Consume Dataset

Description: Download Azure ML dataset to current working directory

Prefix: consume-dataset

#azureml-core of version 1.0.72 or higher is required
from azureml.core import Workspace, Dataset

# get/create experiment
ws = Workspace.from_config()

# get dataset
dataset = Dataset.get_by_name(ws, name='${1:dataset_name}')
dataset.download(target_path='.', overwrite=False)

Create Tabular Dataset

Description: Create Azure ML tabular dataset.

Prefix: create-tabular-dataset

from azureml.core import Workspace, Datastore, Dataset

datastore_name = '${1:datastore_name}'

# get workspace
ws = Workspace.from_config()

# retrieve an existing datastore in the workspace by name
datastore = Datastore.get(ws, datastore_name)

# create a TabularDataset from 1 file paths in datastore
datastore_paths = [(datastore, ${2:file_path})]

custom_ds = Dataset.Tabular.from_delimited_files(path=datastore_paths)

Create File Dataset

Description: Create Azure ML file dataset.

Prefix: create-file-dataset

# create a FileDataset pointing to files in 'animals' folder and its subfolders recursively
from azureml.core import Workspace, Datastore, Dataset

datastore_name = '${1:datastore_name}'

# get workspace
ws = Workspace.from_config()

# retrieve an existing datastore in the workspace by name
datastore = Datastore.get(ws, datastore_name)

# create a FileDataset pointing to files in your folder and its subfolders recursively, you can also use public web urls paths
datastore_paths = [(datastore, ${2:file_path})]

custom_ds = Dataset.File.from_files(path=datastore_paths)