types

type Algorithm string

type BatchPrediction struct {

	// The ID of the DataSource that points to the group of observations to predict.
	BatchPredictionDataSourceId *string

	// The ID assigned to the BatchPrediction at creation. This value should be
	// identical to the value of the BatchPredictionID in the request.
	BatchPredictionId *string

	// Long integer type that is a 64-bit signed number.
	ComputeTime *int64

	// The time that the BatchPrediction was created. The time is expressed in epoch
	// time.
	CreatedAt *time.Time

	// The AWS user account that invoked the BatchPrediction . The account type can be
	// either an AWS root account or an AWS Identity and Access Management (IAM) user
	// account.
	CreatedByIamUser *string

	// A timestamp represented in epoch time.
	FinishedAt *time.Time

	// The location of the data file or directory in Amazon Simple Storage Service
	// (Amazon S3).
	InputDataLocationS3 *string

	// Long integer type that is a 64-bit signed number.
	InvalidRecordCount *int64

	// The time of the most recent edit to the BatchPrediction . The time is expressed
	// in epoch time.
	LastUpdatedAt *time.Time

	// The ID of the MLModel that generated predictions for the BatchPrediction
	// request.
	MLModelId *string

	// A description of the most recent details about processing the batch prediction
	// request.
	Message *string

	// A user-supplied name or description of the BatchPrediction .
	Name *string

	// The location of an Amazon S3 bucket or directory to receive the operation
	// results. The following substrings are not allowed in the s3 key portion of the
	// outputURI field: ':', '//', '/./', '/../'.
	OutputUri *string

	// A timestamp represented in epoch time.
	StartedAt *time.Time

	// The status of the BatchPrediction . This element can have one of the following
	// values:
	//   - PENDING - Amazon Machine Learning (Amazon ML) submitted a request to
	//   generate predictions for a batch of observations.
	//   - INPROGRESS - The process is underway.
	//   - FAILED - The request to perform a batch prediction did not run to
	//   completion. It is not usable.
	//   - COMPLETED - The batch prediction process completed successfully.
	//   - DELETED - The BatchPrediction is marked as deleted. It is not usable.
	Status EntityStatus

	// Long integer type that is a 64-bit signed number.
	TotalRecordCount *int64
	// contains filtered or unexported fields
}

type BatchPredictionFilterVariable string

type DataSource struct {

	// The parameter is true if statistics need to be generated from the observation
	// data.
	ComputeStatistics bool

	// Long integer type that is a 64-bit signed number.
	ComputeTime *int64

	// The time that the DataSource was created. The time is expressed in epoch time.
	CreatedAt *time.Time

	// The AWS user account from which the DataSource was created. The account type
	// can be either an AWS root account or an AWS Identity and Access Management (IAM)
	// user account.
	CreatedByIamUser *string

	// The location and name of the data in Amazon Simple Storage Service (Amazon S3)
	// that is used by a DataSource .
	DataLocationS3 *string

	// A JSON string that represents the splitting and rearrangement requirement used
	// when this DataSource was created.
	DataRearrangement *string

	// The total number of observations contained in the data files that the DataSource
	// references.
	DataSizeInBytes *int64

	// The ID that is assigned to the DataSource during creation.
	DataSourceId *string

	// A timestamp represented in epoch time.
	FinishedAt *time.Time

	// The time of the most recent edit to the BatchPrediction . The time is expressed
	// in epoch time.
	LastUpdatedAt *time.Time

	// A description of the most recent details about creating the DataSource .
	Message *string

	// A user-supplied name or description of the DataSource .
	Name *string

	// The number of data files referenced by the DataSource .
	NumberOfFiles *int64

	// The datasource details that are specific to Amazon RDS.
	RDSMetadata *RDSMetadata

	// Describes the DataSource details specific to Amazon Redshift.
	RedshiftMetadata *RedshiftMetadata

	// The Amazon Resource Name (ARN) of an AWS IAM Role (https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html#roles-about-termsandconcepts)
	// , such as the following: arn:aws:iam::account:role/rolename.
	RoleARN *string

	// A timestamp represented in epoch time.
	StartedAt *time.Time

	// The current status of the DataSource . This element can have one of the
	// following values:
	//   - PENDING - Amazon Machine Learning (Amazon ML) submitted a request to create
	//   a DataSource .
	//   - INPROGRESS - The creation process is underway.
	//   - FAILED - The request to create a DataSource did not run to completion. It is
	//   not usable.
	//   - COMPLETED - The creation process completed successfully.
	//   - DELETED - The DataSource is marked as deleted. It is not usable.
	Status EntityStatus
	// contains filtered or unexported fields
}

