forecast

package
v0.24.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 22, 2020 License: Apache-2.0 Imports: 9 Imported by: 4

Documentation

Overview

Package forecast provides the client and types for making API requests to Amazon Forecast Service.

Provides APIs for creating and managing Amazon Forecast resources.

See https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26 for more information on this service.

See forecast package documentation for more information. https://docs.aws.amazon.com/sdk-for-go/api/service/forecast/

Using the Client

To use Amazon Forecast Service with the SDK use the New function to create a new service client. With that client you can make API requests to the service. These clients are safe to use concurrently.

See the SDK's documentation for more information on how to use the SDK. https://docs.aws.amazon.com/sdk-for-go/api/

See aws.Config documentation for more information on configuring SDK clients. https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config

See the Amazon Forecast Service client for more information on creating client for this service. https://docs.aws.amazon.com/sdk-for-go/api/service/forecast/#New

Index

Constants

View Source 
const (
	ServiceName = "Amazon Forecast Service" // Service's name
	ServiceID   = "Forecast"                // Service's identifier
	EndpointsID = "forecast"                // Service's Endpoint identifier
)
View Source 
const (

	// ErrCodeInvalidInputException for service response error code
	// "InvalidInputException".
	//
	// We can't process the request because it includes an invalid value or a value
	// that exceeds the valid range.
	ErrCodeInvalidInputException = "InvalidInputException"

	// ErrCodeInvalidNextTokenException for service response error code
	// "InvalidNextTokenException".
	//
	// The token is not valid. Tokens expire after 24 hours.
	ErrCodeInvalidNextTokenException = "InvalidNextTokenException"

	// ErrCodeLimitExceededException for service response error code
	// "LimitExceededException".
	//
	// The limit on the number of resources per account has been exceeded.
	ErrCodeLimitExceededException = "LimitExceededException"

	// ErrCodeResourceAlreadyExistsException for service response error code
	// "ResourceAlreadyExistsException".
	//
	// There is already a resource with this name. Try again with a different name.
	ErrCodeResourceAlreadyExistsException = "ResourceAlreadyExistsException"

	// ErrCodeResourceInUseException for service response error code
	// "ResourceInUseException".
	//
	// The specified resource is in use.
	ErrCodeResourceInUseException = "ResourceInUseException"

	// ErrCodeResourceNotFoundException for service response error code
	// "ResourceNotFoundException".
	//
	// We can't find a resource with that Amazon Resource Name (ARN). Check the
	// ARN and try again.
	ErrCodeResourceNotFoundException = "ResourceNotFoundException"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AttributeType 

type AttributeType string
const (
	AttributeTypeString    AttributeType = "string"
	AttributeTypeInteger   AttributeType = "integer"
	AttributeTypeFloat     AttributeType = "float"
	AttributeTypeTimestamp AttributeType = "timestamp"
)

Enum values for AttributeType

func (AttributeType) MarshalValue 

func (enum AttributeType) MarshalValue() (string, error)

func (AttributeType) MarshalValueBuf 

func (enum AttributeType) MarshalValueBuf(b []byte) ([]byte, error)

type CategoricalParameterRange 

type CategoricalParameterRange struct {

	// The name of the categorical hyperparameter to tune.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// A list of the tunable categories for the hyperparameter.
	//
	// Values is a required field
	Values []string `min:"1" type:"list" required:"true"`
	// contains filtered or unexported fields
}

Specifies a categorical hyperparameter and it's range of tunable values. This object is part of the ParameterRanges object.

func (CategoricalParameterRange) String 

func (s CategoricalParameterRange) String() string

String returns the string representation

func (*CategoricalParameterRange) Validate 

func (s *CategoricalParameterRange) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type Client 

type Client struct {
	*aws.Client
}

Client provides the API operation methods for making requests to Amazon Forecast Service. See this package's package overview docs for details on the service.

The client's methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func New 

func New(config aws.Config) *Client

New creates a new instance of the client from the provided Config.

Example: 

// Create a client from just a config.
svc := forecast.New(myConfig)

func (*Client) CreateDatasetGroupRequest 

func (c *Client) CreateDatasetGroupRequest(input *CreateDatasetGroupInput) CreateDatasetGroupRequest

CreateDatasetGroupRequest returns a request value for making API operation for Amazon Forecast Service.

Creates a dataset group, which holds a collection of related datasets. You can add datasets to the dataset group when you create the dataset group, or later by using the UpdateDatasetGroup operation.

After creating a dataset group and adding datasets, you use the dataset group when you create a predictor. For more information, see howitworks-datasets-groups.

To get a list of all your datasets groups, use the ListDatasetGroups operation.

The Status of a dataset group must be ACTIVE before you can create use the dataset group to create a predictor. To get the status, use the DescribeDatasetGroup operation. 

// Example sending a request using CreateDatasetGroupRequest.
req := client.CreateDatasetGroupRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateDatasetGroup

func (*Client) CreateDatasetImportJobRequest 

func (c *Client) CreateDatasetImportJobRequest(input *CreateDatasetImportJobInput) CreateDatasetImportJobRequest

CreateDatasetImportJobRequest returns a request value for making API operation for Amazon Forecast Service.

Imports your training data to an Amazon Forecast dataset. You provide the location of your training data in an Amazon Simple Storage Service (Amazon S3) bucket and the Amazon Resource Name (ARN) of the dataset that you want to import the data to.

You must specify a DataSource object that includes an AWS Identity and Access Management (IAM) role that Amazon Forecast can assume to access the data, as Amazon Forecast makes a copy of your data and processes it in an internal AWS system. For more information, see aws-forecast-iam-roles.

The training data must be in CSV format. The delimiter must be a comma (,).

You can specify the path to a specific CSV file, the S3 bucket, or to a folder in the S3 bucket. For the latter two cases, Amazon Forecast imports all files up to the limit of 10,000 files.

Because dataset imports are not aggregated, your most recent dataset import is the one that is used when training a predictor or generating a forecast. Make sure that your most recent dataset import contains all of the data you want to model off of, and not just the new data collected since the previous import.

To get a list of all your dataset import jobs, filtered by specified criteria, use the ListDatasetImportJobs operation. 

// Example sending a request using CreateDatasetImportJobRequest.
req := client.CreateDatasetImportJobRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateDatasetImportJob

func (*Client) CreateDatasetRequest 

func (c *Client) CreateDatasetRequest(input *CreateDatasetInput) CreateDatasetRequest

CreateDatasetRequest returns a request value for making API operation for Amazon Forecast Service.

Creates an Amazon Forecast dataset. The information about the dataset that you provide helps Forecast understand how to consume the data for model training. This includes the following:

  • DataFrequency - How frequently your historical time-series data is collected.

  • Domain and DatasetType - Each dataset has an associated dataset domain and a type within the domain. Amazon Forecast provides a list of predefined domains and types within each domain. For each unique dataset domain and type within the domain, Amazon Forecast requires your data to include a minimum set of predefined fields.

  • Schema - A schema specifies the fields in the dataset, including the field name and data type.

After creating a dataset, you import your training data into it and add the dataset to a dataset group. You use the dataset group to create a predictor. For more information, see howitworks-datasets-groups.

To get a list of all your datasets, use the ListDatasets operation.

For example Forecast datasets, see the Amazon Forecast Sample GitHub repository (https://github.com/aws-samples/amazon-forecast-samples).

The Status of a dataset must be ACTIVE before you can import training data. Use the DescribeDataset operation to get the status. 

// Example sending a request using CreateDatasetRequest.
req := client.CreateDatasetRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateDataset

func (*Client) CreateForecastExportJobRequest 

func (c *Client) CreateForecastExportJobRequest(input *CreateForecastExportJobInput) CreateForecastExportJobRequest

CreateForecastExportJobRequest returns a request value for making API operation for Amazon Forecast Service.

Exports a forecast created by the CreateForecast operation to your Amazon Simple Storage Service (Amazon S3) bucket. The forecast file name will match the following conventions:

<ForecastExportJobName>_<ExportTimestamp>_<PartNumber>

where the <ExportTimestamp> component is in Java SimpleDateFormat (yyyy-MM-ddTHH-mm-ssZ).

You must specify a DataDestination object that includes an AWS Identity and Access Management (IAM) role that Amazon Forecast can assume to access the Amazon S3 bucket. For more information, see aws-forecast-iam-roles.

For more information, see howitworks-forecast.

To get a list of all your forecast export jobs, use the ListForecastExportJobs operation.

The Status of the forecast export job must be ACTIVE before you can access the forecast in your Amazon S3 bucket. To get the status, use the DescribeForecastExportJob operation. 

// Example sending a request using CreateForecastExportJobRequest.
req := client.CreateForecastExportJobRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateForecastExportJob

func (*Client) CreateForecastRequest 

func (c *Client) CreateForecastRequest(input *CreateForecastInput) CreateForecastRequest

CreateForecastRequest returns a request value for making API operation for Amazon Forecast Service.

Creates a forecast for each item in the TARGET_TIME_SERIES dataset that was used to train the predictor. This is known as inference. To retrieve the forecast for a single item at low latency, use the operation. To export the complete forecast into your Amazon Simple Storage Service (Amazon S3) bucket, use the CreateForecastExportJob operation.

The range of the forecast is determined by the ForecastHorizon value, which you specify in the CreatePredictor request. When you query a forecast, you can request a specific date range within the forecast.

To get a list of all your forecasts, use the ListForecasts operation.

The forecasts generated by Amazon Forecast are in the same time zone as the dataset that was used to create the predictor.

For more information, see howitworks-forecast.

The Status of the forecast must be ACTIVE before you can query or export the forecast. Use the DescribeForecast operation to get the status. 

// Example sending a request using CreateForecastRequest.
req := client.CreateForecastRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreateForecast

func (*Client) CreatePredictorRequest 

func (c *Client) CreatePredictorRequest(input *CreatePredictorInput) CreatePredictorRequest

CreatePredictorRequest returns a request value for making API operation for Amazon Forecast Service.

Creates an Amazon Forecast predictor.

In the request, you provide a dataset group and either specify an algorithm or let Amazon Forecast choose the algorithm for you using AutoML. If you specify an algorithm, you also can override algorithm-specific hyperparameters.

Amazon Forecast uses the chosen algorithm to train a model using the latest version of the datasets in the specified dataset group. The result is called a predictor. You then generate a forecast using the CreateForecast operation.

After training a model, the CreatePredictor operation also evaluates it. To see the evaluation metrics, use the GetAccuracyMetrics operation. Always review the evaluation metrics before deciding to use the predictor to generate a forecast.

Optionally, you can specify a featurization configuration to fill and aggregate the data fields in the TARGET_TIME_SERIES dataset to improve model training. For more information, see FeaturizationConfig.

For RELATED_TIME_SERIES datasets, CreatePredictor verifies that the DataFrequency specified when the dataset was created matches the ForecastFrequency. TARGET_TIME_SERIES datasets don't have this restriction. Amazon Forecast also verifies the delimiter and timestamp format. For more information, see howitworks-datasets-groups.

AutoML

If you want Amazon Forecast to evaluate each algorithm and choose the one that minimizes the objective function, set PerformAutoML to true. The objective function is defined as the mean of the weighted p10, p50, and p90 quantile losses. For more information, see EvaluationResult.

When AutoML is enabled, the following properties are disallowed:

  • AlgorithmArn

  • HPOConfig

  • PerformHPO

  • TrainingParameters

To get a list of all of your predictors, use the ListPredictors operation.

Before you can use the predictor to create a forecast, the Status of the predictor must be ACTIVE, signifying that training has completed. To get the status, use the DescribePredictor operation. 

// Example sending a request using CreatePredictorRequest.
req := client.CreatePredictorRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/CreatePredictor

func (*Client) DeleteDatasetGroupRequest 

func (c *Client) DeleteDatasetGroupRequest(input *DeleteDatasetGroupInput) DeleteDatasetGroupRequest

DeleteDatasetGroupRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes a dataset group created using the CreateDatasetGroup operation. You can only delete dataset groups that have a status of ACTIVE, CREATE_FAILED, or UPDATE_FAILED. To get the status, use the DescribeDatasetGroup operation.

This operation deletes only the dataset group, not the datasets in the group. 

// Example sending a request using DeleteDatasetGroupRequest.
req := client.DeleteDatasetGroupRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteDatasetGroup

func (*Client) DeleteDatasetImportJobRequest 

func (c *Client) DeleteDatasetImportJobRequest(input *DeleteDatasetImportJobInput) DeleteDatasetImportJobRequest

DeleteDatasetImportJobRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes a dataset import job created using the CreateDatasetImportJob operation. You can delete only dataset import jobs that have a status of ACTIVE or CREATE_FAILED. To get the status, use the DescribeDatasetImportJob operation. 

// Example sending a request using DeleteDatasetImportJobRequest.
req := client.DeleteDatasetImportJobRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteDatasetImportJob

func (*Client) DeleteDatasetRequest 

func (c *Client) DeleteDatasetRequest(input *DeleteDatasetInput) DeleteDatasetRequest

DeleteDatasetRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes an Amazon Forecast dataset that was created using the CreateDataset operation. You can only delete datasets that have a status of ACTIVE or CREATE_FAILED. To get the status use the DescribeDataset operation.

Forecast does not automatically update any dataset groups that contain the deleted dataset. In order to update the dataset group, use the operation, omitting the deleted dataset's ARN. 

// Example sending a request using DeleteDatasetRequest.
req := client.DeleteDatasetRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteDataset

func (*Client) DeleteForecastExportJobRequest 

func (c *Client) DeleteForecastExportJobRequest(input *DeleteForecastExportJobInput) DeleteForecastExportJobRequest

DeleteForecastExportJobRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes a forecast export job created using the CreateForecastExportJob operation. You can delete only export jobs that have a status of ACTIVE or CREATE_FAILED. To get the status, use the DescribeForecastExportJob operation. 

// Example sending a request using DeleteForecastExportJobRequest.
req := client.DeleteForecastExportJobRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteForecastExportJob

func (*Client) DeleteForecastRequest 

func (c *Client) DeleteForecastRequest(input *DeleteForecastInput) DeleteForecastRequest

DeleteForecastRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes a forecast created using the CreateForecast operation. You can delete only forecasts that have a status of ACTIVE or CREATE_FAILED. To get the status, use the DescribeForecast operation.

You can't delete a forecast while it is being exported. After a forecast is deleted, you can no longer query the forecast. 

// Example sending a request using DeleteForecastRequest.
req := client.DeleteForecastRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeleteForecast

func (*Client) DeletePredictorRequest 

func (c *Client) DeletePredictorRequest(input *DeletePredictorInput) DeletePredictorRequest

DeletePredictorRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes a predictor created using the CreatePredictor operation. You can delete only predictor that have a status of ACTIVE or CREATE_FAILED. To get the status, use the DescribePredictor operation. 

// Example sending a request using DeletePredictorRequest.
req := client.DeletePredictorRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DeletePredictor

func (*Client) DescribeDatasetGroupRequest 

func (c *Client) DescribeDatasetGroupRequest(input *DescribeDatasetGroupInput) DescribeDatasetGroupRequest

DescribeDatasetGroupRequest returns a request value for making API operation for Amazon Forecast Service.

Describes a dataset group created using the CreateDatasetGroup operation.

In addition to listing the parameters provided in the CreateDatasetGroup request, this operation includes the following properties:

  • DatasetArns - The datasets belonging to the group.

  • CreationTime

  • LastModificationTime

  • Status

    // Example sending a request using DescribeDatasetGroupRequest. req := client.DescribeDatasetGroupRequest(params) resp, err := req.Send(context.TODO()) if err == nil { fmt.Println(resp) }

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeDatasetGroup

func (*Client) DescribeDatasetImportJobRequest 

func (c *Client) DescribeDatasetImportJobRequest(input *DescribeDatasetImportJobInput) DescribeDatasetImportJobRequest

DescribeDatasetImportJobRequest returns a request value for making API operation for Amazon Forecast Service.

Describes a dataset import job created using the CreateDatasetImportJob operation.

In addition to listing the parameters provided in the CreateDatasetImportJob request, this operation includes the following properties:

  • CreationTime

  • LastModificationTime

  • DataSize

  • FieldStatistics

  • Status

  • Message - If an error occurred, information about the error.

    // Example sending a request using DescribeDatasetImportJobRequest. req := client.DescribeDatasetImportJobRequest(params) resp, err := req.Send(context.TODO()) if err == nil { fmt.Println(resp) }

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeDatasetImportJob

func (*Client) DescribeDatasetRequest 

func (c *Client) DescribeDatasetRequest(input *DescribeDatasetInput) DescribeDatasetRequest

DescribeDatasetRequest returns a request value for making API operation for Amazon Forecast Service.

Describes an Amazon Forecast dataset created using the CreateDataset operation.

In addition to listing the parameters specified in the CreateDataset request, this operation includes the following dataset properties:

  • CreationTime

  • LastModificationTime

  • Status

    // Example sending a request using DescribeDatasetRequest. req := client.DescribeDatasetRequest(params) resp, err := req.Send(context.TODO()) if err == nil { fmt.Println(resp) }

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeDataset

func (*Client) DescribeForecastExportJobRequest 

func (c *Client) DescribeForecastExportJobRequest(input *DescribeForecastExportJobInput) DescribeForecastExportJobRequest

DescribeForecastExportJobRequest returns a request value for making API operation for Amazon Forecast Service.

Describes a forecast export job created using the CreateForecastExportJob operation.

In addition to listing the properties provided by the user in the CreateForecastExportJob request, this operation lists the following properties:

  • CreationTime

  • LastModificationTime

  • Status

  • Message - If an error occurred, information about the error.

    // Example sending a request using DescribeForecastExportJobRequest. req := client.DescribeForecastExportJobRequest(params) resp, err := req.Send(context.TODO()) if err == nil { fmt.Println(resp) }

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeForecastExportJob

func (*Client) DescribeForecastRequest 

func (c *Client) DescribeForecastRequest(input *DescribeForecastInput) DescribeForecastRequest

DescribeForecastRequest returns a request value for making API operation for Amazon Forecast Service.

Describes a forecast created using the CreateForecast operation.

In addition to listing the properties provided in the CreateForecast request, this operation lists the following properties:

  • DatasetGroupArn - The dataset group that provided the training data.

  • CreationTime

  • LastModificationTime

  • Status

  • Message - If an error occurred, information about the error.

    // Example sending a request using DescribeForecastRequest. req := client.DescribeForecastRequest(params) resp, err := req.Send(context.TODO()) if err == nil { fmt.Println(resp) }

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribeForecast

func (*Client) DescribePredictorRequest 

func (c *Client) DescribePredictorRequest(input *DescribePredictorInput) DescribePredictorRequest

DescribePredictorRequest returns a request value for making API operation for Amazon Forecast Service.

Describes a predictor created using the CreatePredictor operation.

In addition to listing the properties provided in the CreatePredictor request, this operation lists the following properties:

  • DatasetImportJobArns - The dataset import jobs used to import training data.

  • AutoMLAlgorithmArns - If AutoML is performed, the algorithms that were evaluated.

  • CreationTime

  • LastModificationTime

  • Status

  • Message - If an error occurred, information about the error.

    // Example sending a request using DescribePredictorRequest. req := client.DescribePredictorRequest(params) resp, err := req.Send(context.TODO()) if err == nil { fmt.Println(resp) }

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/DescribePredictor

func (*Client) GetAccuracyMetricsRequest 

func (c *Client) GetAccuracyMetricsRequest(input *GetAccuracyMetricsInput) GetAccuracyMetricsRequest

GetAccuracyMetricsRequest returns a request value for making API operation for Amazon Forecast Service.

Provides metrics on the accuracy of the models that were trained by the CreatePredictor operation. Use metrics to see how well the model performed and to decide whether to use the predictor to generate a forecast. For more information, see metrics.

This operation generates metrics for each backtest window that was evaluated. The number of backtest windows (NumberOfBacktestWindows) is specified using the EvaluationParameters object, which is optionally included in the CreatePredictor request. If NumberOfBacktestWindows isn't specified, the number defaults to one.

The parameters of the filling method determine which items contribute to the metrics. If you want all items to contribute, specify zero. If you want only those items that have complete data in the range being evaluated to contribute, specify nan. For more information, see FeaturizationMethod.

Before you can get accuracy metrics, the Status of the predictor must be ACTIVE, signifying that training has completed. To get the status, use the DescribePredictor operation. 

// Example sending a request using GetAccuracyMetricsRequest.
req := client.GetAccuracyMetricsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/GetAccuracyMetrics

func (*Client) ListDatasetGroupsRequest 

func (c *Client) ListDatasetGroupsRequest(input *ListDatasetGroupsInput) ListDatasetGroupsRequest

ListDatasetGroupsRequest returns a request value for making API operation for Amazon Forecast Service.

Returns a list of dataset groups created using the CreateDatasetGroup operation. For each dataset group, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). You can retrieve the complete set of properties by using the dataset group ARN with the DescribeDatasetGroup operation. 

// Example sending a request using ListDatasetGroupsRequest.
req := client.ListDatasetGroupsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListDatasetGroups

func (*Client) ListDatasetImportJobsRequest 

func (c *Client) ListDatasetImportJobsRequest(input *ListDatasetImportJobsInput) ListDatasetImportJobsRequest

ListDatasetImportJobsRequest returns a request value for making API operation for Amazon Forecast Service.

Returns a list of dataset import jobs created using the CreateDatasetImportJob operation. For each import job, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). You can retrieve the complete set of properties by using the ARN with the DescribeDatasetImportJob operation. You can filter the list by providing an array of Filter objects. 

