Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Google Cloud Native
  3. API Docs
  4. ml
  5. ml/v1
  6. Model

Google Cloud Native is in preview. Google Cloud Classic is fully supported.

Google Cloud Native v0.32.0 published on Wednesday, Nov 29, 2023 by Pulumi
pulumi/pulumi-google-native

google-native.ml/v1.Model

Explore with Pulumi AI

google-native logo

Google Cloud Native is in preview. Google Cloud Classic is fully supported.

Google Cloud Native v0.32.0 published on Wednesday, Nov 29, 2023 by Pulumi
pulumi/pulumi-google-native

    Creates a model which will later contain one or more versions. You must add at least one version before you can request predictions from the model. Add versions by calling projects.models.versions.create.

    Create Model Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Model(name: string, args?: ModelArgs, opts?: CustomResourceOptions);
    @overload
def Model(resource_name: str,
          args: Optional[ModelArgs] = None,
          opts: Optional[ResourceOptions] = None)

@overload
def Model(resource_name: str,
          opts: Optional[ResourceOptions] = None,
          description: Optional[str] = None,
          etag: Optional[str] = None,
          labels: Optional[Mapping[str, str]] = None,
          name: Optional[str] = None,
          online_prediction_console_logging: Optional[bool] = None,
          online_prediction_logging: Optional[bool] = None,
          project: Optional[str] = None,
          regions: Optional[Sequence[str]] = None)
    func NewModel(ctx *Context, name string, args *ModelArgs, opts ...ResourceOption) (*Model, error)
    public Model(string name, ModelArgs? args = null, CustomResourceOptions? opts = null)
    public Model(String name, ModelArgs args)
