Explore Data & Train Models (25-30%) Intermediate

This domain tests your ability to perform exploratory data analysis, engineer features, run AutoML experiments, and write custom training scripts. It is the second-highest weighted domain and requires both conceptual understanding and hands-on SDK knowledge.

Exploratory Data Analysis (EDA)

Before training any model, you need to understand your data. The exam tests your knowledge of EDA techniques and how to perform them in Azure ML notebooks.

Key EDA Tasks for the Exam

• Summary statistics — Mean, median, standard deviation, percentiles using df.describe()
• Missing value analysis — Identify nulls with df.isnull().sum(), decide imputation vs. removal
• Distribution analysis — Histograms, box plots, skewness detection
• Correlation analysis — Pearson/Spearman correlation matrices, multicollinearity detection
• Outlier detection — IQR method, Z-score, isolation forests
• Class imbalance — Check target variable distribution for classification tasks

# EDA in Azure ML notebook (exam-relevant patterns)
import pandas as pd
import matplotlib.pyplot as plt
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# Load data from registered data asset
ml_client = MLClient(
    DefaultAzureCredential(),
    subscription_id="...",
    resource_group_name="dp100-rg",
    workspace_name="dp100-workspace"
)

# Get data asset URI and load
data_asset = ml_client.data.get("customer-churn-data", version="1")
df = pd.read_csv(data_asset.path)

# Summary statistics
print(df.describe())
print(f"\nShape: {df.shape}")
print(f"\nMissing values:\n{df.isnull().sum()}")

# Check class balance for classification
print(f"\nTarget distribution:\n{df['churn'].value_counts(normalize=True)}")

# Correlation matrix
correlation = df.select_dtypes(include='number').corr()
print(f"\nHigh correlations (>0.8):")
for col in correlation.columns:
    for idx in correlation.index:
        if col != idx and abs(correlation.loc[idx, col]) > 0.8:
            print(f"  {col} <-> {idx}: {correlation.loc[idx, col]:.3f}")

Feature Engineering

The exam tests your understanding of common feature engineering techniques and when to apply them.

AutoML in Azure ML

AutoML automates model selection, hyperparameter tuning, and feature engineering. The exam heavily tests AutoML configuration and understanding output.

# Configure and run AutoML with SDK v2
from azure.ai.ml import automl, Input

# Classification task
classification_job = automl.classification(
    compute="dp100-cluster",
    experiment_name="churn-automl",
    training_data=Input(
        type="mltable",
        path="azureml://datastores/workspaceblobstore/paths/data/churn-mltable/"
    ),
    target_column_name="churn",
    primary_metric="AUC_weighted",
    # Key configuration options for the exam:
    enable_model_explainability=True,    # Generate feature importance
    enable_early_termination=True,       # Stop poor-performing runs
    n_cross_validations=5,               # K-fold cross validation
    max_trials=20,                       # Max models to try
    max_concurrent_trials=4,             # Parallel experiments
    timeout_minutes=60,                  # Total time budget
    # Allowed/blocked models
    allowed_training_algorithms=[
        "LogisticRegression",
        "LightGBM",
        "RandomForest",
        "GradientBoosting",
        "XGBoostClassifier"
    ],
    # Featurization settings
    featurization="auto"                 # auto, off, or custom
)

# Submit the job
returned_job = ml_client.jobs.create_or_update(classification_job)
print(f"Job URL: {returned_job.studio_url}")

AutoML Task Types

Custom Training Scripts

When AutoML is not sufficient, you write custom training scripts and submit them as command jobs.

# Custom training script: train.py
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score, roc_auc_score, classification_report

def main():
    # Parse arguments (passed from pipeline/command job)
    parser = argparse.ArgumentParser()
    parser.add_argument("--input-data", type=str, required=True)
    parser.add_argument("--learning-rate", type=float, default=0.1)
    parser.add_argument("--n-estimators", type=int, default=100)
    parser.add_argument("--max-depth", type=int, default=3)
    args = parser.parse_args()

    # Enable MLflow autologging
    mlflow.sklearn.autolog()

    # Load data
    df = pd.read_csv(args.input_data)

    # Split features and target
    X = df.drop("churn", axis=1)
    y = df["churn"]

    # Train/test split
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42, stratify=y
    )

    # Train model
    model = GradientBoostingClassifier(
        learning_rate=args.learning_rate,
        n_estimators=args.n_estimators,
        max_depth=args.max_depth,
        random_state=42
    )
    model.fit(X_train, y_train)

    # Evaluate
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])

    # Log metrics (MLflow)
    mlflow.log_metric("accuracy", accuracy)
    mlflow.log_metric("auc", auc)

    print(f"Accuracy: {accuracy:.4f}")
    print(f"AUC: {auc:.4f}")
    print(classification_report(y_test, predictions))

if __name__ == "__main__":
    main()

# Submit custom training as a command job
from azure.ai.ml import command, Input

# Define command job
job = command(
    code="./src",                          # Local folder with train.py
    command="python train.py --input-data ${{inputs.data}} --learning-rate ${{inputs.lr}} --n-estimators ${{inputs.n_est}}",
    inputs={
        "data": Input(
            type="uri_file",
            path="azureml://datastores/workspaceblobstore/paths/data/churn.csv"
        ),
        "lr": 0.05,
        "n_est": 200
    },
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    compute="dp100-cluster",
    experiment_name="churn-custom-training",
    display_name="gradient-boosting-v1"
)

returned_job = ml_client.jobs.create_or_update(job)
print(f"Job URL: {returned_job.studio_url}")

Hyperparameter Tuning (Sweep Jobs)

Azure ML sweep jobs automate hyperparameter search. Know the sampling methods and early termination policies for the exam.

# Hyperparameter sweep job
from azure.ai.ml.sweep import Choice, Uniform, BanditPolicy

# Convert command to sweep
sweep_job = job.sweep(
    sampling_algorithm="bayesian",          # random, grid, or bayesian
    primary_metric="auc",
    goal="maximize",
)

# Define search space
sweep_job.set_limits(
    max_total_trials=20,
    max_concurrent_trials=4,
    timeout=3600                            # seconds
)

# Early termination policy
sweep_job.early_termination = BanditPolicy(
    slack_factor=0.1,                       # Allow 10% slack from best
    evaluation_interval=2,                  # Check every 2 trials
    delay_evaluation=5                      # Skip first 5 trials
)

# Search space overrides
sweep_job.inputs.lr = Uniform(min_value=0.001, max_value=0.3)
sweep_job.inputs.n_est = Choice(values=[50, 100, 200, 500])

returned_sweep = ml_client.jobs.create_or_update(sweep_job)

Practice Questions