CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-azure-ai-ml

Microsoft Azure Machine Learning Client Library for Python providing comprehensive SDK for ML workflows including job execution, pipeline components, model deployment, and AutoML capabilities

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview
Eval results
Files

automl.mddocs/

AutoML

Automated machine learning capabilities for tabular data (classification, regression, forecasting), computer vision tasks (image classification, object detection, instance segmentation), and natural language processing (text classification, named entity recognition).

Capabilities

Tabular AutoML

Automated ML for structured data with classification, regression, and forecasting tasks.

def classification(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    test_data: Data = None,
    primary_metric: str = "accuracy",
    featurization: TabularFeaturizationSettings = None,
    limits: TabularLimitSettings = None,
    training_settings: TrainingSettings = None,
    **kwargs
) -> ClassificationJob:
    """
    Create an automated classification job for tabular data.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset
    - validation_data: Validation dataset (optional)
    - test_data: Test dataset (optional)
    - primary_metric: Primary metric for optimization
    - featurization: Feature engineering settings
    - limits: Training limits and constraints
    - training_settings: Training configuration
    
    Returns:
    ClassificationJob configured for automated ML
    """

def regression(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    test_data: Data = None,
    primary_metric: str = "normalized_root_mean_squared_error",
    featurization: TabularFeaturizationSettings = None,
    limits: TabularLimitSettings = None,
    training_settings: TrainingSettings = None,
    **kwargs
) -> RegressionJob:
    """
    Create an automated regression job for tabular data.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset
    - validation_data: Validation dataset (optional)
    - test_data: Test dataset (optional)
    - primary_metric: Primary metric for optimization
    - featurization: Feature engineering settings
    - limits: Training limits and constraints
    - training_settings: Training configuration
    
    Returns:
    RegressionJob configured for automated ML
    """

def forecasting(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    test_data: Data = None,
    primary_metric: str = "normalized_root_mean_squared_error",
    forecasting_settings: ForecastingSettings,
    featurization: TabularFeaturizationSettings = None,
    limits: TabularLimitSettings = None,
    training_settings: TrainingSettings = None,
    **kwargs
) -> ForecastingJob:
    """
    Create an automated forecasting job for time series data.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset
    - validation_data: Validation dataset (optional)
    - test_data: Test dataset (optional)
    - primary_metric: Primary metric for optimization
    - forecasting_settings: Time series specific settings
    - featurization: Feature engineering settings
    - limits: Training limits and constraints
    - training_settings: Training configuration
    
    Returns:
    ForecastingJob configured for automated ML
    """

Usage Example

from azure.ai.ml import automl
from azure.ai.ml.entities import Data

# Create training data asset
training_data = Data(
    name="classification-data",
    path="./data/train.csv",
    type="mltable"
)

# Create classification job
classification_job = automl.classification(
    target_column_name="target",
    training_data=training_data,
    primary_metric="accuracy",
    compute="cpu-cluster",
    experiment_name="automl-classification"
)

# Submit the job
submitted_job = ml_client.jobs.create_or_update(classification_job)

Computer Vision AutoML

Automated ML for image-based tasks including classification, object detection, and instance segmentation.

def image_classification(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "accuracy",
    limits: ImageLimitSettings = None,
    sweep_settings: ImageSweepSettings = None,
    model_settings: ImageModelSettingsClassification = None,
    **kwargs
) -> ImageClassificationJob:
    """
    Create an automated image classification job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset with images and labels
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    - limits: Training limits and constraints
    - sweep_settings: Hyperparameter sweep settings
    - model_settings: Model-specific settings
    
    Returns:
    ImageClassificationJob configured for automated ML
    """

def image_classification_multilabel(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "iou",
    **kwargs
) -> ImageClassificationMultilabelJob:
    """
    Create an automated multi-label image classification job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    
    Returns:
    ImageClassificationMultilabelJob configured for automated ML
    """

def image_object_detection(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "mean_average_precision",
    limits: ImageLimitSettings = None,
    sweep_settings: ImageSweepSettings = None,
    model_settings: ImageModelSettingsObjectDetection = None,
    **kwargs
) -> ImageObjectDetectionJob:
    """
    Create an automated object detection job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset with images and bounding boxes
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    - limits: Training limits and constraints
    - sweep_settings: Hyperparameter sweep settings
    - model_settings: Model-specific settings
    
    Returns:
    ImageObjectDetectionJob configured for automated ML
    """

