Introducing Auto ML with Python and the Azure ML SDK

# Load the workspace information from config.json using the Azure ML SDK
from azureml.core import Workspace

ws = Workspace.from_config()
ws.name

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

# Now let's make sure we have a compute resource created
cluster_name = "My-Cluster"  # The name of the cluster
vm_size = 'Standard_D2DS_V4' # There are many different specs available for CPU or GPU tasks.
min_nodes = 0                # This is important to prevent billing while idle
max_nodes = 4                # Azure does limit you to a certain quota, but you can get that extended

# Fetch or create the compute resource
try:
    cpu_cluster = ComputeTarget(workspace=ws, name=cluster_name) # This will throw a ComputeTargetException if this doesn't exist
    print('Using existing compute: ' + cluster_name)

except ComputeTargetException:
    # Create the cluster
    print('Provisioning cluster...')
    compute_config = AmlCompute.provisioning_configuration(vm_size=vm_size, min_nodes=min_nodes, max_nodes=max_nodes)
    cpu_cluster = ComputeTarget.create(ws, cluster_name, compute_config)

# Ensure the cluster is ready to go
cpu_cluster.wait_for_completion(show_output=True)

from azureml.core import Dataset
import pandas as pd

# The default datastore is a blob storage container where datasets are stored
datastore = ws.get_default_datastore()

# Load some data into a dataframe (Note: Pandas is just one path into Azure ML)
df = pd.read_csv('my_data.csv')

# Register the dataset
ds = Dataset.Tabular.register_pandas_dataframe(
        dataframe=df, 
        name='DataSet-Name', 
        description='A description of my dataset',
        target=datastore
    )

# Display information about the dataset
print(ds.name + " v" + str(ds.version) + ' (ID: ' + ds.id + ")")

# Create the configuration for the experiment
from azureml.train.automl import AutoMLConfig

# See https://docs.microsoft.com/en-us/python/api/azureml-train-automl-client/azureml.train.automl.automlconfig.automlconfig?view=azure-ml-py for details
automl_config = AutoMLConfig(
        task='regression',                                  # regression, classification, or forecasting
        training_data=ds,                                   # The data to use to train the model
        label_column_name='thingIWantToPredict',            # The column we're trying to predict
        n_cross_validations=3,                              # How many cross-validation sets to use
        primary_metric='normalized_root_mean_squared_error',# The metric we use to compare model performance
        compute_target=cpu_cluster,                         # Where the experiment should be run
        max_concurrent_iterations=max_nodes,                # How many models can be trained simultaneously
        iterations=40,                                      # The total number of models to train
        iteration_timeout_minutes=5                         # The amount of time before giving up on a single model training run
    )            

from azureml.core.experiment import Experiment
from azureml.widgets import RunDetails

# Find or Create a Machine Learning Experiment in Azure Machine Learning Studio
experiment_name = 'My-Regression-Experiment'
experiment=Experiment(ws, experiment_name)

# Start running the experiment
run = experiment.submit(automl_config)

# Wait for the experiment to complete (displays active details about the run)
RunDetails(run).show()
run.wait_for_completion(show_output=False)

# Grab the resulting model and best run
best_auto_run, automl_model = run.get_output()

# Display details about the best run
print('Best Run: ' + str(best_auto_run.id))
RunDetails(best_auto_run).show()

# Register the model in Azure
best_auto_run.register_model(
    model_name='My-AutoML-Model', 
    model_path='outputs/model.pkl', 
    description='A model I trained with Python Code')

best_auto_run.download_files(output_directory='automl-output')

from azureml.core import Environment
from azureml.core.model import InferenceConfig

# Load the environment from the YAML file downloaded from the best run
env = Environment.from_conda_specification("AutoML-env", "automl-output/outputs/conda_env_v_1_0_0.yml")

# Create an inference config pointing at the files we downloaded. This configuration tells Azure how to handle requests
inference_config = InferenceConfig(environment=env, 
                                   source_directory='./automl-output/outputs', 
                                   entry_script='./scoring_file_v_2_0_0.py')

# The deployment configuration configures how the endpoint is hosted
deployment_config = AciWebservice.deploy_configuration(
    cpu_cores = 1, 
    memory_gb = 1, 
    enable_app_insights=True,
    auth_enabled=False) 

# Deploy the model
service = Model.deploy(ws, "endpoint-name", [automl_model], inference_config, deployment_config, overwrite=True)
service.wait_for_deployment(show_output = True)

# Grab our scoring endpoint for testing
print('Endpoint active at ' + service.scoring_uri)