// Example sending a request using ListDatasetImportJobsRequest.
req := client.ListDatasetImportJobsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListDatasetImportJobs

func (*Client) ListDatasetsRequest 

func (c *Client) ListDatasetsRequest(input *ListDatasetsInput) ListDatasetsRequest

ListDatasetsRequest returns a request value for making API operation for Amazon Forecast Service.

Returns a list of datasets created using the CreateDataset operation. For each dataset, a summary of its properties, including its Amazon Resource Name (ARN), is returned. To retrieve the complete set of properties, use the ARN with the DescribeDataset operation. 

// Example sending a request using ListDatasetsRequest.
req := client.ListDatasetsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListDatasets

func (*Client) ListForecastExportJobsRequest 

func (c *Client) ListForecastExportJobsRequest(input *ListForecastExportJobsInput) ListForecastExportJobsRequest

ListForecastExportJobsRequest returns a request value for making API operation for Amazon Forecast Service.

Returns a list of forecast export jobs created using the CreateForecastExportJob operation. For each forecast export job, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). To retrieve the complete set of properties, use the ARN with the DescribeForecastExportJob operation. You can filter the list using an array of Filter objects. 

// Example sending a request using ListForecastExportJobsRequest.
req := client.ListForecastExportJobsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListForecastExportJobs

func (*Client) ListForecastsRequest 

func (c *Client) ListForecastsRequest(input *ListForecastsInput) ListForecastsRequest

ListForecastsRequest returns a request value for making API operation for Amazon Forecast Service.

Returns a list of forecasts created using the CreateForecast operation. For each forecast, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). To retrieve the complete set of properties, specify the ARN with the DescribeForecast operation. You can filter the list using an array of Filter objects. 

// Example sending a request using ListForecastsRequest.
req := client.ListForecastsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListForecasts

func (*Client) ListPredictorsRequest 

func (c *Client) ListPredictorsRequest(input *ListPredictorsInput) ListPredictorsRequest

ListPredictorsRequest returns a request value for making API operation for Amazon Forecast Service.

Returns a list of predictors created using the CreatePredictor operation. For each predictor, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). You can retrieve the complete set of properties by using the ARN with the DescribePredictor operation. You can filter the list using an array of Filter objects. 

// Example sending a request using ListPredictorsRequest.
req := client.ListPredictorsRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListPredictors

func (*Client) ListTagsForResourceRequest added in v0.24.0 

func (c *Client) ListTagsForResourceRequest(input *ListTagsForResourceInput) ListTagsForResourceRequest

ListTagsForResourceRequest returns a request value for making API operation for Amazon Forecast Service.

Lists the tags for an Amazon Forecast resource. 

// Example sending a request using ListTagsForResourceRequest.
req := client.ListTagsForResourceRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/ListTagsForResource

func (*Client) TagResourceRequest added in v0.24.0 

func (c *Client) TagResourceRequest(input *TagResourceInput) TagResourceRequest

TagResourceRequest returns a request value for making API operation for Amazon Forecast Service.

Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are also deleted. 

// Example sending a request using TagResourceRequest.
req := client.TagResourceRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/TagResource

func (*Client) UntagResourceRequest added in v0.24.0 

func (c *Client) UntagResourceRequest(input *UntagResourceInput) UntagResourceRequest

UntagResourceRequest returns a request value for making API operation for Amazon Forecast Service.

Deletes the specified tags from a resource. 

// Example sending a request using UntagResourceRequest.
req := client.UntagResourceRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/UntagResource

func (*Client) UpdateDatasetGroupRequest 

func (c *Client) UpdateDatasetGroupRequest(input *UpdateDatasetGroupInput) UpdateDatasetGroupRequest

UpdateDatasetGroupRequest returns a request value for making API operation for Amazon Forecast Service.

Replaces the datasets in a dataset group with the specified datasets.

The Status of the dataset group must be ACTIVE before you can use the dataset group to create a predictor. Use the DescribeDatasetGroup operation to get the status. 