type DataSourceFilterVariable string

type DetailsAttributes string

type EntityStatus string

type Evaluation struct {

	// Long integer type that is a 64-bit signed number.
	ComputeTime *int64

	// The time that the Evaluation was created. The time is expressed in epoch time.
	CreatedAt *time.Time

	// The AWS user account that invoked the evaluation. The account type can be
	// either an AWS root account or an AWS Identity and Access Management (IAM) user
	// account.
	CreatedByIamUser *string

	// The ID of the DataSource that is used to evaluate the MLModel .
	EvaluationDataSourceId *string

	// The ID that is assigned to the Evaluation at creation.
	EvaluationId *string

	// A timestamp represented in epoch time.
	FinishedAt *time.Time

	// The location and name of the data in Amazon Simple Storage Server (Amazon S3)
	// that is used in the evaluation.
	InputDataLocationS3 *string

	// The time of the most recent edit to the Evaluation . The time is expressed in
	// epoch time.
	LastUpdatedAt *time.Time

	// The ID of the MLModel that is the focus of the evaluation.
	MLModelId *string

	// A description of the most recent details about evaluating the MLModel .
	Message *string

	// A user-supplied name or description of the Evaluation .
	Name *string

	// Measurements of how well the MLModel performed, using observations referenced
	// by the DataSource . One of the following metrics is returned, based on the type
	// of the MLModel :
	//   - BinaryAUC: A binary MLModel uses the Area Under the Curve (AUC) technique to
	//   measure performance.
	//   - RegressionRMSE: A regression MLModel uses the Root Mean Square Error (RMSE)
	//   technique to measure performance. RMSE measures the difference between predicted
	//   and actual values for a single variable.
	//   - MulticlassAvgFScore: A multiclass MLModel uses the F1 score technique to
	//   measure performance.
	// For more information about performance metrics, please see the Amazon Machine
	// Learning Developer Guide (https://docs.aws.amazon.com/machine-learning/latest/dg)
	// .
	PerformanceMetrics *PerformanceMetrics

	// A timestamp represented in epoch time.
	StartedAt *time.Time

	// The status of the evaluation. This element can have one of the following
	// values:
	//   - PENDING - Amazon Machine Learning (Amazon ML) submitted a request to
	//   evaluate an MLModel .
	//   - INPROGRESS - The evaluation is underway.
	//   - FAILED - The request to evaluate an MLModel did not run to completion. It is
	//   not usable.
	//   - COMPLETED - The evaluation process completed successfully.
	//   - DELETED - The Evaluation is marked as deleted. It is not usable.
	Status EntityStatus
	// contains filtered or unexported fields
}

type EvaluationFilterVariable string

type IdempotentParameterMismatchException struct {
	Message *string

	ErrorCodeOverride *string

	Code int32
	// contains filtered or unexported fields
}

type InternalServerException struct {
	Message *string

	ErrorCodeOverride *string

	Code int32
	// contains filtered or unexported fields
}

type InvalidInputException struct {
	Message *string

	ErrorCodeOverride *string

	Code int32
	// contains filtered or unexported fields
}

type InvalidTagException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type LimitExceededException struct {
	Message *string

	ErrorCodeOverride *string

	Code int32
	// contains filtered or unexported fields
}

