TrainingJob class

Manages an AWS SageMaker AI Training Job.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.sagemaker.TrainingJob("example", {
    algorithmSpecification: {
        trainingInputMode: "File",
        trainingImage: exampleAwsSagemakerPrebuiltEcrImage.registryPath,
    },
    outputDataConfig: {
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.m5.large",
        instanceCount: 1,
        volumeSizeInGb: 30,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 3600,
    },
    trainingJobName: "example",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.sagemaker.TrainingJob("example",
    algorithm_specification={
        "training_input_mode": "File",
        "training_image": example_aws_sagemaker_prebuilt_ecr_image["registryPath"],
    },
    output_data_config={
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/output/",
    },
    resource_config={
        "instance_type": "ml.m5.large",
        "instance_count": 1,
        "volume_size_in_gb": 30,
    },
    stopping_condition={
        "max_runtime_in_seconds": 3600,
    },
    training_job_name="example",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sagemaker.TrainingJob("example", new()
    {
        AlgorithmSpecification = new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationArgs
        {
            TrainingInputMode = "File",
            TrainingImage = exampleAwsSagemakerPrebuiltEcrImage.RegistryPath,
        },
        OutputDataConfig = new Aws.Sagemaker.Inputs.TrainingJobOutputDataConfigArgs
        {
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/output/",
        },
        ResourceConfig = new Aws.Sagemaker.Inputs.TrainingJobResourceConfigArgs
        {
            InstanceType = "ml.m5.large",
            InstanceCount = 1,
            VolumeSizeInGb = 30,
        },
        StoppingCondition = new Aws.Sagemaker.Inputs.TrainingJobStoppingConditionArgs
        {
            MaxRuntimeInSeconds = 3600,
        },
        TrainingJobName = "example",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sagemaker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sagemaker.NewTrainingJob(ctx, "example", &sagemaker.TrainingJobArgs{
			AlgorithmSpecification: &sagemaker.TrainingJobAlgorithmSpecificationArgs{
				TrainingInputMode: pulumi.String("File"),
				TrainingImage:     pulumi.Any(exampleAwsSagemakerPrebuiltEcrImage.RegistryPath),
			},
			OutputDataConfig: &sagemaker.TrainingJobOutputDataConfigArgs{
				S3OutputPath: pulumi.Sprintf("s3://%v/output/", exampleAwsS3Bucket.Bucket),
			},
			ResourceConfig: &sagemaker.TrainingJobResourceConfigArgs{
				InstanceType:   pulumi.String("ml.m5.large"),
				InstanceCount:  pulumi.Int(1),
				VolumeSizeInGb: pulumi.Int(30),
			},
			StoppingCondition: &sagemaker.TrainingJobStoppingConditionArgs{
				MaxRuntimeInSeconds: pulumi.Int(3600),
			},
			TrainingJobName: pulumi.String("example"),
			RoleArn:         pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_sagemaker_trainingjob" "example" {
  algorithm_specification = {
    training_input_mode = "File"
    training_image      = exampleAwsSagemakerPrebuiltEcrImage.registryPath
  }
  output_data_config = {
    s3_output_path ="s3://${exampleAwsS3Bucket.bucket}/output/"
  }
  resource_config = {
    instance_type     = "ml.m5.large"
    instance_count    = 1
    volume_size_in_gb = 30
  }
  stopping_condition = {
    max_runtime_in_seconds = 3600
  }
  training_job_name = "example"
  role_arn          = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sagemaker.TrainingJob;
import com.pulumi.aws.sagemaker.TrainingJobArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobOutputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobResourceConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobStoppingConditionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new TrainingJob("example", TrainingJobArgs.builder()
            .algorithmSpecification(TrainingJobAlgorithmSpecificationArgs.builder()
                .trainingInputMode("File")
                .trainingImage(exampleAwsSagemakerPrebuiltEcrImage.registryPath())
                .build())
            .outputDataConfig(TrainingJobOutputDataConfigArgs.builder()
                .s3OutputPath(String.format("s3://%s/output/", exampleAwsS3Bucket.bucket()))
                .build())
            .resourceConfig(TrainingJobResourceConfigArgs.builder()
                .instanceType("ml.m5.large")
                .instanceCount(1)
                .volumeSizeInGb(30)
                .build())
            .stoppingCondition(TrainingJobStoppingConditionArgs.builder()
                .maxRuntimeInSeconds(3600)
                .build())
            .trainingJobName("example")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:sagemaker:TrainingJob
    properties:
      algorithmSpecification:
        trainingInputMode: File
        trainingImage: ${exampleAwsSagemakerPrebuiltEcrImage.registryPath}
      outputDataConfig:
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/output/
      resourceConfig:
        instanceType: ml.m5.large
        instanceCount: 1
        volumeSizeInGb: 30
      stoppingCondition:
        maxRuntimeInSeconds: 3600
      trainingJobName: example
      roleArn: ${exampleAwsIamRole.arn}

With VPC Configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.sagemaker.TrainingJob("example", {
    algorithmSpecification: {
        trainingInputMode: "File",
        trainingImage: exampleAwsSagemakerPrebuiltEcrImage.registryPath,
    },
    outputDataConfig: {
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.m5.large",
        instanceCount: 1,
        volumeSizeInGb: 30,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 3600,
    },
    vpcConfig: {
        securityGroupIds: [exampleAwsSecurityGroup.id],
        subnets: [exampleAwsSubnet.id],
    },
    trainingJobName: "example",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.sagemaker.TrainingJob("example",
    algorithm_specification={
        "training_input_mode": "File",
        "training_image": example_aws_sagemaker_prebuilt_ecr_image["registryPath"],
    },
    output_data_config={
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/output/",
    },
    resource_config={
        "instance_type": "ml.m5.large",
        "instance_count": 1,
        "volume_size_in_gb": 30,
    },
    stopping_condition={
        "max_runtime_in_seconds": 3600,
    },
    vpc_config={
        "security_group_ids": [example_aws_security_group["id"]],
        "subnets": [example_aws_subnet["id"]],
    },
    training_job_name="example",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sagemaker.TrainingJob("example", new()
    {
        AlgorithmSpecification = new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationArgs
        {
            TrainingInputMode = "File",
            TrainingImage = exampleAwsSagemakerPrebuiltEcrImage.RegistryPath,
        },
        OutputDataConfig = new Aws.Sagemaker.Inputs.TrainingJobOutputDataConfigArgs
        {
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/output/",
        },
        ResourceConfig = new Aws.Sagemaker.Inputs.TrainingJobResourceConfigArgs
        {
            InstanceType = "ml.m5.large",
            InstanceCount = 1,
            VolumeSizeInGb = 30,
        },
        StoppingCondition = new Aws.Sagemaker.Inputs.TrainingJobStoppingConditionArgs
        {
            MaxRuntimeInSeconds = 3600,
        },
        VpcConfig = new Aws.Sagemaker.Inputs.TrainingJobVpcConfigArgs
        {
            SecurityGroupIds = new[]
            {
                exampleAwsSecurityGroup.Id,
            },
            Subnets = new[]
            {
                exampleAwsSubnet.Id,
            },
        },
        TrainingJobName = "example",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sagemaker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sagemaker.NewTrainingJob(ctx, "example", &sagemaker.TrainingJobArgs{
			AlgorithmSpecification: &sagemaker.TrainingJobAlgorithmSpecificationArgs{
				TrainingInputMode: pulumi.String("File"),
				TrainingImage:     pulumi.Any(exampleAwsSagemakerPrebuiltEcrImage.RegistryPath),
			},
			OutputDataConfig: &sagemaker.TrainingJobOutputDataConfigArgs{
				S3OutputPath: pulumi.Sprintf("s3://%v/output/", exampleAwsS3Bucket.Bucket),
			},
			ResourceConfig: &sagemaker.TrainingJobResourceConfigArgs{
				InstanceType:   pulumi.String("ml.m5.large"),
				InstanceCount:  pulumi.Int(1),
				VolumeSizeInGb: pulumi.Int(30),
			},
			StoppingCondition: &sagemaker.TrainingJobStoppingConditionArgs{
				MaxRuntimeInSeconds: pulumi.Int(3600),
			},
			VpcConfig: &sagemaker.TrainingJobVpcConfigArgs{
				SecurityGroupIds: pulumi.StringArray{
					exampleAwsSecurityGroup.Id,
				},
				Subnets: pulumi.StringArray{
					exampleAwsSubnet.Id,
				},
			},
			TrainingJobName: pulumi.String("example"),
			RoleArn:         pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_sagemaker_trainingjob" "example" {
  algorithm_specification = {
    training_input_mode = "File"
    training_image      = exampleAwsSagemakerPrebuiltEcrImage.registryPath
  }
  output_data_config = {
    s3_output_path ="s3://${exampleAwsS3Bucket.bucket}/output/"
  }
  resource_config = {
    instance_type     = "ml.m5.large"
    instance_count    = 1
    volume_size_in_gb = 30
  }
  stopping_condition = {
    max_runtime_in_seconds = 3600
  }
  vpc_config = {
    security_group_ids = [exampleAwsSecurityGroup.id]
    subnets            = [exampleAwsSubnet.id]
  }
  training_job_name = "example"
  role_arn          = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sagemaker.TrainingJob;
import com.pulumi.aws.sagemaker.TrainingJobArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobOutputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobResourceConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobStoppingConditionArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobVpcConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new TrainingJob("example", TrainingJobArgs.builder()
            .algorithmSpecification(TrainingJobAlgorithmSpecificationArgs.builder()
                .trainingInputMode("File")
                .trainingImage(exampleAwsSagemakerPrebuiltEcrImage.registryPath())
                .build())
            .outputDataConfig(TrainingJobOutputDataConfigArgs.builder()
                .s3OutputPath(String.format("s3://%s/output/", exampleAwsS3Bucket.bucket()))
                .build())
            .resourceConfig(TrainingJobResourceConfigArgs.builder()
                .instanceType("ml.m5.large")
                .instanceCount(1)
                .volumeSizeInGb(30)
                .build())
            .stoppingCondition(TrainingJobStoppingConditionArgs.builder()
                .maxRuntimeInSeconds(3600)
                .build())
            .vpcConfig(TrainingJobVpcConfigArgs.builder()
                .securityGroupIds(exampleAwsSecurityGroup.id())
                .subnets(exampleAwsSubnet.id())
                .build())
            .trainingJobName("example")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:sagemaker:TrainingJob
    properties:
      algorithmSpecification:
        trainingInputMode: File
        trainingImage: ${exampleAwsSagemakerPrebuiltEcrImage.registryPath}
      outputDataConfig:
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/output/
      resourceConfig:
        instanceType: ml.m5.large
        instanceCount: 1
        volumeSizeInGb: 30
      stoppingCondition:
        maxRuntimeInSeconds: 3600
      vpcConfig:
        securityGroupIds:
          - ${exampleAwsSecurityGroup.id}
        subnets:
          - ${exampleAwsSubnet.id}
      trainingJobName: example
      roleArn: ${exampleAwsIamRole.arn}

With Input Data and Hyperparameters

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.sagemaker.TrainingJob("example", {
    algorithmSpecification: {
        trainingInputMode: "File",
        trainingImage: exampleAwsSagemakerPrebuiltEcrImage.registryPath,
        enableSagemakerMetricsTimeSeries: true,
    },
    outputDataConfig: {
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.m5.large",
        instanceCount: 1,
        volumeSizeInGb: 30,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 3600,
    },
    inputDataConfigs: [{
        dataSource: {
            s3DataSource: {
                s3DataType: "S3Prefix",
                s3Uri: `s3://${exampleAwsS3Bucket.bucket}/train/`,
            },
        },
        channelName: "train",
    }],
    trainingJobName: "example",
    roleArn: exampleAwsIamRole.arn,
    hyperParameters: {
        mini_batch_size: "200",
        epochs: "10",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.sagemaker.TrainingJob("example",
    algorithm_specification={
        "training_input_mode": "File",
        "training_image": example_aws_sagemaker_prebuilt_ecr_image["registryPath"],
        "enable_sagemaker_metrics_time_series": True,
    },
    output_data_config={
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/output/",
    },
    resource_config={
        "instance_type": "ml.m5.large",
        "instance_count": 1,
        "volume_size_in_gb": 30,
    },
    stopping_condition={
        "max_runtime_in_seconds": 3600,
    },
    input_data_configs=[{
        "data_source": {
            "s3_data_source": {
                "s3_data_type": "S3Prefix",
                "s3_uri": f"s3://{example_aws_s3_bucket['bucket']}/train/",
            },
        },
        "channel_name": "train",
    }],
    training_job_name="example",
    role_arn=example_aws_iam_role["arn"],
    hyper_parameters={
        "mini_batch_size": "200",
        "epochs": "10",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sagemaker.TrainingJob("example", new()
    {
        AlgorithmSpecification = new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationArgs
        {
            TrainingInputMode = "File",
            TrainingImage = exampleAwsSagemakerPrebuiltEcrImage.RegistryPath,
            EnableSagemakerMetricsTimeSeries = true,
        },
        OutputDataConfig = new Aws.Sagemaker.Inputs.TrainingJobOutputDataConfigArgs
        {
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/output/",
        },
        ResourceConfig = new Aws.Sagemaker.Inputs.TrainingJobResourceConfigArgs
        {
            InstanceType = "ml.m5.large",
            InstanceCount = 1,
            VolumeSizeInGb = 30,
        },
        StoppingCondition = new Aws.Sagemaker.Inputs.TrainingJobStoppingConditionArgs
        {
            MaxRuntimeInSeconds = 3600,
        },
        InputDataConfigs = new[]
        {
            new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigArgs
            {
                DataSource = new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigDataSourceArgs
                {
                    S3DataSource = new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigDataSourceS3DataSourceArgs
                    {
                        S3DataType = "S3Prefix",
                        S3Uri = $"s3://{exampleAwsS3Bucket.Bucket}/train/",
                    },
                },
                ChannelName = "train",
            },
        },
        TrainingJobName = "example",
        RoleArn = exampleAwsIamRole.Arn,
        HyperParameters =
        {
            { "mini_batch_size", "200" },
            { "epochs", "10" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sagemaker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sagemaker.NewTrainingJob(ctx, "example", &sagemaker.TrainingJobArgs{
			AlgorithmSpecification: &sagemaker.TrainingJobAlgorithmSpecificationArgs{
				TrainingInputMode:                pulumi.String("File"),
				TrainingImage:                    pulumi.Any(exampleAwsSagemakerPrebuiltEcrImage.RegistryPath),
				EnableSagemakerMetricsTimeSeries: pulumi.Bool(true),
			},
			OutputDataConfig: &sagemaker.TrainingJobOutputDataConfigArgs{
				S3OutputPath: pulumi.Sprintf("s3://%v/output/", exampleAwsS3Bucket.Bucket),
			},
			ResourceConfig: &sagemaker.TrainingJobResourceConfigArgs{
				InstanceType:   pulumi.String("ml.m5.large"),
				InstanceCount:  pulumi.Int(1),
				VolumeSizeInGb: pulumi.Int(30),
			},
			StoppingCondition: &sagemaker.TrainingJobStoppingConditionArgs{
				MaxRuntimeInSeconds: pulumi.Int(3600),
			},
			InputDataConfigs: sagemaker.TrainingJobInputDataConfigArray{
				&sagemaker.TrainingJobInputDataConfigArgs{
					DataSource: &sagemaker.TrainingJobInputDataConfigDataSourceArgs{
						S3DataSource: &sagemaker.TrainingJobInputDataConfigDataSourceS3DataSourceArgs{
							S3DataType: pulumi.String("S3Prefix"),
							S3Uri:      pulumi.Sprintf("s3://%v/train/", exampleAwsS3Bucket.Bucket),
						},
					},
					ChannelName: pulumi.String("train"),
				},
			},
			TrainingJobName: pulumi.String("example"),
			RoleArn:         pulumi.Any(exampleAwsIamRole.Arn),
			HyperParameters: pulumi.StringMap{
				"mini_batch_size": pulumi.String("200"),
				"epochs":          pulumi.String("10"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_sagemaker_trainingjob" "example" {
  algorithm_specification = {
    training_input_mode                  = "File"
    training_image                       = exampleAwsSagemakerPrebuiltEcrImage.registryPath
    enable_sagemaker_metrics_time_series = true
  }
  output_data_config = {
    s3_output_path ="s3://${exampleAwsS3Bucket.bucket}/output/"
  }
  resource_config = {
    instance_type     = "ml.m5.large"
    instance_count    = 1
    volume_size_in_gb = 30
  }
  stopping_condition = {
    max_runtime_in_seconds = 3600
  }
  input_data_configs {
    data_source = {
      s3_data_source = {
        s3_data_type = "S3Prefix"
        s3_uri       ="s3://${exampleAwsS3Bucket.bucket}/train/"
      }
    }
    channel_name = "train"
  }
  training_job_name = "example"
  role_arn          = exampleAwsIamRole.arn
  hyper_parameters = {
    "mini_batch_size" = "200"
    "epochs"          = "10"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sagemaker.TrainingJob;
import com.pulumi.aws.sagemaker.TrainingJobArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobOutputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobResourceConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobStoppingConditionArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInputDataConfigDataSourceArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInputDataConfigDataSourceS3DataSourceArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new TrainingJob("example", TrainingJobArgs.builder()
            .algorithmSpecification(TrainingJobAlgorithmSpecificationArgs.builder()
                .trainingInputMode("File")
                .trainingImage(exampleAwsSagemakerPrebuiltEcrImage.registryPath())
                .enableSagemakerMetricsTimeSeries(true)
                .build())
            .outputDataConfig(TrainingJobOutputDataConfigArgs.builder()
                .s3OutputPath(String.format("s3://%s/output/", exampleAwsS3Bucket.bucket()))
                .build())
            .resourceConfig(TrainingJobResourceConfigArgs.builder()
                .instanceType("ml.m5.large")
                .instanceCount(1)
                .volumeSizeInGb(30)
                .build())
            .stoppingCondition(TrainingJobStoppingConditionArgs.builder()
                .maxRuntimeInSeconds(3600)
                .build())
            .inputDataConfigs(TrainingJobInputDataConfigArgs.builder()
                .dataSource(TrainingJobInputDataConfigDataSourceArgs.builder()
                    .s3DataSource(TrainingJobInputDataConfigDataSourceS3DataSourceArgs.builder()
                        .s3DataType("S3Prefix")
                        .s3Uri(String.format("s3://%s/train/", exampleAwsS3Bucket.bucket()))
                        .build())
                    .build())
                .channelName("train")
                .build())
            .trainingJobName("example")
            .roleArn(exampleAwsIamRole.arn())
            .hyperParameters(Map.ofEntries(
                Map.entry("mini_batch_size", "200"),
                Map.entry("epochs", "10")
            ))
            .build());

    }
}
resources:
  example:
    type: aws:sagemaker:TrainingJob
    properties:
      algorithmSpecification:
        trainingInputMode: File
        trainingImage: ${exampleAwsSagemakerPrebuiltEcrImage.registryPath}
        enableSagemakerMetricsTimeSeries: true
      outputDataConfig:
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/output/
      resourceConfig:
        instanceType: ml.m5.large
        instanceCount: 1
        volumeSizeInGb: 30
      stoppingCondition:
        maxRuntimeInSeconds: 3600
      inputDataConfigs:
        - dataSource:
            s3DataSource:
              s3DataType: S3Prefix
              s3Uri: s3://${exampleAwsS3Bucket.bucket}/train/
          channelName: train
      trainingJobName: example
      roleArn: ${exampleAwsIamRole.arn}
      hyperParameters:
        mini_batch_size: '200'
        epochs: '10'

With Encrypted Output, Checkpoints, and TensorBoard

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.sagemaker.TrainingJob("example", {
    algorithmSpecification: {
        trainingInputMode: "File",
        trainingImage: exampleAwsSagemakerPrebuiltEcrImage.registryPath,
    },
    checkpointConfig: {
        localPath: "/opt/ml/checkpoints",
        s3Uri: `s3://${exampleAwsS3Bucket.bucket}/checkpoints/`,
    },
    outputDataConfig: {
        compressionType: "GZIP",
        kmsKeyId: exampleAwsKmsKey.arn,
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.m5.large",
        instanceCount: 1,
        volumeSizeInGb: 30,
        volumeKmsKeyId: exampleAwsKmsKey.arn,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 3600,
    },
    tensorBoardOutputConfig: {
        localPath: "/opt/ml/output/tensorboard",
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/tensorboard/`,
    },
    trainingJobName: "example",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.sagemaker.TrainingJob("example",
    algorithm_specification={
        "training_input_mode": "File",
        "training_image": example_aws_sagemaker_prebuilt_ecr_image["registryPath"],
    },
    checkpoint_config={
        "local_path": "/opt/ml/checkpoints",
        "s3_uri": f"s3://{example_aws_s3_bucket['bucket']}/checkpoints/",
    },
    output_data_config={
        "compression_type": "GZIP",
        "kms_key_id": example_aws_kms_key["arn"],
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/output/",
    },
    resource_config={
        "instance_type": "ml.m5.large",
        "instance_count": 1,
        "volume_size_in_gb": 30,
        "volume_kms_key_id": example_aws_kms_key["arn"],
    },
    stopping_condition={
        "max_runtime_in_seconds": 3600,
    },
    tensor_board_output_config={
        "local_path": "/opt/ml/output/tensorboard",
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/tensorboard/",
    },
    training_job_name="example",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sagemaker.TrainingJob("example", new()
    {
        AlgorithmSpecification = new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationArgs
        {
            TrainingInputMode = "File",
            TrainingImage = exampleAwsSagemakerPrebuiltEcrImage.RegistryPath,
        },
        CheckpointConfig = new Aws.Sagemaker.Inputs.TrainingJobCheckpointConfigArgs
        {
            LocalPath = "/opt/ml/checkpoints",
            S3Uri = $"s3://{exampleAwsS3Bucket.Bucket}/checkpoints/",
        },
        OutputDataConfig = new Aws.Sagemaker.Inputs.TrainingJobOutputDataConfigArgs
        {
            CompressionType = "GZIP",
            KmsKeyId = exampleAwsKmsKey.Arn,
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/output/",
        },
        ResourceConfig = new Aws.Sagemaker.Inputs.TrainingJobResourceConfigArgs
        {
            InstanceType = "ml.m5.large",
            InstanceCount = 1,
            VolumeSizeInGb = 30,
            VolumeKmsKeyId = exampleAwsKmsKey.Arn,
        },
        StoppingCondition = new Aws.Sagemaker.Inputs.TrainingJobStoppingConditionArgs
        {
            MaxRuntimeInSeconds = 3600,
        },
        TensorBoardOutputConfig = new Aws.Sagemaker.Inputs.TrainingJobTensorBoardOutputConfigArgs
        {
            LocalPath = "/opt/ml/output/tensorboard",
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/tensorboard/",
        },
        TrainingJobName = "example",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sagemaker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sagemaker.NewTrainingJob(ctx, "example", &sagemaker.TrainingJobArgs{
			AlgorithmSpecification: &sagemaker.TrainingJobAlgorithmSpecificationArgs{
				TrainingInputMode: pulumi.String("File"),
				TrainingImage:     pulumi.Any(exampleAwsSagemakerPrebuiltEcrImage.RegistryPath),
			},
			CheckpointConfig: &sagemaker.TrainingJobCheckpointConfigArgs{
				LocalPath: pulumi.String("/opt/ml/checkpoints"),
				S3Uri:     pulumi.Sprintf("s3://%v/checkpoints/", exampleAwsS3Bucket.Bucket),
			},
			OutputDataConfig: &sagemaker.TrainingJobOutputDataConfigArgs{
				CompressionType: pulumi.String("GZIP"),
				KmsKeyId:        pulumi.Any(exampleAwsKmsKey.Arn),
				S3OutputPath:    pulumi.Sprintf("s3://%v/output/", exampleAwsS3Bucket.Bucket),
			},
			ResourceConfig: &sagemaker.TrainingJobResourceConfigArgs{
				InstanceType:   pulumi.String("ml.m5.large"),
				InstanceCount:  pulumi.Int(1),
				VolumeSizeInGb: pulumi.Int(30),
				VolumeKmsKeyId: pulumi.Any(exampleAwsKmsKey.Arn),
			},
			StoppingCondition: &sagemaker.TrainingJobStoppingConditionArgs{
				MaxRuntimeInSeconds: pulumi.Int(3600),
			},
			TensorBoardOutputConfig: &sagemaker.TrainingJobTensorBoardOutputConfigArgs{
				LocalPath:    pulumi.String("/opt/ml/output/tensorboard"),
				S3OutputPath: pulumi.Sprintf("s3://%v/tensorboard/", exampleAwsS3Bucket.Bucket),
			},
			TrainingJobName: pulumi.String("example"),
			RoleArn:         pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_sagemaker_trainingjob" "example" {
  algorithm_specification = {
    training_input_mode = "File"
    training_image      = exampleAwsSagemakerPrebuiltEcrImage.registryPath
  }
  checkpoint_config = {
    local_path = "/opt/ml/checkpoints"
    s3_uri     ="s3://${exampleAwsS3Bucket.bucket}/checkpoints/"
  }
  output_data_config = {
    compression_type = "GZIP"
    kms_key_id       = exampleAwsKmsKey.arn
    s3_output_path   ="s3://${exampleAwsS3Bucket.bucket}/output/"
  }
  resource_config = {
    instance_type     = "ml.m5.large"
    instance_count    = 1
    volume_size_in_gb = 30
    volume_kms_key_id = exampleAwsKmsKey.arn
  }
  stopping_condition = {
    max_runtime_in_seconds = 3600
  }
  tensor_board_output_config = {
    local_path     = "/opt/ml/output/tensorboard"
    s3_output_path ="s3://${exampleAwsS3Bucket.bucket}/tensorboard/"
  }
  training_job_name = "example"
  role_arn          = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sagemaker.TrainingJob;
import com.pulumi.aws.sagemaker.TrainingJobArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobCheckpointConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobOutputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobResourceConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobStoppingConditionArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobTensorBoardOutputConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new TrainingJob("example", TrainingJobArgs.builder()
            .algorithmSpecification(TrainingJobAlgorithmSpecificationArgs.builder()
                .trainingInputMode("File")
                .trainingImage(exampleAwsSagemakerPrebuiltEcrImage.registryPath())
                .build())
            .checkpointConfig(TrainingJobCheckpointConfigArgs.builder()
                .localPath("/opt/ml/checkpoints")
                .s3Uri(String.format("s3://%s/checkpoints/", exampleAwsS3Bucket.bucket()))
                .build())
            .outputDataConfig(TrainingJobOutputDataConfigArgs.builder()
                .compressionType("GZIP")
                .kmsKeyId(exampleAwsKmsKey.arn())
                .s3OutputPath(String.format("s3://%s/output/", exampleAwsS3Bucket.bucket()))
                .build())
            .resourceConfig(TrainingJobResourceConfigArgs.builder()
                .instanceType("ml.m5.large")
                .instanceCount(1)
                .volumeSizeInGb(30)
                .volumeKmsKeyId(exampleAwsKmsKey.arn())
                .build())
            .stoppingCondition(TrainingJobStoppingConditionArgs.builder()
                .maxRuntimeInSeconds(3600)
                .build())
            .tensorBoardOutputConfig(TrainingJobTensorBoardOutputConfigArgs.builder()
                .localPath("/opt/ml/output/tensorboard")
                .s3OutputPath(String.format("s3://%s/tensorboard/", exampleAwsS3Bucket.bucket()))
                .build())
            .trainingJobName("example")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:sagemaker:TrainingJob
    properties:
      algorithmSpecification:
        trainingInputMode: File
        trainingImage: ${exampleAwsSagemakerPrebuiltEcrImage.registryPath}
      checkpointConfig:
        localPath: /opt/ml/checkpoints
        s3Uri: s3://${exampleAwsS3Bucket.bucket}/checkpoints/
      outputDataConfig:
        compressionType: GZIP
        kmsKeyId: ${exampleAwsKmsKey.arn}
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/output/
      resourceConfig:
        instanceType: ml.m5.large
        instanceCount: 1
        volumeSizeInGb: 30
        volumeKmsKeyId: ${exampleAwsKmsKey.arn}
      stoppingCondition:
        maxRuntimeInSeconds: 3600
      tensorBoardOutputConfig:
        localPath: /opt/ml/output/tensorboard
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/tensorboard/
      trainingJobName: example
      roleArn: ${exampleAwsIamRole.arn}

With Managed Spot Training and Custom Metrics

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.sagemaker.TrainingJob("example", {
    algorithmSpecification: {
        metricDefinitions: [
            {
                name: "train:loss",
                regex: "loss: ([0-9\\.]+)",
            },
            {
                name: "validation:accuracy",
                regex: "accuracy: ([0-9\\.]+)",
            },
        ],
        trainingInputMode: "File",
        trainingImage: trainingImage,
        containerEntrypoints: [
            "python",
            "/opt/ml/code/train.py",
        ],
        containerArguments: [
            "--epochs",
            "10",
            "--batch-size",
            "128",
        ],
    },
    outputDataConfig: {
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.m5.xlarge",
        instanceCount: 1,
        volumeSizeInGb: 50,
        keepAlivePeriodInSeconds: 600,
    },
    retryStrategy: {
        maximumRetryAttempts: 3,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 3600,
        maxWaitTimeInSeconds: 7200,
    },
    trainingJobName: "example",
    roleArn: exampleAwsIamRole.arn,
    enableManagedSpotTraining: true,
    enableNetworkIsolation: true,
    enableInterContainerTrafficEncryption: true,
    environment: {
        MODEL_DIR: "/opt/ml/model",
        SM_LOG_LEVEL: "20",
    },
    hyperParameters: {
        epochs: "10",
        batch_size: "128",
    },
    tags: {
        Environment: "test",
        Workload: "training",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.sagemaker.TrainingJob("example",
    algorithm_specification={
        "metric_definitions": [
            {
                "name": "train:loss",
                "regex": "loss: ([0-9\\.]+)",
            },
            {
                "name": "validation:accuracy",
                "regex": "accuracy: ([0-9\\.]+)",
            },
        ],
        "training_input_mode": "File",
        "training_image": training_image,
        "container_entrypoints": [
            "python",
            "/opt/ml/code/train.py",
        ],
        "container_arguments": [
            "--epochs",
            "10",
            "--batch-size",
            "128",
        ],
    },
    output_data_config={
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/output/",
    },
    resource_config={
        "instance_type": "ml.m5.xlarge",
        "instance_count": 1,
        "volume_size_in_gb": 50,
        "keep_alive_period_in_seconds": 600,
    },
    retry_strategy={
        "maximum_retry_attempts": 3,
    },
    stopping_condition={
        "max_runtime_in_seconds": 3600,
        "max_wait_time_in_seconds": 7200,
    },
    training_job_name="example",
    role_arn=example_aws_iam_role["arn"],
    enable_managed_spot_training=True,
    enable_network_isolation=True,
    enable_inter_container_traffic_encryption=True,
    environment={
        "MODEL_DIR": "/opt/ml/model",
        "SM_LOG_LEVEL": "20",
    },
    hyper_parameters={
        "epochs": "10",
        "batch_size": "128",
    },
    tags={
        "Environment": "test",
        "Workload": "training",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sagemaker.TrainingJob("example", new()
    {
        AlgorithmSpecification = new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationArgs
        {
            MetricDefinitions = new[]
            {
                new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationMetricDefinitionArgs
                {
                    Name = "train:loss",
                    Regex = "loss: ([0-9\\.]+)",
                },
                new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationMetricDefinitionArgs
                {
                    Name = "validation:accuracy",
                    Regex = "accuracy: ([0-9\\.]+)",
                },
            },
            TrainingInputMode = "File",
            TrainingImage = trainingImage,
            ContainerEntrypoints = new[]
            {
                "python",
                "/opt/ml/code/train.py",
            },
            ContainerArguments = new[]
            {
                "--epochs",
                "10",
                "--batch-size",
                "128",
            },
        },
        OutputDataConfig = new Aws.Sagemaker.Inputs.TrainingJobOutputDataConfigArgs
        {
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/output/",
        },
        ResourceConfig = new Aws.Sagemaker.Inputs.TrainingJobResourceConfigArgs
        {
            InstanceType = "ml.m5.xlarge",
            InstanceCount = 1,
            VolumeSizeInGb = 50,
            KeepAlivePeriodInSeconds = 600,
        },
        RetryStrategy = new Aws.Sagemaker.Inputs.TrainingJobRetryStrategyArgs
        {
            MaximumRetryAttempts = 3,
        },
        StoppingCondition = new Aws.Sagemaker.Inputs.TrainingJobStoppingConditionArgs
        {
            MaxRuntimeInSeconds = 3600,
            MaxWaitTimeInSeconds = 7200,
        },
        TrainingJobName = "example",
        RoleArn = exampleAwsIamRole.Arn,
        EnableManagedSpotTraining = true,
        EnableNetworkIsolation = true,
        EnableInterContainerTrafficEncryption = true,
        Environment =
        {
            { "MODEL_DIR", "/opt/ml/model" },
            { "SM_LOG_LEVEL", "20" },
        },
        HyperParameters =
        {
            { "epochs", "10" },
            { "batch_size", "128" },
        },
        Tags =
        {
            { "Environment", "test" },
            { "Workload", "training" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sagemaker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sagemaker.NewTrainingJob(ctx, "example", &sagemaker.TrainingJobArgs{
			AlgorithmSpecification: &sagemaker.TrainingJobAlgorithmSpecificationArgs{
				MetricDefinitions: sagemaker.TrainingJobAlgorithmSpecificationMetricDefinitionArray{
					&sagemaker.TrainingJobAlgorithmSpecificationMetricDefinitionArgs{
						Name:  pulumi.String("train:loss"),
						Regex: pulumi.String("loss: ([0-9\\.]+)"),
					},
					&sagemaker.TrainingJobAlgorithmSpecificationMetricDefinitionArgs{
						Name:  pulumi.String("validation:accuracy"),
						Regex: pulumi.String("accuracy: ([0-9\\.]+)"),
					},
				},
				TrainingInputMode: pulumi.String("File"),
				TrainingImage:     pulumi.Any(trainingImage),
				ContainerEntrypoints: pulumi.StringArray{
					pulumi.String("python"),
					pulumi.String("/opt/ml/code/train.py"),
				},
				ContainerArguments: pulumi.StringArray{
					pulumi.String("--epochs"),
					pulumi.String("10"),
					pulumi.String("--batch-size"),
					pulumi.String("128"),
				},
			},
			OutputDataConfig: &sagemaker.TrainingJobOutputDataConfigArgs{
				S3OutputPath: pulumi.Sprintf("s3://%v/output/", exampleAwsS3Bucket.Bucket),
			},
			ResourceConfig: &sagemaker.TrainingJobResourceConfigArgs{
				InstanceType:             pulumi.String("ml.m5.xlarge"),
				InstanceCount:            pulumi.Int(1),
				VolumeSizeInGb:           pulumi.Int(50),
				KeepAlivePeriodInSeconds: pulumi.Int(600),
			},
			RetryStrategy: &sagemaker.TrainingJobRetryStrategyArgs{
				MaximumRetryAttempts: pulumi.Int(3),
			},
			StoppingCondition: &sagemaker.TrainingJobStoppingConditionArgs{
				MaxRuntimeInSeconds:  pulumi.Int(3600),
				MaxWaitTimeInSeconds: pulumi.Int(7200),
			},
			TrainingJobName:                       pulumi.String("example"),
			RoleArn:                               pulumi.Any(exampleAwsIamRole.Arn),
			EnableManagedSpotTraining:             pulumi.Bool(true),
			EnableNetworkIsolation:                pulumi.Bool(true),
			EnableInterContainerTrafficEncryption: pulumi.Bool(true),
			Environment: pulumi.StringMap{
				"MODEL_DIR":    pulumi.String("/opt/ml/model"),
				"SM_LOG_LEVEL": pulumi.String("20"),
			},
			HyperParameters: pulumi.StringMap{
				"epochs":     pulumi.String("10"),
				"batch_size": pulumi.String("128"),
			},
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("test"),
				"Workload":    pulumi.String("training"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_sagemaker_trainingjob" "example" {
  algorithm_specification = {
    metric_definitions = [{
      "name"  = "train:loss"
      "regex" = "loss: ([0-9\\.]+)"
      }, {
      "name"  = "validation:accuracy"
      "regex" = "accuracy: ([0-9\\.]+)"
    }]
    training_input_mode   = "File"
    training_image        = trainingImage
    container_entrypoints = ["python", "/opt/ml/code/train.py"]
    container_arguments   = ["--epochs", "10", "--batch-size", "128"]
  }
  output_data_config = {
    s3_output_path ="s3://${exampleAwsS3Bucket.bucket}/output/"
  }
  resource_config = {
    instance_type                = "ml.m5.xlarge"
    instance_count               = 1
    volume_size_in_gb            = 50
    keep_alive_period_in_seconds = 600
  }
  retry_strategy = {
    maximum_retry_attempts = 3
  }
  stopping_condition = {
    max_runtime_in_seconds   = 3600
    max_wait_time_in_seconds = 7200
  }
  training_job_name                         = "example"
  role_arn                                  = exampleAwsIamRole.arn
  enable_managed_spot_training              = true
  enable_network_isolation                  = true
  enable_inter_container_traffic_encryption = true
  environment = {
    "MODEL_DIR"    = "/opt/ml/model"
    "SM_LOG_LEVEL" = "20"
  }
  hyper_parameters = {
    "epochs"     = "10"
    "batch_size" = "128"
  }
  tags = {
    "Environment" = "test"
    "Workload"    = "training"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sagemaker.TrainingJob;
import com.pulumi.aws.sagemaker.TrainingJobArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationMetricDefinitionArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobOutputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobResourceConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobRetryStrategyArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobStoppingConditionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new TrainingJob("example", TrainingJobArgs.builder()
            .algorithmSpecification(TrainingJobAlgorithmSpecificationArgs.builder()
                .metricDefinitions(
                    TrainingJobAlgorithmSpecificationMetricDefinitionArgs.builder()
                        .name("train:loss")
                        .regex("loss: ([0-9\\.]+)")
                        .build(),
                    TrainingJobAlgorithmSpecificationMetricDefinitionArgs.builder()
                        .name("validation:accuracy")
                        .regex("accuracy: ([0-9\\.]+)")
                        .build())
                .trainingInputMode("File")
                .trainingImage(trainingImage)
                .containerEntrypoints(
                    "python",
                    "/opt/ml/code/train.py")
                .containerArguments(
                    "--epochs",
                    "10",
                    "--batch-size",
                    "128")
                .build())
            .outputDataConfig(TrainingJobOutputDataConfigArgs.builder()
                .s3OutputPath(String.format("s3://%s/output/", exampleAwsS3Bucket.bucket()))
                .build())
            .resourceConfig(TrainingJobResourceConfigArgs.builder()
                .instanceType("ml.m5.xlarge")
                .instanceCount(1)
                .volumeSizeInGb(50)
                .keepAlivePeriodInSeconds(600)
                .build())
            .retryStrategy(TrainingJobRetryStrategyArgs.builder()
                .maximumRetryAttempts(3)
                .build())
            .stoppingCondition(TrainingJobStoppingConditionArgs.builder()
                .maxRuntimeInSeconds(3600)
                .maxWaitTimeInSeconds(7200)
                .build())
            .trainingJobName("example")
            .roleArn(exampleAwsIamRole.arn())
            .enableManagedSpotTraining(true)
            .enableNetworkIsolation(true)
            .enableInterContainerTrafficEncryption(true)
            .environment(Map.ofEntries(
                Map.entry("MODEL_DIR", "/opt/ml/model"),
                Map.entry("SM_LOG_LEVEL", "20")
            ))
            .hyperParameters(Map.ofEntries(
                Map.entry("epochs", "10"),
                Map.entry("batch_size", "128")
            ))
            .tags(Map.ofEntries(
                Map.entry("Environment", "test"),
                Map.entry("Workload", "training")
            ))
            .build());

    }
}
resources:
  example:
    type: aws:sagemaker:TrainingJob
    properties:
      algorithmSpecification:
        metricDefinitions:
          - name: train:loss
            regex: 'loss: ([0-9\.]+)'
          - name: validation:accuracy
            regex: 'accuracy: ([0-9\.]+)'
        trainingInputMode: File
        trainingImage: ${trainingImage}
        containerEntrypoints:
          - python
          - /opt/ml/code/train.py
        containerArguments:
          - --epochs
          - '10'
          - --batch-size
          - '128'
      outputDataConfig:
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/output/
      resourceConfig:
        instanceType: ml.m5.xlarge
        instanceCount: 1
        volumeSizeInGb: 50
        keepAlivePeriodInSeconds: 600
      retryStrategy:
        maximumRetryAttempts: 3
      stoppingCondition:
        maxRuntimeInSeconds: 3600
        maxWaitTimeInSeconds: 7200
      trainingJobName: example
      roleArn: ${exampleAwsIamRole.arn}
      enableManagedSpotTraining: true
      enableNetworkIsolation: true
      enableInterContainerTrafficEncryption: true
      environment:
        MODEL_DIR: /opt/ml/model
        SM_LOG_LEVEL: '20'
      hyperParameters:
        epochs: '10'
        batch_size: '128'
      tags:
        Environment: test
        Workload: training

With Multiple Input Channels, Infrastructure Checks, and Session Tag Chaining

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.sagemaker.TrainingJob("example", {
    algorithmSpecification: {
        trainingInputMode: "File",
        trainingImage: exampleAwsSagemakerPrebuiltEcrImage.registryPath,
    },
    infraCheckConfig: {
        enableInfraCheck: true,
    },
    outputDataConfig: {
        s3OutputPath: `s3://${exampleAwsS3Bucket.bucket}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.m5.large",
        instanceCount: 1,
        volumeSizeInGb: 30,
    },
    sessionChainingConfig: {
        enableSessionTagChaining: true,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 3600,
    },
    inputDataConfigs: [
        {
            dataSource: {
                s3DataSource: {
                    s3DataDistributionType: "FullyReplicated",
                    s3DataType: "S3Prefix",
                    s3Uri: `s3://${exampleAwsS3Bucket.bucket}/train/`,
                },
            },
            channelName: "train",
            contentType: "text/csv",
            inputMode: "File",
        },
        {
            dataSource: {
                s3DataSource: {
                    s3DataDistributionType: "FullyReplicated",
                    s3DataType: "S3Prefix",
                    s3Uri: `s3://${exampleAwsS3Bucket.bucket}/validation/`,
                },
            },
            channelName: "validation",
            contentType: "text/csv",
            inputMode: "File",
        },
    ],
    trainingJobName: "example",
    roleArn: exampleAwsIamRole.arn,
});
import pulumi
import pulumi_aws as aws

example = aws.sagemaker.TrainingJob("example",
    algorithm_specification={
        "training_input_mode": "File",
        "training_image": example_aws_sagemaker_prebuilt_ecr_image["registryPath"],
    },
    infra_check_config={
        "enable_infra_check": True,
    },
    output_data_config={
        "s3_output_path": f"s3://{example_aws_s3_bucket['bucket']}/output/",
    },
    resource_config={
        "instance_type": "ml.m5.large",
        "instance_count": 1,
        "volume_size_in_gb": 30,
    },
    session_chaining_config={
        "enable_session_tag_chaining": True,
    },
    stopping_condition={
        "max_runtime_in_seconds": 3600,
    },
    input_data_configs=[
        {
            "data_source": {
                "s3_data_source": {
                    "s3_data_distribution_type": "FullyReplicated",
                    "s3_data_type": "S3Prefix",
                    "s3_uri": f"s3://{example_aws_s3_bucket['bucket']}/train/",
                },
            },
            "channel_name": "train",
            "content_type": "text/csv",
            "input_mode": "File",
        },
        {
            "data_source": {
                "s3_data_source": {
                    "s3_data_distribution_type": "FullyReplicated",
                    "s3_data_type": "S3Prefix",
                    "s3_uri": f"s3://{example_aws_s3_bucket['bucket']}/validation/",
                },
            },
            "channel_name": "validation",
            "content_type": "text/csv",
            "input_mode": "File",
        },
    ],
    training_job_name="example",
    role_arn=example_aws_iam_role["arn"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sagemaker.TrainingJob("example", new()
    {
        AlgorithmSpecification = new Aws.Sagemaker.Inputs.TrainingJobAlgorithmSpecificationArgs
        {
            TrainingInputMode = "File",
            TrainingImage = exampleAwsSagemakerPrebuiltEcrImage.RegistryPath,
        },
        InfraCheckConfig = new Aws.Sagemaker.Inputs.TrainingJobInfraCheckConfigArgs
        {
            EnableInfraCheck = true,
        },
        OutputDataConfig = new Aws.Sagemaker.Inputs.TrainingJobOutputDataConfigArgs
        {
            S3OutputPath = $"s3://{exampleAwsS3Bucket.Bucket}/output/",
        },
        ResourceConfig = new Aws.Sagemaker.Inputs.TrainingJobResourceConfigArgs
        {
            InstanceType = "ml.m5.large",
            InstanceCount = 1,
            VolumeSizeInGb = 30,
        },
        SessionChainingConfig = new Aws.Sagemaker.Inputs.TrainingJobSessionChainingConfigArgs
        {
            EnableSessionTagChaining = true,
        },
        StoppingCondition = new Aws.Sagemaker.Inputs.TrainingJobStoppingConditionArgs
        {
            MaxRuntimeInSeconds = 3600,
        },
        InputDataConfigs = new[]
        {
            new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigArgs
            {
                DataSource = new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigDataSourceArgs
                {
                    S3DataSource = new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigDataSourceS3DataSourceArgs
                    {
                        S3DataDistributionType = "FullyReplicated",
                        S3DataType = "S3Prefix",
                        S3Uri = $"s3://{exampleAwsS3Bucket.Bucket}/train/",
                    },
                },
                ChannelName = "train",
                ContentType = "text/csv",
                InputMode = "File",
            },
            new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigArgs
            {
                DataSource = new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigDataSourceArgs
                {
                    S3DataSource = new Aws.Sagemaker.Inputs.TrainingJobInputDataConfigDataSourceS3DataSourceArgs
                    {
                        S3DataDistributionType = "FullyReplicated",
                        S3DataType = "S3Prefix",
                        S3Uri = $"s3://{exampleAwsS3Bucket.Bucket}/validation/",
                    },
                },
                ChannelName = "validation",
                ContentType = "text/csv",
                InputMode = "File",
            },
        },
        TrainingJobName = "example",
        RoleArn = exampleAwsIamRole.Arn,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sagemaker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sagemaker.NewTrainingJob(ctx, "example", &sagemaker.TrainingJobArgs{
			AlgorithmSpecification: &sagemaker.TrainingJobAlgorithmSpecificationArgs{
				TrainingInputMode: pulumi.String("File"),
				TrainingImage:     pulumi.Any(exampleAwsSagemakerPrebuiltEcrImage.RegistryPath),
			},
			InfraCheckConfig: &sagemaker.TrainingJobInfraCheckConfigArgs{
				EnableInfraCheck: pulumi.Bool(true),
			},
			OutputDataConfig: &sagemaker.TrainingJobOutputDataConfigArgs{
				S3OutputPath: pulumi.Sprintf("s3://%v/output/", exampleAwsS3Bucket.Bucket),
			},
			ResourceConfig: &sagemaker.TrainingJobResourceConfigArgs{
				InstanceType:   pulumi.String("ml.m5.large"),
				InstanceCount:  pulumi.Int(1),
				VolumeSizeInGb: pulumi.Int(30),
			},
			SessionChainingConfig: &sagemaker.TrainingJobSessionChainingConfigArgs{
				EnableSessionTagChaining: pulumi.Bool(true),
			},
			StoppingCondition: &sagemaker.TrainingJobStoppingConditionArgs{
				MaxRuntimeInSeconds: pulumi.Int(3600),
			},
			InputDataConfigs: sagemaker.TrainingJobInputDataConfigArray{
				&sagemaker.TrainingJobInputDataConfigArgs{
					DataSource: &sagemaker.TrainingJobInputDataConfigDataSourceArgs{
						S3DataSource: &sagemaker.TrainingJobInputDataConfigDataSourceS3DataSourceArgs{
							S3DataDistributionType: pulumi.String("FullyReplicated"),
							S3DataType:             pulumi.String("S3Prefix"),
							S3Uri:                  pulumi.Sprintf("s3://%v/train/", exampleAwsS3Bucket.Bucket),
						},
					},
					ChannelName: pulumi.String("train"),
					ContentType: pulumi.String("text/csv"),
					InputMode:   pulumi.String("File"),
				},
				&sagemaker.TrainingJobInputDataConfigArgs{
					DataSource: &sagemaker.TrainingJobInputDataConfigDataSourceArgs{
						S3DataSource: &sagemaker.TrainingJobInputDataConfigDataSourceS3DataSourceArgs{
							S3DataDistributionType: pulumi.String("FullyReplicated"),
							S3DataType:             pulumi.String("S3Prefix"),
							S3Uri:                  pulumi.Sprintf("s3://%v/validation/", exampleAwsS3Bucket.Bucket),
						},
					},
					ChannelName: pulumi.String("validation"),
					ContentType: pulumi.String("text/csv"),
					InputMode:   pulumi.String("File"),
				},
			},
			TrainingJobName: pulumi.String("example"),
			RoleArn:         pulumi.Any(exampleAwsIamRole.Arn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_sagemaker_trainingjob" "example" {
  algorithm_specification = {
    training_input_mode = "File"
    training_image      = exampleAwsSagemakerPrebuiltEcrImage.registryPath
  }
  infra_check_config = {
    enable_infra_check = true
  }
  output_data_config = {
    s3_output_path ="s3://${exampleAwsS3Bucket.bucket}/output/"
  }
  resource_config = {
    instance_type     = "ml.m5.large"
    instance_count    = 1
    volume_size_in_gb = 30
  }
  session_chaining_config = {
    enable_session_tag_chaining = true
  }
  stopping_condition = {
    max_runtime_in_seconds = 3600
  }
  input_data_configs {
    data_source = {
      s3_data_source = {
        s3_data_distribution_type = "FullyReplicated"
        s3_data_type              = "S3Prefix"
        s3_uri                    ="s3://${exampleAwsS3Bucket.bucket}/train/"
      }
    }
    channel_name = "train"
    content_type = "text/csv"
    input_mode   = "File"
  }
  input_data_configs {
    data_source = {
      s3_data_source = {
        s3_data_distribution_type = "FullyReplicated"
        s3_data_type              = "S3Prefix"
        s3_uri                    ="s3://${exampleAwsS3Bucket.bucket}/validation/"
      }
    }
    channel_name = "validation"
    content_type = "text/csv"
    input_mode   = "File"
  }
  training_job_name = "example"
  role_arn          = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sagemaker.TrainingJob;
import com.pulumi.aws.sagemaker.TrainingJobArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobAlgorithmSpecificationArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInfraCheckConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobOutputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobResourceConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobSessionChainingConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobStoppingConditionArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInputDataConfigArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInputDataConfigDataSourceArgs;
import com.pulumi.aws.sagemaker.inputs.TrainingJobInputDataConfigDataSourceS3DataSourceArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new TrainingJob("example", TrainingJobArgs.builder()
            .algorithmSpecification(TrainingJobAlgorithmSpecificationArgs.builder()
                .trainingInputMode("File")
                .trainingImage(exampleAwsSagemakerPrebuiltEcrImage.registryPath())
                .build())
            .infraCheckConfig(TrainingJobInfraCheckConfigArgs.builder()
                .enableInfraCheck(true)
                .build())
            .outputDataConfig(TrainingJobOutputDataConfigArgs.builder()
                .s3OutputPath(String.format("s3://%s/output/", exampleAwsS3Bucket.bucket()))
                .build())
            .resourceConfig(TrainingJobResourceConfigArgs.builder()
                .instanceType("ml.m5.large")
                .instanceCount(1)
                .volumeSizeInGb(30)
                .build())
            .sessionChainingConfig(TrainingJobSessionChainingConfigArgs.builder()
                .enableSessionTagChaining(true)
                .build())
            .stoppingCondition(TrainingJobStoppingConditionArgs.builder()
                .maxRuntimeInSeconds(3600)
                .build())
            .inputDataConfigs(
                TrainingJobInputDataConfigArgs.builder()
                    .dataSource(TrainingJobInputDataConfigDataSourceArgs.builder()
                        .s3DataSource(TrainingJobInputDataConfigDataSourceS3DataSourceArgs.builder()
                            .s3DataDistributionType("FullyReplicated")
                            .s3DataType("S3Prefix")
                            .s3Uri(String.format("s3://%s/train/", exampleAwsS3Bucket.bucket()))
                            .build())
                        .build())
                    .channelName("train")
                    .contentType("text/csv")
                    .inputMode("File")
                    .build(),
                TrainingJobInputDataConfigArgs.builder()
                    .dataSource(TrainingJobInputDataConfigDataSourceArgs.builder()
                        .s3DataSource(TrainingJobInputDataConfigDataSourceS3DataSourceArgs.builder()
                            .s3DataDistributionType("FullyReplicated")
                            .s3DataType("S3Prefix")
                            .s3Uri(String.format("s3://%s/validation/", exampleAwsS3Bucket.bucket()))
                            .build())
                        .build())
                    .channelName("validation")
                    .contentType("text/csv")
                    .inputMode("File")
                    .build())
            .trainingJobName("example")
            .roleArn(exampleAwsIamRole.arn())
            .build());

    }
}
resources:
  example:
    type: aws:sagemaker:TrainingJob
    properties:
      algorithmSpecification:
        trainingInputMode: File
        trainingImage: ${exampleAwsSagemakerPrebuiltEcrImage.registryPath}
      infraCheckConfig:
        enableInfraCheck: true
      outputDataConfig:
        s3OutputPath: s3://${exampleAwsS3Bucket.bucket}/output/
      resourceConfig:
        instanceType: ml.m5.large
        instanceCount: 1
        volumeSizeInGb: 30
      sessionChainingConfig:
        enableSessionTagChaining: true
      stoppingCondition:
        maxRuntimeInSeconds: 3600
      inputDataConfigs:
        - dataSource:
            s3DataSource:
              s3DataDistributionType: FullyReplicated
              s3DataType: S3Prefix
              s3Uri: s3://${exampleAwsS3Bucket.bucket}/train/
          channelName: train
          contentType: text/csv
          inputMode: File
        - dataSource:
            s3DataSource:
              s3DataDistributionType: FullyReplicated
              s3DataType: S3Prefix
              s3Uri: s3://${exampleAwsS3Bucket.bucket}/validation/
          channelName: validation
          contentType: text/csv
          inputMode: File
      trainingJobName: example
      roleArn: ${exampleAwsIamRole.arn}

Import

Identity Schema

Required

  • trainingJobName - (String) Name of the Training Job.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import SageMaker AI Training Job using the trainingJobName. For example:

$ pulumi import aws:sagemaker/trainingJob:TrainingJob example my-training-job

Constructors

TrainingJob(String name, {TrainingJobArgs? args, CustomResourceOptions? options})
Creates a new TrainingJob. name The Pulumi resource name. args Arguments used to configure this TrainingJob. The set of arguments for TrainingJob. options Resource options controlling this resource's behavior.
TrainingJob.reference(String urn)
Creates a typed reference to an existing TrainingJob resource.

Properties

algorithmSpecification ↔ Output<TrainingJobAlgorithmSpecification?>
Algorithm-related parameters of the training job. See algorithmSpecification below. Conflicts with serverlessJobConfig.
latefinal
arn ↔ Output<String>
ARN of the Training Job.
latefinal
checkpointConfig ↔ Output<TrainingJobCheckpointConfig?>
Location of checkpoints during training. See checkpointConfig below. Conflicts with serverlessJobConfig.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
debugHookConfig ↔ Output<TrainingJobDebugHookConfig?>
Configuration for debugging rules. See debugHookConfig below. Conflicts with serverlessJobConfig.
latefinal
debugRuleConfigurations ↔ Output<List<TrainingJobDebugRuleConfiguration>?>
List of debug rule configurations. Maximum of 20. See debugRuleConfigurations below.
latefinal
deleteModelPackagesOnDestroy ↔ Output<bool?>
Whether to delete model packages in the configured model package group when the training job is destroyed. Default is false.
latefinal
deleteVpcEnisOnDestroy ↔ Output<bool?>
Whether to delete detached VPC ENIs SageMaker may leave behind when the training job is destroyed. Default is false.
latefinal
enableInterContainerTrafficEncryption ↔ Output<bool>
Whether to encrypt inter-container traffic. When enabled, communications between containers are encrypted.
latefinal
enableManagedSpotTraining ↔ Output<bool>
Whether to use managed spot training. Optimizes the cost of training by using Amazon EC2 Spot Instances. Conflicts with serverlessJobConfig.
latefinal
enableNetworkIsolation ↔ Output<bool>
Whether to isolate the training container from the network. No inbound or outbound network calls can be made.
latefinal
environment ↔ Output<Map<String, String>?>
Map of environment variables to set in the training container. Maximum of 100 entries. Conflicts with serverlessJobConfig.
latefinal
experimentConfig ↔ Output<TrainingJobExperimentConfig?>
Associates a SageMaker AI Experiment or Trial to the training job. See experimentConfig below. Conflicts with serverlessJobConfig.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
hyperParameters ↔ Output<Map<String, String>?>
Map of hyperparameters for the training algorithm. Maximum of 100 entries.
latefinal
id ↔ Output<String>
getter/setter pairinherited
infraCheckConfig ↔ Output<TrainingJobInfraCheckConfig?>
Infrastructure health check configuration. See infraCheckConfig below.
latefinal
inputDataConfigs ↔ Output<List<TrainingJobInputDataConfig>?>
List of input data channel configurations for the training job. Maximum of 20. See inputDataConfig below.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
mlflowConfig ↔ Output<TrainingJobMlflowConfig?>
MLflow integration configuration. See mlflowConfig below.
latefinal
modelPackageConfig ↔ Output<TrainingJobModelPackageConfig?>
Model package configuration. Requires serverlessJobConfig. See modelPackageConfig below.
latefinal
outputDataConfig ↔ Output<TrainingJobOutputDataConfig?>
Location of the output data from the training job. See outputDataConfig below.
latefinal
profilerConfig ↔ Output<TrainingJobProfilerConfig?>
Configuration for the profiler. See profilerConfig below. Conflicts with serverlessJobConfig.
latefinal
profilerRuleConfigurations ↔ Output<List<TrainingJobProfilerRuleConfiguration>?>
List of profiler rule configurations. Maximum of 20. See profilerRuleConfigurations below. Conflicts with serverlessJobConfig.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
remoteDebugConfig ↔ Output<TrainingJobRemoteDebugConfig?>
Configuration for remote debugging. See remoteDebugConfig below.
latefinal
resourceConfig ↔ Output<TrainingJobResourceConfig?>
Resources for the training job, including compute instances and storage volumes. See resourceConfig below.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
retryStrategy ↔ Output<TrainingJobRetryStrategy?>
Number of times to retry the job if it fails. See retryStrategy below. Conflicts with serverlessJobConfig.
latefinal
roleArn ↔ Output<String>
ARN of the IAM role that SageMaker AI assumes to perform tasks on your behalf during training.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
serverlessJobConfig ↔ Output<TrainingJobServerlessJobConfig?>
Configuration for serverless training jobs using foundation models. Conflicts with algorithmSpecification, enableManagedSpotTraining, environment, retryStrategy, checkpointConfig, debugHookConfig, experimentConfig, profilerConfig, profilerRuleConfigurations, and tensorBoardOutputConfig. See serverlessJobConfig below.
latefinal
sessionChainingConfig ↔ Output<TrainingJobSessionChainingConfig?>
Configuration for session tag chaining. See sessionChainingConfig below.
latefinal
stoppingCondition ↔ Output<TrainingJobStoppingCondition?>
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
tensorBoardOutputConfig ↔ Output<TrainingJobTensorBoardOutputConfig?>
Configuration for TensorBoard output. See tensorBoardOutputConfig below. Conflicts with serverlessJobConfig.
latefinal
timeouts ↔ Output<TrainingJobTimeouts?>
latefinal
trainingJobName ↔ Output<String>
Name of the training job. Must be between 1 and 63 characters, start with a letter or number, and contain only letters, numbers, and hyphens.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
vpcConfig ↔ Output<TrainingJobVpcConfig?>
VPC configuration for the training job. See vpcConfig below.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {TrainingJobState? state, CustomResourceOptions? options}) → TrainingJob
Gets an existing TrainingJob resource's state with the given name and id.