// Example sending a request using UpdateDatasetGroupRequest.
req := client.UpdateDatasetGroupRequest(params)
resp, err := req.Send(context.TODO())
if err == nil {
    fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/forecast-2018-06-26/UpdateDatasetGroup

type ContinuousParameterRange 

type ContinuousParameterRange struct {

	// The maximum tunable value of the hyperparameter.
	//
	// MaxValue is a required field
	MaxValue *float64 `type:"double" required:"true"`

	// The minimum tunable value of the hyperparameter.
	//
	// MinValue is a required field
	MinValue *float64 `type:"double" required:"true"`

	// The name of the hyperparameter to tune.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The scale that hyperparameter tuning uses to search the hyperparameter range.
	// Valid values:
	//
	// Auto
	//
	// Amazon Forecast hyperparameter tuning chooses the best scale for the hyperparameter.
	//
	// Linear
	//
	// Hyperparameter tuning searches the values in the hyperparameter range by
	// using a linear scale.
	//
	// Logarithmic
	//
	// Hyperparameter tuning searches the values in the hyperparameter range by
	// using a logarithmic scale.
	//
	// Logarithmic scaling works only for ranges that have values greater than 0.
	//
	// ReverseLogarithmic
	//
	// hyperparameter tuning searches the values in the hyperparameter range by
	// using a reverse logarithmic scale.
	//
	// Reverse logarithmic scaling works only for ranges that are entirely within
	// the range 0 <= x < 1.0.
	//
	// For information about choosing a hyperparameter scale, see Hyperparameter
	// Scaling (http://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html#scaling-type).
	// One of the following values:
	ScalingType ScalingType `type:"string" enum:"true"`
	// contains filtered or unexported fields
}

Specifies a continuous hyperparameter and it's range of tunable values. This object is part of the ParameterRanges object.

func (ContinuousParameterRange) String 

func (s ContinuousParameterRange) String() string

String returns the string representation

func (*ContinuousParameterRange) Validate 

func (s *ContinuousParameterRange) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateDatasetGroupInput 

type CreateDatasetGroupInput struct {

	// An array of Amazon Resource Names (ARNs) of the datasets that you want to
	// include in the dataset group.
	DatasetArns []string `type:"list"`

	// A name for the dataset group.
	//
	// DatasetGroupName is a required field
	DatasetGroupName *string `min:"1" type:"string" required:"true"`

	// The domain associated with the dataset group. When you add a dataset to a
	// dataset group, this value and the value specified for the Domain parameter
	// of the CreateDataset operation must match.
	//
	// The Domain and DatasetType that you choose determine the fields that must
	// be present in training data that you import to a dataset. For example, if
	// you choose the RETAIL domain and TARGET_TIME_SERIES as the DatasetType, Amazon
	// Forecast requires that item_id, timestamp, and demand fields are present
	// in your data. For more information, see howitworks-datasets-groups.
	//
	// Domain is a required field
	Domain Domain `type:"string" required:"true" enum:"true"`

	// The optional metadata that you apply to the dataset group to help you categorize
	// and organize them. Each tag consists of a key and an optional value, both
	// of which you define.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	Tags []Tag `type:"list"`
	// contains filtered or unexported fields
}

func (CreateDatasetGroupInput) String 

func (s CreateDatasetGroupInput) String() string

String returns the string representation

func (*CreateDatasetGroupInput) Validate 

func (s *CreateDatasetGroupInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateDatasetGroupOutput 

type CreateDatasetGroupOutput struct {

	// The Amazon Resource Name (ARN) of the dataset group.
	DatasetGroupArn *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreateDatasetGroupOutput) String 

func (s CreateDatasetGroupOutput) String() string

String returns the string representation

type CreateDatasetGroupRequest 

type CreateDatasetGroupRequest struct {
	*aws.Request
	Input *CreateDatasetGroupInput
	Copy  func(*CreateDatasetGroupInput) CreateDatasetGroupRequest
}

CreateDatasetGroupRequest is the request type for the CreateDatasetGroup API operation.

func (CreateDatasetGroupRequest) Send 

func (r CreateDatasetGroupRequest) Send(ctx context.Context) (*CreateDatasetGroupResponse, error)

Send marshals and sends the CreateDatasetGroup API request.

type CreateDatasetGroupResponse 

type CreateDatasetGroupResponse struct {
	*CreateDatasetGroupOutput
	// contains filtered or unexported fields
}

CreateDatasetGroupResponse is the response type for the CreateDatasetGroup API operation.

func (*CreateDatasetGroupResponse) SDKResponseMetdata 

func (r *CreateDatasetGroupResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreateDatasetGroup request.

type CreateDatasetImportJobInput 

type CreateDatasetImportJobInput struct {

	// The location of the training data to import and an AWS Identity and Access
	// Management (IAM) role that Amazon Forecast can assume to access the data.
	// The training data must be stored in an Amazon S3 bucket.
	//
	// If encryption is used, DataSource must include an AWS Key Management Service
	// (KMS) key and the IAM role must allow Amazon Forecast permission to access
	// the key. The KMS key and IAM role must match those specified in the EncryptionConfig
	// parameter of the CreateDataset operation.
	//
	// DataSource is a required field
	DataSource *DataSource `type:"structure" required:"true"`

	// The Amazon Resource Name (ARN) of the Amazon Forecast dataset that you want
	// to import data to.
	//
	// DatasetArn is a required field
	DatasetArn *string `type:"string" required:"true"`

	// The name for the dataset import job. We recommend including the current timestamp
	// in the name, for example, 20190721DatasetImport. This can help you avoid
	// getting a ResourceAlreadyExistsException exception.
	//
	// DatasetImportJobName is a required field
	DatasetImportJobName *string `min:"1" type:"string" required:"true"`

	// The optional metadata that you apply to the dataset import job to help you
	// categorize and organize them. Each tag consists of a key and an optional
	// value, both of which you define.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	Tags []Tag `type:"list"`

	// The format of timestamps in the dataset. The format that you specify depends
	// on the DataFrequency specified when the dataset was created. The following
	// formats are supported
	//
	//    * "yyyy-MM-dd" For the following data frequencies: Y, M, W, and D
	//
	//    * "yyyy-MM-dd HH:mm:ss" For the following data frequencies: H, 30min,
	//    15min, and 1min; and optionally, for: Y, M, W, and D
	//
	// If the format isn't specified, Amazon Forecast expects the format to be "yyyy-MM-dd
	// HH:mm:ss".
	TimestampFormat *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreateDatasetImportJobInput) String 

func (s CreateDatasetImportJobInput) String() string

String returns the string representation

func (*CreateDatasetImportJobInput) Validate 

func (s *CreateDatasetImportJobInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateDatasetImportJobOutput 

type CreateDatasetImportJobOutput struct {

	// The Amazon Resource Name (ARN) of the dataset import job.
	DatasetImportJobArn *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreateDatasetImportJobOutput) String 

func (s CreateDatasetImportJobOutput) String() string

String returns the string representation

type CreateDatasetImportJobRequest 

type CreateDatasetImportJobRequest struct {
	*aws.Request
	Input *CreateDatasetImportJobInput
	Copy  func(*CreateDatasetImportJobInput) CreateDatasetImportJobRequest
}

CreateDatasetImportJobRequest is the request type for the CreateDatasetImportJob API operation.

func (CreateDatasetImportJobRequest) Send 

func (r CreateDatasetImportJobRequest) Send(ctx context.Context) (*CreateDatasetImportJobResponse, error)

Send marshals and sends the CreateDatasetImportJob API request.

type CreateDatasetImportJobResponse 

type CreateDatasetImportJobResponse struct {
	*CreateDatasetImportJobOutput
	// contains filtered or unexported fields
}

CreateDatasetImportJobResponse is the response type for the CreateDatasetImportJob API operation.

func (*CreateDatasetImportJobResponse) SDKResponseMetdata 

func (r *CreateDatasetImportJobResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreateDatasetImportJob request.

type CreateDatasetInput 

type CreateDatasetInput struct {

	// The frequency of data collection. This parameter is required for RELATED_TIME_SERIES
	// datasets.
	//
	// Valid intervals are Y (Year), M (Month), W (Week), D (Day), H (Hour), 30min
	// (30 minutes), 15min (15 minutes), 10min (10 minutes), 5min (5 minutes), and
	// 1min (1 minute). For example, "D" indicates every day and "15min" indicates
	// every 15 minutes.
	DataFrequency *string `type:"string"`

	// A name for the dataset.
	//
	// DatasetName is a required field
	DatasetName *string `min:"1" type:"string" required:"true"`

	// The dataset type. Valid values depend on the chosen Domain.
	//
	// DatasetType is a required field
	DatasetType DatasetType `type:"string" required:"true" enum:"true"`

	// The domain associated with the dataset. When you add a dataset to a dataset
	// group, this value and the value specified for the Domain parameter of the
	// CreateDatasetGroup operation must match.
	//
	// The Domain and DatasetType that you choose determine the fields that must
	// be present in the training data that you import to the dataset. For example,
	// if you choose the RETAIL domain and TARGET_TIME_SERIES as the DatasetType,
	// Amazon Forecast requires item_id, timestamp, and demand fields to be present
	// in your data. For more information, see howitworks-datasets-groups.
	//
	// Domain is a required field
	Domain Domain `type:"string" required:"true" enum:"true"`

	// An AWS Key Management Service (KMS) key and the AWS Identity and Access Management
	// (IAM) role that Amazon Forecast can assume to access the key.
	EncryptionConfig *EncryptionConfig `type:"structure"`

	// The schema for the dataset. The schema attributes and their order must match
	// the fields in your data. The dataset Domain and DatasetType that you choose
	// determine the minimum required fields in your training data. For information
	// about the required fields for a specific dataset domain and type, see howitworks-domains-ds-types.
	//
	// Schema is a required field
	Schema *Schema `type:"structure" required:"true"`

	// The optional metadata that you apply to the dataset to help you categorize
	// and organize them. Each tag consists of a key and an optional value, both
	// of which you define.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	Tags []Tag `type:"list"`
	// contains filtered or unexported fields
}

func (CreateDatasetInput) String 

func (s CreateDatasetInput) String() string

String returns the string representation

func (*CreateDatasetInput) Validate 

func (s *CreateDatasetInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateDatasetOutput 

type CreateDatasetOutput struct {

	// The Amazon Resource Name (ARN) of the dataset.
	DatasetArn *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreateDatasetOutput) String 

func (s CreateDatasetOutput) String() string

String returns the string representation

type CreateDatasetRequest 

type CreateDatasetRequest struct {
	*aws.Request
	Input *CreateDatasetInput
	Copy  func(*CreateDatasetInput) CreateDatasetRequest
}

CreateDatasetRequest is the request type for the CreateDataset API operation.

func (CreateDatasetRequest) Send 

func (r CreateDatasetRequest) Send(ctx context.Context) (*CreateDatasetResponse, error)

Send marshals and sends the CreateDataset API request.

type CreateDatasetResponse 

type CreateDatasetResponse struct {
	*CreateDatasetOutput
	// contains filtered or unexported fields
}

CreateDatasetResponse is the response type for the CreateDataset API operation.

func (*CreateDatasetResponse) SDKResponseMetdata 

func (r *CreateDatasetResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreateDataset request.

type CreateForecastExportJobInput 

type CreateForecastExportJobInput struct {

	// The location where you want to save the forecast and an AWS Identity and
	// Access Management (IAM) role that Amazon Forecast can assume to access the
	// location. The forecast must be exported to an Amazon S3 bucket.
	//
	// If encryption is used, Destination must include an AWS Key Management Service
	// (KMS) key. The IAM role must allow Amazon Forecast permission to access the
	// key.
	//
	// Destination is a required field
	Destination *DataDestination `type:"structure" required:"true"`

	// The Amazon Resource Name (ARN) of the forecast that you want to export.
	//
	// ForecastArn is a required field
	ForecastArn *string `type:"string" required:"true"`

	// The name for the forecast export job.
	//
	// ForecastExportJobName is a required field
	ForecastExportJobName *string `min:"1" type:"string" required:"true"`

	// The optional metadata that you apply to the forecast export job to help you
	// categorize and organize them. Each tag consists of a key and an optional
	// value, both of which you define.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	Tags []Tag `type:"list"`
	// contains filtered or unexported fields
}

func (CreateForecastExportJobInput) String 

func (s CreateForecastExportJobInput) String() string

String returns the string representation

func (*CreateForecastExportJobInput) Validate 

func (s *CreateForecastExportJobInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateForecastExportJobOutput 

type CreateForecastExportJobOutput struct {

	// The Amazon Resource Name (ARN) of the export job.
	ForecastExportJobArn *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreateForecastExportJobOutput) String 

func (s CreateForecastExportJobOutput) String() string

String returns the string representation

type CreateForecastExportJobRequest 

type CreateForecastExportJobRequest struct {
	*aws.Request
	Input *CreateForecastExportJobInput
	Copy  func(*CreateForecastExportJobInput) CreateForecastExportJobRequest
}

CreateForecastExportJobRequest is the request type for the CreateForecastExportJob API operation.

func (CreateForecastExportJobRequest) Send 

func (r CreateForecastExportJobRequest) Send(ctx context.Context) (*CreateForecastExportJobResponse, error)

Send marshals and sends the CreateForecastExportJob API request.

type CreateForecastExportJobResponse 

type CreateForecastExportJobResponse struct {
	*CreateForecastExportJobOutput
	// contains filtered or unexported fields
}

CreateForecastExportJobResponse is the response type for the CreateForecastExportJob API operation.

func (*CreateForecastExportJobResponse) SDKResponseMetdata 

func (r *CreateForecastExportJobResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreateForecastExportJob request.

type CreateForecastInput 

type CreateForecastInput struct {

	// A name for the forecast.
	//
	// ForecastName is a required field
	ForecastName *string `min:"1" type:"string" required:"true"`

	// The quantiles at which probabilistic forecasts are generated. You can currently
	// specify up to 5 quantiles per forecast. Accepted values include 0.01 to 0.99
	// (increments of .01 only) and mean. The mean forecast is different from the
	// median (0.50) when the distribution is not symmetric (for example, Beta and
	// Negative Binomial). The default value is ["0.1", "0.5", "0.9"].
	ForecastTypes []string `min:"1" type:"list"`

	// The Amazon Resource Name (ARN) of the predictor to use to generate the forecast.
	//
	// PredictorArn is a required field
	PredictorArn *string `type:"string" required:"true"`

	// The optional metadata that you apply to the forecast to help you categorize
	// and organize them. Each tag consists of a key and an optional value, both
	// of which you define.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	Tags []Tag `type:"list"`
	// contains filtered or unexported fields
}

func (CreateForecastInput) String 

func (s CreateForecastInput) String() string

String returns the string representation

func (*CreateForecastInput) Validate 

func (s *CreateForecastInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreateForecastOutput 

type CreateForecastOutput struct {

	// The Amazon Resource Name (ARN) of the forecast.
	ForecastArn *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreateForecastOutput) String 

func (s CreateForecastOutput) String() string

String returns the string representation

type CreateForecastRequest 

type CreateForecastRequest struct {
	*aws.Request
	Input *CreateForecastInput
	Copy  func(*CreateForecastInput) CreateForecastRequest
}

CreateForecastRequest is the request type for the CreateForecast API operation.

func (CreateForecastRequest) Send 

func (r CreateForecastRequest) Send(ctx context.Context) (*CreateForecastResponse, error)

Send marshals and sends the CreateForecast API request.

type CreateForecastResponse 

type CreateForecastResponse struct {
	*CreateForecastOutput
	// contains filtered or unexported fields
}

CreateForecastResponse is the response type for the CreateForecast API operation.

func (*CreateForecastResponse) SDKResponseMetdata 

func (r *CreateForecastResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreateForecast request.

type CreatePredictorInput 

type CreatePredictorInput struct {

	// The Amazon Resource Name (ARN) of the algorithm to use for model training.
	// Required if PerformAutoML is not set to true.
	//
	// Supported algorithms:
	//
	//    * arn:aws:forecast:::algorithm/ARIMA
	//
	//    * arn:aws:forecast:::algorithm/Deep_AR_Plus Supports hyperparameter optimization
	//    (HPO)
	//
	//    * arn:aws:forecast:::algorithm/ETS
	//
	//    * arn:aws:forecast:::algorithm/NPTS
	//
	//    * arn:aws:forecast:::algorithm/Prophet
	AlgorithmArn *string `type:"string"`

	// An AWS Key Management Service (KMS) key and the AWS Identity and Access Management
	// (IAM) role that Amazon Forecast can assume to access the key.
	EncryptionConfig *EncryptionConfig `type:"structure"`

	// Used to override the default evaluation parameters of the specified algorithm.
	// Amazon Forecast evaluates a predictor by splitting a dataset into training
	// data and testing data. The evaluation parameters define how to perform the
	// split and the number of iterations.
	EvaluationParameters *EvaluationParameters `type:"structure"`

	// The featurization configuration.
	//
	// FeaturizationConfig is a required field
	FeaturizationConfig *FeaturizationConfig `type:"structure" required:"true"`

	// Specifies the number of time-steps that the model is trained to predict.
	// The forecast horizon is also called the prediction length.
	//
	// For example, if you configure a dataset for daily data collection (using
	// the DataFrequency parameter of the CreateDataset operation) and set the forecast
	// horizon to 10, the model returns predictions for 10 days.
	//
	// The maximum forecast horizon is the lesser of 500 time-steps or 1/3 of the
	// TARGET_TIME_SERIES dataset length.
	//
	// ForecastHorizon is a required field
	ForecastHorizon *int64 `type:"integer" required:"true"`

	// Provides hyperparameter override values for the algorithm. If you don't provide
	// this parameter, Amazon Forecast uses default values. The individual algorithms
	// specify which hyperparameters support hyperparameter optimization (HPO).
	// For more information, see aws-forecast-choosing-recipes.
	//
	// If you included the HPOConfig object, you must set PerformHPO to true.
	HPOConfig *HyperParameterTuningJobConfig `type:"structure"`

	// Describes the dataset group that contains the data to use to train the predictor.
	//
	// InputDataConfig is a required field
	InputDataConfig *InputDataConfig `type:"structure" required:"true"`

	// Whether to perform AutoML. When Amazon Forecast performs AutoML, it evaluates
	// the algorithms it provides and chooses the best algorithm and configuration
	// for your training dataset.
	//
	// The default value is false. In this case, you are required to specify an
	// algorithm.
	//
	// Set PerformAutoML to true to have Amazon Forecast perform AutoML. This is
	// a good option if you aren't sure which algorithm is suitable for your training
	// data. In this case, PerformHPO must be false.
	PerformAutoML *bool `type:"boolean"`

	// Whether to perform hyperparameter optimization (HPO). HPO finds optimal hyperparameter
	// values for your training data. The process of performing HPO is known as
	// running a hyperparameter tuning job.
	//
	// The default value is false. In this case, Amazon Forecast uses default hyperparameter
	// values from the chosen algorithm.
	//
	// To override the default values, set PerformHPO to true and, optionally, supply
	// the HyperParameterTuningJobConfig object. The tuning job specifies a metric
	// to optimize, which hyperparameters participate in tuning, and the valid range
	// for each tunable hyperparameter. In this case, you are required to specify
	// an algorithm and PerformAutoML must be false.
	//
	// The following algorithm supports HPO:
	//
	//    * DeepAR+
	PerformHPO *bool `type:"boolean"`

	// A name for the predictor.
	//
	// PredictorName is a required field
	PredictorName *string `min:"1" type:"string" required:"true"`

	// The optional metadata that you apply to the predictor to help you categorize
	// and organize them. Each tag consists of a key and an optional value, both
	// of which you define.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	Tags []Tag `type:"list"`

	// The hyperparameters to override for model training. The hyperparameters that
	// you can override are listed in the individual algorithms. For the list of
	// supported algorithms, see aws-forecast-choosing-recipes.
	TrainingParameters map[string]string `type:"map"`
	// contains filtered or unexported fields
}

func (CreatePredictorInput) String 

func (s CreatePredictorInput) String() string

String returns the string representation

func (*CreatePredictorInput) Validate 

func (s *CreatePredictorInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type CreatePredictorOutput 

type CreatePredictorOutput struct {

	// The Amazon Resource Name (ARN) of the predictor.
	PredictorArn *string `type:"string"`
	// contains filtered or unexported fields
}

func (CreatePredictorOutput) String 

func (s CreatePredictorOutput) String() string

String returns the string representation

type CreatePredictorRequest 

type CreatePredictorRequest struct {
	*aws.Request
	Input *CreatePredictorInput
	Copy  func(*CreatePredictorInput) CreatePredictorRequest
}

CreatePredictorRequest is the request type for the CreatePredictor API operation.

func (CreatePredictorRequest) Send 

func (r CreatePredictorRequest) Send(ctx context.Context) (*CreatePredictorResponse, error)

Send marshals and sends the CreatePredictor API request.

type CreatePredictorResponse 

type CreatePredictorResponse struct {
	*CreatePredictorOutput
	// contains filtered or unexported fields
}

CreatePredictorResponse is the response type for the CreatePredictor API operation.

func (*CreatePredictorResponse) SDKResponseMetdata 

func (r *CreatePredictorResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the CreatePredictor request.

type DataDestination 

type DataDestination struct {

	// The path to an Amazon Simple Storage Service (Amazon S3) bucket along with
	// the credentials to access the bucket.
	//
	// S3Config is a required field
	S3Config *S3Config `type:"structure" required:"true"`
	// contains filtered or unexported fields
}

The destination for an exported forecast, an AWS Identity and Access Management (IAM) role that allows Amazon Forecast to access the location and, optionally, an AWS Key Management Service (KMS) key. This object is submitted in the CreateForecastExportJob request.

func (DataDestination) String 

func (s DataDestination) String() string

String returns the string representation

func (*DataDestination) Validate 

func (s *DataDestination) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DataSource 

type DataSource struct {

	// The path to the training data stored in an Amazon Simple Storage Service
	// (Amazon S3) bucket along with the credentials to access the data.
	//
	// S3Config is a required field
	S3Config *S3Config `type:"structure" required:"true"`
	// contains filtered or unexported fields
}

The source of your training data, an AWS Identity and Access Management (IAM) role that allows Amazon Forecast to access the data and, optionally, an AWS Key Management Service (KMS) key. This object is submitted in the CreateDatasetImportJob request.

func (DataSource) String 

func (s DataSource) String() string

String returns the string representation

func (*DataSource) Validate 

func (s *DataSource) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DatasetGroupSummary 

type DatasetGroupSummary struct {

	// When the dataset group was created.
	CreationTime *time.Time `type:"timestamp"`

	// The Amazon Resource Name (ARN) of the dataset group.
	DatasetGroupArn *string `type:"string"`

	// The name of the dataset group.
	DatasetGroupName *string `min:"1" type:"string"`

	// When the dataset group was created or last updated from a call to the UpdateDatasetGroup
	// operation. While the dataset group is being updated, LastModificationTime
	// is the current time of the ListDatasetGroups call.
	LastModificationTime *time.Time `type:"timestamp"`
	// contains filtered or unexported fields
}

Provides a summary of the dataset group properties used in the ListDatasetGroups operation. To get the complete set of properties, call the DescribeDatasetGroup operation, and provide the DatasetGroupArn.

func (DatasetGroupSummary) String 

func (s DatasetGroupSummary) String() string

String returns the string representation

type DatasetImportJobSummary 

type DatasetImportJobSummary struct {

	// When the dataset import job was created.
	CreationTime *time.Time `type:"timestamp"`

	// The location of the training data to import and an AWS Identity and Access
	// Management (IAM) role that Amazon Forecast can assume to access the data.
	// The training data must be stored in an Amazon S3 bucket.
	//
	// If encryption is used, DataSource includes an AWS Key Management Service
	// (KMS) key.
	DataSource *DataSource `type:"structure"`

	// The Amazon Resource Name (ARN) of the dataset import job.
	DatasetImportJobArn *string `type:"string"`

	// The name of the dataset import job.
	DatasetImportJobName *string `min:"1" type:"string"`

	// The last time that the dataset was modified. The time depends on the status
	// of the job, as follows:
	//
	//    * CREATE_PENDING - The same time as CreationTime.
	//
	//    * CREATE_IN_PROGRESS - The current timestamp.
	//
	//    * ACTIVE or CREATE_FAILED - When the job finished or failed.
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The status of the dataset import job. The status is reflected in the status
	// of the dataset. For example, when the import job status is CREATE_IN_PROGRESS,
	// the status of the dataset is UPDATE_IN_PROGRESS. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

Provides a summary of the dataset import job properties used in the ListDatasetImportJobs operation. To get the complete set of properties, call the DescribeDatasetImportJob operation, and provide the DatasetImportJobArn.

func (DatasetImportJobSummary) String 

func (s DatasetImportJobSummary) String() string

String returns the string representation

type DatasetSummary 

type DatasetSummary struct {

	// When the dataset was created.
	CreationTime *time.Time `type:"timestamp"`

	// The Amazon Resource Name (ARN) of the dataset.
	DatasetArn *string `type:"string"`

	// The name of the dataset.
	DatasetName *string `min:"1" type:"string"`

	// The dataset type.
	DatasetType DatasetType `type:"string" enum:"true"`

	// The domain associated with the dataset.
	Domain Domain `type:"string" enum:"true"`

	// When you create a dataset, LastModificationTime is the same as CreationTime.
	// While data is being imported to the dataset, LastModificationTime is the
	// current time of the ListDatasets call. After a CreateDatasetImportJob operation
	// has finished, LastModificationTime is when the import job completed or failed.
	LastModificationTime *time.Time `type:"timestamp"`
	// contains filtered or unexported fields
}

Provides a summary of the dataset properties used in the ListDatasets operation. To get the complete set of properties, call the DescribeDataset operation, and provide the DatasetArn.

func (DatasetSummary) String 

func (s DatasetSummary) String() string

String returns the string representation

type DatasetType 

type DatasetType string
const (
	DatasetTypeTargetTimeSeries  DatasetType = "TARGET_TIME_SERIES"
	DatasetTypeRelatedTimeSeries DatasetType = "RELATED_TIME_SERIES"
	DatasetTypeItemMetadata      DatasetType = "ITEM_METADATA"
)

Enum values for DatasetType

func (DatasetType) MarshalValue 

func (enum DatasetType) MarshalValue() (string, error)

func (DatasetType) MarshalValueBuf 

func (enum DatasetType) MarshalValueBuf(b []byte) ([]byte, error)

type DeleteDatasetGroupInput 

type DeleteDatasetGroupInput struct {

	// The Amazon Resource Name (ARN) of the dataset group to delete.
	//
	// DatasetGroupArn is a required field
	DatasetGroupArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteDatasetGroupInput) String 

func (s DeleteDatasetGroupInput) String() string

String returns the string representation

func (*DeleteDatasetGroupInput) Validate 

func (s *DeleteDatasetGroupInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteDatasetGroupOutput 

type DeleteDatasetGroupOutput struct {
	// contains filtered or unexported fields
}

func (DeleteDatasetGroupOutput) String 

func (s DeleteDatasetGroupOutput) String() string

String returns the string representation

type DeleteDatasetGroupRequest 

type DeleteDatasetGroupRequest struct {
	*aws.Request
	Input *DeleteDatasetGroupInput
	Copy  func(*DeleteDatasetGroupInput) DeleteDatasetGroupRequest
}

DeleteDatasetGroupRequest is the request type for the DeleteDatasetGroup API operation.

func (DeleteDatasetGroupRequest) Send 

func (r DeleteDatasetGroupRequest) Send(ctx context.Context) (*DeleteDatasetGroupResponse, error)

Send marshals and sends the DeleteDatasetGroup API request.

type DeleteDatasetGroupResponse 

type DeleteDatasetGroupResponse struct {
	*DeleteDatasetGroupOutput
	// contains filtered or unexported fields
}

DeleteDatasetGroupResponse is the response type for the DeleteDatasetGroup API operation.

func (*DeleteDatasetGroupResponse) SDKResponseMetdata 

func (r *DeleteDatasetGroupResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteDatasetGroup request.

type DeleteDatasetImportJobInput 

type DeleteDatasetImportJobInput struct {

	// The Amazon Resource Name (ARN) of the dataset import job to delete.
	//
	// DatasetImportJobArn is a required field
	DatasetImportJobArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteDatasetImportJobInput) String 

func (s DeleteDatasetImportJobInput) String() string

String returns the string representation

func (*DeleteDatasetImportJobInput) Validate 

func (s *DeleteDatasetImportJobInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteDatasetImportJobOutput 

type DeleteDatasetImportJobOutput struct {
	// contains filtered or unexported fields
}

func (DeleteDatasetImportJobOutput) String 

func (s DeleteDatasetImportJobOutput) String() string

String returns the string representation

type DeleteDatasetImportJobRequest 

type DeleteDatasetImportJobRequest struct {
	*aws.Request
	Input *DeleteDatasetImportJobInput
	Copy  func(*DeleteDatasetImportJobInput) DeleteDatasetImportJobRequest
}

DeleteDatasetImportJobRequest is the request type for the DeleteDatasetImportJob API operation.

func (DeleteDatasetImportJobRequest) Send 

func (r DeleteDatasetImportJobRequest) Send(ctx context.Context) (*DeleteDatasetImportJobResponse, error)

Send marshals and sends the DeleteDatasetImportJob API request.

type DeleteDatasetImportJobResponse 

type DeleteDatasetImportJobResponse struct {
	*DeleteDatasetImportJobOutput
	// contains filtered or unexported fields
}

DeleteDatasetImportJobResponse is the response type for the DeleteDatasetImportJob API operation.

func (*DeleteDatasetImportJobResponse) SDKResponseMetdata 

func (r *DeleteDatasetImportJobResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteDatasetImportJob request.

type DeleteDatasetInput 

type DeleteDatasetInput struct {

	// The Amazon Resource Name (ARN) of the dataset to delete.
	//
	// DatasetArn is a required field
	DatasetArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteDatasetInput) String 

func (s DeleteDatasetInput) String() string

String returns the string representation

func (*DeleteDatasetInput) Validate 

func (s *DeleteDatasetInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteDatasetOutput 

type DeleteDatasetOutput struct {
	// contains filtered or unexported fields
}

func (DeleteDatasetOutput) String 

func (s DeleteDatasetOutput) String() string

String returns the string representation

type DeleteDatasetRequest 

type DeleteDatasetRequest struct {
	*aws.Request
	Input *DeleteDatasetInput
	Copy  func(*DeleteDatasetInput) DeleteDatasetRequest
}

DeleteDatasetRequest is the request type for the DeleteDataset API operation.

func (DeleteDatasetRequest) Send 

func (r DeleteDatasetRequest) Send(ctx context.Context) (*DeleteDatasetResponse, error)

Send marshals and sends the DeleteDataset API request.

type DeleteDatasetResponse 

type DeleteDatasetResponse struct {
	*DeleteDatasetOutput
	// contains filtered or unexported fields
}

DeleteDatasetResponse is the response type for the DeleteDataset API operation.

func (*DeleteDatasetResponse) SDKResponseMetdata 

func (r *DeleteDatasetResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteDataset request.

type DeleteForecastExportJobInput 

type DeleteForecastExportJobInput struct {

	// The Amazon Resource Name (ARN) of the forecast export job to delete.
	//
	// ForecastExportJobArn is a required field
	ForecastExportJobArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteForecastExportJobInput) String 

func (s DeleteForecastExportJobInput) String() string

String returns the string representation

func (*DeleteForecastExportJobInput) Validate 

func (s *DeleteForecastExportJobInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteForecastExportJobOutput 

type DeleteForecastExportJobOutput struct {
	// contains filtered or unexported fields
}

func (DeleteForecastExportJobOutput) String 

func (s DeleteForecastExportJobOutput) String() string

String returns the string representation

type DeleteForecastExportJobRequest 

type DeleteForecastExportJobRequest struct {
	*aws.Request
	Input *DeleteForecastExportJobInput
	Copy  func(*DeleteForecastExportJobInput) DeleteForecastExportJobRequest
}

DeleteForecastExportJobRequest is the request type for the DeleteForecastExportJob API operation.

func (DeleteForecastExportJobRequest) Send 

func (r DeleteForecastExportJobRequest) Send(ctx context.Context) (*DeleteForecastExportJobResponse, error)

Send marshals and sends the DeleteForecastExportJob API request.

type DeleteForecastExportJobResponse 

type DeleteForecastExportJobResponse struct {
	*DeleteForecastExportJobOutput
	// contains filtered or unexported fields
}

DeleteForecastExportJobResponse is the response type for the DeleteForecastExportJob API operation.

func (*DeleteForecastExportJobResponse) SDKResponseMetdata 

func (r *DeleteForecastExportJobResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteForecastExportJob request.

type DeleteForecastInput 

type DeleteForecastInput struct {

	// The Amazon Resource Name (ARN) of the forecast to delete.
	//
	// ForecastArn is a required field
	ForecastArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeleteForecastInput) String 

func (s DeleteForecastInput) String() string

String returns the string representation

func (*DeleteForecastInput) Validate 

func (s *DeleteForecastInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeleteForecastOutput 

type DeleteForecastOutput struct {
	// contains filtered or unexported fields
}

func (DeleteForecastOutput) String 

func (s DeleteForecastOutput) String() string

String returns the string representation

type DeleteForecastRequest 

type DeleteForecastRequest struct {
	*aws.Request
	Input *DeleteForecastInput
	Copy  func(*DeleteForecastInput) DeleteForecastRequest
}

DeleteForecastRequest is the request type for the DeleteForecast API operation.

func (DeleteForecastRequest) Send 

func (r DeleteForecastRequest) Send(ctx context.Context) (*DeleteForecastResponse, error)

Send marshals and sends the DeleteForecast API request.

type DeleteForecastResponse 

type DeleteForecastResponse struct {
	*DeleteForecastOutput
	// contains filtered or unexported fields
}

DeleteForecastResponse is the response type for the DeleteForecast API operation.

func (*DeleteForecastResponse) SDKResponseMetdata 

func (r *DeleteForecastResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeleteForecast request.

type DeletePredictorInput 

type DeletePredictorInput struct {

	// The Amazon Resource Name (ARN) of the predictor to delete.
	//
	// PredictorArn is a required field
	PredictorArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DeletePredictorInput) String 

func (s DeletePredictorInput) String() string

String returns the string representation

func (*DeletePredictorInput) Validate 

func (s *DeletePredictorInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DeletePredictorOutput 

type DeletePredictorOutput struct {
	// contains filtered or unexported fields
}

func (DeletePredictorOutput) String 

func (s DeletePredictorOutput) String() string

String returns the string representation

type DeletePredictorRequest 

type DeletePredictorRequest struct {
	*aws.Request
	Input *DeletePredictorInput
	Copy  func(*DeletePredictorInput) DeletePredictorRequest
}

DeletePredictorRequest is the request type for the DeletePredictor API operation.

func (DeletePredictorRequest) Send 

func (r DeletePredictorRequest) Send(ctx context.Context) (*DeletePredictorResponse, error)

Send marshals and sends the DeletePredictor API request.

type DeletePredictorResponse 

type DeletePredictorResponse struct {
	*DeletePredictorOutput
	// contains filtered or unexported fields
}

DeletePredictorResponse is the response type for the DeletePredictor API operation.

func (*DeletePredictorResponse) SDKResponseMetdata 

func (r *DeletePredictorResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DeletePredictor request.

type DescribeDatasetGroupInput 

type DescribeDatasetGroupInput struct {

	// The Amazon Resource Name (ARN) of the dataset group.
	//
	// DatasetGroupArn is a required field
	DatasetGroupArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeDatasetGroupInput) String 

func (s DescribeDatasetGroupInput) String() string

String returns the string representation

func (*DescribeDatasetGroupInput) Validate 

func (s *DescribeDatasetGroupInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeDatasetGroupOutput 

type DescribeDatasetGroupOutput struct {

	// When the dataset group was created.
	CreationTime *time.Time `type:"timestamp"`

	// An array of Amazon Resource Names (ARNs) of the datasets contained in the
	// dataset group.
	DatasetArns []string `type:"list"`

	// The ARN of the dataset group.
	DatasetGroupArn *string `type:"string"`

	// The name of the dataset group.
	DatasetGroupName *string `min:"1" type:"string"`

	// The domain associated with the dataset group.
	Domain Domain `type:"string" enum:"true"`

	// When the dataset group was created or last updated from a call to the UpdateDatasetGroup
	// operation. While the dataset group is being updated, LastModificationTime
	// is the current time of the DescribeDatasetGroup call.
	LastModificationTime *time.Time `type:"timestamp"`

	// The status of the dataset group. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	//    * UPDATE_PENDING, UPDATE_IN_PROGRESS, UPDATE_FAILED
	//
	// The UPDATE states apply when you call the UpdateDatasetGroup operation.
	//
	// The Status of the dataset group must be ACTIVE before you can use the dataset
	// group to create a predictor.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

func (DescribeDatasetGroupOutput) String 

func (s DescribeDatasetGroupOutput) String() string

String returns the string representation

type DescribeDatasetGroupRequest 

type DescribeDatasetGroupRequest struct {
	*aws.Request
	Input *DescribeDatasetGroupInput
	Copy  func(*DescribeDatasetGroupInput) DescribeDatasetGroupRequest
}

DescribeDatasetGroupRequest is the request type for the DescribeDatasetGroup API operation.

func (DescribeDatasetGroupRequest) Send 

func (r DescribeDatasetGroupRequest) Send(ctx context.Context) (*DescribeDatasetGroupResponse, error)

Send marshals and sends the DescribeDatasetGroup API request.

type DescribeDatasetGroupResponse 

type DescribeDatasetGroupResponse struct {
	*DescribeDatasetGroupOutput
	// contains filtered or unexported fields
}

DescribeDatasetGroupResponse is the response type for the DescribeDatasetGroup API operation.

func (*DescribeDatasetGroupResponse) SDKResponseMetdata 

func (r *DescribeDatasetGroupResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeDatasetGroup request.

type DescribeDatasetImportJobInput 

type DescribeDatasetImportJobInput struct {

	// The Amazon Resource Name (ARN) of the dataset import job.
	//
	// DatasetImportJobArn is a required field
	DatasetImportJobArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeDatasetImportJobInput) String 

func (s DescribeDatasetImportJobInput) String() string

String returns the string representation

func (*DescribeDatasetImportJobInput) Validate 

func (s *DescribeDatasetImportJobInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeDatasetImportJobOutput 

type DescribeDatasetImportJobOutput struct {

	// When the dataset import job was created.
	CreationTime *time.Time `type:"timestamp"`

	// The size of the dataset in gigabytes (GB) after the import job has finished.
	DataSize *float64 `type:"double"`

	// The location of the training data to import and an AWS Identity and Access
	// Management (IAM) role that Amazon Forecast can assume to access the data.
	//
	// If encryption is used, DataSource includes an AWS Key Management Service
	// (KMS) key.
	DataSource *DataSource `type:"structure"`

	// The Amazon Resource Name (ARN) of the dataset that the training data was
	// imported to.
	DatasetArn *string `type:"string"`

	// The ARN of the dataset import job.
	DatasetImportJobArn *string `type:"string"`

	// The name of the dataset import job.
	DatasetImportJobName *string `min:"1" type:"string"`

	// Statistical information about each field in the input data.
	FieldStatistics map[string]Statistics `type:"map"`

	// The last time that the dataset was modified. The time depends on the status
	// of the job, as follows:
	//
	//    * CREATE_PENDING - The same time as CreationTime.
	//
	//    * CREATE_IN_PROGRESS - The current timestamp.
	//
	//    * ACTIVE or CREATE_FAILED - When the job finished or failed.
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The status of the dataset import job. The status is reflected in the status
	// of the dataset. For example, when the import job status is CREATE_IN_PROGRESS,
	// the status of the dataset is UPDATE_IN_PROGRESS. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	Status *string `type:"string"`

	// The format of timestamps in the dataset. The format that you specify depends
	// on the DataFrequency specified when the dataset was created. The following
	// formats are supported
	//
	//    * "yyyy-MM-dd" For the following data frequencies: Y, M, W, and D
	//
	//    * "yyyy-MM-dd HH:mm:ss" For the following data frequencies: H, 30min,
	//    15min, and 1min; and optionally, for: Y, M, W, and D
	TimestampFormat *string `type:"string"`
	// contains filtered or unexported fields
}

func (DescribeDatasetImportJobOutput) String 

func (s DescribeDatasetImportJobOutput) String() string

String returns the string representation

type DescribeDatasetImportJobRequest 

type DescribeDatasetImportJobRequest struct {
	*aws.Request
	Input *DescribeDatasetImportJobInput
	Copy  func(*DescribeDatasetImportJobInput) DescribeDatasetImportJobRequest
}

DescribeDatasetImportJobRequest is the request type for the DescribeDatasetImportJob API operation.

func (DescribeDatasetImportJobRequest) Send 

func (r DescribeDatasetImportJobRequest) Send(ctx context.Context) (*DescribeDatasetImportJobResponse, error)

Send marshals and sends the DescribeDatasetImportJob API request.

type DescribeDatasetImportJobResponse 

type DescribeDatasetImportJobResponse struct {
	*DescribeDatasetImportJobOutput
	// contains filtered or unexported fields
}

DescribeDatasetImportJobResponse is the response type for the DescribeDatasetImportJob API operation.

func (*DescribeDatasetImportJobResponse) SDKResponseMetdata 

func (r *DescribeDatasetImportJobResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeDatasetImportJob request.

type DescribeDatasetInput 

type DescribeDatasetInput struct {

	// The Amazon Resource Name (ARN) of the dataset.
	//
	// DatasetArn is a required field
	DatasetArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeDatasetInput) String 

func (s DescribeDatasetInput) String() string

String returns the string representation

func (*DescribeDatasetInput) Validate 

func (s *DescribeDatasetInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeDatasetOutput 

type DescribeDatasetOutput struct {

	// When the dataset was created.
	CreationTime *time.Time `type:"timestamp"`

	// The frequency of data collection.
	//
	// Valid intervals are Y (Year), M (Month), W (Week), D (Day), H (Hour), 30min
	// (30 minutes), 15min (15 minutes), 10min (10 minutes), 5min (5 minutes), and
	// 1min (1 minute). For example, "M" indicates every month and "30min" indicates
	// every 30 minutes.
	DataFrequency *string `type:"string"`

	// The Amazon Resource Name (ARN) of the dataset.
	DatasetArn *string `type:"string"`

	// The name of the dataset.
	DatasetName *string `min:"1" type:"string"`

	// The dataset type.
	DatasetType DatasetType `type:"string" enum:"true"`

	// The domain associated with the dataset.
	Domain Domain `type:"string" enum:"true"`

	// The AWS Key Management Service (KMS) key and the AWS Identity and Access
	// Management (IAM) role that Amazon Forecast can assume to access the key.
	EncryptionConfig *EncryptionConfig `type:"structure"`

	// When you create a dataset, LastModificationTime is the same as CreationTime.
	// While data is being imported to the dataset, LastModificationTime is the
	// current time of the DescribeDataset call. After a CreateDatasetImportJob
	// operation has finished, LastModificationTime is when the import job completed
	// or failed.
	LastModificationTime *time.Time `type:"timestamp"`

	// An array of SchemaAttribute objects that specify the dataset fields. Each
	// SchemaAttribute specifies the name and data type of a field.
	Schema *Schema `type:"structure"`

	// The status of the dataset. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	//    * UPDATE_PENDING, UPDATE_IN_PROGRESS, UPDATE_FAILED
	//
	// The UPDATE states apply while data is imported to the dataset from a call
	// to the CreateDatasetImportJob operation and reflect the status of the dataset
	// import job. For example, when the import job status is CREATE_IN_PROGRESS,
	// the status of the dataset is UPDATE_IN_PROGRESS.
	//
	// The Status of the dataset must be ACTIVE before you can import training data.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

func (DescribeDatasetOutput) String 

func (s DescribeDatasetOutput) String() string

String returns the string representation

type DescribeDatasetRequest 

type DescribeDatasetRequest struct {
	*aws.Request
	Input *DescribeDatasetInput
	Copy  func(*DescribeDatasetInput) DescribeDatasetRequest
}

DescribeDatasetRequest is the request type for the DescribeDataset API operation.

func (DescribeDatasetRequest) Send 

func (r DescribeDatasetRequest) Send(ctx context.Context) (*DescribeDatasetResponse, error)

Send marshals and sends the DescribeDataset API request.

type DescribeDatasetResponse 

type DescribeDatasetResponse struct {
	*DescribeDatasetOutput
	// contains filtered or unexported fields
}

DescribeDatasetResponse is the response type for the DescribeDataset API operation.

func (*DescribeDatasetResponse) SDKResponseMetdata 

func (r *DescribeDatasetResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeDataset request.

type DescribeForecastExportJobInput 

type DescribeForecastExportJobInput struct {

	// The Amazon Resource Name (ARN) of the forecast export job.
	//
	// ForecastExportJobArn is a required field
	ForecastExportJobArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeForecastExportJobInput) String 

func (s DescribeForecastExportJobInput) String() string

String returns the string representation

func (*DescribeForecastExportJobInput) Validate 

func (s *DescribeForecastExportJobInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeForecastExportJobOutput 

type DescribeForecastExportJobOutput struct {

	// When the forecast export job was created.
	CreationTime *time.Time `type:"timestamp"`

	// The path to the Amazon Simple Storage Service (Amazon S3) bucket where the
	// forecast is exported.
	Destination *DataDestination `type:"structure"`

	// The Amazon Resource Name (ARN) of the exported forecast.
	ForecastArn *string `type:"string"`

	// The ARN of the forecast export job.
	ForecastExportJobArn *string `type:"string"`

	// The name of the forecast export job.
	ForecastExportJobName *string `min:"1" type:"string"`

	// When the last successful export job finished.
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The status of the forecast export job. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	// The Status of the forecast export job must be ACTIVE before you can access
	// the forecast in your S3 bucket.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

func (DescribeForecastExportJobOutput) String 

func (s DescribeForecastExportJobOutput) String() string

String returns the string representation

type DescribeForecastExportJobRequest 

type DescribeForecastExportJobRequest struct {
	*aws.Request
	Input *DescribeForecastExportJobInput
	Copy  func(*DescribeForecastExportJobInput) DescribeForecastExportJobRequest
}

DescribeForecastExportJobRequest is the request type for the DescribeForecastExportJob API operation.

func (DescribeForecastExportJobRequest) Send 

func (r DescribeForecastExportJobRequest) Send(ctx context.Context) (*DescribeForecastExportJobResponse, error)

Send marshals and sends the DescribeForecastExportJob API request.

type DescribeForecastExportJobResponse 

type DescribeForecastExportJobResponse struct {
	*DescribeForecastExportJobOutput
	// contains filtered or unexported fields
}

DescribeForecastExportJobResponse is the response type for the DescribeForecastExportJob API operation.

func (*DescribeForecastExportJobResponse) SDKResponseMetdata 

func (r *DescribeForecastExportJobResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeForecastExportJob request.

type DescribeForecastInput 

type DescribeForecastInput struct {

	// The Amazon Resource Name (ARN) of the forecast.
	//
	// ForecastArn is a required field
	ForecastArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribeForecastInput) String 

func (s DescribeForecastInput) String() string

String returns the string representation

func (*DescribeForecastInput) Validate 

func (s *DescribeForecastInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribeForecastOutput 

type DescribeForecastOutput struct {

	// When the forecast creation task was created.
	CreationTime *time.Time `type:"timestamp"`

	// The ARN of the dataset group that provided the data used to train the predictor.
	DatasetGroupArn *string `type:"string"`

	// The forecast ARN as specified in the request.
	ForecastArn *string `type:"string"`

	// The name of the forecast.
	ForecastName *string `min:"1" type:"string"`

	// The quantiles at which probabilistic forecasts were generated.
	ForecastTypes []string `min:"1" type:"list"`

	// Initially, the same as CreationTime (status is CREATE_PENDING). Updated when
	// inference (creating the forecast) starts (status changed to CREATE_IN_PROGRESS),
	// and when inference is complete (status changed to ACTIVE) or fails (status
	// changed to CREATE_FAILED).
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The ARN of the predictor used to generate the forecast.
	PredictorArn *string `type:"string"`

	// The status of the forecast. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	// The Status of the forecast must be ACTIVE before you can query or export
	// the forecast.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

func (DescribeForecastOutput) String 

func (s DescribeForecastOutput) String() string

String returns the string representation

type DescribeForecastRequest 

type DescribeForecastRequest struct {
	*aws.Request
	Input *DescribeForecastInput
	Copy  func(*DescribeForecastInput) DescribeForecastRequest
}

DescribeForecastRequest is the request type for the DescribeForecast API operation.

func (DescribeForecastRequest) Send 

func (r DescribeForecastRequest) Send(ctx context.Context) (*DescribeForecastResponse, error)

Send marshals and sends the DescribeForecast API request.

type DescribeForecastResponse 

type DescribeForecastResponse struct {
	*DescribeForecastOutput
	// contains filtered or unexported fields
}

DescribeForecastResponse is the response type for the DescribeForecast API operation.

func (*DescribeForecastResponse) SDKResponseMetdata 

func (r *DescribeForecastResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribeForecast request.

type DescribePredictorInput 

type DescribePredictorInput struct {

	// The Amazon Resource Name (ARN) of the predictor that you want information
	// about.
	//
	// PredictorArn is a required field
	PredictorArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (DescribePredictorInput) String 

func (s DescribePredictorInput) String() string

String returns the string representation

func (*DescribePredictorInput) Validate 

func (s *DescribePredictorInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type DescribePredictorOutput 

type DescribePredictorOutput struct {

	// The Amazon Resource Name (ARN) of the algorithm used for model training.
	AlgorithmArn *string `type:"string"`

	// When PerformAutoML is specified, the ARN of the chosen algorithm.
	AutoMLAlgorithmArns []string `type:"list"`

	// When the model training task was created.
	CreationTime *time.Time `type:"timestamp"`

	// An array of the ARNs of the dataset import jobs used to import training data
	// for the predictor.
	DatasetImportJobArns []string `type:"list"`

	// An AWS Key Management Service (KMS) key and the AWS Identity and Access Management
	// (IAM) role that Amazon Forecast can assume to access the key.
	EncryptionConfig *EncryptionConfig `type:"structure"`

	// Used to override the default evaluation parameters of the specified algorithm.
	// Amazon Forecast evaluates a predictor by splitting a dataset into training
	// data and testing data. The evaluation parameters define how to perform the
	// split and the number of iterations.
	EvaluationParameters *EvaluationParameters `type:"structure"`

	// The featurization configuration.
	FeaturizationConfig *FeaturizationConfig `type:"structure"`

	// The number of time-steps of the forecast. The forecast horizon is also called
	// the prediction length.
	ForecastHorizon *int64 `type:"integer"`

	// The hyperparameter override values for the algorithm.
	HPOConfig *HyperParameterTuningJobConfig `type:"structure"`

	// Describes the dataset group that contains the data to use to train the predictor.
	InputDataConfig *InputDataConfig `type:"structure"`

	// Initially, the same as CreationTime (when the status is CREATE_PENDING).
	// This value is updated when training starts (when the status changes to CREATE_IN_PROGRESS),
	// and when training has completed (when the status changes to ACTIVE) or fails
	// (when the status changes to CREATE_FAILED).
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// Whether the predictor is set to perform AutoML.
	PerformAutoML *bool `type:"boolean"`

	// Whether the predictor is set to perform hyperparameter optimization (HPO).
	PerformHPO *bool `type:"boolean"`

	// The ARN of the predictor.
	PredictorArn *string `min:"1" type:"string"`

	// Details on the the status and results of the backtests performed to evaluate
	// the accuracy of the predictor. You specify the number of backtests to perform
	// when you call the operation.
	PredictorExecutionDetails *PredictorExecutionDetails `type:"structure"`

	// The name of the predictor.
	PredictorName *string `min:"1" type:"string"`

	// The status of the predictor. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	//    * UPDATE_PENDING, UPDATE_IN_PROGRESS, UPDATE_FAILED
	//
	// The Status of the predictor must be ACTIVE before you can use the predictor
	// to create a forecast.
	Status *string `type:"string"`

	// The default training parameters or overrides selected during model training.
	// If using the AutoML algorithm or if HPO is turned on while using the DeepAR+
	// algorithms, the optimized values for the chosen hyperparameters are returned.
	// For more information, see aws-forecast-choosing-recipes.
	TrainingParameters map[string]string `type:"map"`
	// contains filtered or unexported fields
}

func (DescribePredictorOutput) String 

func (s DescribePredictorOutput) String() string

String returns the string representation

type DescribePredictorRequest 

type DescribePredictorRequest struct {
	*aws.Request
	Input *DescribePredictorInput
	Copy  func(*DescribePredictorInput) DescribePredictorRequest
}

DescribePredictorRequest is the request type for the DescribePredictor API operation.

func (DescribePredictorRequest) Send 

func (r DescribePredictorRequest) Send(ctx context.Context) (*DescribePredictorResponse, error)

Send marshals and sends the DescribePredictor API request.

type DescribePredictorResponse 

type DescribePredictorResponse struct {
	*DescribePredictorOutput
	// contains filtered or unexported fields
}

DescribePredictorResponse is the response type for the DescribePredictor API operation.

func (*DescribePredictorResponse) SDKResponseMetdata 

func (r *DescribePredictorResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the DescribePredictor request.

type Domain 

type Domain string
const (
	DomainRetail            Domain = "RETAIL"
	DomainCustom            Domain = "CUSTOM"
	DomainInventoryPlanning Domain = "INVENTORY_PLANNING"
	DomainEc2Capacity       Domain = "EC2_CAPACITY"
	DomainWorkForce         Domain = "WORK_FORCE"
	DomainWebTraffic        Domain = "WEB_TRAFFIC"
	DomainMetrics           Domain = "METRICS"
)

Enum values for Domain

func (Domain) MarshalValue 

func (enum Domain) MarshalValue() (string, error)

func (Domain) MarshalValueBuf 

func (enum Domain) MarshalValueBuf(b []byte) ([]byte, error)

type EncryptionConfig 

type EncryptionConfig struct {

	// The Amazon Resource Name (ARN) of the KMS key.
	//
	// KMSKeyArn is a required field
	KMSKeyArn *string `type:"string" required:"true"`

	// The ARN of the IAM role that Amazon Forecast can assume to access the AWS
	// KMS key.
	//
	// Passing a role across AWS accounts is not allowed. If you pass a role that
	// isn't in your account, you get an InvalidInputException error.
	//
	// RoleArn is a required field
	RoleArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

An AWS Key Management Service (KMS) key and an AWS Identity and Access Management (IAM) role that Amazon Forecast can assume to access the key. You can specify this optional object in the CreateDataset and CreatePredictor requests.

func (EncryptionConfig) String 

func (s EncryptionConfig) String() string

String returns the string representation

func (*EncryptionConfig) Validate 

func (s *EncryptionConfig) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type EvaluationParameters 

type EvaluationParameters struct {

	// The point from the end of the dataset where you want to split the data for
	// model training and testing (evaluation). Specify the value as the number
	// of data points. The default is the value of the forecast horizon. BackTestWindowOffset
	// can be used to mimic a past virtual forecast start date. This value must
	// be greater than or equal to the forecast horizon and less than half of the
	// TARGET_TIME_SERIES dataset length.
	//
	// ForecastHorizon <= BackTestWindowOffset < 1/2 * TARGET_TIME_SERIES dataset
	// length
	BackTestWindowOffset *int64 `type:"integer"`

	// The number of times to split the input data. The default is 1. Valid values
	// are 1 through 5.
	NumberOfBacktestWindows *int64 `type:"integer"`
	// contains filtered or unexported fields
}

Parameters that define how to split a dataset into training data and testing data, and the number of iterations to perform. These parameters are specified in the predefined algorithms but you can override them in the CreatePredictor request.

func (EvaluationParameters) String 

func (s EvaluationParameters) String() string

String returns the string representation

type EvaluationResult 

type EvaluationResult struct {

	// The Amazon Resource Name (ARN) of the algorithm that was evaluated.
	AlgorithmArn *string `type:"string"`

	// The array of test windows used for evaluating the algorithm. The NumberOfBacktestWindows
	// from the EvaluationParameters object determines the number of windows in
	// the array.
	TestWindows []WindowSummary `type:"list"`
	// contains filtered or unexported fields
}

The results of evaluating an algorithm. Returned as part of the GetAccuracyMetrics response.

func (EvaluationResult) String 

func (s EvaluationResult) String() string

String returns the string representation

type EvaluationType 

type EvaluationType string
const (
	EvaluationTypeSummary  EvaluationType = "SUMMARY"
	EvaluationTypeComputed EvaluationType = "COMPUTED"
)

Enum values for EvaluationType

func (EvaluationType) MarshalValue 

func (enum EvaluationType) MarshalValue() (string, error)

func (EvaluationType) MarshalValueBuf 

func (enum EvaluationType) MarshalValueBuf(b []byte) ([]byte, error)

type Featurization 

type Featurization struct {

	// The name of the schema attribute that specifies the data field to be featurized.
	// Amazon Forecast supports the target field of the TARGET_TIME_SERIES and the
	// RELATED_TIME_SERIES datasets. For example, for the RETAIL domain, the target
	// is demand, and for the CUSTOM domain, the target is target_value. For more
	// information, see howitworks-missing-values.
	//
	// AttributeName is a required field
	AttributeName *string `min:"1" type:"string" required:"true"`

	// An array of one FeaturizationMethod object that specifies the feature transformation
	// method.
	FeaturizationPipeline []FeaturizationMethod `min:"1" type:"list"`
	// contains filtered or unexported fields
}

Provides featurization (transformation) information for a dataset field. This object is part of the FeaturizationConfig object.

For example:

{

"AttributeName": "demand",

FeaturizationPipeline [ {

"FeaturizationMethodName": "filling",

"FeaturizationMethodParameters": {"aggregation": "avg", "backfill": "nan"}

} ]

}

func (Featurization) String 

func (s Featurization) String() string

String returns the string representation

func (*Featurization) Validate 

func (s *Featurization) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type FeaturizationConfig 

type FeaturizationConfig struct {

	// An array of featurization (transformation) information for the fields of
	// a dataset.
	Featurizations []Featurization `min:"1" type:"list"`

	// An array of dimension (field) names that specify how to group the generated
	// forecast.
	//
	// For example, suppose that you are generating a forecast for item sales across
	// all of your stores, and your dataset contains a store_id field. If you want
	// the sales forecast for each item by store, you would specify store_id as
	// the dimension.
	//
	// All forecast dimensions specified in the TARGET_TIME_SERIES dataset don't
	// need to be specified in the CreatePredictor request. All forecast dimensions
	// specified in the RELATED_TIME_SERIES dataset must be specified in the CreatePredictor
	// request.
	ForecastDimensions []string `min:"1" type:"list"`

	// The frequency of predictions in a forecast.
	//
	// Valid intervals are Y (Year), M (Month), W (Week), D (Day), H (Hour), 30min
	// (30 minutes), 15min (15 minutes), 10min (10 minutes), 5min (5 minutes), and
	// 1min (1 minute). For example, "Y" indicates every year and "5min" indicates
	// every five minutes.
	//
	// The frequency must be greater than or equal to the TARGET_TIME_SERIES dataset
	// frequency.
	//
	// When a RELATED_TIME_SERIES dataset is provided, the frequency must be equal
	// to the RELATED_TIME_SERIES dataset frequency.
	//
	// ForecastFrequency is a required field
	ForecastFrequency *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

In a CreatePredictor operation, the specified algorithm trains a model using the specified dataset group. You can optionally tell the operation to modify data fields prior to training a model. These modifications are referred to as featurization.

You define featurization using the FeaturizationConfig object. You specify an array of transformations, one for each field that you want to featurize. You then include the FeaturizationConfig object in your CreatePredictor request. Amazon Forecast applies the featurization to the TARGET_TIME_SERIES and RELATED_TIME_SERIES datasets before model training.

You can create multiple featurization configurations. For example, you might call the CreatePredictor operation twice by specifying different featurization configurations.

func (FeaturizationConfig) String 

func (s FeaturizationConfig) String() string

String returns the string representation

func (*FeaturizationConfig) Validate 

func (s *FeaturizationConfig) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type FeaturizationMethod 

type FeaturizationMethod struct {

	// The name of the method. The "filling" method is the only supported method.
	//
	// FeaturizationMethodName is a required field
	FeaturizationMethodName FeaturizationMethodName `type:"string" required:"true" enum:"true"`

	// The method parameters (key-value pairs), which are a map of override parameters.
	// Specify these parameters to override the default values. Related Time Series
	// attributes do not accept aggregation parameters.
	//
	// The following list shows the parameters and their valid values for the "filling"
	// featurization method for a Target Time Series dataset. Bold signifies the
	// default value.
	//
	//    * aggregation: sum, avg, first, min, max
	//
	//    * frontfill: none
	//
	//    * middlefill: zero, nan (not a number), value, median, mean, min, max
	//
	//    * backfill: zero, nan, value, median, mean, min, max
	//
	// The following list shows the parameters and their valid values for a Related
	// Time Series featurization method (there are no defaults):
	//
	//    * middlefill: zero, value, median, mean, min, max
	//
	//    * backfill: zero, value, median, mean, min, max
	//
	//    * futurefill: zero, value, median, mean, min, max
	FeaturizationMethodParameters map[string]string `min:"1" type:"map"`
	// contains filtered or unexported fields
}

Provides information about the method that featurizes (transforms) a dataset field. The method is part of the FeaturizationPipeline of the Featurization object.

The following is an example of how you specify a FeaturizationMethod object.

{

"FeaturizationMethodName": "filling",

"FeaturizationMethodParameters": {"aggregation": "sum", "middlefill": "zero", "backfill": "zero"}

}

func (FeaturizationMethod) String 

func (s FeaturizationMethod) String() string

String returns the string representation

func (*FeaturizationMethod) Validate 

func (s *FeaturizationMethod) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type FeaturizationMethodName 

type FeaturizationMethodName string
const (
	FeaturizationMethodNameFilling FeaturizationMethodName = "filling"
)

Enum values for FeaturizationMethodName

func (FeaturizationMethodName) MarshalValue 

func (enum FeaturizationMethodName) MarshalValue() (string, error)

func (FeaturizationMethodName) MarshalValueBuf 

func (enum FeaturizationMethodName) MarshalValueBuf(b []byte) ([]byte, error)

type Filter 

type Filter struct {

	// The condition to apply. To include the objects that match the statement,
	// specify IS. To exclude matching objects, specify IS_NOT.
	//
	// Condition is a required field
	Condition FilterConditionString `type:"string" required:"true" enum:"true"`

	// The name of the parameter to filter on.
	//
	// Key is a required field
	Key *string `type:"string" required:"true"`

	// The value to match.
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

Describes a filter for choosing a subset of objects. Each filter consists of a condition and a match statement. The condition is either IS or IS_NOT, which specifies whether to include or exclude the objects that match the statement, respectively. The match statement consists of a key and a value.

func (Filter) String 

func (s Filter) String() string

String returns the string representation

func (*Filter) Validate 

func (s *Filter) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type FilterConditionString 

type FilterConditionString string
const (
	FilterConditionStringIs    FilterConditionString = "IS"
	FilterConditionStringIsNot FilterConditionString = "IS_NOT"
)

Enum values for FilterConditionString

func (FilterConditionString) MarshalValue 

func (enum FilterConditionString) MarshalValue() (string, error)

func (FilterConditionString) MarshalValueBuf 

func (enum FilterConditionString) MarshalValueBuf(b []byte) ([]byte, error)

type ForecastExportJobSummary 

type ForecastExportJobSummary struct {

	// When the forecast export job was created.
	CreationTime *time.Time `type:"timestamp"`

	// The path to the Amazon Simple Storage Service (Amazon S3) bucket where the
	// forecast is exported.
	Destination *DataDestination `type:"structure"`

	// The Amazon Resource Name (ARN) of the forecast export job.
	ForecastExportJobArn *string `type:"string"`

	// The name of the forecast export job.
	ForecastExportJobName *string `min:"1" type:"string"`

	// When the last successful export job finished.
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The status of the forecast export job. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	// The Status of the forecast export job must be ACTIVE before you can access
	// the forecast in your S3 bucket.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

Provides a summary of the forecast export job properties used in the ListForecastExportJobs operation. To get the complete set of properties, call the DescribeForecastExportJob operation, and provide the listed ForecastExportJobArn.

func (ForecastExportJobSummary) String 

func (s ForecastExportJobSummary) String() string

String returns the string representation

type ForecastSummary 

type ForecastSummary struct {

	// When the forecast creation task was created.
	CreationTime *time.Time `type:"timestamp"`

	// The Amazon Resource Name (ARN) of the dataset group that provided the data
	// used to train the predictor.
	DatasetGroupArn *string `type:"string"`

	// The ARN of the forecast.
	ForecastArn *string `type:"string"`

	// The name of the forecast.
	ForecastName *string `min:"1" type:"string"`

	// Initially, the same as CreationTime (status is CREATE_PENDING). Updated when
	// inference (creating the forecast) starts (status changed to CREATE_IN_PROGRESS),
	// and when inference is complete (status changed to ACTIVE) or fails (status
	// changed to CREATE_FAILED).
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The ARN of the predictor used to generate the forecast.
	PredictorArn *string `type:"string"`

	// The status of the forecast. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	// The Status of the forecast must be ACTIVE before you can query or export
	// the forecast.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

Provides a summary of the forecast properties used in the ListForecasts operation. To get the complete set of properties, call the DescribeForecast operation, and provide the ForecastArn that is listed in the summary.

func (ForecastSummary) String 

func (s ForecastSummary) String() string

String returns the string representation

type GetAccuracyMetricsInput 

type GetAccuracyMetricsInput struct {

	// The Amazon Resource Name (ARN) of the predictor to get metrics for.
	//
	// PredictorArn is a required field
	PredictorArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (GetAccuracyMetricsInput) String 

func (s GetAccuracyMetricsInput) String() string

String returns the string representation

func (*GetAccuracyMetricsInput) Validate 

func (s *GetAccuracyMetricsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type GetAccuracyMetricsOutput 

type GetAccuracyMetricsOutput struct {

	// An array of results from evaluating the predictor.
	PredictorEvaluationResults []EvaluationResult `type:"list"`
	// contains filtered or unexported fields
}

func (GetAccuracyMetricsOutput) String 

func (s GetAccuracyMetricsOutput) String() string

String returns the string representation

type GetAccuracyMetricsRequest 

type GetAccuracyMetricsRequest struct {
	*aws.Request
	Input *GetAccuracyMetricsInput
	Copy  func(*GetAccuracyMetricsInput) GetAccuracyMetricsRequest
}

GetAccuracyMetricsRequest is the request type for the GetAccuracyMetrics API operation.

func (GetAccuracyMetricsRequest) Send 

func (r GetAccuracyMetricsRequest) Send(ctx context.Context) (*GetAccuracyMetricsResponse, error)

Send marshals and sends the GetAccuracyMetrics API request.

type GetAccuracyMetricsResponse 

type GetAccuracyMetricsResponse struct {
	*GetAccuracyMetricsOutput
	// contains filtered or unexported fields
}

GetAccuracyMetricsResponse is the response type for the GetAccuracyMetrics API operation.

func (*GetAccuracyMetricsResponse) SDKResponseMetdata 

func (r *GetAccuracyMetricsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the GetAccuracyMetrics request.

type HyperParameterTuningJobConfig 

type HyperParameterTuningJobConfig struct {

	// Specifies the ranges of valid values for the hyperparameters.
	ParameterRanges *ParameterRanges `type:"structure"`
	// contains filtered or unexported fields
}

Configuration information for a hyperparameter tuning job. You specify this object in the CreatePredictor request.

A hyperparameter is a parameter that governs the model training process. You set hyperparameters before training starts, unlike model parameters, which are determined during training. The values of the hyperparameters effect which values are chosen for the model parameters.

In a hyperparameter tuning job, Amazon Forecast chooses the set of hyperparameter values that optimize a specified metric. Forecast accomplishes this by running many training jobs over a range of hyperparameter values. The optimum set of values depends on the algorithm, the training data, and the specified metric objective.

func (HyperParameterTuningJobConfig) String 

func (s HyperParameterTuningJobConfig) String() string

String returns the string representation

func (*HyperParameterTuningJobConfig) Validate 

func (s *HyperParameterTuningJobConfig) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type InputDataConfig 

type InputDataConfig struct {

	// The Amazon Resource Name (ARN) of the dataset group.
	//
	// DatasetGroupArn is a required field
	DatasetGroupArn *string `type:"string" required:"true"`

	// An array of supplementary features. The only supported feature is a holiday
	// calendar.
	SupplementaryFeatures []SupplementaryFeature `min:"1" type:"list"`
	// contains filtered or unexported fields
}

The data used to train a predictor. The data includes a dataset group and any supplementary features. You specify this object in the CreatePredictor request.

func (InputDataConfig) String 

func (s InputDataConfig) String() string

String returns the string representation

func (*InputDataConfig) Validate 

func (s *InputDataConfig) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type IntegerParameterRange 

type IntegerParameterRange struct {

	// The maximum tunable value of the hyperparameter.
	//
	// MaxValue is a required field
	MaxValue *int64 `type:"integer" required:"true"`

	// The minimum tunable value of the hyperparameter.
	//
	// MinValue is a required field
	MinValue *int64 `type:"integer" required:"true"`

	// The name of the hyperparameter to tune.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The scale that hyperparameter tuning uses to search the hyperparameter range.
	// Valid values:
	//
	// Auto
	//
	// Amazon Forecast hyperparameter tuning chooses the best scale for the hyperparameter.
	//
	// Linear
	//
	// Hyperparameter tuning searches the values in the hyperparameter range by
	// using a linear scale.
	//
	// Logarithmic
	//
	// Hyperparameter tuning searches the values in the hyperparameter range by
	// using a logarithmic scale.
	//
	// Logarithmic scaling works only for ranges that have values greater than 0.
	//
	// ReverseLogarithmic
	//
	// Not supported for IntegerParameterRange.
	//
	// Reverse logarithmic scaling works only for ranges that are entirely within
	// the range 0 <= x < 1.0.
	//
	// For information about choosing a hyperparameter scale, see Hyperparameter
	// Scaling (http://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html#scaling-type).
	// One of the following values:
	ScalingType ScalingType `type:"string" enum:"true"`
	// contains filtered or unexported fields
}

Specifies an integer hyperparameter and it's range of tunable values. This object is part of the ParameterRanges object.

func (IntegerParameterRange) String 

func (s IntegerParameterRange) String() string

String returns the string representation

func (*IntegerParameterRange) Validate 

func (s *IntegerParameterRange) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListDatasetGroupsInput 

type ListDatasetGroupsInput struct {

	// The number of items to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the result of the previous request was truncated, the response includes
	// a NextToken. To retrieve the next set of results, use the token in the next
	// request. Tokens expire after 24 hours.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListDatasetGroupsInput) String 

func (s ListDatasetGroupsInput) String() string

String returns the string representation

func (*ListDatasetGroupsInput) Validate 

func (s *ListDatasetGroupsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListDatasetGroupsOutput 

type ListDatasetGroupsOutput struct {

	// An array of objects that summarize each dataset group's properties.
	DatasetGroups []DatasetGroupSummary `type:"list"`

	// If the response is truncated, Amazon Forecast returns this token. To retrieve
	// the next set of results, use the token in the next request.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListDatasetGroupsOutput) String 

func (s ListDatasetGroupsOutput) String() string

String returns the string representation

type ListDatasetGroupsPaginator 

type ListDatasetGroupsPaginator struct {
	aws.Pager
}

ListDatasetGroupsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListDatasetGroupsPaginator 

func NewListDatasetGroupsPaginator(req ListDatasetGroupsRequest) ListDatasetGroupsPaginator

NewListDatasetGroupsRequestPaginator returns a paginator for ListDatasetGroups. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListDatasetGroupsRequest(input)
p := forecast.NewListDatasetGroupsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListDatasetGroupsPaginator) CurrentPage 

func (p *ListDatasetGroupsPaginator) CurrentPage() *ListDatasetGroupsOutput

type ListDatasetGroupsRequest 

type ListDatasetGroupsRequest struct {
	*aws.Request
	Input *ListDatasetGroupsInput
	Copy  func(*ListDatasetGroupsInput) ListDatasetGroupsRequest
}

ListDatasetGroupsRequest is the request type for the ListDatasetGroups API operation.

func (ListDatasetGroupsRequest) Send 

func (r ListDatasetGroupsRequest) Send(ctx context.Context) (*ListDatasetGroupsResponse, error)

Send marshals and sends the ListDatasetGroups API request.

type ListDatasetGroupsResponse 

type ListDatasetGroupsResponse struct {
	*ListDatasetGroupsOutput
	// contains filtered or unexported fields
}

ListDatasetGroupsResponse is the response type for the ListDatasetGroups API operation.

func (*ListDatasetGroupsResponse) SDKResponseMetdata 

func (r *ListDatasetGroupsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListDatasetGroups request.

type ListDatasetImportJobsInput 

type ListDatasetImportJobsInput struct {

	// An array of filters. For each filter, you provide a condition and a match
	// statement. The condition is either IS or IS_NOT, which specifies whether
	// to include or exclude the datasets that match the statement from the list,
	// respectively. The match statement consists of a key and a value.
	//
	// Filter properties
	//
	//    * Condition - The condition to apply. Valid values are IS and IS_NOT.
	//    To include the datasets that match the statement, specify IS. To exclude
	//    matching datasets, specify IS_NOT.
	//
	//    * Key - The name of the parameter to filter on. Valid values are DatasetArn
	//    and Status.
	//
	//    * Value - The value to match.
	//
	// For example, to list all dataset import jobs whose status is ACTIVE, you
	// specify the following filter:
	//
	// "Filters": [ { "Condition": "IS", "Key": "Status", "Value": "ACTIVE" } ]
	Filters []Filter `type:"list"`

	// The number of items to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the result of the previous request was truncated, the response includes
	// a NextToken. To retrieve the next set of results, use the token in the next
	// request. Tokens expire after 24 hours.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListDatasetImportJobsInput) String 

func (s ListDatasetImportJobsInput) String() string

String returns the string representation

func (*ListDatasetImportJobsInput) Validate 

func (s *ListDatasetImportJobsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListDatasetImportJobsOutput 

type ListDatasetImportJobsOutput struct {

	// An array of objects that summarize each dataset import job's properties.
	DatasetImportJobs []DatasetImportJobSummary `type:"list"`

	// If the response is truncated, Amazon Forecast returns this token. To retrieve
	// the next set of results, use the token in the next request.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListDatasetImportJobsOutput) String 

func (s ListDatasetImportJobsOutput) String() string

String returns the string representation

type ListDatasetImportJobsPaginator 

type ListDatasetImportJobsPaginator struct {
	aws.Pager
}

ListDatasetImportJobsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListDatasetImportJobsPaginator 

func NewListDatasetImportJobsPaginator(req ListDatasetImportJobsRequest) ListDatasetImportJobsPaginator

NewListDatasetImportJobsRequestPaginator returns a paginator for ListDatasetImportJobs. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListDatasetImportJobsRequest(input)
p := forecast.NewListDatasetImportJobsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListDatasetImportJobsPaginator) CurrentPage 

func (p *ListDatasetImportJobsPaginator) CurrentPage() *ListDatasetImportJobsOutput

type ListDatasetImportJobsRequest 

type ListDatasetImportJobsRequest struct {
	*aws.Request
	Input *ListDatasetImportJobsInput
	Copy  func(*ListDatasetImportJobsInput) ListDatasetImportJobsRequest
}

ListDatasetImportJobsRequest is the request type for the ListDatasetImportJobs API operation.

func (ListDatasetImportJobsRequest) Send 

func (r ListDatasetImportJobsRequest) Send(ctx context.Context) (*ListDatasetImportJobsResponse, error)

Send marshals and sends the ListDatasetImportJobs API request.

type ListDatasetImportJobsResponse 

type ListDatasetImportJobsResponse struct {
	*ListDatasetImportJobsOutput
	// contains filtered or unexported fields
}

ListDatasetImportJobsResponse is the response type for the ListDatasetImportJobs API operation.

func (*ListDatasetImportJobsResponse) SDKResponseMetdata 

func (r *ListDatasetImportJobsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListDatasetImportJobs request.

type ListDatasetsInput 

type ListDatasetsInput struct {

	// The number of items to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the result of the previous request was truncated, the response includes
	// a NextToken. To retrieve the next set of results, use the token in the next
	// request. Tokens expire after 24 hours.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListDatasetsInput) String 

func (s ListDatasetsInput) String() string

String returns the string representation

func (*ListDatasetsInput) Validate 

func (s *ListDatasetsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListDatasetsOutput 

type ListDatasetsOutput struct {

	// An array of objects that summarize each dataset's properties.
	Datasets []DatasetSummary `type:"list"`

	// If the response is truncated, Amazon Forecast returns this token. To retrieve
	// the next set of results, use the token in the next request.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListDatasetsOutput) String 

func (s ListDatasetsOutput) String() string

String returns the string representation

type ListDatasetsPaginator 

type ListDatasetsPaginator struct {
	aws.Pager
}

ListDatasetsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListDatasetsPaginator 

func NewListDatasetsPaginator(req ListDatasetsRequest) ListDatasetsPaginator

NewListDatasetsRequestPaginator returns a paginator for ListDatasets. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListDatasetsRequest(input)
p := forecast.NewListDatasetsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListDatasetsPaginator) CurrentPage 

func (p *ListDatasetsPaginator) CurrentPage() *ListDatasetsOutput

type ListDatasetsRequest 

type ListDatasetsRequest struct {
	*aws.Request
	Input *ListDatasetsInput
	Copy  func(*ListDatasetsInput) ListDatasetsRequest
}

ListDatasetsRequest is the request type for the ListDatasets API operation.

func (ListDatasetsRequest) Send 

func (r ListDatasetsRequest) Send(ctx context.Context) (*ListDatasetsResponse, error)

Send marshals and sends the ListDatasets API request.

type ListDatasetsResponse 

type ListDatasetsResponse struct {
	*ListDatasetsOutput
	// contains filtered or unexported fields
}

ListDatasetsResponse is the response type for the ListDatasets API operation.

func (*ListDatasetsResponse) SDKResponseMetdata 

func (r *ListDatasetsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListDatasets request.

type ListForecastExportJobsInput 

type ListForecastExportJobsInput struct {

	// An array of filters. For each filter, you provide a condition and a match
	// statement. The condition is either IS or IS_NOT, which specifies whether
	// to include or exclude the forecast export jobs that match the statement from
	// the list, respectively. The match statement consists of a key and a value.
	//
	// Filter properties
	//
	//    * Condition - The condition to apply. Valid values are IS and IS_NOT.
	//    To include the forecast export jobs that match the statement, specify
	//    IS. To exclude matching forecast export jobs, specify IS_NOT.
	//
	//    * Key - The name of the parameter to filter on. Valid values are ForecastArn
	//    and Status.
	//
	//    * Value - The value to match.
	//
	// For example, to list all jobs that export a forecast named electricityforecast,
	// specify the following filter:
	//
	// "Filters": [ { "Condition": "IS", "Key": "ForecastArn", "Value": "arn:aws:forecast:us-west-2:<acct-id>:forecast/electricityforecast"
	// } ]
	Filters []Filter `type:"list"`

	// The number of items to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the result of the previous request was truncated, the response includes
	// a NextToken. To retrieve the next set of results, use the token in the next
	// request. Tokens expire after 24 hours.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListForecastExportJobsInput) String 

func (s ListForecastExportJobsInput) String() string

String returns the string representation

func (*ListForecastExportJobsInput) Validate 

func (s *ListForecastExportJobsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListForecastExportJobsOutput 

type ListForecastExportJobsOutput struct {

	// An array of objects that summarize each export job's properties.
	ForecastExportJobs []ForecastExportJobSummary `type:"list"`

	// If the response is truncated, Amazon Forecast returns this token. To retrieve
	// the next set of results, use the token in the next request.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListForecastExportJobsOutput) String 

func (s ListForecastExportJobsOutput) String() string

String returns the string representation

type ListForecastExportJobsPaginator 

type ListForecastExportJobsPaginator struct {
	aws.Pager
}

ListForecastExportJobsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListForecastExportJobsPaginator 

func NewListForecastExportJobsPaginator(req ListForecastExportJobsRequest) ListForecastExportJobsPaginator

NewListForecastExportJobsRequestPaginator returns a paginator for ListForecastExportJobs. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListForecastExportJobsRequest(input)
p := forecast.NewListForecastExportJobsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListForecastExportJobsPaginator) CurrentPage 

func (p *ListForecastExportJobsPaginator) CurrentPage() *ListForecastExportJobsOutput

type ListForecastExportJobsRequest 

type ListForecastExportJobsRequest struct {
	*aws.Request
	Input *ListForecastExportJobsInput
	Copy  func(*ListForecastExportJobsInput) ListForecastExportJobsRequest
}

ListForecastExportJobsRequest is the request type for the ListForecastExportJobs API operation.

func (ListForecastExportJobsRequest) Send 

func (r ListForecastExportJobsRequest) Send(ctx context.Context) (*ListForecastExportJobsResponse, error)

Send marshals and sends the ListForecastExportJobs API request.

type ListForecastExportJobsResponse 

type ListForecastExportJobsResponse struct {
	*ListForecastExportJobsOutput
	// contains filtered or unexported fields
}

ListForecastExportJobsResponse is the response type for the ListForecastExportJobs API operation.

func (*ListForecastExportJobsResponse) SDKResponseMetdata 

func (r *ListForecastExportJobsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListForecastExportJobs request.

type ListForecastsInput 

type ListForecastsInput struct {

	// An array of filters. For each filter, you provide a condition and a match
	// statement. The condition is either IS or IS_NOT, which specifies whether
	// to include or exclude the forecasts that match the statement from the list,
	// respectively. The match statement consists of a key and a value.
	//
	// Filter properties
	//
	//    * Condition - The condition to apply. Valid values are IS and IS_NOT.
	//    To include the forecasts that match the statement, specify IS. To exclude
	//    matching forecasts, specify IS_NOT.
	//
	//    * Key - The name of the parameter to filter on. Valid values are DatasetGroupArn,
	//    PredictorArn, and Status.
	//
	//    * Value - The value to match.
	//
	// For example, to list all forecasts whose status is not ACTIVE, you would
	// specify:
	//
	// "Filters": [ { "Condition": "IS_NOT", "Key": "Status", "Value": "ACTIVE"
	// } ]
	Filters []Filter `type:"list"`

	// The number of items to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the result of the previous request was truncated, the response includes
	// a NextToken. To retrieve the next set of results, use the token in the next
	// request. Tokens expire after 24 hours.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListForecastsInput) String 

func (s ListForecastsInput) String() string

String returns the string representation

func (*ListForecastsInput) Validate 

func (s *ListForecastsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListForecastsOutput 

type ListForecastsOutput struct {

	// An array of objects that summarize each forecast's properties.
	Forecasts []ForecastSummary `type:"list"`

	// If the response is truncated, Amazon Forecast returns this token. To retrieve
	// the next set of results, use the token in the next request.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListForecastsOutput) String 

func (s ListForecastsOutput) String() string

String returns the string representation

type ListForecastsPaginator 

type ListForecastsPaginator struct {
	aws.Pager
}

ListForecastsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListForecastsPaginator 

func NewListForecastsPaginator(req ListForecastsRequest) ListForecastsPaginator

NewListForecastsRequestPaginator returns a paginator for ListForecasts. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListForecastsRequest(input)
p := forecast.NewListForecastsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListForecastsPaginator) CurrentPage 

func (p *ListForecastsPaginator) CurrentPage() *ListForecastsOutput

type ListForecastsRequest 

type ListForecastsRequest struct {
	*aws.Request
	Input *ListForecastsInput
	Copy  func(*ListForecastsInput) ListForecastsRequest
}

ListForecastsRequest is the request type for the ListForecasts API operation.

func (ListForecastsRequest) Send 

func (r ListForecastsRequest) Send(ctx context.Context) (*ListForecastsResponse, error)

Send marshals and sends the ListForecasts API request.

type ListForecastsResponse 

type ListForecastsResponse struct {
	*ListForecastsOutput
	// contains filtered or unexported fields
}

ListForecastsResponse is the response type for the ListForecasts API operation.

func (*ListForecastsResponse) SDKResponseMetdata 

func (r *ListForecastsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListForecasts request.

type ListPredictorsInput 

type ListPredictorsInput struct {

	// An array of filters. For each filter, you provide a condition and a match
	// statement. The condition is either IS or IS_NOT, which specifies whether
	// to include or exclude the predictors that match the statement from the list,
	// respectively. The match statement consists of a key and a value.
	//
	// Filter properties
	//
	//    * Condition - The condition to apply. Valid values are IS and IS_NOT.
	//    To include the predictors that match the statement, specify IS. To exclude
	//    matching predictors, specify IS_NOT.
	//
	//    * Key - The name of the parameter to filter on. Valid values are DatasetGroupArn
	//    and Status.
	//
	//    * Value - The value to match.
	//
	// For example, to list all predictors whose status is ACTIVE, you would specify:
	//
	// "Filters": [ { "Condition": "IS", "Key": "Status", "Value": "ACTIVE" } ]
	Filters []Filter `type:"list"`

	// The number of items to return in the response.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the result of the previous request was truncated, the response includes
	// a NextToken. To retrieve the next set of results, use the token in the next
	// request. Tokens expire after 24 hours.
	NextToken *string `min:"1" type:"string"`
	// contains filtered or unexported fields
}

func (ListPredictorsInput) String 

func (s ListPredictorsInput) String() string

String returns the string representation

func (*ListPredictorsInput) Validate 

func (s *ListPredictorsInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListPredictorsOutput 

type ListPredictorsOutput struct {

	// If the response is truncated, Amazon Forecast returns this token. To retrieve
	// the next set of results, use the token in the next request.
	NextToken *string `min:"1" type:"string"`

	// An array of objects that summarize each predictor's properties.
	Predictors []PredictorSummary `type:"list"`
	// contains filtered or unexported fields
}

func (ListPredictorsOutput) String 

func (s ListPredictorsOutput) String() string

String returns the string representation

type ListPredictorsPaginator 

type ListPredictorsPaginator struct {
	aws.Pager
}

ListPredictorsPaginator is used to paginate the request. This can be done by calling Next and CurrentPage.

func NewListPredictorsPaginator 

func NewListPredictorsPaginator(req ListPredictorsRequest) ListPredictorsPaginator

NewListPredictorsRequestPaginator returns a paginator for ListPredictors. Use Next method to get the next page, and CurrentPage to get the current response page from the paginator. Next will return false, if there are no more pages, or an error was encountered.

Note: This operation can generate multiple requests to a service. 

// Example iterating over pages.
req := client.ListPredictorsRequest(input)
p := forecast.NewListPredictorsRequestPaginator(req)

for p.Next(context.TODO()) {
    page := p.CurrentPage()
}

if err := p.Err(); err != nil {
    return err
}

func (*ListPredictorsPaginator) CurrentPage 

func (p *ListPredictorsPaginator) CurrentPage() *ListPredictorsOutput

type ListPredictorsRequest 

type ListPredictorsRequest struct {
	*aws.Request
	Input *ListPredictorsInput
	Copy  func(*ListPredictorsInput) ListPredictorsRequest
}

ListPredictorsRequest is the request type for the ListPredictors API operation.

func (ListPredictorsRequest) Send 

func (r ListPredictorsRequest) Send(ctx context.Context) (*ListPredictorsResponse, error)

Send marshals and sends the ListPredictors API request.

type ListPredictorsResponse 

type ListPredictorsResponse struct {
	*ListPredictorsOutput
	// contains filtered or unexported fields
}

ListPredictorsResponse is the response type for the ListPredictors API operation.

func (*ListPredictorsResponse) SDKResponseMetdata 

func (r *ListPredictorsResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListPredictors request.

type ListTagsForResourceInput added in v0.24.0 

type ListTagsForResourceInput struct {

	// The Amazon Resource Name (ARN) that identifies the resource for which to
	// list the tags. Currently, the supported resources are Forecast dataset groups,
	// datasets, dataset import jobs, predictors, forecasts, and forecast export
	// jobs.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (ListTagsForResourceInput) String added in v0.24.0 

func (s ListTagsForResourceInput) String() string

String returns the string representation

func (*ListTagsForResourceInput) Validate added in v0.24.0 

func (s *ListTagsForResourceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ListTagsForResourceOutput added in v0.24.0 

type ListTagsForResourceOutput struct {

	// The tags for the resource.
	Tags []Tag `type:"list"`
	// contains filtered or unexported fields
}

func (ListTagsForResourceOutput) String added in v0.24.0 

func (s ListTagsForResourceOutput) String() string

String returns the string representation

type ListTagsForResourceRequest added in v0.24.0 

type ListTagsForResourceRequest struct {
	*aws.Request
	Input *ListTagsForResourceInput
	Copy  func(*ListTagsForResourceInput) ListTagsForResourceRequest
}

ListTagsForResourceRequest is the request type for the ListTagsForResource API operation.

func (ListTagsForResourceRequest) Send added in v0.24.0 

func (r ListTagsForResourceRequest) Send(ctx context.Context) (*ListTagsForResourceResponse, error)

Send marshals and sends the ListTagsForResource API request.

type ListTagsForResourceResponse added in v0.24.0 

type ListTagsForResourceResponse struct {
	*ListTagsForResourceOutput
	// contains filtered or unexported fields
}

ListTagsForResourceResponse is the response type for the ListTagsForResource API operation.

func (*ListTagsForResourceResponse) SDKResponseMetdata added in v0.24.0 

func (r *ListTagsForResourceResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the ListTagsForResource request.

type Metrics 

type Metrics struct {

	// The root mean square error (RMSE).
	RMSE *float64 `type:"double"`

	// An array of weighted quantile losses. Quantiles divide a probability distribution
	// into regions of equal probability. The distribution in this case is the loss
	// function.
	WeightedQuantileLosses []WeightedQuantileLoss `type:"list"`
	// contains filtered or unexported fields
}

Provides metrics that are used to evaluate the performance of a predictor. This object is part of the WindowSummary object.

func (Metrics) String 

func (s Metrics) String() string

String returns the string representation

type ParameterRanges 

type ParameterRanges struct {

	// Specifies the tunable range for each categorical hyperparameter.
	CategoricalParameterRanges []CategoricalParameterRange `min:"1" type:"list"`

	// Specifies the tunable range for each continuous hyperparameter.
	ContinuousParameterRanges []ContinuousParameterRange `min:"1" type:"list"`

	// Specifies the tunable range for each integer hyperparameter.
	IntegerParameterRanges []IntegerParameterRange `min:"1" type:"list"`
	// contains filtered or unexported fields
}

Specifies the categorical, continuous, and integer hyperparameters, and their ranges of tunable values. The range of tunable values determines which values that a hyperparameter tuning job can choose for the specified hyperparameter. This object is part of the HyperParameterTuningJobConfig object.

func (ParameterRanges) String 

func (s ParameterRanges) String() string

String returns the string representation

func (*ParameterRanges) Validate 

func (s *ParameterRanges) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type PredictorExecution added in v0.18.0 

type PredictorExecution struct {

	// The ARN of the algorithm used to test the predictor.
	AlgorithmArn *string `type:"string"`

	// An array of test windows used to evaluate the algorithm. The NumberOfBacktestWindows
	// from the object determines the number of windows in the array.
	TestWindows []TestWindowSummary `type:"list"`
	// contains filtered or unexported fields
}

The algorithm used to perform a backtest and the status of those tests.

func (PredictorExecution) String added in v0.18.0 

func (s PredictorExecution) String() string

String returns the string representation

type PredictorExecutionDetails added in v0.18.0 

type PredictorExecutionDetails struct {

	// An array of the backtests performed to evaluate the accuracy of the predictor
	// against a particular algorithm. The NumberOfBacktestWindows from the object
	// determines the number of windows in the array.
	PredictorExecutions []PredictorExecution `min:"1" type:"list"`
	// contains filtered or unexported fields
}

Contains details on the backtests performed to evaluate the accuracy of the predictor. The tests are returned in descending order of accuracy, with the most accurate backtest appearing first. You specify the number of backtests to perform when you call the operation.

func (PredictorExecutionDetails) String added in v0.18.0 

func (s PredictorExecutionDetails) String() string

String returns the string representation

type PredictorSummary 

type PredictorSummary struct {

	// When the model training task was created.
	CreationTime *time.Time `type:"timestamp"`

	// The Amazon Resource Name (ARN) of the dataset group that contains the data
	// used to train the predictor.
	DatasetGroupArn *string `type:"string"`

	// Initially, the same as CreationTime (status is CREATE_PENDING). Updated when
	// training starts (status changed to CREATE_IN_PROGRESS), and when training
	// is complete (status changed to ACTIVE) or fails (status changed to CREATE_FAILED).
	LastModificationTime *time.Time `type:"timestamp"`

	// If an error occurred, an informational message about the error.
	Message *string `type:"string"`

	// The ARN of the predictor.
	PredictorArn *string `type:"string"`

	// The name of the predictor.
	PredictorName *string `min:"1" type:"string"`

	// The status of the predictor. States include:
	//
	//    * ACTIVE
	//
	//    * CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_FAILED
	//
	//    * DELETE_PENDING, DELETE_IN_PROGRESS, DELETE_FAILED
	//
	//    * UPDATE_PENDING, UPDATE_IN_PROGRESS, UPDATE_FAILED
	//
	// The Status of the predictor must be ACTIVE before you can use the predictor
	// to create a forecast.
	Status *string `type:"string"`
	// contains filtered or unexported fields
}

Provides a summary of the predictor properties that are used in the ListPredictors operation. To get the complete set of properties, call the DescribePredictor operation, and provide the listed PredictorArn.

func (PredictorSummary) String 

func (s PredictorSummary) String() string

String returns the string representation

type S3Config 

type S3Config struct {

	// The Amazon Resource Name (ARN) of an AWS Key Management Service (KMS) key.
	KMSKeyArn *string `type:"string"`

	// The path to an Amazon Simple Storage Service (Amazon S3) bucket or file(s)
	// in an Amazon S3 bucket.
	//
	// Path is a required field
	Path *string `type:"string" required:"true"`

	// The ARN of the AWS Identity and Access Management (IAM) role that Amazon
	// Forecast can assume to access the Amazon S3 bucket or files. If you provide
	// a value for the KMSKeyArn key, the role must allow access to the key.
	//
	// Passing a role across AWS accounts is not allowed. If you pass a role that
	// isn't in your account, you get an InvalidInputException error.
	//
	// RoleArn is a required field
	RoleArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The path to the file(s) in an Amazon Simple Storage Service (Amazon S3) bucket, and an AWS Identity and Access Management (IAM) role that Amazon Forecast can assume to access the file(s). Optionally, includes an AWS Key Management Service (KMS) key. This object is part of the DataSource object that is submitted in the CreateDatasetImportJob request, and part of the DataDestination object that is submitted in the CreateForecastExportJob request.

func (S3Config) String 

func (s S3Config) String() string

String returns the string representation

func (*S3Config) Validate 

func (s *S3Config) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type ScalingType 

type ScalingType string
const (
	ScalingTypeAuto               ScalingType = "Auto"
	ScalingTypeLinear             ScalingType = "Linear"
	ScalingTypeLogarithmic        ScalingType = "Logarithmic"
	ScalingTypeReverseLogarithmic ScalingType = "ReverseLogarithmic"
)

Enum values for ScalingType

func (ScalingType) MarshalValue 

func (enum ScalingType) MarshalValue() (string, error)

func (ScalingType) MarshalValueBuf 

func (enum ScalingType) MarshalValueBuf(b []byte) ([]byte, error)

type Schema 

type Schema struct {

	// An array of attributes specifying the name and type of each field in a dataset.
	Attributes []SchemaAttribute `min:"1" type:"list"`
	// contains filtered or unexported fields
}

Defines the fields of a dataset. You specify this object in the CreateDataset request.

func (Schema) String 

func (s Schema) String() string

String returns the string representation

func (*Schema) Validate 

func (s *Schema) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type SchemaAttribute 

type SchemaAttribute struct {

	// The name of the dataset field.
	AttributeName *string `min:"1" type:"string"`

	// The data type of the field.
	AttributeType AttributeType `type:"string" enum:"true"`
	// contains filtered or unexported fields
}

An attribute of a schema, which defines a dataset field. A schema attribute is required for every field in a dataset. The Schema object contains an array of SchemaAttribute objects.

func (SchemaAttribute) String 

func (s SchemaAttribute) String() string

String returns the string representation

func (*SchemaAttribute) Validate 

func (s *SchemaAttribute) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type Statistics 

type Statistics struct {

	// For a numeric field, the average value in the field.
	Avg *float64 `type:"double"`

	// The number of values in the field.
	Count *int64 `type:"integer"`

	// The number of distinct values in the field.
	CountDistinct *int64 `type:"integer"`

	// The number of NAN (not a number) values in the field.
	CountNan *int64 `type:"integer"`

	// The number of null values in the field.
	CountNull *int64 `type:"integer"`

	// For a numeric field, the maximum value in the field.
	Max *string `type:"string"`

	// For a numeric field, the minimum value in the field.
	Min *string `type:"string"`

	// For a numeric field, the standard deviation.
	Stddev *float64 `type:"double"`
	// contains filtered or unexported fields
}

Provides statistics for each data field imported into to an Amazon Forecast dataset with the CreateDatasetImportJob operation.

func (Statistics) String 

func (s Statistics) String() string

String returns the string representation

type SupplementaryFeature 

type SupplementaryFeature struct {

	// The name of the feature. This must be "holiday".
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// One of the following 2 letter country codes:
	//
	//    * "AR" - ARGENTINA
	//
	//    * "AT" - AUSTRIA
	//
	//    * "AU" - AUSTRALIA
	//
	//    * "BE" - BELGIUM
	//
	//    * "BR" - BRAZIL
	//
	//    * "CA" - CANADA
	//
	//    * "CN" - CHINA
	//
	//    * "CZ" - CZECH REPUBLIC
	//
	//    * "DK" - DENMARK
	//
	//    * "EC" - ECUADOR
	//
	//    * "FI" - FINLAND
	//
	//    * "FR" - FRANCE
	//
	//    * "DE" - GERMANY
	//
	//    * "HU" - HUNGARY
	//
	//    * "IE" - IRELAND
	//
	//    * "IN" - INDIA
	//
	//    * "IT" - ITALY
	//
	//    * "JP" - JAPAN
	//
	//    * "KR" - KOREA
	//
	//    * "LU" - LUXEMBOURG
	//
	//    * "MX" - MEXICO
	//
	//    * "NL" - NETHERLANDS
	//
	//    * "NO" - NORWAY
	//
	//    * "PL" - POLAND
	//
	//    * "PT" - PORTUGAL
	//
	//    * "RU" - RUSSIA
	//
	//    * "ZA" - SOUTH AFRICA
	//
	//    * "ES" - SPAIN
	//
	//    * "SE" - SWEDEN
	//
	//    * "CH" - SWITZERLAND
	//
	//    * "US" - UNITED STATES
	//
	//    * "UK" - UNITED KINGDOM
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

Describes a supplementary feature of a dataset group. This object is part of the InputDataConfig object.

The only supported feature is a holiday calendar. If you use the calendar, all data in the datasets should belong to the same country as the calendar. For the holiday calendar data, see the Jollyday (http://jollyday.sourceforge.net/data.html) web site.

India and Korea's holidays are not included in the Jollyday library, but both are supported by Amazon Forecast. Their holidays are:

"IN" - INDIA

  • JANUARY 26 - REPUBLIC DAY

  • AUGUST 15 - INDEPENDENCE DAY

  • OCTOBER 2 GANDHI'S BIRTHDAY

"KR" - KOREA

  • JANUARY 1 - NEW YEAR

  • MARCH 1 - INDEPENDENCE MOVEMENT DAY

  • MAY 5 - CHILDREN'S DAY

  • JUNE 6 - MEMORIAL DAY

  • AUGUST 15 - LIBERATION DAY

  • OCTOBER 3 - NATIONAL FOUNDATION DAY

  • OCTOBER 9 - HANGEUL DAY

  • DECEMBER 25 - CHRISTMAS DAY

func (SupplementaryFeature) String 

func (s SupplementaryFeature) String() string

String returns the string representation

func (*SupplementaryFeature) Validate 

func (s *SupplementaryFeature) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type Tag added in v0.24.0 

type Tag struct {

	// One part of a key-value pair that makes up a tag. A key is a general label
	// that acts like a category for more specific tag values.
	//
	// Key is a required field
	Key *string `min:"1" type:"string" required:"true"`

	// The optional part of a key-value pair that makes up a tag. A value acts as
	// a descriptor within a tag category (key).
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

The optional metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define.

The following basic restrictions apply to tags:

  • Maximum number of tags per resource - 50.

  • For each resource, each tag key must be unique, and each tag key can have only one value.

  • Maximum key length - 128 Unicode characters in UTF-8.

  • Maximum value length - 256 Unicode characters in UTF-8.

  • If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.

  • Tag keys and values are case sensitive.

  • Do not use aws:, AWS:, or any upper or lowercase combination of such as a prefix for keys as it is reserved for AWS use. You cannot edit or delete tag keys with this prefix. Values can have this prefix. If a tag value has aws as its prefix but the key does not, then Forecast considers it to be a user tag and will count against the limit of 50 tags. Tags with only the key prefix of aws do not count against your tags per resource limit.

func (Tag) String added in v0.24.0 

func (s Tag) String() string

String returns the string representation

func (*Tag) Validate added in v0.24.0 

func (s *Tag) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type TagResourceInput added in v0.24.0 

type TagResourceInput struct {

	// The Amazon Resource Name (ARN) that identifies the resource for which to
	// list the tags. Currently, the supported resources are Forecast dataset groups,
	// datasets, dataset import jobs, predictors, forecasts, and forecast export
	// jobs.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`

	// The tags to add to the resource. A tag is an array of key-value pairs.
	//
	// The following basic restrictions apply to tags:
	//
	//    * Maximum number of tags per resource - 50.
	//
	//    * For each resource, each tag key must be unique, and each tag key can
	//    have only one value.
	//
	//    * Maximum key length - 128 Unicode characters in UTF-8.
	//
	//    * Maximum value length - 256 Unicode characters in UTF-8.
	//
	//    * If your tagging schema is used across multiple services and resources,
	//    remember that other services may have restrictions on allowed characters.
	//    Generally allowed characters are: letters, numbers, and spaces representable
	//    in UTF-8, and the following characters: + - = . _ : / @.
	//
	//    * Tag keys and values are case sensitive.
	//
	//    * Do not use aws:, AWS:, or any upper or lowercase combination of such
	//    as a prefix for keys as it is reserved for AWS use. You cannot edit or
	//    delete tag keys with this prefix. Values can have this prefix. If a tag
	//    value has aws as its prefix but the key does not, then Forecast considers
	//    it to be a user tag and will count against the limit of 50 tags. Tags
	//    with only the key prefix of aws do not count against your tags per resource
	//    limit.
	//
	// Tags is a required field
	Tags []Tag `type:"list" required:"true"`
	// contains filtered or unexported fields
}

func (TagResourceInput) String added in v0.24.0 

func (s TagResourceInput) String() string

String returns the string representation

func (*TagResourceInput) Validate added in v0.24.0 

func (s *TagResourceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type TagResourceOutput added in v0.24.0 

type TagResourceOutput struct {
	// contains filtered or unexported fields
}

func (TagResourceOutput) String added in v0.24.0 

func (s TagResourceOutput) String() string

String returns the string representation

type TagResourceRequest added in v0.24.0 

type TagResourceRequest struct {
	*aws.Request
	Input *TagResourceInput
	Copy  func(*TagResourceInput) TagResourceRequest
}

TagResourceRequest is the request type for the TagResource API operation.

func (TagResourceRequest) Send added in v0.24.0 

func (r TagResourceRequest) Send(ctx context.Context) (*TagResourceResponse, error)

Send marshals and sends the TagResource API request.

type TagResourceResponse added in v0.24.0 

type TagResourceResponse struct {
	*TagResourceOutput
	// contains filtered or unexported fields
}

TagResourceResponse is the response type for the TagResource API operation.

func (*TagResourceResponse) SDKResponseMetdata added in v0.24.0 

func (r *TagResourceResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the TagResource request.

type TestWindowSummary added in v0.18.0 

type TestWindowSummary struct {

	// If the test failed, the reason why it failed.
	Message *string `type:"string"`

	// The status of the test. Possible status values are:
	//
	//    * ACTIVE
	//
	//    * CREATE_IN_PROGRESS
	//
	//    * CREATE_FAILED
	Status *string `type:"string"`

	// The time at which the test ended.
	TestWindowEnd *time.Time `type:"timestamp"`

	// The time at which the test began.
	TestWindowStart *time.Time `type:"timestamp"`
	// contains filtered or unexported fields
}

The status, start time, and end time of a backtest, as well as a failure reason if applicable.

func (TestWindowSummary) String added in v0.18.0 

func (s TestWindowSummary) String() string

String returns the string representation

type UntagResourceInput added in v0.24.0 

type UntagResourceInput struct {

	// The Amazon Resource Name (ARN) that identifies the resource for which to
	// list the tags. Currently, the supported resources are Forecast dataset groups,
	// datasets, dataset import jobs, predictors, forecasts, and forecast exports.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`

	// The keys of the tags to be removed.
	//
	// TagKeys is a required field
	TagKeys []string `type:"list" required:"true"`
	// contains filtered or unexported fields
}

func (UntagResourceInput) String added in v0.24.0 

func (s UntagResourceInput) String() string

String returns the string representation

func (*UntagResourceInput) Validate added in v0.24.0 

func (s *UntagResourceInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UntagResourceOutput added in v0.24.0 

type UntagResourceOutput struct {
	// contains filtered or unexported fields
}

func (UntagResourceOutput) String added in v0.24.0 

func (s UntagResourceOutput) String() string

String returns the string representation

type UntagResourceRequest added in v0.24.0 

type UntagResourceRequest struct {
	*aws.Request
	Input *UntagResourceInput
	Copy  func(*UntagResourceInput) UntagResourceRequest
}

UntagResourceRequest is the request type for the UntagResource API operation.

func (UntagResourceRequest) Send added in v0.24.0 

func (r UntagResourceRequest) Send(ctx context.Context) (*UntagResourceResponse, error)

Send marshals and sends the UntagResource API request.

type UntagResourceResponse added in v0.24.0 

type UntagResourceResponse struct {
	*UntagResourceOutput
	// contains filtered or unexported fields
}

UntagResourceResponse is the response type for the UntagResource API operation.

func (*UntagResourceResponse) SDKResponseMetdata added in v0.24.0 

func (r *UntagResourceResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the UntagResource request.

type UpdateDatasetGroupInput 

type UpdateDatasetGroupInput struct {

	// An array of the Amazon Resource Names (ARNs) of the datasets to add to the
	// dataset group.
	//
	// DatasetArns is a required field
	DatasetArns []string `type:"list" required:"true"`

	// The ARN of the dataset group.
	//
	// DatasetGroupArn is a required field
	DatasetGroupArn *string `type:"string" required:"true"`
	// contains filtered or unexported fields
}

func (UpdateDatasetGroupInput) String 

func (s UpdateDatasetGroupInput) String() string

String returns the string representation

func (*UpdateDatasetGroupInput) Validate 

func (s *UpdateDatasetGroupInput) Validate() error

Validate inspects the fields of the type to determine if they are valid.

type UpdateDatasetGroupOutput 

type UpdateDatasetGroupOutput struct {
	// contains filtered or unexported fields
}

func (UpdateDatasetGroupOutput) String 

func (s UpdateDatasetGroupOutput) String() string

String returns the string representation

type UpdateDatasetGroupRequest 

type UpdateDatasetGroupRequest struct {
	*aws.Request
	Input *UpdateDatasetGroupInput
	Copy  func(*UpdateDatasetGroupInput) UpdateDatasetGroupRequest
}

UpdateDatasetGroupRequest is the request type for the UpdateDatasetGroup API operation.

func (UpdateDatasetGroupRequest) Send 

func (r UpdateDatasetGroupRequest) Send(ctx context.Context) (*UpdateDatasetGroupResponse, error)

Send marshals and sends the UpdateDatasetGroup API request.

type UpdateDatasetGroupResponse 

type UpdateDatasetGroupResponse struct {
	*UpdateDatasetGroupOutput
	// contains filtered or unexported fields
}

UpdateDatasetGroupResponse is the response type for the UpdateDatasetGroup API operation.

func (*UpdateDatasetGroupResponse) SDKResponseMetdata 

func (r *UpdateDatasetGroupResponse) SDKResponseMetdata() *aws.Response

SDKResponseMetdata returns the response metadata for the UpdateDatasetGroup request.

type WeightedQuantileLoss 

type WeightedQuantileLoss struct {

	// The difference between the predicted value and the actual value over the
	// quantile, weighted (normalized) by dividing by the sum over all quantiles.
	LossValue *float64 `type:"double"`

	// The quantile. Quantiles divide a probability distribution into regions of
	// equal probability. For example, if the distribution was divided into 5 regions
	// of equal probability, the quantiles would be 0.2, 0.4, 0.6, and 0.8.
	Quantile *float64 `type:"double"`
	// contains filtered or unexported fields
}

The weighted loss value for a quantile. This object is part of the Metrics object.

func (WeightedQuantileLoss) String 

func (s WeightedQuantileLoss) String() string

String returns the string representation

type WindowSummary 

type WindowSummary struct {

	// The type of evaluation.
	//
	//    * SUMMARY - The average metrics across all windows.
	//
	//    * COMPUTED - The metrics for the specified window.
	EvaluationType EvaluationType `type:"string" enum:"true"`

	// The number of data points within the window.
	ItemCount *int64 `type:"integer"`

	// Provides metrics used to evaluate the performance of a predictor.
	Metrics *Metrics `type:"structure"`

	// The timestamp that defines the end of the window.
	TestWindowEnd *time.Time `type:"timestamp"`

	// The timestamp that defines the start of the window.
	TestWindowStart *time.Time `type:"timestamp"`
	// contains filtered or unexported fields
}

The metrics for a time range within the evaluation portion of a dataset. This object is part of the EvaluationResult object.

The TestWindowStart and TestWindowEnd parameters are determined by the BackTestWindowOffset parameter of the EvaluationParameters object.

func (WindowSummary) String 

func (s WindowSummary) String() string

String returns the string representation

Source Files

View all Source files

Directories

Path Synopsis
Package forecastiface provides an interface to enable mocking the Amazon Forecast Service service client for testing your code.
 Package forecastiface provides an interface to enable mocking the Amazon Forecast Service service client for testing your code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.