type MLModel struct {

	// The algorithm used to train the MLModel . The following algorithm is supported:
	//   - SGD -- Stochastic gradient descent. The goal of SGD is to minimize the
	//   gradient of the loss function.
	Algorithm Algorithm

	// Long integer type that is a 64-bit signed number.
	ComputeTime *int64

	// The time that the MLModel was created. The time is expressed in epoch time.
	CreatedAt *time.Time

	// The AWS user account from which the MLModel was created. The account type can
	// be either an AWS root account or an AWS Identity and Access Management (IAM)
	// user account.
	CreatedByIamUser *string

	// The current endpoint of the MLModel .
	EndpointInfo *RealtimeEndpointInfo

	// A timestamp represented in epoch time.
	FinishedAt *time.Time

	// The location of the data file or directory in Amazon Simple Storage Service
	// (Amazon S3).
	InputDataLocationS3 *string

	// The time of the most recent edit to the MLModel . The time is expressed in epoch
	// time.
	LastUpdatedAt *time.Time

	// The ID assigned to the MLModel at creation.
	MLModelId *string

	// Identifies the MLModel category. The following are the available types:
	//   - REGRESSION - Produces a numeric result. For example, "What price should a
	//   house be listed at?"
	//   - BINARY - Produces one of two possible results. For example, "Is this a
	//   child-friendly web site?".
	//   - MULTICLASS - Produces one of several possible results. For example, "Is this
	//   a HIGH-, LOW-, or MEDIUM-risk trade?".
	MLModelType MLModelType

	// A description of the most recent details about accessing the MLModel .
	Message *string

	// A user-supplied name or description of the MLModel .
	Name *string

	ScoreThreshold *float32

	// The time of the most recent edit to the ScoreThreshold . The time is expressed
	// in epoch time.
	ScoreThresholdLastUpdatedAt *time.Time

	// Long integer type that is a 64-bit signed number.
	SizeInBytes *int64

	// A timestamp represented in epoch time.
	StartedAt *time.Time

	// The current status of an MLModel . This element can have one of the following
	// values:
	//   - PENDING - Amazon Machine Learning (Amazon ML) submitted a request to create
	//   an MLModel .
	//   - INPROGRESS - The creation process is underway.
	//   - FAILED - The request to create an MLModel didn't run to completion. The
	//   model isn't usable.
	//   - COMPLETED - The creation process completed successfully.
	//   - DELETED - The MLModel is marked as deleted. It isn't usable.
	Status EntityStatus

	// The ID of the training DataSource . The CreateMLModel operation uses the
	// TrainingDataSourceId .
	TrainingDataSourceId *string

	// A list of the training parameters in the MLModel . The list is implemented as a
	// map of key-value pairs. The following is the current set of training parameters:
	//
	//   - sgd.maxMLModelSizeInBytes - The maximum allowed size of the model. Depending
	//   on the input data, the size of the model might affect its performance. The value
	//   is an integer that ranges from 100000 to 2147483648 . The default value is
	//   33554432 .
	//   - sgd.maxPasses - The number of times that the training process traverses the
	//   observations to build the MLModel . The value is an integer that ranges from 1
	//   to 10000 . The default value is 10 .
	//   - sgd.shuffleType - Whether Amazon ML shuffles the training data. Shuffling
	//   the data improves a model's ability to find the optimal solution for a variety
	//   of data types. The valid values are auto and none . The default value is none
	//   .
	//   - sgd.l1RegularizationAmount - The coefficient regularization L1 norm, which
	//   controls overfitting the data by penalizing large coefficients. This parameter
	//   tends to drive coefficients to zero, resulting in sparse feature set. If you use
	//   this parameter, start by specifying a small value, such as 1.0E-08 . The value
	//   is a double that ranges from 0 to MAX_DOUBLE . The default is to not use L1
	//   normalization. This parameter can't be used when L2 is specified. Use this
	//   parameter sparingly.
	//   - sgd.l2RegularizationAmount - The coefficient regularization L2 norm, which
	//   controls overfitting the data by penalizing large coefficients. This tends to
	//   drive coefficients to small, nonzero values. If you use this parameter, start by
	//   specifying a small value, such as 1.0E-08 . The value is a double that ranges
	//   from 0 to MAX_DOUBLE . The default is to not use L2 normalization. This
	//   parameter can't be used when L1 is specified. Use this parameter sparingly.
	TrainingParameters map[string]string
	// contains filtered or unexported fields
}

type MLModelFilterVariable string

type MLModelType string

type PerformanceMetrics struct {
	Properties map[string]string
	// contains filtered or unexported fields
}

type Prediction struct {

	// Provides any additional details regarding the prediction.
	Details map[string]string

	// The prediction label for either a BINARY or MULTICLASS MLModel .
	PredictedLabel *string

	// Provides the raw classification score corresponding to each label.
	PredictedScores map[string]float32

	// The prediction value for REGRESSION MLModel .
	PredictedValue *float32
	// contains filtered or unexported fields
}

type PredictorNotMountedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type RDSDataSpec struct {

	// The AWS Identity and Access Management (IAM) credentials that are used connect
	// to the Amazon RDS database.
	//
	// This member is required.
	DatabaseCredentials *RDSDatabaseCredentials

	// Describes the DatabaseName and InstanceIdentifier of an Amazon RDS database.
	//
	// This member is required.
	DatabaseInformation *RDSDatabase

	// The role (DataPipelineDefaultResourceRole) assumed by an Amazon Elastic Compute
	// Cloud (Amazon EC2) instance to carry out the copy operation from Amazon RDS to
	// an Amazon S3 task. For more information, see Role templates (https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-iam-roles.html)
	// for data pipelines.
	//
	// This member is required.
	ResourceRole *string

	// The Amazon S3 location for staging Amazon RDS data. The data retrieved from
	// Amazon RDS using SelectSqlQuery is stored in this location.
	//
	// This member is required.
	S3StagingLocation *string

	// The security group IDs to be used to access a VPC-based RDS DB instance. Ensure
	// that there are appropriate ingress rules set up to allow access to the RDS DB
	// instance. This attribute is used by Data Pipeline to carry out the copy
	// operation from Amazon RDS to an Amazon S3 task.
	//
	// This member is required.
	SecurityGroupIds []string

	// The query that is used to retrieve the observation data for the DataSource .
	//
	// This member is required.
	SelectSqlQuery *string

	// The role (DataPipelineDefaultRole) assumed by AWS Data Pipeline service to
	// monitor the progress of the copy task from Amazon RDS to Amazon S3. For more
	// information, see Role templates (https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-iam-roles.html)
	// for data pipelines.
	//
	// This member is required.
	ServiceRole *string

	// The subnet ID to be used to access a VPC-based RDS DB instance. This attribute
	// is used by Data Pipeline to carry out the copy task from Amazon RDS to Amazon
	// S3.
	//
	// This member is required.
	SubnetId *string

	// A JSON string that represents the splitting and rearrangement processing to be
	// applied to a DataSource . If the DataRearrangement parameter is not provided,
	// all of the input data is used to create the Datasource . There are multiple
	// parameters that control what data is used to create a datasource:
	//   - percentBegin Use percentBegin to indicate the beginning of the range of the
	//   data used to create the Datasource. If you do not include percentBegin and
	//   percentEnd , Amazon ML includes all of the data when creating the datasource.
	//   - percentEnd Use percentEnd to indicate the end of the range of the data used
	//   to create the Datasource. If you do not include percentBegin and percentEnd ,
	//   Amazon ML includes all of the data when creating the datasource.
	//   - complement The complement parameter instructs Amazon ML to use the data that
	//   is not included in the range of percentBegin to percentEnd to create a
	//   datasource. The complement parameter is useful if you need to create
	//   complementary datasources for training and evaluation. To create a complementary
	//   datasource, use the same values for percentBegin and percentEnd , along with
	//   the complement parameter. For example, the following two datasources do not
	//   share any data, and can be used to train and evaluate a model. The first
	//   datasource has 25 percent of the data, and the second one has 75 percent of the
	//   data. Datasource for evaluation: {"splitting":{"percentBegin":0,
	//   "percentEnd":25}} Datasource for training: {"splitting":{"percentBegin":0,
	//   "percentEnd":25, "complement":"true"}}
	//   - strategy To change how Amazon ML splits the data for a datasource, use the
	//   strategy parameter. The default value for the strategy parameter is sequential
	//   , meaning that Amazon ML takes all of the data records between the
	//   percentBegin and percentEnd parameters for the datasource, in the order that
	//   the records appear in the input data. The following two DataRearrangement
	//   lines are examples of sequentially ordered training and evaluation datasources:
	//   Datasource for evaluation: {"splitting":{"percentBegin":70, "percentEnd":100,
	//   "strategy":"sequential"}} Datasource for training:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"sequential",
	//   "complement":"true"}} To randomly split the input data into the proportions
	//   indicated by the percentBegin and percentEnd parameters, set the strategy
	//   parameter to random and provide a string that is used as the seed value for
	//   the random data splitting (for example, you can use the S3 path to your data as
	//   the random seed string). If you choose the random split strategy, Amazon ML
	//   assigns each row of data a pseudo-random number between 0 and 100, and then
	//   selects the rows that have an assigned number between percentBegin and
	//   percentEnd . Pseudo-random numbers are assigned using both the input seed
	//   string value and the byte offset as a seed, so changing the data results in a
	//   different split. Any existing ordering is preserved. The random splitting
	//   strategy ensures that variables in the training and evaluation data are
	//   distributed similarly. It is useful in the cases where the input data may have
	//   an implicit sort order, which would otherwise result in training and evaluation
	//   datasources containing non-similar data records. The following two
	//   DataRearrangement lines are examples of non-sequentially ordered training and
	//   evaluation datasources: Datasource for evaluation:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"random",
	//   "randomSeed"="s3://my_s3_path/bucket/file.csv"}} Datasource for training:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"random",
	//   "randomSeed"="s3://my_s3_path/bucket/file.csv", "complement":"true"}}
	DataRearrangement *string

	// A JSON string that represents the schema for an Amazon RDS DataSource . The
	// DataSchema defines the structure of the observation data in the data file(s)
	// referenced in the DataSource . A DataSchema is not required if you specify a
	// DataSchemaUri Define your DataSchema as a series of key-value pairs. attributes
	// and excludedVariableNames have an array of key-value pairs for their value. Use
	// the following format to define your DataSchema . { "version": "1.0",
	// "recordAnnotationFieldName": "F1", "recordWeightFieldName": "F2",
	// "targetFieldName": "F3", "dataFormat": "CSV", "dataFileContainsHeader": true,
	// "attributes": [ { "fieldName": "F1", "fieldType": "TEXT" }, { "fieldName": "F2",
	// "fieldType": "NUMERIC" }, { "fieldName": "F3", "fieldType": "CATEGORICAL" }, {
	// "fieldName": "F4", "fieldType": "NUMERIC" }, { "fieldName": "F5", "fieldType":
	// "CATEGORICAL" }, { "fieldName": "F6", "fieldType": "TEXT" }, { "fieldName":
	// "F7", "fieldType": "WEIGHTED_INT_SEQUENCE" }, { "fieldName": "F8", "fieldType":
	// "WEIGHTED_STRING_SEQUENCE" } ], "excludedVariableNames": [ "F6" ] }
	DataSchema *string

	// The Amazon S3 location of the DataSchema .
	DataSchemaUri *string
	// contains filtered or unexported fields
}