public Model(String name, ModelArgs args, CustomResourceOptions options)

    type: google-native:ml/v1:Model
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args ModelArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ModelArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ModelArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ModelArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ModelArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var google_nativeModelResource = new GoogleNative.Ml.V1.Model("google-nativeModelResource", new()
{
    Description = "string",
    Etag = "string",
    Labels = 
    {
        { "string", "string" },
    },
    Name = "string",
    OnlinePredictionConsoleLogging = false,
    OnlinePredictionLogging = false,
    Project = "string",
    Regions = new[]
    {
        "string",
    },
});

    example, err := ml.NewModel(ctx, "google-nativeModelResource", &ml.ModelArgs{
	Description: pulumi.String("string"),
	Etag:        pulumi.String("string"),
	Labels: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name:                           pulumi.String("string"),
	OnlinePredictionConsoleLogging: pulumi.Bool(false),
	OnlinePredictionLogging:        pulumi.Bool(false),
	Project:                        pulumi.String("string"),
	Regions: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    var google_nativeModelResource = new Model("google-nativeModelResource", ModelArgs.builder()
    .description("string")
    .etag("string")
    .labels(Map.of("string", "string"))
    .name("string")
    .onlinePredictionConsoleLogging(false)
    .onlinePredictionLogging(false)
    .project("string")
    .regions("string")
    .build());

    google_native_model_resource = google_native.ml.v1.Model("google-nativeModelResource",
    description="string",
    etag="string",
    labels={
        "string": "string",
    },
    name="string",
    online_prediction_console_logging=False,
    online_prediction_logging=False,
    project="string",
    regions=["string"])

    const google_nativeModelResource = new google_native.ml.v1.Model("google-nativeModelResource", {
    description: "string",
    etag: "string",
    labels: {
        string: "string",
    },
    name: "string",
    onlinePredictionConsoleLogging: false,
    onlinePredictionLogging: false,
    project: "string",
    regions: ["string"],
});

    type: google-native:ml/v1:Model
properties:
    description: string
    etag: string
    labels:
        string: string
    name: string
    onlinePredictionConsoleLogging: false
    onlinePredictionLogging: false
    project: string
    regions:
        - string

    Model Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Model resource accepts the following input properties:

    Description string
    Optional. The description specified for the model when it was created.
    Etag string
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetModel, and systems are expected to put that etag in the request to UpdateModel to ensure that their change will be applied to the model as intended.
    Labels Dictionary<string, string>
    Optional. One or more labels that you can add, to organize your models. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    Name string
    The name specified for the model when it was created. The model name must be unique within the project it is created in.
    OnlinePredictionConsoleLogging bool
    Optional. If true, online prediction nodes send stderr and stdout streams to Cloud Logging. These can be more verbose than the standard access logs (see onlinePredictionLogging) and can incur higher cost. However, they are helpful for debugging. Note that logs may incur a cost, especially if your project receives prediction requests at a high QPS. Estimate your costs before enabling this option. Default is false.
    OnlinePredictionLogging bool
    Optional. If true, online prediction access logs are sent to Cloud Logging. These logs are like standard server access logs, containing information like timestamp and latency for each request. Note that logs may incur a cost, especially if your project receives prediction requests at a high queries per second rate (QPS). Estimate your costs before enabling this option. Default is false.
    Project string
    Regions List<string>
    Optional. The list of regions where the model is going to be deployed. Only one region per model is supported. Defaults to 'us-central1' if nothing is set. See the available regions for AI Platform services. Note: * No matter where a model is deployed, it can always be accessed by users from anywhere, both for online and batch prediction. * The region for a batch prediction job is set by the region field when submitting the batch prediction job and does not take its value from this field.
    Description string
    Optional. The description specified for the model when it was created.
    Etag string
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetModel, and systems are expected to put that etag in the request to UpdateModel to ensure that their change will be applied to the model as intended.
    Labels map[string]string
    Optional. One or more labels that you can add, to organize your models. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    Name string
    The name specified for the model when it was created. The model name must be unique within the project it is created in.
    OnlinePredictionConsoleLogging bool
    Optional. If true, online prediction nodes send stderr and stdout streams to Cloud Logging. These can be more verbose than the standard access logs (see onlinePredictionLogging) and can incur higher cost. However, they are helpful for debugging. Note that logs may incur a cost, especially if your project receives prediction requests at a high QPS. Estimate your costs before enabling this option. Default is false.
    OnlinePredictionLogging bool
    Optional. If true, online prediction access logs are sent to Cloud Logging. These logs are like standard server access logs, containing information like timestamp and latency for each request. Note that logs may incur a cost, especially if your project receives prediction requests at a high queries per second rate (QPS). Estimate your costs before enabling this option. Default is false.
    Project string
    Regions []string
    Optional. The list of regions where the model is going to be deployed. Only one region per model is supported. Defaults to 'us-central1' if nothing is set. See the available regions for AI Platform services. Note: * No matter where a model is deployed, it can always be accessed by users from anywhere, both for online and batch prediction. * The region for a batch prediction job is set by the region field when submitting the batch prediction job and does not take its value from this field.
    description String
    Optional. The description specified for the model when it was created.
    etag String
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetModel, and systems are expected to put that etag in the request to UpdateModel to ensure that their change will be applied to the model as intended.
    labels Map<String,String>
    Optional. One or more labels that you can add, to organize your models. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    name String
    The name specified for the model when it was created. The model name must be unique within the project it is created in.
    onlinePredictionConsoleLogging Boolean
    Optional. If true, online prediction nodes send stderr and stdout streams to Cloud Logging. These can be more verbose than the standard access logs (see onlinePredictionLogging) and can incur higher cost. However, they are helpful for debugging. Note that logs may incur a cost, especially if your project receives prediction requests at a high QPS. Estimate your costs before enabling this option. Default is false.
    onlinePredictionLogging Boolean
    Optional. If true, online prediction access logs are sent to Cloud Logging. These logs are like standard server access logs, containing information like timestamp and latency for each request. Note that logs may incur a cost, especially if your project receives prediction requests at a high queries per second rate (QPS). Estimate your costs before enabling this option. Default is false.
    project String
    regions List<String>
    Optional. The list of regions where the model is going to be deployed. Only one region per model is supported. Defaults to 'us-central1' if nothing is set. See the available regions for AI Platform services. Note: * No matter where a model is deployed, it can always be accessed by users from anywhere, both for online and batch prediction. * The region for a batch prediction job is set by the region field when submitting the batch prediction job and does not take its value from this field.
    description string
    Optional. The description specified for the model when it was created.
    etag string
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetModel, and systems are expected to put that etag in the request to UpdateModel to ensure that their change will be applied to the model as intended.
    labels {[key: string]: string}
    Optional. One or more labels that you can add, to organize your models. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    name string
    The name specified for the model when it was created. The model name must be unique within the project it is created in.
    onlinePredictionConsoleLogging boolean
    Optional. If true, online prediction nodes send stderr and stdout streams to Cloud Logging. These can be more verbose than the standard access logs (see onlinePredictionLogging) and can incur higher cost. However, they are helpful for debugging. Note that logs may incur a cost, especially if your project receives prediction requests at a high QPS. Estimate your costs before enabling this option. Default is false.
    onlinePredictionLogging boolean
    Optional. If true, online prediction access logs are sent to Cloud Logging. These logs are like standard server access logs, containing information like timestamp and latency for each request. Note that logs may incur a cost, especially if your project receives prediction requests at a high queries per second rate (QPS). Estimate your costs before enabling this option. Default is false.
    project string
    regions string[]
    Optional. The list of regions where the model is going to be deployed. Only one region per model is supported. Defaults to 'us-central1' if nothing is set. See the available regions for AI Platform services. Note: * No matter where a model is deployed, it can always be accessed by users from anywhere, both for online and batch prediction. * The region for a batch prediction job is set by the region field when submitting the batch prediction job and does not take its value from this field.
    description str
    Optional. The description specified for the model when it was created.
    etag str
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetModel, and systems are expected to put that etag in the request to UpdateModel to ensure that their change will be applied to the model as intended.
    labels Mapping[str, str]
    Optional. One or more labels that you can add, to organize your models. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    name str
    The name specified for the model when it was created. The model name must be unique within the project it is created in.
    online_prediction_console_logging bool
    Optional. If true, online prediction nodes send stderr and stdout streams to Cloud Logging. These can be more verbose than the standard access logs (see onlinePredictionLogging) and can incur higher cost. However, they are helpful for debugging. Note that logs may incur a cost, especially if your project receives prediction requests at a high QPS. Estimate your costs before enabling this option. Default is false.
    online_prediction_logging bool
    Optional. If true, online prediction access logs are sent to Cloud Logging. These logs are like standard server access logs, containing information like timestamp and latency for each request. Note that logs may incur a cost, especially if your project receives prediction requests at a high queries per second rate (QPS). Estimate your costs before enabling this option. Default is false.
    project str
    regions Sequence[str]
    Optional. The list of regions where the model is going to be deployed. Only one region per model is supported. Defaults to 'us-central1' if nothing is set. See the available regions for AI Platform services. Note: * No matter where a model is deployed, it can always be accessed by users from anywhere, both for online and batch prediction. * The region for a batch prediction job is set by the region field when submitting the batch prediction job and does not take its value from this field.
    description String
    Optional. The description specified for the model when it was created.
    etag String
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetModel, and systems are expected to put that etag in the request to UpdateModel to ensure that their change will be applied to the model as intended.
    labels Map<String>
    Optional. One or more labels that you can add, to organize your models. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    name String
    The name specified for the model when it was created. The model name must be unique within the project it is created in.
    onlinePredictionConsoleLogging Boolean
    Optional. If true, online prediction nodes send stderr and stdout streams to Cloud Logging. These can be more verbose than the standard access logs (see onlinePredictionLogging) and can incur higher cost. However, they are helpful for debugging. Note that logs may incur a cost, especially if your project receives prediction requests at a high QPS. Estimate your costs before enabling this option. Default is false.
    onlinePredictionLogging Boolean
    Optional. If true, online prediction access logs are sent to Cloud Logging. These logs are like standard server access logs, containing information like timestamp and latency for each request. Note that logs may incur a cost, especially if your project receives prediction requests at a high queries per second rate (QPS). Estimate your costs before enabling this option. Default is false.
    project String
    regions List<String>
    Optional. The list of regions where the model is going to be deployed. Only one region per model is supported. Defaults to 'us-central1' if nothing is set. See the available regions for AI Platform services. Note: * No matter where a model is deployed, it can always be accessed by users from anywhere, both for online and batch prediction. * The region for a batch prediction job is set by the region field when submitting the batch prediction job and does not take its value from this field.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Model resource produces the following output properties:

    DefaultVersion Pulumi.GoogleNative.Ml.V1.Outputs.GoogleCloudMlV1__VersionResponse
    The default version of the model. This version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.models.versions.setDefault.
    Id string
    The provider-assigned unique ID for this managed resource.
    DefaultVersion GoogleCloudMlV1__VersionResponse
    The default version of the model. This version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.models.versions.setDefault.
    Id string
    The provider-assigned unique ID for this managed resource.
    defaultVersion GoogleCloudMlV1__VersionResponse
    The default version of the model. This version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.models.versions.setDefault.
    id String
    The provider-assigned unique ID for this managed resource.
    defaultVersion GoogleCloudMlV1__VersionResponse
    The default version of the model. This version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.models.versions.setDefault.
    id string
    The provider-assigned unique ID for this managed resource.
    default_version GoogleCloudMlV1VersionResponse
    The default version of the model. This version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.models.versions.setDefault.
    id str
    The provider-assigned unique ID for this managed resource.
    defaultVersion Property Map
    The default version of the model. This version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.models.versions.setDefault.
    id String
    The provider-assigned unique ID for this managed resource.

    Supporting Types

    GoogleCloudMlV1__AcceleratorConfigResponse, GoogleCloudMlV1__AcceleratorConfigResponseArgs

    Count string
    The number of accelerators to attach to each machine running the job.
    Type string
    The type of accelerator to use.
    Count string
    The number of accelerators to attach to each machine running the job.
    Type string
    The type of accelerator to use.
    count String
    The number of accelerators to attach to each machine running the job.
    type String
    The type of accelerator to use.
    count string
    The number of accelerators to attach to each machine running the job.
    type string
    The type of accelerator to use.
    count str
    The number of accelerators to attach to each machine running the job.
    type str
    The type of accelerator to use.
    count String
    The number of accelerators to attach to each machine running the job.
    type String
    The type of accelerator to use.

    GoogleCloudMlV1__AutoScalingResponse, GoogleCloudMlV1__AutoScalingResponseArgs

    MaxNodes int
    The maximum number of nodes to scale this model under load. The actual value will depend on resource quota and availability.
    Metrics List<Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__MetricSpecResponse>
    MetricSpec contains the specifications to use to calculate the desired nodes count.
    MinNodes int
    Optional. The minimum number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed. Therefore, the cost of operating this model will be at least rate * min_nodes * number of hours since last billing cycle, where rate is the cost per node-hour as documented in the pricing guide, even if no predictions are performed. There is additional cost for each prediction performed. Unlike manual scaling, if the load gets too heavy for the nodes that are up, the service will automatically add nodes to handle the increased load as well as scale back as traffic drops, always maintaining at least min_nodes. You will be charged for the time in which additional nodes are used. If min_nodes is not specified and AutoScaling is used with a legacy (MLS1) machine type, min_nodes defaults to 0, in which case, when traffic to a model stops (and after a cool-down period), nodes will be shut down and no charges will be incurred until traffic to the model resumes. If min_nodes is not specified and AutoScaling is used with a Compute Engine (N1) machine type, min_nodes defaults to 1. min_nodes must be at least 1 for use with a Compute Engine machine type. You can set min_nodes when creating the model version, and you can also update min_nodes for an existing version: update_body.json: { 'autoScaling': { 'minNodes': 5 } } HTTP request: PATCH https://ml.googleapis.com/v1/{name=projects//models//versions/*}?update_mask=autoScaling.minNodes -d @./update_body.json
    MaxNodes int
    The maximum number of nodes to scale this model under load. The actual value will depend on resource quota and availability.
    Metrics []GoogleCloudMlV1__MetricSpecResponse
    MetricSpec contains the specifications to use to calculate the desired nodes count.
    MinNodes int
    Optional. The minimum number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed. Therefore, the cost of operating this model will be at least rate * min_nodes * number of hours since last billing cycle, where rate is the cost per node-hour as documented in the pricing guide, even if no predictions are performed. There is additional cost for each prediction performed. Unlike manual scaling, if the load gets too heavy for the nodes that are up, the service will automatically add nodes to handle the increased load as well as scale back as traffic drops, always maintaining at least min_nodes. You will be charged for the time in which additional nodes are used. If min_nodes is not specified and AutoScaling is used with a legacy (MLS1) machine type, min_nodes defaults to 0, in which case, when traffic to a model stops (and after a cool-down period), nodes will be shut down and no charges will be incurred until traffic to the model resumes. If min_nodes is not specified and AutoScaling is used with a Compute Engine (N1) machine type, min_nodes defaults to 1. min_nodes must be at least 1 for use with a Compute Engine machine type. You can set min_nodes when creating the model version, and you can also update min_nodes for an existing version: update_body.json: { 'autoScaling': { 'minNodes': 5 } } HTTP request: PATCH https://ml.googleapis.com/v1/{name=projects//models//versions/*}?update_mask=autoScaling.minNodes -d @./update_body.json
    maxNodes Integer
    The maximum number of nodes to scale this model under load. The actual value will depend on resource quota and availability.
    metrics List<GoogleCloudMlV1__MetricSpecResponse>
    MetricSpec contains the specifications to use to calculate the desired nodes count.
    minNodes Integer
    Optional. The minimum number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed. Therefore, the cost of operating this model will be at least rate * min_nodes * number of hours since last billing cycle, where rate is the cost per node-hour as documented in the pricing guide, even if no predictions are performed. There is additional cost for each prediction performed. Unlike manual scaling, if the load gets too heavy for the nodes that are up, the service will automatically add nodes to handle the increased load as well as scale back as traffic drops, always maintaining at least min_nodes. You will be charged for the time in which additional nodes are used. If min_nodes is not specified and AutoScaling is used with a legacy (MLS1) machine type, min_nodes defaults to 0, in which case, when traffic to a model stops (and after a cool-down period), nodes will be shut down and no charges will be incurred until traffic to the model resumes. If min_nodes is not specified and AutoScaling is used with a Compute Engine (N1) machine type, min_nodes defaults to 1. min_nodes must be at least 1 for use with a Compute Engine machine type. You can set min_nodes when creating the model version, and you can also update min_nodes for an existing version: update_body.json: { 'autoScaling': { 'minNodes': 5 } } HTTP request: PATCH https://ml.googleapis.com/v1/{name=projects//models//versions/*}?update_mask=autoScaling.minNodes -d @./update_body.json
    maxNodes number
    The maximum number of nodes to scale this model under load. The actual value will depend on resource quota and availability.
    metrics GoogleCloudMlV1__MetricSpecResponse[]
    MetricSpec contains the specifications to use to calculate the desired nodes count.
    minNodes number
    Optional. The minimum number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed. Therefore, the cost of operating this model will be at least rate * min_nodes * number of hours since last billing cycle, where rate is the cost per node-hour as documented in the pricing guide, even if no predictions are performed. There is additional cost for each prediction performed. Unlike manual scaling, if the load gets too heavy for the nodes that are up, the service will automatically add nodes to handle the increased load as well as scale back as traffic drops, always maintaining at least min_nodes. You will be charged for the time in which additional nodes are used. If min_nodes is not specified and AutoScaling is used with a legacy (MLS1) machine type, min_nodes defaults to 0, in which case, when traffic to a model stops (and after a cool-down period), nodes will be shut down and no charges will be incurred until traffic to the model resumes. If min_nodes is not specified and AutoScaling is used with a Compute Engine (N1) machine type, min_nodes defaults to 1. min_nodes must be at least 1 for use with a Compute Engine machine type. You can set min_nodes when creating the model version, and you can also update min_nodes for an existing version: update_body.json: { 'autoScaling': { 'minNodes': 5 } } HTTP request: PATCH https://ml.googleapis.com/v1/{name=projects//models//versions/*}?update_mask=autoScaling.minNodes -d @./update_body.json
    max_nodes int
    The maximum number of nodes to scale this model under load. The actual value will depend on resource quota and availability.
    metrics Sequence[GoogleCloudMlV1MetricSpecResponse]
    MetricSpec contains the specifications to use to calculate the desired nodes count.
    min_nodes int
    Optional. The minimum number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed. Therefore, the cost of operating this model will be at least rate * min_nodes * number of hours since last billing cycle, where rate is the cost per node-hour as documented in the pricing guide, even if no predictions are performed. There is additional cost for each prediction performed. Unlike manual scaling, if the load gets too heavy for the nodes that are up, the service will automatically add nodes to handle the increased load as well as scale back as traffic drops, always maintaining at least min_nodes. You will be charged for the time in which additional nodes are used. If min_nodes is not specified and AutoScaling is used with a legacy (MLS1) machine type, min_nodes defaults to 0, in which case, when traffic to a model stops (and after a cool-down period), nodes will be shut down and no charges will be incurred until traffic to the model resumes. If min_nodes is not specified and AutoScaling is used with a Compute Engine (N1) machine type, min_nodes defaults to 1. min_nodes must be at least 1 for use with a Compute Engine machine type. You can set min_nodes when creating the model version, and you can also update min_nodes for an existing version: update_body.json: { 'autoScaling': { 'minNodes': 5 } } HTTP request: PATCH https://ml.googleapis.com/v1/{name=projects//models//versions/*}?update_mask=autoScaling.minNodes -d @./update_body.json
    maxNodes Number
    The maximum number of nodes to scale this model under load. The actual value will depend on resource quota and availability.
    metrics List<Property Map>
    MetricSpec contains the specifications to use to calculate the desired nodes count.
    minNodes Number
    Optional. The minimum number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed. Therefore, the cost of operating this model will be at least rate * min_nodes * number of hours since last billing cycle, where rate is the cost per node-hour as documented in the pricing guide, even if no predictions are performed. There is additional cost for each prediction performed. Unlike manual scaling, if the load gets too heavy for the nodes that are up, the service will automatically add nodes to handle the increased load as well as scale back as traffic drops, always maintaining at least min_nodes. You will be charged for the time in which additional nodes are used. If min_nodes is not specified and AutoScaling is used with a legacy (MLS1) machine type, min_nodes defaults to 0, in which case, when traffic to a model stops (and after a cool-down period), nodes will be shut down and no charges will be incurred until traffic to the model resumes. If min_nodes is not specified and AutoScaling is used with a Compute Engine (N1) machine type, min_nodes defaults to 1. min_nodes must be at least 1 for use with a Compute Engine machine type. You can set min_nodes when creating the model version, and you can also update min_nodes for an existing version: update_body.json: { 'autoScaling': { 'minNodes': 5 } } HTTP request: PATCH https://ml.googleapis.com/v1/{name=projects//models//versions/*}?update_mask=autoScaling.minNodes -d @./update_body.json

    GoogleCloudMlV1__ContainerPortResponse, GoogleCloudMlV1__ContainerPortResponseArgs

    ContainerPort int
    Number of the port to expose on the container. This must be a valid port number: 0 < PORT_NUMBER < 65536.
    ContainerPort int
    Number of the port to expose on the container. This must be a valid port number: 0 < PORT_NUMBER < 65536.
    containerPort Integer
    Number of the port to expose on the container. This must be a valid port number: 0 < PORT_NUMBER < 65536.
    containerPort number
    Number of the port to expose on the container. This must be a valid port number: 0 < PORT_NUMBER < 65536.
    container_port int
    Number of the port to expose on the container. This must be a valid port number: 0 < PORT_NUMBER < 65536.
    containerPort Number
    Number of the port to expose on the container. This must be a valid port number: 0 < PORT_NUMBER < 65536.

    GoogleCloudMlV1__ContainerSpecResponse, GoogleCloudMlV1__ContainerSpecResponseArgs

    Args List<string>
    Immutable. Specifies arguments for the command that runs when the container starts. This overrides the container's CMD. Specify this field as an array of executable and arguments, similar to a Docker CMD's "default parameters" form. If you don't specify this field but do specify the command field, then the command from the command field runs without any additional arguments. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. If you don't specify this field and don't specify the commmand field, then the container's ENTRYPOINT and CMD determine what runs based on their default behavior. See the Docker documentation about how CMD and ENTRYPOINT interact. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the args field of the Kubernetes Containers v1 core API.
    Command List<string>
    Immutable. Specifies the command that runs when the container starts. This overrides the container's ENTRYPOINT. Specify this field as an array of executable and arguments, similar to a Docker ENTRYPOINT's "exec" form, not its "shell" form. If you do not specify this field, then the container's ENTRYPOINT runs, in conjunction with the args field or the container's CMD, if either exists. If this field is not specified and the container does not have an ENTRYPOINT, then refer to the Docker documentation about how CMD and ENTRYPOINT interact. If you specify this field, then you can also specify the args field to provide additional arguments for this command. However, if you specify this field, then the container's CMD is ignored. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the command field of the Kubernetes Containers v1 core API.
    Env List<Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__EnvVarResponse>
    Immutable. List of environment variables to set in the container. After the container starts running, code running in the container can read these environment variables. Additionally, the command and args fields can reference these variables. Later entries in this list can also reference earlier entries. For example, the following example sets the variable VAR_2 to have the value foo bar: json [ { "name": "VAR_1", "value": "foo" }, { "name": "VAR_2", "value": "$(VAR_1) bar" } ] If you switch the order of the variables in the example, then the expansion does not occur. This field corresponds to the env field of the Kubernetes Containers v1 core API.
    Image string
    URI of the Docker image to be used as the custom container for serving predictions. This URI must identify an image in Artifact Registry and begin with the hostname {REGION}-docker.pkg.dev, where {REGION} is replaced by the region that matches AI Platform Prediction regional endpoint that you are using. For example, if you are using the us-central1-ml.googleapis.com endpoint, then this URI must begin with us-central1-docker.pkg.dev. To use a custom container, the AI Platform Google-managed service account must have permission to pull (read) the Docker image at this URI. The AI Platform Google-managed service account has the following format: service-{PROJECT_NUMBER}@cloud-ml.google.com.iam.gserviceaccount.com {PROJECT_NUMBER} is replaced by your Google Cloud project number. By default, this service account has necessary permissions to pull an Artifact Registry image in the same Google Cloud project where you are using AI Platform Prediction. In this case, no configuration is necessary. If you want to use an image from a different Google Cloud project, learn how to grant the Artifact Registry Reader (roles/artifactregistry.reader) role for a repository to your projet's AI Platform Google-managed service account. To learn about the requirements for the Docker image itself, read Custom container requirements.
    Ports List<Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__ContainerPortResponse>
    Immutable. List of ports to expose from the container. AI Platform Prediction sends any prediction requests that it receives to the first port on this list. AI Platform Prediction also sends liveness and health checks to this port. If you do not specify this field, it defaults to following value: json [ { "containerPort": 8080 } ] AI Platform Prediction does not use ports other than the first one listed. This field corresponds to the ports field of the Kubernetes Containers v1 core API.
    Args []string
    Immutable. Specifies arguments for the command that runs when the container starts. This overrides the container's CMD. Specify this field as an array of executable and arguments, similar to a Docker CMD's "default parameters" form. If you don't specify this field but do specify the command field, then the command from the command field runs without any additional arguments. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. If you don't specify this field and don't specify the commmand field, then the container's ENTRYPOINT and CMD determine what runs based on their default behavior. See the Docker documentation about how CMD and ENTRYPOINT interact. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the args field of the Kubernetes Containers v1 core API.
    Command []string
    Immutable. Specifies the command that runs when the container starts. This overrides the container's ENTRYPOINT. Specify this field as an array of executable and arguments, similar to a Docker ENTRYPOINT's "exec" form, not its "shell" form. If you do not specify this field, then the container's ENTRYPOINT runs, in conjunction with the args field or the container's CMD, if either exists. If this field is not specified and the container does not have an ENTRYPOINT, then refer to the Docker documentation about how CMD and ENTRYPOINT interact. If you specify this field, then you can also specify the args field to provide additional arguments for this command. However, if you specify this field, then the container's CMD is ignored. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the command field of the Kubernetes Containers v1 core API.
    Env []GoogleCloudMlV1__EnvVarResponse
    Immutable. List of environment variables to set in the container. After the container starts running, code running in the container can read these environment variables. Additionally, the command and args fields can reference these variables. Later entries in this list can also reference earlier entries. For example, the following example sets the variable VAR_2 to have the value foo bar: json [ { "name": "VAR_1", "value": "foo" }, { "name": "VAR_2", "value": "$(VAR_1) bar" } ] If you switch the order of the variables in the example, then the expansion does not occur. This field corresponds to the env field of the Kubernetes Containers v1 core API.
    Image string
    URI of the Docker image to be used as the custom container for serving predictions. This URI must identify an image in Artifact Registry and begin with the hostname {REGION}-docker.pkg.dev, where {REGION} is replaced by the region that matches AI Platform Prediction regional endpoint that you are using. For example, if you are using the us-central1-ml.googleapis.com endpoint, then this URI must begin with us-central1-docker.pkg.dev. To use a custom container, the AI Platform Google-managed service account must have permission to pull (read) the Docker image at this URI. The AI Platform Google-managed service account has the following format: service-{PROJECT_NUMBER}@cloud-ml.google.com.iam.gserviceaccount.com {PROJECT_NUMBER} is replaced by your Google Cloud project number. By default, this service account has necessary permissions to pull an Artifact Registry image in the same Google Cloud project where you are using AI Platform Prediction. In this case, no configuration is necessary. If you want to use an image from a different Google Cloud project, learn how to grant the Artifact Registry Reader (roles/artifactregistry.reader) role for a repository to your projet's AI Platform Google-managed service account. To learn about the requirements for the Docker image itself, read Custom container requirements.
    Ports []GoogleCloudMlV1__ContainerPortResponse
    Immutable. List of ports to expose from the container. AI Platform Prediction sends any prediction requests that it receives to the first port on this list. AI Platform Prediction also sends liveness and health checks to this port. If you do not specify this field, it defaults to following value: json [ { "containerPort": 8080 } ] AI Platform Prediction does not use ports other than the first one listed. This field corresponds to the ports field of the Kubernetes Containers v1 core API.
    args List<String>
    Immutable. Specifies arguments for the command that runs when the container starts. This overrides the container's CMD. Specify this field as an array of executable and arguments, similar to a Docker CMD's "default parameters" form. If you don't specify this field but do specify the command field, then the command from the command field runs without any additional arguments. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. If you don't specify this field and don't specify the commmand field, then the container's ENTRYPOINT and CMD determine what runs based on their default behavior. See the Docker documentation about how CMD and ENTRYPOINT interact. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the args field of the Kubernetes Containers v1 core API.
    command List<String>
    Immutable. Specifies the command that runs when the container starts. This overrides the container's ENTRYPOINT. Specify this field as an array of executable and arguments, similar to a Docker ENTRYPOINT's "exec" form, not its "shell" form. If you do not specify this field, then the container's ENTRYPOINT runs, in conjunction with the args field or the container's CMD, if either exists. If this field is not specified and the container does not have an ENTRYPOINT, then refer to the Docker documentation about how CMD and ENTRYPOINT interact. If you specify this field, then you can also specify the args field to provide additional arguments for this command. However, if you specify this field, then the container's CMD is ignored. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the command field of the Kubernetes Containers v1 core API.
    env List<GoogleCloudMlV1__EnvVarResponse>
    Immutable. List of environment variables to set in the container. After the container starts running, code running in the container can read these environment variables. Additionally, the command and args fields can reference these variables. Later entries in this list can also reference earlier entries. For example, the following example sets the variable VAR_2 to have the value foo bar: json [ { "name": "VAR_1", "value": "foo" }, { "name": "VAR_2", "value": "$(VAR_1) bar" } ] If you switch the order of the variables in the example, then the expansion does not occur. This field corresponds to the env field of the Kubernetes Containers v1 core API.
    image String
    URI of the Docker image to be used as the custom container for serving predictions. This URI must identify an image in Artifact Registry and begin with the hostname {REGION}-docker.pkg.dev, where {REGION} is replaced by the region that matches AI Platform Prediction regional endpoint that you are using. For example, if you are using the us-central1-ml.googleapis.com endpoint, then this URI must begin with us-central1-docker.pkg.dev. To use a custom container, the AI Platform Google-managed service account must have permission to pull (read) the Docker image at this URI. The AI Platform Google-managed service account has the following format: service-{PROJECT_NUMBER}@cloud-ml.google.com.iam.gserviceaccount.com {PROJECT_NUMBER} is replaced by your Google Cloud project number. By default, this service account has necessary permissions to pull an Artifact Registry image in the same Google Cloud project where you are using AI Platform Prediction. In this case, no configuration is necessary. If you want to use an image from a different Google Cloud project, learn how to grant the Artifact Registry Reader (roles/artifactregistry.reader) role for a repository to your projet's AI Platform Google-managed service account. To learn about the requirements for the Docker image itself, read Custom container requirements.
    ports List<GoogleCloudMlV1__ContainerPortResponse>
    Immutable. List of ports to expose from the container. AI Platform Prediction sends any prediction requests that it receives to the first port on this list. AI Platform Prediction also sends liveness and health checks to this port. If you do not specify this field, it defaults to following value: json [ { "containerPort": 8080 } ] AI Platform Prediction does not use ports other than the first one listed. This field corresponds to the ports field of the Kubernetes Containers v1 core API.
    args string[]
    Immutable. Specifies arguments for the command that runs when the container starts. This overrides the container's CMD. Specify this field as an array of executable and arguments, similar to a Docker CMD's "default parameters" form. If you don't specify this field but do specify the command field, then the command from the command field runs without any additional arguments. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. If you don't specify this field and don't specify the commmand field, then the container's ENTRYPOINT and CMD determine what runs based on their default behavior. See the Docker documentation about how CMD and ENTRYPOINT interact. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the args field of the Kubernetes Containers v1 core API.
    command string[]
    Immutable. Specifies the command that runs when the container starts. This overrides the container's ENTRYPOINT. Specify this field as an array of executable and arguments, similar to a Docker ENTRYPOINT's "exec" form, not its "shell" form. If you do not specify this field, then the container's ENTRYPOINT runs, in conjunction with the args field or the container's CMD, if either exists. If this field is not specified and the container does not have an ENTRYPOINT, then refer to the Docker documentation about how CMD and ENTRYPOINT interact. If you specify this field, then you can also specify the args field to provide additional arguments for this command. However, if you specify this field, then the container's CMD is ignored. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the command field of the Kubernetes Containers v1 core API.
    env GoogleCloudMlV1__EnvVarResponse[]
    Immutable. List of environment variables to set in the container. After the container starts running, code running in the container can read these environment variables. Additionally, the command and args fields can reference these variables. Later entries in this list can also reference earlier entries. For example, the following example sets the variable VAR_2 to have the value foo bar: json [ { "name": "VAR_1", "value": "foo" }, { "name": "VAR_2", "value": "$(VAR_1) bar" } ] If you switch the order of the variables in the example, then the expansion does not occur. This field corresponds to the env field of the Kubernetes Containers v1 core API.
    image string
    URI of the Docker image to be used as the custom container for serving predictions. This URI must identify an image in Artifact Registry and begin with the hostname {REGION}-docker.pkg.dev, where {REGION} is replaced by the region that matches AI Platform Prediction regional endpoint that you are using. For example, if you are using the us-central1-ml.googleapis.com endpoint, then this URI must begin with us-central1-docker.pkg.dev. To use a custom container, the AI Platform Google-managed service account must have permission to pull (read) the Docker image at this URI. The AI Platform Google-managed service account has the following format: service-{PROJECT_NUMBER}@cloud-ml.google.com.iam.gserviceaccount.com {PROJECT_NUMBER} is replaced by your Google Cloud project number. By default, this service account has necessary permissions to pull an Artifact Registry image in the same Google Cloud project where you are using AI Platform Prediction. In this case, no configuration is necessary. If you want to use an image from a different Google Cloud project, learn how to grant the Artifact Registry Reader (roles/artifactregistry.reader) role for a repository to your projet's AI Platform Google-managed service account. To learn about the requirements for the Docker image itself, read Custom container requirements.
    ports GoogleCloudMlV1__ContainerPortResponse[]
    Immutable. List of ports to expose from the container. AI Platform Prediction sends any prediction requests that it receives to the first port on this list. AI Platform Prediction also sends liveness and health checks to this port. If you do not specify this field, it defaults to following value: json [ { "containerPort": 8080 } ] AI Platform Prediction does not use ports other than the first one listed. This field corresponds to the ports field of the Kubernetes Containers v1 core API.
    args Sequence[str]
    Immutable. Specifies arguments for the command that runs when the container starts. This overrides the container's CMD. Specify this field as an array of executable and arguments, similar to a Docker CMD's "default parameters" form. If you don't specify this field but do specify the command field, then the command from the command field runs without any additional arguments. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. If you don't specify this field and don't specify the commmand field, then the container's ENTRYPOINT and CMD determine what runs based on their default behavior. See the Docker documentation about how CMD and ENTRYPOINT interact. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the args field of the Kubernetes Containers v1 core API.
    command Sequence[str]
    Immutable. Specifies the command that runs when the container starts. This overrides the container's ENTRYPOINT. Specify this field as an array of executable and arguments, similar to a Docker ENTRYPOINT's "exec" form, not its "shell" form. If you do not specify this field, then the container's ENTRYPOINT runs, in conjunction with the args field or the container's CMD, if either exists. If this field is not specified and the container does not have an ENTRYPOINT, then refer to the Docker documentation about how CMD and ENTRYPOINT interact. If you specify this field, then you can also specify the args field to provide additional arguments for this command. However, if you specify this field, then the container's CMD is ignored. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the command field of the Kubernetes Containers v1 core API.
    env Sequence[GoogleCloudMlV1EnvVarResponse]
    Immutable. List of environment variables to set in the container. After the container starts running, code running in the container can read these environment variables. Additionally, the command and args fields can reference these variables. Later entries in this list can also reference earlier entries. For example, the following example sets the variable VAR_2 to have the value foo bar: json [ { "name": "VAR_1", "value": "foo" }, { "name": "VAR_2", "value": "$(VAR_1) bar" } ] If you switch the order of the variables in the example, then the expansion does not occur. This field corresponds to the env field of the Kubernetes Containers v1 core API.
    image str
    URI of the Docker image to be used as the custom container for serving predictions. This URI must identify an image in Artifact Registry and begin with the hostname {REGION}-docker.pkg.dev, where {REGION} is replaced by the region that matches AI Platform Prediction regional endpoint that you are using. For example, if you are using the us-central1-ml.googleapis.com endpoint, then this URI must begin with us-central1-docker.pkg.dev. To use a custom container, the AI Platform Google-managed service account must have permission to pull (read) the Docker image at this URI. The AI Platform Google-managed service account has the following format: service-{PROJECT_NUMBER}@cloud-ml.google.com.iam.gserviceaccount.com {PROJECT_NUMBER} is replaced by your Google Cloud project number. By default, this service account has necessary permissions to pull an Artifact Registry image in the same Google Cloud project where you are using AI Platform Prediction. In this case, no configuration is necessary. If you want to use an image from a different Google Cloud project, learn how to grant the Artifact Registry Reader (roles/artifactregistry.reader) role for a repository to your projet's AI Platform Google-managed service account. To learn about the requirements for the Docker image itself, read Custom container requirements.
    ports Sequence[GoogleCloudMlV1ContainerPortResponse]
    Immutable. List of ports to expose from the container. AI Platform Prediction sends any prediction requests that it receives to the first port on this list. AI Platform Prediction also sends liveness and health checks to this port. If you do not specify this field, it defaults to following value: json [ { "containerPort": 8080 } ] AI Platform Prediction does not use ports other than the first one listed. This field corresponds to the ports field of the Kubernetes Containers v1 core API.
    args List<String>
    Immutable. Specifies arguments for the command that runs when the container starts. This overrides the container's CMD. Specify this field as an array of executable and arguments, similar to a Docker CMD's "default parameters" form. If you don't specify this field but do specify the command field, then the command from the command field runs without any additional arguments. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. If you don't specify this field and don't specify the commmand field, then the container's ENTRYPOINT and CMD determine what runs based on their default behavior. See the Docker documentation about how CMD and ENTRYPOINT interact. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the args field of the Kubernetes Containers v1 core API.
    command List<String>
    Immutable. Specifies the command that runs when the container starts. This overrides the container's ENTRYPOINT. Specify this field as an array of executable and arguments, similar to a Docker ENTRYPOINT's "exec" form, not its "shell" form. If you do not specify this field, then the container's ENTRYPOINT runs, in conjunction with the args field or the container's CMD, if either exists. If this field is not specified and the container does not have an ENTRYPOINT, then refer to the Docker documentation about how CMD and ENTRYPOINT interact. If you specify this field, then you can also specify the args field to provide additional arguments for this command. However, if you specify this field, then the container's CMD is ignored. See the Kubernetes documentation about how the command and args fields interact with a container's ENTRYPOINT and CMD. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set in the env field. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $( VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME) This field corresponds to the command field of the Kubernetes Containers v1 core API.
    env List<Property Map>
    Immutable. List of environment variables to set in the container. After the container starts running, code running in the container can read these environment variables. Additionally, the command and args fields can reference these variables. Later entries in this list can also reference earlier entries. For example, the following example sets the variable VAR_2 to have the value foo bar: json [ { "name": "VAR_1", "value": "foo" }, { "name": "VAR_2", "value": "$(VAR_1) bar" } ] If you switch the order of the variables in the example, then the expansion does not occur. This field corresponds to the env field of the Kubernetes Containers v1 core API.
    image String
    URI of the Docker image to be used as the custom container for serving predictions. This URI must identify an image in Artifact Registry and begin with the hostname {REGION}-docker.pkg.dev, where {REGION} is replaced by the region that matches AI Platform Prediction regional endpoint that you are using. For example, if you are using the us-central1-ml.googleapis.com endpoint, then this URI must begin with us-central1-docker.pkg.dev. To use a custom container, the AI Platform Google-managed service account must have permission to pull (read) the Docker image at this URI. The AI Platform Google-managed service account has the following format: service-{PROJECT_NUMBER}@cloud-ml.google.com.iam.gserviceaccount.com {PROJECT_NUMBER} is replaced by your Google Cloud project number. By default, this service account has necessary permissions to pull an Artifact Registry image in the same Google Cloud project where you are using AI Platform Prediction. In this case, no configuration is necessary. If you want to use an image from a different Google Cloud project, learn how to grant the Artifact Registry Reader (roles/artifactregistry.reader) role for a repository to your projet's AI Platform Google-managed service account. To learn about the requirements for the Docker image itself, read Custom container requirements.
    ports List<Property Map>
    Immutable. List of ports to expose from the container. AI Platform Prediction sends any prediction requests that it receives to the first port on this list. AI Platform Prediction also sends liveness and health checks to this port. If you do not specify this field, it defaults to following value: json [ { "containerPort": 8080 } ] AI Platform Prediction does not use ports other than the first one listed. This field corresponds to the ports field of the Kubernetes Containers v1 core API.

    GoogleCloudMlV1__EnvVarResponse, GoogleCloudMlV1__EnvVarResponseArgs

    Name string
    Name of the environment variable. Must be a valid C identifier and must not begin with the prefix AIP_.
    Value string
    Value of the environment variable. Defaults to an empty string. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set earlier in the same env field as where this message occurs. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $(VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME)
    Name string
    Name of the environment variable. Must be a valid C identifier and must not begin with the prefix AIP_.
    Value string
    Value of the environment variable. Defaults to an empty string. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set earlier in the same env field as where this message occurs. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $(VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME)
    name String
    Name of the environment variable. Must be a valid C identifier and must not begin with the prefix AIP_.
    value String
    Value of the environment variable. Defaults to an empty string. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set earlier in the same env field as where this message occurs. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $(VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME)
    name string
    Name of the environment variable. Must be a valid C identifier and must not begin with the prefix AIP_.
    value string
    Value of the environment variable. Defaults to an empty string. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set earlier in the same env field as where this message occurs. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $(VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME)
    name str
    Name of the environment variable. Must be a valid C identifier and must not begin with the prefix AIP_.
    value str
    Value of the environment variable. Defaults to an empty string. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set earlier in the same env field as where this message occurs. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $(VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME)
    name String
    Name of the environment variable. Must be a valid C identifier and must not begin with the prefix AIP_.
    value String
    Value of the environment variable. Defaults to an empty string. In this field, you can reference environment variables set by AI Platform Prediction and environment variables set earlier in the same env field as where this message occurs. You cannot reference environment variables set in the Docker image. In order for environment variables to be expanded, reference them by using the following syntax: $(VARIABLE_NAME) Note that this differs from Bash variable expansion, which does not use parentheses. If a variable cannot be resolved, the reference in the input string is used unchanged. To avoid variable expansion, you can escape this syntax with $$; for example: $$(VARIABLE_NAME)

    GoogleCloudMlV1__ExplanationConfigResponse, GoogleCloudMlV1__ExplanationConfigResponseArgs

    IntegratedGradientsAttribution Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__IntegratedGradientsAttributionResponse
    Attributes credit by computing the Aumann-Shapley value taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1703.01365
    SampledShapleyAttribution Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__SampledShapleyAttributionResponse
    An attribution method that approximates Shapley values for features that contribute to the label being predicted. A sampling strategy is used to approximate the value rather than considering all subsets of features.
    XraiAttribution Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__XraiAttributionResponse
    Attributes credit by computing the XRAI taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1906.02825 Currently only implemented for models with natural image inputs.
    IntegratedGradientsAttribution GoogleCloudMlV1__IntegratedGradientsAttributionResponse
    Attributes credit by computing the Aumann-Shapley value taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1703.01365
    SampledShapleyAttribution GoogleCloudMlV1__SampledShapleyAttributionResponse
    An attribution method that approximates Shapley values for features that contribute to the label being predicted. A sampling strategy is used to approximate the value rather than considering all subsets of features.
    XraiAttribution GoogleCloudMlV1__XraiAttributionResponse
    Attributes credit by computing the XRAI taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1906.02825 Currently only implemented for models with natural image inputs.
    integratedGradientsAttribution GoogleCloudMlV1__IntegratedGradientsAttributionResponse
    Attributes credit by computing the Aumann-Shapley value taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1703.01365
    sampledShapleyAttribution GoogleCloudMlV1__SampledShapleyAttributionResponse
    An attribution method that approximates Shapley values for features that contribute to the label being predicted. A sampling strategy is used to approximate the value rather than considering all subsets of features.
    xraiAttribution GoogleCloudMlV1__XraiAttributionResponse
    Attributes credit by computing the XRAI taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1906.02825 Currently only implemented for models with natural image inputs.
    integratedGradientsAttribution GoogleCloudMlV1__IntegratedGradientsAttributionResponse
    Attributes credit by computing the Aumann-Shapley value taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1703.01365
    sampledShapleyAttribution GoogleCloudMlV1__SampledShapleyAttributionResponse
    An attribution method that approximates Shapley values for features that contribute to the label being predicted. A sampling strategy is used to approximate the value rather than considering all subsets of features.
    xraiAttribution GoogleCloudMlV1__XraiAttributionResponse
    Attributes credit by computing the XRAI taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1906.02825 Currently only implemented for models with natural image inputs.
    integrated_gradients_attribution GoogleCloudMlV1IntegratedGradientsAttributionResponse
    Attributes credit by computing the Aumann-Shapley value taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1703.01365
    sampled_shapley_attribution GoogleCloudMlV1SampledShapleyAttributionResponse
    An attribution method that approximates Shapley values for features that contribute to the label being predicted. A sampling strategy is used to approximate the value rather than considering all subsets of features.
    xrai_attribution GoogleCloudMlV1XraiAttributionResponse
    Attributes credit by computing the XRAI taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1906.02825 Currently only implemented for models with natural image inputs.
    integratedGradientsAttribution Property Map
    Attributes credit by computing the Aumann-Shapley value taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1703.01365
    sampledShapleyAttribution Property Map
    An attribution method that approximates Shapley values for features that contribute to the label being predicted. A sampling strategy is used to approximate the value rather than considering all subsets of features.
    xraiAttribution Property Map
    Attributes credit by computing the XRAI taking advantage of the model's fully differentiable structure. Refer to this paper for more details: https://arxiv.org/abs/1906.02825 Currently only implemented for models with natural image inputs.

    GoogleCloudMlV1__IntegratedGradientsAttributionResponse, GoogleCloudMlV1__IntegratedGradientsAttributionResponseArgs

    NumIntegralSteps int
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    NumIntegralSteps int
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    numIntegralSteps Integer
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    numIntegralSteps number
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    num_integral_steps int
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    numIntegralSteps Number
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.

    GoogleCloudMlV1__ManualScalingResponse, GoogleCloudMlV1__ManualScalingResponseArgs

    Nodes int
    The number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed, so the cost of operating this model will be proportional to nodes * number of hours since last billing cycle plus the cost for each prediction performed.
    Nodes int
    The number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed, so the cost of operating this model will be proportional to nodes * number of hours since last billing cycle plus the cost for each prediction performed.
    nodes Integer
    The number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed, so the cost of operating this model will be proportional to nodes * number of hours since last billing cycle plus the cost for each prediction performed.
    nodes number
    The number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed, so the cost of operating this model will be proportional to nodes * number of hours since last billing cycle plus the cost for each prediction performed.
    nodes int
    The number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed, so the cost of operating this model will be proportional to nodes * number of hours since last billing cycle plus the cost for each prediction performed.
    nodes Number
    The number of nodes to allocate for this model. These nodes are always up, starting from the time the model is deployed, so the cost of operating this model will be proportional to nodes * number of hours since last billing cycle plus the cost for each prediction performed.

    GoogleCloudMlV1__MetricSpecResponse, GoogleCloudMlV1__MetricSpecResponseArgs

    Name string
    metric name.
    Target int
    Target specifies the target value for the given metric; once real metric deviates from the threshold by a certain percentage, the node count changes.
    Name string
    metric name.
    Target int
    Target specifies the target value for the given metric; once real metric deviates from the threshold by a certain percentage, the node count changes.
    name String
    metric name.
    target Integer
    Target specifies the target value for the given metric; once real metric deviates from the threshold by a certain percentage, the node count changes.
    name string
    metric name.
    target number
    Target specifies the target value for the given metric; once real metric deviates from the threshold by a certain percentage, the node count changes.
    name str
    metric name.
    target int
    Target specifies the target value for the given metric; once real metric deviates from the threshold by a certain percentage, the node count changes.
    name String
    metric name.
    target Number
    Target specifies the target value for the given metric; once real metric deviates from the threshold by a certain percentage, the node count changes.

    GoogleCloudMlV1__RequestLoggingConfigResponse, GoogleCloudMlV1__RequestLoggingConfigResponseArgs

    BigqueryTableName string
    Fully qualified BigQuery table name in the following format: " project_id.dataset_name.table_name" The specified table must already exist, and the "Cloud ML Service Agent" for your project must have permission to write to it. The table must have the following schema: Field nameType Mode model STRING REQUIRED model_version STRING REQUIRED time TIMESTAMP REQUIRED raw_data STRING REQUIRED raw_prediction STRING NULLABLE groundtruth STRING NULLABLE
    SamplingPercentage double
    Percentage of requests to be logged, expressed as a fraction from 0 to 1. For example, if you want to log 10% of requests, enter 0.1. The sampling window is the lifetime of the model version. Defaults to 0.
    BigqueryTableName string
    Fully qualified BigQuery table name in the following format: " project_id.dataset_name.table_name" The specified table must already exist, and the "Cloud ML Service Agent" for your project must have permission to write to it. The table must have the following schema: Field nameType Mode model STRING REQUIRED model_version STRING REQUIRED time TIMESTAMP REQUIRED raw_data STRING REQUIRED raw_prediction STRING NULLABLE groundtruth STRING NULLABLE
    SamplingPercentage float64
    Percentage of requests to be logged, expressed as a fraction from 0 to 1. For example, if you want to log 10% of requests, enter 0.1. The sampling window is the lifetime of the model version. Defaults to 0.
    bigqueryTableName String
    Fully qualified BigQuery table name in the following format: " project_id.dataset_name.table_name" The specified table must already exist, and the "Cloud ML Service Agent" for your project must have permission to write to it. The table must have the following schema: Field nameType Mode model STRING REQUIRED model_version STRING REQUIRED time TIMESTAMP REQUIRED raw_data STRING REQUIRED raw_prediction STRING NULLABLE groundtruth STRING NULLABLE
    samplingPercentage Double
    Percentage of requests to be logged, expressed as a fraction from 0 to 1. For example, if you want to log 10% of requests, enter 0.1. The sampling window is the lifetime of the model version. Defaults to 0.
    bigqueryTableName string
    Fully qualified BigQuery table name in the following format: " project_id.dataset_name.table_name" The specified table must already exist, and the "Cloud ML Service Agent" for your project must have permission to write to it. The table must have the following schema: Field nameType Mode model STRING REQUIRED model_version STRING REQUIRED time TIMESTAMP REQUIRED raw_data STRING REQUIRED raw_prediction STRING NULLABLE groundtruth STRING NULLABLE
    samplingPercentage number
    Percentage of requests to be logged, expressed as a fraction from 0 to 1. For example, if you want to log 10% of requests, enter 0.1. The sampling window is the lifetime of the model version. Defaults to 0.
    bigquery_table_name str
    Fully qualified BigQuery table name in the following format: " project_id.dataset_name.table_name" The specified table must already exist, and the "Cloud ML Service Agent" for your project must have permission to write to it. The table must have the following schema: Field nameType Mode model STRING REQUIRED model_version STRING REQUIRED time TIMESTAMP REQUIRED raw_data STRING REQUIRED raw_prediction STRING NULLABLE groundtruth STRING NULLABLE
    sampling_percentage float
    Percentage of requests to be logged, expressed as a fraction from 0 to 1. For example, if you want to log 10% of requests, enter 0.1. The sampling window is the lifetime of the model version. Defaults to 0.
    bigqueryTableName String
    Fully qualified BigQuery table name in the following format: " project_id.dataset_name.table_name" The specified table must already exist, and the "Cloud ML Service Agent" for your project must have permission to write to it. The table must have the following schema: Field nameType Mode model STRING REQUIRED model_version STRING REQUIRED time TIMESTAMP REQUIRED raw_data STRING REQUIRED raw_prediction STRING NULLABLE groundtruth STRING NULLABLE
    samplingPercentage Number
    Percentage of requests to be logged, expressed as a fraction from 0 to 1. For example, if you want to log 10% of requests, enter 0.1. The sampling window is the lifetime of the model version. Defaults to 0.

    GoogleCloudMlV1__RouteMapResponse, GoogleCloudMlV1__RouteMapResponseArgs

    Health string
    HTTP path on the container to send health checkss to. AI Platform Prediction intermittently sends GET requests to this path on the container's IP address and port to check that the container is healthy. Read more about health checks. For example, if you set this field to /bar, then AI Platform Prediction intermittently sends a GET request to the /bar path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/ MODEL/versions/VERSION The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID /models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    Predict string
    HTTP path on the container to send prediction requests to. AI Platform Prediction forwards requests sent using projects.predict to this path on the container's IP address and port. AI Platform Prediction then returns the container's response in the API response. For example, if you set this field to /foo, then when AI Platform Prediction receives a prediction request, it forwards the request body in a POST request to the /foo path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/MODEL/versions/VERSION:predict The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID/models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    Health string
    HTTP path on the container to send health checkss to. AI Platform Prediction intermittently sends GET requests to this path on the container's IP address and port to check that the container is healthy. Read more about health checks. For example, if you set this field to /bar, then AI Platform Prediction intermittently sends a GET request to the /bar path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/ MODEL/versions/VERSION The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID /models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    Predict string
    HTTP path on the container to send prediction requests to. AI Platform Prediction forwards requests sent using projects.predict to this path on the container's IP address and port. AI Platform Prediction then returns the container's response in the API response. For example, if you set this field to /foo, then when AI Platform Prediction receives a prediction request, it forwards the request body in a POST request to the /foo path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/MODEL/versions/VERSION:predict The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID/models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    health String
    HTTP path on the container to send health checkss to. AI Platform Prediction intermittently sends GET requests to this path on the container's IP address and port to check that the container is healthy. Read more about health checks. For example, if you set this field to /bar, then AI Platform Prediction intermittently sends a GET request to the /bar path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/ MODEL/versions/VERSION The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID /models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    predict String
    HTTP path on the container to send prediction requests to. AI Platform Prediction forwards requests sent using projects.predict to this path on the container's IP address and port. AI Platform Prediction then returns the container's response in the API response. For example, if you set this field to /foo, then when AI Platform Prediction receives a prediction request, it forwards the request body in a POST request to the /foo path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/MODEL/versions/VERSION:predict The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID/models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    health string
    HTTP path on the container to send health checkss to. AI Platform Prediction intermittently sends GET requests to this path on the container's IP address and port to check that the container is healthy. Read more about health checks. For example, if you set this field to /bar, then AI Platform Prediction intermittently sends a GET request to the /bar path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/ MODEL/versions/VERSION The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID /models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    predict string
    HTTP path on the container to send prediction requests to. AI Platform Prediction forwards requests sent using projects.predict to this path on the container's IP address and port. AI Platform Prediction then returns the container's response in the API response. For example, if you set this field to /foo, then when AI Platform Prediction receives a prediction request, it forwards the request body in a POST request to the /foo path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/MODEL/versions/VERSION:predict The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID/models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    health str
    HTTP path on the container to send health checkss to. AI Platform Prediction intermittently sends GET requests to this path on the container's IP address and port to check that the container is healthy. Read more about health checks. For example, if you set this field to /bar, then AI Platform Prediction intermittently sends a GET request to the /bar path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/ MODEL/versions/VERSION The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID /models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    predict str
    HTTP path on the container to send prediction requests to. AI Platform Prediction forwards requests sent using projects.predict to this path on the container's IP address and port. AI Platform Prediction then returns the container's response in the API response. For example, if you set this field to /foo, then when AI Platform Prediction receives a prediction request, it forwards the request body in a POST request to the /foo path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/MODEL/versions/VERSION:predict The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID/models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    health String
    HTTP path on the container to send health checkss to. AI Platform Prediction intermittently sends GET requests to this path on the container's IP address and port to check that the container is healthy. Read more about health checks. For example, if you set this field to /bar, then AI Platform Prediction intermittently sends a GET request to the /bar path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/ MODEL/versions/VERSION The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID /models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.
    predict String
    HTTP path on the container to send prediction requests to. AI Platform Prediction forwards requests sent using projects.predict to this path on the container's IP address and port. AI Platform Prediction then returns the container's response in the API response. For example, if you set this field to /foo, then when AI Platform Prediction receives a prediction request, it forwards the request body in a POST request to the /foo path on the port of your container specified by the first value of Version.container.ports. If you don't specify this field, it defaults to the following value: /v1/models/MODEL/versions/VERSION:predict The placeholders in this value are replaced as follows: * MODEL: The name of the parent Model. This does not include the "projects/PROJECT_ID/models/" prefix that the API returns in output; it is the bare model name, as provided to projects.models.create. * VERSION: The name of the model version. This does not include the "projects/PROJECT_ID/models/MODEL/versions/" prefix that the API returns in output; it is the bare version name, as provided to projects.models.versions.create.

    GoogleCloudMlV1__SampledShapleyAttributionResponse, GoogleCloudMlV1__SampledShapleyAttributionResponseArgs

    NumPaths int
    The number of feature permutations to consider when approximating the Shapley values.
    NumPaths int
    The number of feature permutations to consider when approximating the Shapley values.
    numPaths Integer
    The number of feature permutations to consider when approximating the Shapley values.
    numPaths number
    The number of feature permutations to consider when approximating the Shapley values.
    num_paths int
    The number of feature permutations to consider when approximating the Shapley values.
    numPaths Number
    The number of feature permutations to consider when approximating the Shapley values.

    GoogleCloudMlV1__VersionResponse, GoogleCloudMlV1__VersionResponseArgs

    AcceleratorConfig Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__AcceleratorConfigResponse
    Optional. Accelerator config for using GPUs for online prediction (beta). Only specify this field if you have specified a Compute Engine (N1) machine type in the machineType field. Learn more about using GPUs for online prediction.
    AutoScaling Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__AutoScalingResponse
    Automatically scale the number of nodes used to serve the model in response to increases and decreases in traffic. Care should be taken to ramp up traffic according to the model's ability to scale or you will start seeing increases in latency and 429 response codes.
    Container Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__ContainerSpecResponse
    Optional. Specifies a custom container to use for serving predictions. If you specify this field, then machineType is required. If you specify this field, then deploymentUri is optional. If you specify this field, then you must not specify runtimeVersion, packageUris, framework, pythonVersion, or predictionClass.
    CreateTime string
    The time the version was created.
    DeploymentUri string
    The Cloud Storage URI of a directory containing trained model artifacts to be used to create the model version. See the guide to deploying models for more information. The total number of files under this directory must not exceed 1000. During projects.models.versions.create, AI Platform Prediction copies all files from the specified directory to a location managed by the service. From then on, AI Platform Prediction uses these copies of the model artifacts to serve predictions, not the original files in Cloud Storage, so this location is useful only as a historical record. If you specify container, then this field is optional. Otherwise, it is required. Learn how to use this field with a custom container.
    Description string
    Optional. The description specified for the version when it was created.
    ErrorMessage string
    The details of a failure or a cancellation.
    Etag string
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetVersion, and systems are expected to put that etag in the request to UpdateVersion to ensure that their change will be applied to the model as intended.
    ExplanationConfig Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__ExplanationConfigResponse
    Optional. Configures explainability features on the model's version. Some explanation features require additional metadata to be loaded as part of the model payload.
    Framework string
    Optional. The machine learning framework AI Platform uses to train this version of the model. Valid values are TENSORFLOW, SCIKIT_LEARN, XGBOOST. If you do not specify a framework, AI Platform will analyze files in the deployment_uri to determine a framework. If you choose SCIKIT_LEARN or XGBOOST, you must also set the runtime version of the model to 1.4 or greater. Do not specify a framework if you're deploying a custom prediction routine or if you're using a custom container.
    IsDefault bool
    If true, this version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.methods.versions.setDefault.
    Labels Dictionary<string, string>
    Optional. One or more labels that you can add, to organize your model versions. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    LastMigrationModelId string
    The AI Platform (Unified) Model ID for the last model migration.
    LastMigrationTime string
    The last time this version was successfully migrated to AI Platform (Unified).
    LastUseTime string
    The time the version was last used for prediction.
    MachineType string
    Optional. The type of machine on which to serve the model. Currently only applies to online prediction service. To learn about valid values for this field, read Choosing a machine type for online prediction. If this field is not specified and you are using a regional endpoint, then the machine type defaults to n1-standard-2. If this field is not specified and you are using the global endpoint (ml.googleapis.com), then the machine type defaults to mls1-c1-m2.
    ManualScaling Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__ManualScalingResponse
    Manually select the number of nodes to use for serving the model. You should generally use auto_scaling with an appropriate min_nodes instead, but this option is available if you want more predictable billing. Beware that latency and error rates will increase if the traffic exceeds that capability of the system to serve it based on the selected number of nodes.
    Name string
    The name specified for the version when it was created. The version name must be unique within the model it is created in.
    PackageUris List<string>
    Optional. Cloud Storage paths (gs://…) of packages for custom prediction routines or scikit-learn pipelines with custom code. For a custom prediction routine, one of these packages must contain your Predictor class (see predictionClass). Additionally, include any dependencies used by your Predictor or scikit-learn pipeline uses that are not already included in your selected runtime version. If you specify this field, you must also set runtimeVersion to 1.4 or greater.
    PredictionClass string
    Optional. The fully qualified name (module_name.class_name) of a class that implements the Predictor interface described in this reference field. The module containing this class should be included in a package provided to the packageUris field. Specify this field if and only if you are deploying a custom prediction routine (beta). If you specify this field, you must set runtimeVersion to 1.4 or greater and you must set machineType to a legacy (MLS1) machine type. The following code sample provides the Predictor interface: class Predictor(object): """Interface for constructing custom predictors.""" def predict(self, instances, **kwargs): """Performs custom prediction. Instances are the decoded values from the request. They have already been deserialized from JSON. Args: instances: A list of prediction input instances. **kwargs: A dictionary of keyword args provided as additional fields on the predict request body. Returns: A list of outputs containing the prediction results. This list must be JSON serializable. """ raise NotImplementedError() @classmethod def from_path(cls, model_dir): """Creates an instance of Predictor using the given path. Loading of the predictor should be done in this method. Args: model_dir: The local directory that contains the exported model file along with any additional files uploaded when creating the version resource. Returns: An instance implementing this Predictor class. """ raise NotImplementedError() Learn more about the Predictor interface and custom prediction routines.
    PythonVersion string
    The version of Python used in prediction. The following Python versions are available: * Python '3.7' is available when runtime_version is set to '1.15' or later. * Python '3.5' is available when runtime_version is set to a version from '1.4' to '1.14'. * Python '2.7' is available when runtime_version is set to '1.15' or earlier. Read more about the Python versions available for each runtime version.
    RequestLoggingConfig Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__RequestLoggingConfigResponse
    Optional. Only specify this field in a projects.models.versions.patch request. Specifying it in a projects.models.versions.create request has no effect. Configures the request-response pair logging on predictions from this Version.
    Routes Pulumi.GoogleNative.Ml.V1.Inputs.GoogleCloudMlV1__RouteMapResponse
    Optional. Specifies paths on a custom container's HTTP server where AI Platform Prediction sends certain requests. If you specify this field, then you must also specify the container field. If you specify the container field and do not specify this field, it defaults to the following: json { "predict": "/v1/models/MODEL/versions/VERSION:predict", "health": "/v1/models/MODEL/versions/VERSION" } See RouteMap for more details about these default values.
    RuntimeVersion string
    The AI Platform runtime version to use for this deployment. For more information, see the runtime version list and how to manage runtime versions.
    ServiceAccount string
    Optional. Specifies the service account for resource access control. If you specify this field, then you must also specify either the containerSpec or the predictionClass field. Learn more about using a custom service account.
    State string
    The state of a version.
    AcceleratorConfig GoogleCloudMlV1__AcceleratorConfigResponse
    Optional. Accelerator config for using GPUs for online prediction (beta). Only specify this field if you have specified a Compute Engine (N1) machine type in the machineType field. Learn more about using GPUs for online prediction.
    AutoScaling GoogleCloudMlV1__AutoScalingResponse
    Automatically scale the number of nodes used to serve the model in response to increases and decreases in traffic. Care should be taken to ramp up traffic according to the model's ability to scale or you will start seeing increases in latency and 429 response codes.
    Container GoogleCloudMlV1__ContainerSpecResponse
    Optional. Specifies a custom container to use for serving predictions. If you specify this field, then machineType is required. If you specify this field, then deploymentUri is optional. If you specify this field, then you must not specify runtimeVersion, packageUris, framework, pythonVersion, or predictionClass.
    CreateTime string
    The time the version was created.
    DeploymentUri string
    The Cloud Storage URI of a directory containing trained model artifacts to be used to create the model version. See the guide to deploying models for more information. The total number of files under this directory must not exceed 1000. During projects.models.versions.create, AI Platform Prediction copies all files from the specified directory to a location managed by the service. From then on, AI Platform Prediction uses these copies of the model artifacts to serve predictions, not the original files in Cloud Storage, so this location is useful only as a historical record. If you specify container, then this field is optional. Otherwise, it is required. Learn how to use this field with a custom container.
    Description string
    Optional. The description specified for the version when it was created.
    ErrorMessage string
    The details of a failure or a cancellation.
    Etag string
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetVersion, and systems are expected to put that etag in the request to UpdateVersion to ensure that their change will be applied to the model as intended.
    ExplanationConfig GoogleCloudMlV1__ExplanationConfigResponse
    Optional. Configures explainability features on the model's version. Some explanation features require additional metadata to be loaded as part of the model payload.
    Framework string
    Optional. The machine learning framework AI Platform uses to train this version of the model. Valid values are TENSORFLOW, SCIKIT_LEARN, XGBOOST. If you do not specify a framework, AI Platform will analyze files in the deployment_uri to determine a framework. If you choose SCIKIT_LEARN or XGBOOST, you must also set the runtime version of the model to 1.4 or greater. Do not specify a framework if you're deploying a custom prediction routine or if you're using a custom container.
    IsDefault bool
    If true, this version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.methods.versions.setDefault.
    Labels map[string]string
    Optional. One or more labels that you can add, to organize your model versions. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    LastMigrationModelId string
    The AI Platform (Unified) Model ID for the last model migration.
    LastMigrationTime string
    The last time this version was successfully migrated to AI Platform (Unified).
    LastUseTime string
    The time the version was last used for prediction.
    MachineType string
    Optional. The type of machine on which to serve the model. Currently only applies to online prediction service. To learn about valid values for this field, read Choosing a machine type for online prediction. If this field is not specified and you are using a regional endpoint, then the machine type defaults to n1-standard-2. If this field is not specified and you are using the global endpoint (ml.googleapis.com), then the machine type defaults to mls1-c1-m2.
    ManualScaling GoogleCloudMlV1__ManualScalingResponse
    Manually select the number of nodes to use for serving the model. You should generally use auto_scaling with an appropriate min_nodes instead, but this option is available if you want more predictable billing. Beware that latency and error rates will increase if the traffic exceeds that capability of the system to serve it based on the selected number of nodes.
    Name string
    The name specified for the version when it was created. The version name must be unique within the model it is created in.
    PackageUris []string
    Optional. Cloud Storage paths (gs://…) of packages for custom prediction routines or scikit-learn pipelines with custom code. For a custom prediction routine, one of these packages must contain your Predictor class (see predictionClass). Additionally, include any dependencies used by your Predictor or scikit-learn pipeline uses that are not already included in your selected runtime version. If you specify this field, you must also set runtimeVersion to 1.4 or greater.
    PredictionClass string
    Optional. The fully qualified name (module_name.class_name) of a class that implements the Predictor interface described in this reference field. The module containing this class should be included in a package provided to the packageUris field. Specify this field if and only if you are deploying a custom prediction routine (beta). If you specify this field, you must set runtimeVersion to 1.4 or greater and you must set machineType to a legacy (MLS1) machine type. The following code sample provides the Predictor interface: class Predictor(object): """Interface for constructing custom predictors.""" def predict(self, instances, **kwargs): """Performs custom prediction. Instances are the decoded values from the request. They have already been deserialized from JSON. Args: instances: A list of prediction input instances. **kwargs: A dictionary of keyword args provided as additional fields on the predict request body. Returns: A list of outputs containing the prediction results. This list must be JSON serializable. """ raise NotImplementedError() @classmethod def from_path(cls, model_dir): """Creates an instance of Predictor using the given path. Loading of the predictor should be done in this method. Args: model_dir: The local directory that contains the exported model file along with any additional files uploaded when creating the version resource. Returns: An instance implementing this Predictor class. """ raise NotImplementedError() Learn more about the Predictor interface and custom prediction routines.
    PythonVersion string
    The version of Python used in prediction. The following Python versions are available: * Python '3.7' is available when runtime_version is set to '1.15' or later. * Python '3.5' is available when runtime_version is set to a version from '1.4' to '1.14'. * Python '2.7' is available when runtime_version is set to '1.15' or earlier. Read more about the Python versions available for each runtime version.
    RequestLoggingConfig GoogleCloudMlV1__RequestLoggingConfigResponse
    Optional. Only specify this field in a projects.models.versions.patch request. Specifying it in a projects.models.versions.create request has no effect. Configures the request-response pair logging on predictions from this Version.
    Routes GoogleCloudMlV1__RouteMapResponse
    Optional. Specifies paths on a custom container's HTTP server where AI Platform Prediction sends certain requests. If you specify this field, then you must also specify the container field. If you specify the container field and do not specify this field, it defaults to the following: json { "predict": "/v1/models/MODEL/versions/VERSION:predict", "health": "/v1/models/MODEL/versions/VERSION" } See RouteMap for more details about these default values.
    RuntimeVersion string
    The AI Platform runtime version to use for this deployment. For more information, see the runtime version list and how to manage runtime versions.
    ServiceAccount string
    Optional. Specifies the service account for resource access control. If you specify this field, then you must also specify either the containerSpec or the predictionClass field. Learn more about using a custom service account.
    State string
    The state of a version.
    acceleratorConfig GoogleCloudMlV1__AcceleratorConfigResponse
    Optional. Accelerator config for using GPUs for online prediction (beta). Only specify this field if you have specified a Compute Engine (N1) machine type in the machineType field. Learn more about using GPUs for online prediction.
    autoScaling GoogleCloudMlV1__AutoScalingResponse
    Automatically scale the number of nodes used to serve the model in response to increases and decreases in traffic. Care should be taken to ramp up traffic according to the model's ability to scale or you will start seeing increases in latency and 429 response codes.
    container GoogleCloudMlV1__ContainerSpecResponse
    Optional. Specifies a custom container to use for serving predictions. If you specify this field, then machineType is required. If you specify this field, then deploymentUri is optional. If you specify this field, then you must not specify runtimeVersion, packageUris, framework, pythonVersion, or predictionClass.
    createTime String
    The time the version was created.
    deploymentUri String
    The Cloud Storage URI of a directory containing trained model artifacts to be used to create the model version. See the guide to deploying models for more information. The total number of files under this directory must not exceed 1000. During projects.models.versions.create, AI Platform Prediction copies all files from the specified directory to a location managed by the service. From then on, AI Platform Prediction uses these copies of the model artifacts to serve predictions, not the original files in Cloud Storage, so this location is useful only as a historical record. If you specify container, then this field is optional. Otherwise, it is required. Learn how to use this field with a custom container.
    description String
    Optional. The description specified for the version when it was created.
    errorMessage String
    The details of a failure or a cancellation.
    etag String
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetVersion, and systems are expected to put that etag in the request to UpdateVersion to ensure that their change will be applied to the model as intended.
    explanationConfig GoogleCloudMlV1__ExplanationConfigResponse
    Optional. Configures explainability features on the model's version. Some explanation features require additional metadata to be loaded as part of the model payload.
    framework String
    Optional. The machine learning framework AI Platform uses to train this version of the model. Valid values are TENSORFLOW, SCIKIT_LEARN, XGBOOST. If you do not specify a framework, AI Platform will analyze files in the deployment_uri to determine a framework. If you choose SCIKIT_LEARN or XGBOOST, you must also set the runtime version of the model to 1.4 or greater. Do not specify a framework if you're deploying a custom prediction routine or if you're using a custom container.
    isDefault Boolean
    If true, this version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.methods.versions.setDefault.
    labels Map<String,String>
    Optional. One or more labels that you can add, to organize your model versions. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    lastMigrationModelId String
    The AI Platform (Unified) Model ID for the last model migration.
    lastMigrationTime String
    The last time this version was successfully migrated to AI Platform (Unified).
    lastUseTime String
    The time the version was last used for prediction.
    machineType String
    Optional. The type of machine on which to serve the model. Currently only applies to online prediction service. To learn about valid values for this field, read Choosing a machine type for online prediction. If this field is not specified and you are using a regional endpoint, then the machine type defaults to n1-standard-2. If this field is not specified and you are using the global endpoint (ml.googleapis.com), then the machine type defaults to mls1-c1-m2.
    manualScaling GoogleCloudMlV1__ManualScalingResponse
    Manually select the number of nodes to use for serving the model. You should generally use auto_scaling with an appropriate min_nodes instead, but this option is available if you want more predictable billing. Beware that latency and error rates will increase if the traffic exceeds that capability of the system to serve it based on the selected number of nodes.
    name String
    The name specified for the version when it was created. The version name must be unique within the model it is created in.
    packageUris List<String>
    Optional. Cloud Storage paths (gs://…) of packages for custom prediction routines or scikit-learn pipelines with custom code. For a custom prediction routine, one of these packages must contain your Predictor class (see predictionClass). Additionally, include any dependencies used by your Predictor or scikit-learn pipeline uses that are not already included in your selected runtime version. If you specify this field, you must also set runtimeVersion to 1.4 or greater.
    predictionClass String
    Optional. The fully qualified name (module_name.class_name) of a class that implements the Predictor interface described in this reference field. The module containing this class should be included in a package provided to the packageUris field. Specify this field if and only if you are deploying a custom prediction routine (beta). If you specify this field, you must set runtimeVersion to 1.4 or greater and you must set machineType to a legacy (MLS1) machine type. The following code sample provides the Predictor interface: class Predictor(object): """Interface for constructing custom predictors.""" def predict(self, instances, **kwargs): """Performs custom prediction. Instances are the decoded values from the request. They have already been deserialized from JSON. Args: instances: A list of prediction input instances. **kwargs: A dictionary of keyword args provided as additional fields on the predict request body. Returns: A list of outputs containing the prediction results. This list must be JSON serializable. """ raise NotImplementedError() @classmethod def from_path(cls, model_dir): """Creates an instance of Predictor using the given path. Loading of the predictor should be done in this method. Args: model_dir: The local directory that contains the exported model file along with any additional files uploaded when creating the version resource. Returns: An instance implementing this Predictor class. """ raise NotImplementedError() Learn more about the Predictor interface and custom prediction routines.
    pythonVersion String
    The version of Python used in prediction. The following Python versions are available: * Python '3.7' is available when runtime_version is set to '1.15' or later. * Python '3.5' is available when runtime_version is set to a version from '1.4' to '1.14'. * Python '2.7' is available when runtime_version is set to '1.15' or earlier. Read more about the Python versions available for each runtime version.
    requestLoggingConfig GoogleCloudMlV1__RequestLoggingConfigResponse
    Optional. Only specify this field in a projects.models.versions.patch request. Specifying it in a projects.models.versions.create request has no effect. Configures the request-response pair logging on predictions from this Version.
    routes GoogleCloudMlV1__RouteMapResponse
    Optional. Specifies paths on a custom container's HTTP server where AI Platform Prediction sends certain requests. If you specify this field, then you must also specify the container field. If you specify the container field and do not specify this field, it defaults to the following: json { "predict": "/v1/models/MODEL/versions/VERSION:predict", "health": "/v1/models/MODEL/versions/VERSION" } See RouteMap for more details about these default values.
    runtimeVersion String
    The AI Platform runtime version to use for this deployment. For more information, see the runtime version list and how to manage runtime versions.
    serviceAccount String
    Optional. Specifies the service account for resource access control. If you specify this field, then you must also specify either the containerSpec or the predictionClass field. Learn more about using a custom service account.
    state String
    The state of a version.
    acceleratorConfig GoogleCloudMlV1__AcceleratorConfigResponse
    Optional. Accelerator config for using GPUs for online prediction (beta). Only specify this field if you have specified a Compute Engine (N1) machine type in the machineType field. Learn more about using GPUs for online prediction.
    autoScaling GoogleCloudMlV1__AutoScalingResponse
    Automatically scale the number of nodes used to serve the model in response to increases and decreases in traffic. Care should be taken to ramp up traffic according to the model's ability to scale or you will start seeing increases in latency and 429 response codes.
    container GoogleCloudMlV1__ContainerSpecResponse
    Optional. Specifies a custom container to use for serving predictions. If you specify this field, then machineType is required. If you specify this field, then deploymentUri is optional. If you specify this field, then you must not specify runtimeVersion, packageUris, framework, pythonVersion, or predictionClass.
    createTime string
    The time the version was created.
    deploymentUri string
    The Cloud Storage URI of a directory containing trained model artifacts to be used to create the model version. See the guide to deploying models for more information. The total number of files under this directory must not exceed 1000. During projects.models.versions.create, AI Platform Prediction copies all files from the specified directory to a location managed by the service. From then on, AI Platform Prediction uses these copies of the model artifacts to serve predictions, not the original files in Cloud Storage, so this location is useful only as a historical record. If you specify container, then this field is optional. Otherwise, it is required. Learn how to use this field with a custom container.
    description string
    Optional. The description specified for the version when it was created.
    errorMessage string
    The details of a failure or a cancellation.
    etag string
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetVersion, and systems are expected to put that etag in the request to UpdateVersion to ensure that their change will be applied to the model as intended.
    explanationConfig GoogleCloudMlV1__ExplanationConfigResponse
    Optional. Configures explainability features on the model's version. Some explanation features require additional metadata to be loaded as part of the model payload.
    framework string
    Optional. The machine learning framework AI Platform uses to train this version of the model. Valid values are TENSORFLOW, SCIKIT_LEARN, XGBOOST. If you do not specify a framework, AI Platform will analyze files in the deployment_uri to determine a framework. If you choose SCIKIT_LEARN or XGBOOST, you must also set the runtime version of the model to 1.4 or greater. Do not specify a framework if you're deploying a custom prediction routine or if you're using a custom container.
    isDefault boolean
    If true, this version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.methods.versions.setDefault.
    labels {[key: string]: string}
    Optional. One or more labels that you can add, to organize your model versions. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    lastMigrationModelId string
    The AI Platform (Unified) Model ID for the last model migration.
    lastMigrationTime string
    The last time this version was successfully migrated to AI Platform (Unified).
    lastUseTime string
    The time the version was last used for prediction.
    machineType string
    Optional. The type of machine on which to serve the model. Currently only applies to online prediction service. To learn about valid values for this field, read Choosing a machine type for online prediction. If this field is not specified and you are using a regional endpoint, then the machine type defaults to n1-standard-2. If this field is not specified and you are using the global endpoint (ml.googleapis.com), then the machine type defaults to mls1-c1-m2.
    manualScaling GoogleCloudMlV1__ManualScalingResponse
    Manually select the number of nodes to use for serving the model. You should generally use auto_scaling with an appropriate min_nodes instead, but this option is available if you want more predictable billing. Beware that latency and error rates will increase if the traffic exceeds that capability of the system to serve it based on the selected number of nodes.
    name string
    The name specified for the version when it was created. The version name must be unique within the model it is created in.
    packageUris string[]
    Optional. Cloud Storage paths (gs://…) of packages for custom prediction routines or scikit-learn pipelines with custom code. For a custom prediction routine, one of these packages must contain your Predictor class (see predictionClass). Additionally, include any dependencies used by your Predictor or scikit-learn pipeline uses that are not already included in your selected runtime version. If you specify this field, you must also set runtimeVersion to 1.4 or greater.
    predictionClass string
    Optional. The fully qualified name (module_name.class_name) of a class that implements the Predictor interface described in this reference field. The module containing this class should be included in a package provided to the packageUris field. Specify this field if and only if you are deploying a custom prediction routine (beta). If you specify this field, you must set runtimeVersion to 1.4 or greater and you must set machineType to a legacy (MLS1) machine type. The following code sample provides the Predictor interface: class Predictor(object): """Interface for constructing custom predictors.""" def predict(self, instances, **kwargs): """Performs custom prediction. Instances are the decoded values from the request. They have already been deserialized from JSON. Args: instances: A list of prediction input instances. **kwargs: A dictionary of keyword args provided as additional fields on the predict request body. Returns: A list of outputs containing the prediction results. This list must be JSON serializable. """ raise NotImplementedError() @classmethod def from_path(cls, model_dir): """Creates an instance of Predictor using the given path. Loading of the predictor should be done in this method. Args: model_dir: The local directory that contains the exported model file along with any additional files uploaded when creating the version resource. Returns: An instance implementing this Predictor class. """ raise NotImplementedError() Learn more about the Predictor interface and custom prediction routines.
    pythonVersion string
    The version of Python used in prediction. The following Python versions are available: * Python '3.7' is available when runtime_version is set to '1.15' or later. * Python '3.5' is available when runtime_version is set to a version from '1.4' to '1.14'. * Python '2.7' is available when runtime_version is set to '1.15' or earlier. Read more about the Python versions available for each runtime version.
    requestLoggingConfig GoogleCloudMlV1__RequestLoggingConfigResponse
    Optional. Only specify this field in a projects.models.versions.patch request. Specifying it in a projects.models.versions.create request has no effect. Configures the request-response pair logging on predictions from this Version.
    routes GoogleCloudMlV1__RouteMapResponse
    Optional. Specifies paths on a custom container's HTTP server where AI Platform Prediction sends certain requests. If you specify this field, then you must also specify the container field. If you specify the container field and do not specify this field, it defaults to the following: json { "predict": "/v1/models/MODEL/versions/VERSION:predict", "health": "/v1/models/MODEL/versions/VERSION" } See RouteMap for more details about these default values.
    runtimeVersion string
    The AI Platform runtime version to use for this deployment. For more information, see the runtime version list and how to manage runtime versions.
    serviceAccount string
    Optional. Specifies the service account for resource access control. If you specify this field, then you must also specify either the containerSpec or the predictionClass field. Learn more about using a custom service account.
    state string
    The state of a version.
    accelerator_config GoogleCloudMlV1AcceleratorConfigResponse
    Optional. Accelerator config for using GPUs for online prediction (beta). Only specify this field if you have specified a Compute Engine (N1) machine type in the machineType field. Learn more about using GPUs for online prediction.
    auto_scaling GoogleCloudMlV1AutoScalingResponse
    Automatically scale the number of nodes used to serve the model in response to increases and decreases in traffic. Care should be taken to ramp up traffic according to the model's ability to scale or you will start seeing increases in latency and 429 response codes.
    container GoogleCloudMlV1ContainerSpecResponse
    Optional. Specifies a custom container to use for serving predictions. If you specify this field, then machineType is required. If you specify this field, then deploymentUri is optional. If you specify this field, then you must not specify runtimeVersion, packageUris, framework, pythonVersion, or predictionClass.
    create_time str
    The time the version was created.
    deployment_uri str
    The Cloud Storage URI of a directory containing trained model artifacts to be used to create the model version. See the guide to deploying models for more information. The total number of files under this directory must not exceed 1000. During projects.models.versions.create, AI Platform Prediction copies all files from the specified directory to a location managed by the service. From then on, AI Platform Prediction uses these copies of the model artifacts to serve predictions, not the original files in Cloud Storage, so this location is useful only as a historical record. If you specify container, then this field is optional. Otherwise, it is required. Learn how to use this field with a custom container.
    description str
    Optional. The description specified for the version when it was created.
    error_message str
    The details of a failure or a cancellation.
    etag str
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetVersion, and systems are expected to put that etag in the request to UpdateVersion to ensure that their change will be applied to the model as intended.
    explanation_config GoogleCloudMlV1ExplanationConfigResponse
    Optional. Configures explainability features on the model's version. Some explanation features require additional metadata to be loaded as part of the model payload.
    framework str
    Optional. The machine learning framework AI Platform uses to train this version of the model. Valid values are TENSORFLOW, SCIKIT_LEARN, XGBOOST. If you do not specify a framework, AI Platform will analyze files in the deployment_uri to determine a framework. If you choose SCIKIT_LEARN or XGBOOST, you must also set the runtime version of the model to 1.4 or greater. Do not specify a framework if you're deploying a custom prediction routine or if you're using a custom container.
    is_default bool
    If true, this version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.methods.versions.setDefault.
    labels Mapping[str, str]
    Optional. One or more labels that you can add, to organize your model versions. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    last_migration_model_id str
    The AI Platform (Unified) Model ID for the last model migration.
    last_migration_time str
    The last time this version was successfully migrated to AI Platform (Unified).
    last_use_time str
    The time the version was last used for prediction.
    machine_type str
    Optional. The type of machine on which to serve the model. Currently only applies to online prediction service. To learn about valid values for this field, read Choosing a machine type for online prediction. If this field is not specified and you are using a regional endpoint, then the machine type defaults to n1-standard-2. If this field is not specified and you are using the global endpoint (ml.googleapis.com), then the machine type defaults to mls1-c1-m2.
    manual_scaling GoogleCloudMlV1ManualScalingResponse
    Manually select the number of nodes to use for serving the model. You should generally use auto_scaling with an appropriate min_nodes instead, but this option is available if you want more predictable billing. Beware that latency and error rates will increase if the traffic exceeds that capability of the system to serve it based on the selected number of nodes.
    name str
    The name specified for the version when it was created. The version name must be unique within the model it is created in.
    package_uris Sequence[str]
    Optional. Cloud Storage paths (gs://…) of packages for custom prediction routines or scikit-learn pipelines with custom code. For a custom prediction routine, one of these packages must contain your Predictor class (see predictionClass). Additionally, include any dependencies used by your Predictor or scikit-learn pipeline uses that are not already included in your selected runtime version. If you specify this field, you must also set runtimeVersion to 1.4 or greater.
    prediction_class str
    Optional. The fully qualified name (module_name.class_name) of a class that implements the Predictor interface described in this reference field. The module containing this class should be included in a package provided to the packageUris field. Specify this field if and only if you are deploying a custom prediction routine (beta). If you specify this field, you must set runtimeVersion to 1.4 or greater and you must set machineType to a legacy (MLS1) machine type. The following code sample provides the Predictor interface: class Predictor(object): """Interface for constructing custom predictors.""" def predict(self, instances, **kwargs): """Performs custom prediction. Instances are the decoded values from the request. They have already been deserialized from JSON. Args: instances: A list of prediction input instances. **kwargs: A dictionary of keyword args provided as additional fields on the predict request body. Returns: A list of outputs containing the prediction results. This list must be JSON serializable. """ raise NotImplementedError() @classmethod def from_path(cls, model_dir): """Creates an instance of Predictor using the given path. Loading of the predictor should be done in this method. Args: model_dir: The local directory that contains the exported model file along with any additional files uploaded when creating the version resource. Returns: An instance implementing this Predictor class. """ raise NotImplementedError() Learn more about the Predictor interface and custom prediction routines.
    python_version str
    The version of Python used in prediction. The following Python versions are available: * Python '3.7' is available when runtime_version is set to '1.15' or later. * Python '3.5' is available when runtime_version is set to a version from '1.4' to '1.14'. * Python '2.7' is available when runtime_version is set to '1.15' or earlier. Read more about the Python versions available for each runtime version.
    request_logging_config GoogleCloudMlV1RequestLoggingConfigResponse
    Optional. Only specify this field in a projects.models.versions.patch request. Specifying it in a projects.models.versions.create request has no effect. Configures the request-response pair logging on predictions from this Version.
    routes GoogleCloudMlV1RouteMapResponse
    Optional. Specifies paths on a custom container's HTTP server where AI Platform Prediction sends certain requests. If you specify this field, then you must also specify the container field. If you specify the container field and do not specify this field, it defaults to the following: json { "predict": "/v1/models/MODEL/versions/VERSION:predict", "health": "/v1/models/MODEL/versions/VERSION" } See RouteMap for more details about these default values.
    runtime_version str
    The AI Platform runtime version to use for this deployment. For more information, see the runtime version list and how to manage runtime versions.
    service_account str
    Optional. Specifies the service account for resource access control. If you specify this field, then you must also specify either the containerSpec or the predictionClass field. Learn more about using a custom service account.
    state str
    The state of a version.
    acceleratorConfig Property Map
    Optional. Accelerator config for using GPUs for online prediction (beta). Only specify this field if you have specified a Compute Engine (N1) machine type in the machineType field. Learn more about using GPUs for online prediction.
    autoScaling Property Map
    Automatically scale the number of nodes used to serve the model in response to increases and decreases in traffic. Care should be taken to ramp up traffic according to the model's ability to scale or you will start seeing increases in latency and 429 response codes.
    container Property Map
    Optional. Specifies a custom container to use for serving predictions. If you specify this field, then machineType is required. If you specify this field, then deploymentUri is optional. If you specify this field, then you must not specify runtimeVersion, packageUris, framework, pythonVersion, or predictionClass.
    createTime String
    The time the version was created.
    deploymentUri String
    The Cloud Storage URI of a directory containing trained model artifacts to be used to create the model version. See the guide to deploying models for more information. The total number of files under this directory must not exceed 1000. During projects.models.versions.create, AI Platform Prediction copies all files from the specified directory to a location managed by the service. From then on, AI Platform Prediction uses these copies of the model artifacts to serve predictions, not the original files in Cloud Storage, so this location is useful only as a historical record. If you specify container, then this field is optional. Otherwise, it is required. Learn how to use this field with a custom container.
    description String
    Optional. The description specified for the version when it was created.
    errorMessage String
    The details of a failure or a cancellation.
    etag String
    etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a model from overwriting each other. It is strongly suggested that systems make use of the etag in the read-modify-write cycle to perform model updates in order to avoid race conditions: An etag is returned in the response to GetVersion, and systems are expected to put that etag in the request to UpdateVersion to ensure that their change will be applied to the model as intended.
    explanationConfig Property Map
    Optional. Configures explainability features on the model's version. Some explanation features require additional metadata to be loaded as part of the model payload.
    framework String
    Optional. The machine learning framework AI Platform uses to train this version of the model. Valid values are TENSORFLOW, SCIKIT_LEARN, XGBOOST. If you do not specify a framework, AI Platform will analyze files in the deployment_uri to determine a framework. If you choose SCIKIT_LEARN or XGBOOST, you must also set the runtime version of the model to 1.4 or greater. Do not specify a framework if you're deploying a custom prediction routine or if you're using a custom container.
    isDefault Boolean
    If true, this version will be used to handle prediction requests that do not specify a version. You can change the default version by calling projects.methods.versions.setDefault.
    labels Map<String>
    Optional. One or more labels that you can add, to organize your model versions. Each label is a key-value pair, where both the key and the value are arbitrary strings that you supply. For more information, see the documentation on using labels. Note that this field is not updatable for mls1* models.
    lastMigrationModelId String
    The AI Platform (Unified) Model ID for the last model migration.
    lastMigrationTime String
    The last time this version was successfully migrated to AI Platform (Unified).
    lastUseTime String
    The time the version was last used for prediction.
    machineType String
    Optional. The type of machine on which to serve the model. Currently only applies to online prediction service. To learn about valid values for this field, read Choosing a machine type for online prediction. If this field is not specified and you are using a regional endpoint, then the machine type defaults to n1-standard-2. If this field is not specified and you are using the global endpoint (ml.googleapis.com), then the machine type defaults to mls1-c1-m2.
    manualScaling Property Map
    Manually select the number of nodes to use for serving the model. You should generally use auto_scaling with an appropriate min_nodes instead, but this option is available if you want more predictable billing. Beware that latency and error rates will increase if the traffic exceeds that capability of the system to serve it based on the selected number of nodes.
    name String
    The name specified for the version when it was created. The version name must be unique within the model it is created in.
    packageUris List<String>
    Optional. Cloud Storage paths (gs://…) of packages for custom prediction routines or scikit-learn pipelines with custom code. For a custom prediction routine, one of these packages must contain your Predictor class (see predictionClass). Additionally, include any dependencies used by your Predictor or scikit-learn pipeline uses that are not already included in your selected runtime version. If you specify this field, you must also set runtimeVersion to 1.4 or greater.
    predictionClass String
    Optional. The fully qualified name (module_name.class_name) of a class that implements the Predictor interface described in this reference field. The module containing this class should be included in a package provided to the packageUris field. Specify this field if and only if you are deploying a custom prediction routine (beta). If you specify this field, you must set runtimeVersion to 1.4 or greater and you must set machineType to a legacy (MLS1) machine type. The following code sample provides the Predictor interface: class Predictor(object): """Interface for constructing custom predictors.""" def predict(self, instances, **kwargs): """Performs custom prediction. Instances are the decoded values from the request. They have already been deserialized from JSON. Args: instances: A list of prediction input instances. **kwargs: A dictionary of keyword args provided as additional fields on the predict request body. Returns: A list of outputs containing the prediction results. This list must be JSON serializable. """ raise NotImplementedError() @classmethod def from_path(cls, model_dir): """Creates an instance of Predictor using the given path. Loading of the predictor should be done in this method. Args: model_dir: The local directory that contains the exported model file along with any additional files uploaded when creating the version resource. Returns: An instance implementing this Predictor class. """ raise NotImplementedError() Learn more about the Predictor interface and custom prediction routines.
    pythonVersion String
    The version of Python used in prediction. The following Python versions are available: * Python '3.7' is available when runtime_version is set to '1.15' or later. * Python '3.5' is available when runtime_version is set to a version from '1.4' to '1.14'. * Python '2.7' is available when runtime_version is set to '1.15' or earlier. Read more about the Python versions available for each runtime version.
    requestLoggingConfig Property Map
    Optional. Only specify this field in a projects.models.versions.patch request. Specifying it in a projects.models.versions.create request has no effect. Configures the request-response pair logging on predictions from this Version.
    routes Property Map
    Optional. Specifies paths on a custom container's HTTP server where AI Platform Prediction sends certain requests. If you specify this field, then you must also specify the container field. If you specify the container field and do not specify this field, it defaults to the following: json { "predict": "/v1/models/MODEL/versions/VERSION:predict", "health": "/v1/models/MODEL/versions/VERSION" } See RouteMap for more details about these default values.
    runtimeVersion String
    The AI Platform runtime version to use for this deployment. For more information, see the runtime version list and how to manage runtime versions.
    serviceAccount String
    Optional. Specifies the service account for resource access control. If you specify this field, then you must also specify either the containerSpec or the predictionClass field. Learn more about using a custom service account.
    state String
    The state of a version.

    GoogleCloudMlV1__XraiAttributionResponse, GoogleCloudMlV1__XraiAttributionResponseArgs

    NumIntegralSteps int
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    NumIntegralSteps int
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    numIntegralSteps Integer
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    numIntegralSteps number
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    num_integral_steps int
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.
    numIntegralSteps Number
    Number of steps for approximating the path integral. A good value to start is 50 and gradually increase until the sum to diff property is met within the desired error range.

    Package Details

    Repository
    Google Cloud Native pulumi/pulumi-google-native
    License
    Apache-2.0
    google-native logo

    Google Cloud Native is in preview. Google Cloud Classic is fully supported.

    Google Cloud Native v0.32.0 published on Wednesday, Nov 29, 2023 by Pulumi
    pulumi/pulumi-google-native