Module aws_sdk_machinelearning::types

source ·
Expand description

Data structures used by operation inputs/outputs.

Modules§

  • builders
    Builders
  • error
    Error types that Amazon Machine Learning can respond with.

Structs§

  • BatchPrediction

    Represents the output of a GetBatchPrediction operation.

  • DataSource

    Represents the output of the GetDataSource operation.

  • Evaluation

    Represents the output of GetEvaluation operation.

  • MlModel

    Represents the output of a GetMLModel operation.

  • PerformanceMetrics

    Measurements of how well the MLModel performed on known observations. One of the following metrics is returned, based on the type of the MLModel:

  • Prediction

    The output from a Predict operation:

  • RdsDataSpec

    The data specification of an Amazon Relational Database Service (Amazon RDS) DataSource.

  • RdsDatabase

    The database details of an Amazon RDS database.

  • RdsDatabaseCredentials

    The database credentials to connect to a database on an RDS DB instance.

  • RdsMetadata

    The datasource details that are specific to Amazon RDS.

  • RealtimeEndpointInfo

    Describes the real-time endpoint information for an MLModel.

  • RedshiftDataSpec

    Describes the data specification of an Amazon Redshift DataSource.

  • RedshiftDatabase

    Describes the database details required to connect to an Amazon Redshift database.

  • RedshiftDatabaseCredentials

    Describes the database credentials for connecting to a database on an Amazon Redshift cluster.

  • RedshiftMetadata

    Describes the DataSource details specific to Amazon Redshift.

  • S3DataSpec

    Describes the data specification of a DataSource.

  • Tag

    A custom key-value pair associated with an ML object, such as an ML model.

Enums§

  • Algorithm
    When writing a match expression against Algorithm, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • BatchPredictionFilterVariable
    When writing a match expression against BatchPredictionFilterVariable, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DataSourceFilterVariable
    When writing a match expression against DataSourceFilterVariable, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • DetailsAttributes
    When writing a match expression against DetailsAttributes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • EntityStatus
    When writing a match expression against EntityStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • EvaluationFilterVariable
    When writing a match expression against EvaluationFilterVariable, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • MlModelFilterVariable
    When writing a match expression against MlModelFilterVariable, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • MlModelType
    When writing a match expression against MlModelType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • RealtimeEndpointStatus
    When writing a match expression against RealtimeEndpointStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • SortOrder
    When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
  • TaggableResourceType
    When writing a match expression against TaggableResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.