type RDSDatabase struct {

	// The name of a database hosted on an RDS DB instance.
	//
	// This member is required.
	DatabaseName *string

	// The ID of an RDS DB instance.
	//
	// This member is required.
	InstanceIdentifier *string
	// contains filtered or unexported fields
}

type RDSDatabaseCredentials struct {

	// The password to be used by Amazon ML to connect to a database on an RDS DB
	// instance. The password should have sufficient permissions to execute the
	// RDSSelectQuery query.
	//
	// This member is required.
	Password *string

	// The username to be used by Amazon ML to connect to database on an Amazon RDS
	// instance. The username should have sufficient permissions to execute an
	// RDSSelectSqlQuery query.
	//
	// This member is required.
	Username *string
	// contains filtered or unexported fields
}

type RDSMetadata struct {

	// The ID of the Data Pipeline instance that is used to carry to copy data from
	// Amazon RDS to Amazon S3. You can use the ID to find details about the instance
	// in the Data Pipeline console.
	DataPipelineId *string

	// The database details required to connect to an Amazon RDS.
	Database *RDSDatabase

	// The username to be used by Amazon ML to connect to database on an Amazon RDS
	// instance. The username should have sufficient permissions to execute an
	// RDSSelectSqlQuery query.
	DatabaseUserName *string

	// The role (DataPipelineDefaultResourceRole) assumed by an Amazon EC2 instance to
	// carry out the copy task from Amazon RDS to Amazon S3. For more information, see
	// Role templates (https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-iam-roles.html)
	// for data pipelines.
	ResourceRole *string

	// The SQL query that is supplied during CreateDataSourceFromRDS . Returns only if
	// Verbose is true in GetDataSourceInput .
	SelectSqlQuery *string

	// The role (DataPipelineDefaultRole) assumed by the Data Pipeline service to
	// monitor the progress of the copy task from Amazon RDS to Amazon S3. For more
	// information, see Role templates (https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-iam-roles.html)
	// for data pipelines.
	ServiceRole *string
	// contains filtered or unexported fields
}

type RealtimeEndpointInfo struct {

	// The time that the request to create the real-time endpoint for the MLModel was
	// received. The time is expressed in epoch time.
	CreatedAt *time.Time

	// The current status of the real-time endpoint for the MLModel . This element can
	// have one of the following values:
	//   - NONE - Endpoint does not exist or was previously deleted.
	//   - READY - Endpoint is ready to be used for real-time predictions.
	//   - UPDATING - Updating/creating the endpoint.
	EndpointStatus RealtimeEndpointStatus

	// The URI that specifies where to send real-time prediction requests for the
	// MLModel . Note: The application must wait until the real-time endpoint is ready
	// before using this URI.
	EndpointUrl *string

	// The maximum processing rate for the real-time endpoint for MLModel , measured in
	// incoming requests per second.
	PeakRequestsPerSecond int32
	// contains filtered or unexported fields
}