def image_instance_segmentation(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "mean_average_precision",
    **kwargs
) -> ImageInstanceSegmentationJob:
    """
    Create an automated instance segmentation job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset with images and segmentation masks
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    
    Returns:
    ImageInstanceSegmentationJob configured for automated ML
    """

Natural Language Processing AutoML

Automated ML for text-based tasks including classification and named entity recognition.

def text_classification(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "accuracy",
    featurization: NlpFeaturizationSettings = None,
    limits: NlpLimitSettings = None,
    sweep_settings: NlpSweepSettings = None,
    **kwargs
) -> TextClassificationJob:
    """
    Create an automated text classification job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset with text and labels
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    - featurization: NLP feature engineering settings
    - limits: Training limits and constraints
    - sweep_settings: Hyperparameter sweep settings
    
    Returns:
    TextClassificationJob configured for automated ML
    """

def text_classification_multilabel(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "accuracy",
    **kwargs
) -> TextClassificationMultilabelJob:
    """
    Create an automated multi-label text classification job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    
    Returns:
    TextClassificationMultilabelJob configured for automated ML
    """

def text_ner(
    *,
    target_column_name: str,
    training_data: Data,
    validation_data: Data = None,
    primary_metric: str = "accuracy",
    **kwargs
) -> TextNerJob:
    """
    Create an automated named entity recognition job.
    
    Parameters:
    - target_column_name: Name of the target column
    - training_data: Training dataset with text and entity labels
    - validation_data: Validation dataset (optional)
    - primary_metric: Primary metric for optimization
    
    Returns:
    TextNerJob configured for automated ML
    """

AutoML Job Classes

class ClassificationJob:
    def __init__(
        self,
        *,
        target_column_name: str,
        training_data: Data,
        primary_metric: str = "accuracy",
        **kwargs
    ):
        """Tabular classification AutoML job."""

class RegressionJob:
    def __init__(
        self,
        *,
        target_column_name: str,
        training_data: Data,
        primary_metric: str = "normalized_root_mean_squared_error",
        **kwargs
    ):
        """Tabular regression AutoML job."""

class ForecastingJob:
    def __init__(
        self,
        *,
        target_column_name: str,
        training_data: Data,
        forecasting_settings: ForecastingSettings,
        primary_metric: str = "normalized_root_mean_squared_error",
        **kwargs
    ):
        """Time series forecasting AutoML job."""

class ImageClassificationJob:
    def __init__(
        self,
        *,
        target_column_name: str,
        training_data: Data,
        primary_metric: str = "accuracy",
        **kwargs
    ):
        """Image classification AutoML job."""

class TextClassificationJob:
    def __init__(
        self,
        *,
        target_column_name: str,
        training_data: Data,
        primary_metric: str = "accuracy",
        **kwargs
    ):
        """Text classification AutoML job."""

Configuration Classes

class TrainingSettings:
    def __init__(
        self,
        *,
        enable_onnx_compatible_models: bool = False,
        enable_dnn_training: bool = False,
        enable_model_explainability: bool = True,
        enable_stack_ensemble: bool = True,
        enable_vote_ensemble: bool = True,
        stack_ensemble_settings: StackEnsembleSettings = None,
        blocked_training_algorithms: list = None,
        allowed_training_algorithms: list = None
    ):
        """
        Training configuration for AutoML jobs.
        
        Parameters:
        - enable_onnx_compatible_models: Enable ONNX model generation
        - enable_dnn_training: Enable deep neural network training
        - enable_model_explainability: Enable model explanations
        - enable_stack_ensemble: Enable stack ensemble models
        - enable_vote_ensemble: Enable vote ensemble models
        - stack_ensemble_settings: Stack ensemble configuration
        - blocked_training_algorithms: Algorithms to exclude
        - allowed_training_algorithms: Algorithms to include
        """

class TabularFeaturizationSettings:
    def __init__(
        self,
        *,
        mode: str = "auto",
        transformer_params: dict = None,
        column_name_and_types: dict = None,
        dataset_language: str = "eng",
        blocked_transformers: list = None
    ):
        """
        Feature engineering settings for tabular data.
        
        Parameters:
        - mode: Featurization mode ("auto", "custom", "off")
        - transformer_params: Custom transformer parameters
        - column_name_and_types: Column data types
        - dataset_language: Dataset language for text features
        - blocked_transformers: Transformers to exclude
        """