type RealtimeEndpointStatus string

type RedshiftDataSpec struct {

	// Describes AWS Identity and Access Management (IAM) credentials that are used
	// connect to the Amazon Redshift database.
	//
	// This member is required.
	DatabaseCredentials *RedshiftDatabaseCredentials

	// Describes the DatabaseName and ClusterIdentifier for an Amazon Redshift
	// DataSource .
	//
	// This member is required.
	DatabaseInformation *RedshiftDatabase

	// Describes an Amazon S3 location to store the result set of the SelectSqlQuery
	// query.
	//
	// This member is required.
	S3StagingLocation *string

	// Describes the SQL Query to execute on an Amazon Redshift database for an Amazon
	// Redshift DataSource .
	//
	// This member is required.
	SelectSqlQuery *string

	// A JSON string that represents the splitting and rearrangement processing to be
	// applied to a DataSource . If the DataRearrangement parameter is not provided,
	// all of the input data is used to create the Datasource . There are multiple
	// parameters that control what data is used to create a datasource:
	//   - percentBegin Use percentBegin to indicate the beginning of the range of the
	//   data used to create the Datasource. If you do not include percentBegin and
	//   percentEnd , Amazon ML includes all of the data when creating the datasource.
	//   - percentEnd Use percentEnd to indicate the end of the range of the data used
	//   to create the Datasource. If you do not include percentBegin and percentEnd ,
	//   Amazon ML includes all of the data when creating the datasource.
	//   - complement The complement parameter instructs Amazon ML to use the data that
	//   is not included in the range of percentBegin to percentEnd to create a
	//   datasource. The complement parameter is useful if you need to create
	//   complementary datasources for training and evaluation. To create a complementary
	//   datasource, use the same values for percentBegin and percentEnd , along with
	//   the complement parameter. For example, the following two datasources do not
	//   share any data, and can be used to train and evaluate a model. The first
	//   datasource has 25 percent of the data, and the second one has 75 percent of the
	//   data. Datasource for evaluation: {"splitting":{"percentBegin":0,
	//   "percentEnd":25}} Datasource for training: {"splitting":{"percentBegin":0,
	//   "percentEnd":25, "complement":"true"}}
	//   - strategy To change how Amazon ML splits the data for a datasource, use the
	//   strategy parameter. The default value for the strategy parameter is sequential
	//   , meaning that Amazon ML takes all of the data records between the
	//   percentBegin and percentEnd parameters for the datasource, in the order that
	//   the records appear in the input data. The following two DataRearrangement
	//   lines are examples of sequentially ordered training and evaluation datasources:
	//   Datasource for evaluation: {"splitting":{"percentBegin":70, "percentEnd":100,
	//   "strategy":"sequential"}} Datasource for training:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"sequential",
	//   "complement":"true"}} To randomly split the input data into the proportions
	//   indicated by the percentBegin and percentEnd parameters, set the strategy
	//   parameter to random and provide a string that is used as the seed value for
	//   the random data splitting (for example, you can use the S3 path to your data as
	//   the random seed string). If you choose the random split strategy, Amazon ML
	//   assigns each row of data a pseudo-random number between 0 and 100, and then
	//   selects the rows that have an assigned number between percentBegin and
	//   percentEnd . Pseudo-random numbers are assigned using both the input seed
	//   string value and the byte offset as a seed, so changing the data results in a
	//   different split. Any existing ordering is preserved. The random splitting
	//   strategy ensures that variables in the training and evaluation data are
	//   distributed similarly. It is useful in the cases where the input data may have
	//   an implicit sort order, which would otherwise result in training and evaluation
	//   datasources containing non-similar data records. The following two
	//   DataRearrangement lines are examples of non-sequentially ordered training and
	//   evaluation datasources: Datasource for evaluation:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"random",
	//   "randomSeed"="s3://my_s3_path/bucket/file.csv"}} Datasource for training:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"random",
	//   "randomSeed"="s3://my_s3_path/bucket/file.csv", "complement":"true"}}
	DataRearrangement *string

	// A JSON string that represents the schema for an Amazon Redshift DataSource . The
	// DataSchema defines the structure of the observation data in the data file(s)
	// referenced in the DataSource . A DataSchema is not required if you specify a
	// DataSchemaUri . Define your DataSchema as a series of key-value pairs.
	// attributes and excludedVariableNames have an array of key-value pairs for their
	// value. Use the following format to define your DataSchema . { "version": "1.0",
	// "recordAnnotationFieldName": "F1", "recordWeightFieldName": "F2",
	// "targetFieldName": "F3", "dataFormat": "CSV", "dataFileContainsHeader": true,
	// "attributes": [ { "fieldName": "F1", "fieldType": "TEXT" }, { "fieldName": "F2",
	// "fieldType": "NUMERIC" }, { "fieldName": "F3", "fieldType": "CATEGORICAL" }, {
	// "fieldName": "F4", "fieldType": "NUMERIC" }, { "fieldName": "F5", "fieldType":
	// "CATEGORICAL" }, { "fieldName": "F6", "fieldType": "TEXT" }, { "fieldName":
	// "F7", "fieldType": "WEIGHTED_INT_SEQUENCE" }, { "fieldName": "F8", "fieldType":
	// "WEIGHTED_STRING_SEQUENCE" } ], "excludedVariableNames": [ "F6" ] }
	DataSchema *string

	// Describes the schema location for an Amazon Redshift DataSource .
	DataSchemaUri *string
	// contains filtered or unexported fields
}

type RedshiftDatabase struct {

	// The ID of an Amazon Redshift cluster.
	//
	// This member is required.
	ClusterIdentifier *string

	// The name of a database hosted on an Amazon Redshift cluster.
	//
	// This member is required.
	DatabaseName *string
	// contains filtered or unexported fields
}

type RedshiftDatabaseCredentials struct {

	// A password to be used by Amazon ML to connect to a database on an Amazon
	// Redshift cluster. The password should have sufficient permissions to execute a
	// RedshiftSelectSqlQuery query. The password should be valid for an Amazon
	// Redshift USER (https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html)
	// .
	//
	// This member is required.
	Password *string

	// A username to be used by Amazon Machine Learning (Amazon ML)to connect to a
	// database on an Amazon Redshift cluster. The username should have sufficient
	// permissions to execute the RedshiftSelectSqlQuery query. The username should be
	// valid for an Amazon Redshift USER (https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html)
	// .
	//
	// This member is required.
	Username *string
	// contains filtered or unexported fields
}

type RedshiftMetadata struct {

	// A username to be used by Amazon Machine Learning (Amazon ML)to connect to a
	// database on an Amazon Redshift cluster. The username should have sufficient
	// permissions to execute the RedshiftSelectSqlQuery query. The username should be
	// valid for an Amazon Redshift USER (https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html)
	// .
	DatabaseUserName *string

	// Describes the database details required to connect to an Amazon Redshift
	// database.
	RedshiftDatabase *RedshiftDatabase

	// The SQL query that is specified during CreateDataSourceFromRedshift . Returns
	// only if Verbose is true in GetDataSourceInput.
	SelectSqlQuery *string
	// contains filtered or unexported fields
}

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string

	Code int32
	// contains filtered or unexported fields
}