class TabularLimitSettings:
    def __init__(
        self,
        *,
        max_trials: int = 1000,
        max_concurrent_trials: int = None,
        max_cores_per_trial: int = None,
        trial_timeout_minutes: int = None,
        experiment_timeout_minutes: int = None,
        enable_early_termination: bool = True
    ):
        """
        Training limits for tabular AutoML.
        
        Parameters:
        - max_trials: Maximum number of trials
        - max_concurrent_trials: Maximum concurrent trials
        - max_cores_per_trial: Maximum cores per trial
        - trial_timeout_minutes: Timeout per trial in minutes
        - experiment_timeout_minutes: Total experiment timeout
        - enable_early_termination: Enable early stopping
        """

class ForecastingSettings:
    def __init__(
        self,
        *,
        time_column_name: str,
        forecast_horizon: int,
        time_series_id_column_names: list = None,
        frequency: str = None,
        target_lags: list = None,
        target_rolling_window_size: int = None,
        country_or_region_for_holidays: str = None,
        use_stl: str = None
    ):
        """
        Time series forecasting specific settings.
        
        Parameters:
        - time_column_name: Name of the time column
        - forecast_horizon: Number of periods to forecast
        - time_series_id_column_names: Columns identifying time series
        - frequency: Data frequency (D, H, M, etc.)
        - target_lags: Lag values for target variable
        - target_rolling_window_size: Rolling window size
        - country_or_region_for_holidays: Holiday calendar region
        - use_stl: STL decomposition usage
        """

class ImageLimitSettings:
    def __init__(
        self,
        *,
        max_trials: int = 1,
        max_concurrent_trials: int = 1,
        timeout_minutes: int = None
    ):
        """
        Training limits for image AutoML.
        
        Parameters:
        - max_trials: Maximum number of trials
        - max_concurrent_trials: Maximum concurrent trials
        - timeout_minutes: Total timeout in minutes
        """

class NlpLimitSettings:
    def __init__(
        self,
        *,
        max_trials: int = 1,
        max_concurrent_trials: int = 1,
        timeout_minutes: int = None
    ):
        """
        Training limits for NLP AutoML.
        
        Parameters:
        - max_trials: Maximum number of trials
        - max_concurrent_trials: Maximum concurrent trials
        - timeout_minutes: Total timeout in minutes
        """

Usage Example

from azure.ai.ml import automl
from azure.ai.ml.entities import Data
from azure.ai.ml.automl import TabularLimitSettings, TrainingSettings

# Configure AutoML settings
limits = TabularLimitSettings(
    max_trials=10,
    max_concurrent_trials=2,
    trial_timeout_minutes=30,
    experiment_timeout_minutes=180
)

training_settings = TrainingSettings(
    enable_onnx_compatible_models=True,
    enable_model_explainability=True,
    enable_stack_ensemble=True
)

# Create regression job with settings
regression_job = automl.regression(
    target_column_name="price",
    training_data=training_data,
    primary_metric="r2_score",
    limits=limits,
    training_settings=training_settings,
    compute="cpu-cluster"
)

# Submit job
submitted_job = ml_client.jobs.create_or_update(regression_job)
print(f"AutoML job submitted: {submitted_job.name}")

Primary Metrics

Available primary metrics for different AutoML task types:

Classification Metrics

  • accuracy - Overall accuracy
  • AUC_weighted - Area under ROC curve (weighted)
  • average_precision_score_weighted - Average precision score
  • precision_score_weighted - Precision score (weighted)
  • recall_score_weighted - Recall score (weighted)

Regression Metrics

  • normalized_root_mean_squared_error - Normalized RMSE
  • r2_score - R-squared score
  • mean_absolute_error - Mean absolute error
  • normalized_mean_absolute_error - Normalized MAE
  • spearman_correlation - Spearman correlation

Forecasting Metrics

  • normalized_root_mean_squared_error - Normalized RMSE
  • r2_score - R-squared score
  • mean_absolute_error - Mean absolute error
  • normalized_mean_absolute_error - Normalized MAE

Computer Vision Metrics

  • accuracy - Classification accuracy
  • mean_average_precision - Object detection/segmentation mAP
  • iou - Intersection over Union

Install with Tessl CLI

npx tessl i tessl/pypi-azure-ai-ml

docs

asset-management.md

automl.md

client-auth.md

compute-management.md

hyperparameter-tuning.md

index.md

job-management.md

model-deployment.md

tile.json