type S3DataSpec struct {

	// The location of the data file(s) used by a DataSource . The URI specifies a data
	// file or an Amazon Simple Storage Service (Amazon S3) directory or bucket
	// containing data files.
	//
	// This member is required.
	DataLocationS3 *string

	// A JSON string that represents the splitting and rearrangement processing to be
	// applied to a DataSource . If the DataRearrangement parameter is not provided,
	// all of the input data is used to create the Datasource . There are multiple
	// parameters that control what data is used to create a datasource:
	//   - percentBegin Use percentBegin to indicate the beginning of the range of the
	//   data used to create the Datasource. If you do not include percentBegin and
	//   percentEnd , Amazon ML includes all of the data when creating the datasource.
	//   - percentEnd Use percentEnd to indicate the end of the range of the data used
	//   to create the Datasource. If you do not include percentBegin and percentEnd ,
	//   Amazon ML includes all of the data when creating the datasource.
	//   - complement The complement parameter instructs Amazon ML to use the data that
	//   is not included in the range of percentBegin to percentEnd to create a
	//   datasource. The complement parameter is useful if you need to create
	//   complementary datasources for training and evaluation. To create a complementary
	//   datasource, use the same values for percentBegin and percentEnd , along with
	//   the complement parameter. For example, the following two datasources do not
	//   share any data, and can be used to train and evaluate a model. The first
	//   datasource has 25 percent of the data, and the second one has 75 percent of the
	//   data. Datasource for evaluation: {"splitting":{"percentBegin":0,
	//   "percentEnd":25}} Datasource for training: {"splitting":{"percentBegin":0,
	//   "percentEnd":25, "complement":"true"}}
	//   - strategy To change how Amazon ML splits the data for a datasource, use the
	//   strategy parameter. The default value for the strategy parameter is sequential
	//   , meaning that Amazon ML takes all of the data records between the
	//   percentBegin and percentEnd parameters for the datasource, in the order that
	//   the records appear in the input data. The following two DataRearrangement
	//   lines are examples of sequentially ordered training and evaluation datasources:
	//   Datasource for evaluation: {"splitting":{"percentBegin":70, "percentEnd":100,
	//   "strategy":"sequential"}} Datasource for training:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"sequential",
	//   "complement":"true"}} To randomly split the input data into the proportions
	//   indicated by the percentBegin and percentEnd parameters, set the strategy
	//   parameter to random and provide a string that is used as the seed value for
	//   the random data splitting (for example, you can use the S3 path to your data as
	//   the random seed string). If you choose the random split strategy, Amazon ML
	//   assigns each row of data a pseudo-random number between 0 and 100, and then
	//   selects the rows that have an assigned number between percentBegin and
	//   percentEnd . Pseudo-random numbers are assigned using both the input seed
	//   string value and the byte offset as a seed, so changing the data results in a
	//   different split. Any existing ordering is preserved. The random splitting
	//   strategy ensures that variables in the training and evaluation data are
	//   distributed similarly. It is useful in the cases where the input data may have
	//   an implicit sort order, which would otherwise result in training and evaluation
	//   datasources containing non-similar data records. The following two
	//   DataRearrangement lines are examples of non-sequentially ordered training and
	//   evaluation datasources: Datasource for evaluation:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"random",
	//   "randomSeed"="s3://my_s3_path/bucket/file.csv"}} Datasource for training:
	//   {"splitting":{"percentBegin":70, "percentEnd":100, "strategy":"random",
	//   "randomSeed"="s3://my_s3_path/bucket/file.csv", "complement":"true"}}
	DataRearrangement *string

	// A JSON string that represents the schema for an Amazon S3 DataSource . The
	// DataSchema defines the structure of the observation data in the data file(s)
	// referenced in the DataSource . You must provide either the DataSchema or the
	// DataSchemaLocationS3 . Define your DataSchema as a series of key-value pairs.
	// attributes and excludedVariableNames have an array of key-value pairs for their
	// value. Use the following format to define your DataSchema . { "version": "1.0",
	// "recordAnnotationFieldName": "F1", "recordWeightFieldName": "F2",
	// "targetFieldName": "F3", "dataFormat": "CSV", "dataFileContainsHeader": true,
	// "attributes": [ { "fieldName": "F1", "fieldType": "TEXT" }, { "fieldName": "F2",
	// "fieldType": "NUMERIC" }, { "fieldName": "F3", "fieldType": "CATEGORICAL" }, {
	// "fieldName": "F4", "fieldType": "NUMERIC" }, { "fieldName": "F5", "fieldType":
	// "CATEGORICAL" }, { "fieldName": "F6", "fieldType": "TEXT" }, { "fieldName":
	// "F7", "fieldType": "WEIGHTED_INT_SEQUENCE" }, { "fieldName": "F8", "fieldType":
	// "WEIGHTED_STRING_SEQUENCE" } ], "excludedVariableNames": [ "F6" ] }
	DataSchema *string

	// Describes the schema location in Amazon S3. You must provide either the
	// DataSchema or the DataSchemaLocationS3 .
	DataSchemaLocationS3 *string
	// contains filtered or unexported fields
}

type SortOrder string

type Tag struct {

	// A unique identifier for the tag. Valid characters include Unicode letters,
	// digits, white space, _, ., /, =, +, -, %, and @.
	Key *string

	// An optional string, typically used to describe or define the tag. Valid
	// characters include Unicode letters, digits, white space, _, ., /, =, +, -, %,
	// and @.
	Value *string
	// contains filtered or unexported fields
}

type TagLimitExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type TaggableResourceType string