{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Forecast.CreatePredictor
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- This operation creates a legacy predictor that does not include all the
-- predictor functionalities provided by Amazon Forecast. To create a
-- predictor that is compatible with all aspects of Forecast, use
-- CreateAutoPredictor.
--
-- Creates an Amazon Forecast predictor.
--
-- In the request, provide a dataset group and either specify an algorithm
-- or let Amazon Forecast choose an algorithm for you using AutoML. If you
-- specify an algorithm, you also can override algorithm-specific
-- hyperparameters.
--
-- Amazon Forecast uses the algorithm to train a predictor using the latest
-- version of the datasets in the specified dataset group. You can then
-- generate a forecast using the CreateForecast operation.
--
-- To see the evaluation metrics, use the GetAccuracyMetrics operation.
--
-- 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.
--
-- By default, predictors are trained and evaluated at the 0.1 (P10), 0.5
-- (P50), and 0.9 (P90) quantiles. You can choose custom forecast types to
-- train and evaluate your predictor by setting the @ForecastTypes@.
--
-- __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
-- losses over the forecast types. By default, these are the 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.
module Amazonka.Forecast.CreatePredictor
  ( -- * Creating a Request
    CreatePredictor (..),
    newCreatePredictor,

    -- * Request Lenses
    createPredictor_algorithmArn,
    createPredictor_autoMLOverrideStrategy,
    createPredictor_encryptionConfig,
    createPredictor_evaluationParameters,
    createPredictor_forecastTypes,
    createPredictor_hPOConfig,
    createPredictor_optimizationMetric,
    createPredictor_performAutoML,
    createPredictor_performHPO,
    createPredictor_tags,
    createPredictor_trainingParameters,
    createPredictor_predictorName,
    createPredictor_forecastHorizon,
    createPredictor_inputDataConfig,
    createPredictor_featurizationConfig,

    -- * Destructuring the Response
    CreatePredictorResponse (..),
    newCreatePredictorResponse,

    -- * Response Lenses
    createPredictorResponse_predictorArn,
    createPredictorResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Forecast.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreatePredictor' smart constructor.
data CreatePredictor = CreatePredictor'
  { -- | 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\/CNN-QR@
    --
    -- -   @arn:aws:forecast:::algorithm\/Deep_AR_Plus@
    --
    -- -   @arn:aws:forecast:::algorithm\/ETS@
    --
    -- -   @arn:aws:forecast:::algorithm\/NPTS@
    --
    -- -   @arn:aws:forecast:::algorithm\/Prophet@
    CreatePredictor -> Maybe Text
algorithmArn :: Prelude.Maybe Prelude.Text,
    -- | The @LatencyOptimized@ AutoML override strategy is only available in
    -- private beta. Contact AWS Support or your account manager to learn more
    -- about access privileges.
    --
    -- Used to overide the default AutoML strategy, which is to optimize
    -- predictor accuracy. To apply an AutoML strategy that minimizes training
    -- time, use @LatencyOptimized@.
    --
    -- This parameter is only valid for predictors trained using AutoML.
    CreatePredictor -> Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy :: Prelude.Maybe AutoMLOverrideStrategy,
    -- | 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.
    CreatePredictor -> Maybe EncryptionConfig
encryptionConfig :: Prelude.Maybe EncryptionConfig,
    -- | 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.
    CreatePredictor -> Maybe EvaluationParameters
evaluationParameters :: Prelude.Maybe EvaluationParameters,
    -- | Specifies the forecast types used to train a predictor. You can specify
    -- up to five forecast types. Forecast types can be quantiles from 0.01 to
    -- 0.99, by increments of 0.01 or higher. You can also specify the mean
    -- forecast with @mean@.
    --
    -- The default value is @[\"0.10\", \"0.50\", \"0.9\"]@.
    CreatePredictor -> Maybe (NonEmpty Text)
forecastTypes :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | 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.
    CreatePredictor -> Maybe HyperParameterTuningJobConfig
hPOConfig :: Prelude.Maybe HyperParameterTuningJobConfig,
    -- | The accuracy metric used to optimize the predictor.
    CreatePredictor -> Maybe OptimizationMetric
optimizationMetric :: Prelude.Maybe OptimizationMetric,
    -- | 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.
    CreatePredictor -> Maybe Bool
performAutoML :: Prelude.Maybe Prelude.Bool,
    -- | 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 algorithms support HPO:
    --
    -- -   DeepAR+
    --
    -- -   CNN-QR
    CreatePredictor -> Maybe Bool
performHPO :: Prelude.Maybe Prelude.Bool,
    -- | 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.
    CreatePredictor -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | 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.
    CreatePredictor -> Maybe (HashMap Text Text)
trainingParameters :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A name for the predictor.
    CreatePredictor -> Text
predictorName :: Prelude.Text,
    -- | 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.
    CreatePredictor -> Int
forecastHorizon :: Prelude.Int,
    -- | Describes the dataset group that contains the data to use to train the
    -- predictor.
    CreatePredictor -> InputDataConfig
inputDataConfig :: InputDataConfig,
    -- | The featurization configuration.
    CreatePredictor -> FeaturizationConfig
featurizationConfig :: FeaturizationConfig
  }
  deriving (CreatePredictor -> CreatePredictor -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreatePredictor -> CreatePredictor -> Bool
$c/= :: CreatePredictor -> CreatePredictor -> Bool
== :: CreatePredictor -> CreatePredictor -> Bool
$c== :: CreatePredictor -> CreatePredictor -> Bool
Prelude.Eq, Int -> CreatePredictor -> ShowS
[CreatePredictor] -> ShowS
CreatePredictor -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreatePredictor] -> ShowS
$cshowList :: [CreatePredictor] -> ShowS
show :: CreatePredictor -> String
$cshow :: CreatePredictor -> String
showsPrec :: Int -> CreatePredictor -> ShowS
$cshowsPrec :: Int -> CreatePredictor -> ShowS
Prelude.Show, forall x. Rep CreatePredictor x -> CreatePredictor
forall x. CreatePredictor -> Rep CreatePredictor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreatePredictor x -> CreatePredictor
$cfrom :: forall x. CreatePredictor -> Rep CreatePredictor x
Prelude.Generic)

-- |
-- Create a value of 'CreatePredictor' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'algorithmArn', 'createPredictor_algorithmArn' - 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\/CNN-QR@
--
-- -   @arn:aws:forecast:::algorithm\/Deep_AR_Plus@
--
-- -   @arn:aws:forecast:::algorithm\/ETS@
--
-- -   @arn:aws:forecast:::algorithm\/NPTS@
--
-- -   @arn:aws:forecast:::algorithm\/Prophet@
--
-- 'autoMLOverrideStrategy', 'createPredictor_autoMLOverrideStrategy' - The @LatencyOptimized@ AutoML override strategy is only available in
-- private beta. Contact AWS Support or your account manager to learn more
-- about access privileges.
--
-- Used to overide the default AutoML strategy, which is to optimize
-- predictor accuracy. To apply an AutoML strategy that minimizes training
-- time, use @LatencyOptimized@.
--
-- This parameter is only valid for predictors trained using AutoML.
--
-- 'encryptionConfig', 'createPredictor_encryptionConfig' - 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.
--
-- 'evaluationParameters', 'createPredictor_evaluationParameters' - 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.
--
-- 'forecastTypes', 'createPredictor_forecastTypes' - Specifies the forecast types used to train a predictor. You can specify
-- up to five forecast types. Forecast types can be quantiles from 0.01 to
-- 0.99, by increments of 0.01 or higher. You can also specify the mean
-- forecast with @mean@.
--
-- The default value is @[\"0.10\", \"0.50\", \"0.9\"]@.
--
-- 'hPOConfig', 'createPredictor_hPOConfig' - 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.
--
-- 'optimizationMetric', 'createPredictor_optimizationMetric' - The accuracy metric used to optimize the predictor.
--
-- 'performAutoML', 'createPredictor_performAutoML' - 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.
--
-- 'performHPO', 'createPredictor_performHPO' - 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 algorithms support HPO:
--
-- -   DeepAR+
--
-- -   CNN-QR
--
-- 'tags', 'createPredictor_tags' - 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.
--
-- 'trainingParameters', 'createPredictor_trainingParameters' - 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.
--
-- 'predictorName', 'createPredictor_predictorName' - A name for the predictor.
--
-- 'forecastHorizon', 'createPredictor_forecastHorizon' - 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.
--
-- 'inputDataConfig', 'createPredictor_inputDataConfig' - Describes the dataset group that contains the data to use to train the
-- predictor.
--
-- 'featurizationConfig', 'createPredictor_featurizationConfig' - The featurization configuration.
newCreatePredictor ::
  -- | 'predictorName'
  Prelude.Text ->
  -- | 'forecastHorizon'
  Prelude.Int ->
  -- | 'inputDataConfig'
  InputDataConfig ->
  -- | 'featurizationConfig'
  FeaturizationConfig ->
  CreatePredictor
newCreatePredictor :: Text
-> Int -> InputDataConfig -> FeaturizationConfig -> CreatePredictor
newCreatePredictor
  Text
pPredictorName_
  Int
pForecastHorizon_
  InputDataConfig
pInputDataConfig_
  FeaturizationConfig
pFeaturizationConfig_ =
    CreatePredictor'
      { $sel:algorithmArn:CreatePredictor' :: Maybe Text
algorithmArn = forall a. Maybe a
Prelude.Nothing,
        $sel:autoMLOverrideStrategy:CreatePredictor' :: Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy = forall a. Maybe a
Prelude.Nothing,
        $sel:encryptionConfig:CreatePredictor' :: Maybe EncryptionConfig
encryptionConfig = forall a. Maybe a
Prelude.Nothing,
        $sel:evaluationParameters:CreatePredictor' :: Maybe EvaluationParameters
evaluationParameters = forall a. Maybe a
Prelude.Nothing,
        $sel:forecastTypes:CreatePredictor' :: Maybe (NonEmpty Text)
forecastTypes = forall a. Maybe a
Prelude.Nothing,
        $sel:hPOConfig:CreatePredictor' :: Maybe HyperParameterTuningJobConfig
hPOConfig = forall a. Maybe a
Prelude.Nothing,
        $sel:optimizationMetric:CreatePredictor' :: Maybe OptimizationMetric
optimizationMetric = forall a. Maybe a
Prelude.Nothing,
        $sel:performAutoML:CreatePredictor' :: Maybe Bool
performAutoML = forall a. Maybe a
Prelude.Nothing,
        $sel:performHPO:CreatePredictor' :: Maybe Bool
performHPO = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreatePredictor' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:trainingParameters:CreatePredictor' :: Maybe (HashMap Text Text)
trainingParameters = forall a. Maybe a
Prelude.Nothing,
        $sel:predictorName:CreatePredictor' :: Text
predictorName = Text
pPredictorName_,
        $sel:forecastHorizon:CreatePredictor' :: Int
forecastHorizon = Int
pForecastHorizon_,
        $sel:inputDataConfig:CreatePredictor' :: InputDataConfig
inputDataConfig = InputDataConfig
pInputDataConfig_,
        $sel:featurizationConfig:CreatePredictor' :: FeaturizationConfig
featurizationConfig = FeaturizationConfig
pFeaturizationConfig_
      }

-- | 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\/CNN-QR@
--
-- -   @arn:aws:forecast:::algorithm\/Deep_AR_Plus@
--
-- -   @arn:aws:forecast:::algorithm\/ETS@
--
-- -   @arn:aws:forecast:::algorithm\/NPTS@
--
-- -   @arn:aws:forecast:::algorithm\/Prophet@
createPredictor_algorithmArn :: Lens.Lens' CreatePredictor (Prelude.Maybe Prelude.Text)
createPredictor_algorithmArn :: Lens' CreatePredictor (Maybe Text)
createPredictor_algorithmArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe Text
algorithmArn :: Maybe Text
$sel:algorithmArn:CreatePredictor' :: CreatePredictor -> Maybe Text
algorithmArn} -> Maybe Text
algorithmArn) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe Text
a -> CreatePredictor
s {$sel:algorithmArn:CreatePredictor' :: Maybe Text
algorithmArn = Maybe Text
a} :: CreatePredictor)

-- | The @LatencyOptimized@ AutoML override strategy is only available in
-- private beta. Contact AWS Support or your account manager to learn more
-- about access privileges.
--
-- Used to overide the default AutoML strategy, which is to optimize
-- predictor accuracy. To apply an AutoML strategy that minimizes training
-- time, use @LatencyOptimized@.
--
-- This parameter is only valid for predictors trained using AutoML.
createPredictor_autoMLOverrideStrategy :: Lens.Lens' CreatePredictor (Prelude.Maybe AutoMLOverrideStrategy)
createPredictor_autoMLOverrideStrategy :: Lens' CreatePredictor (Maybe AutoMLOverrideStrategy)
createPredictor_autoMLOverrideStrategy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy :: Maybe AutoMLOverrideStrategy
$sel:autoMLOverrideStrategy:CreatePredictor' :: CreatePredictor -> Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy} -> Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe AutoMLOverrideStrategy
a -> CreatePredictor
s {$sel:autoMLOverrideStrategy:CreatePredictor' :: Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy = Maybe AutoMLOverrideStrategy
a} :: CreatePredictor)

-- | 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.
createPredictor_encryptionConfig :: Lens.Lens' CreatePredictor (Prelude.Maybe EncryptionConfig)
createPredictor_encryptionConfig :: Lens' CreatePredictor (Maybe EncryptionConfig)
createPredictor_encryptionConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe EncryptionConfig
encryptionConfig :: Maybe EncryptionConfig
$sel:encryptionConfig:CreatePredictor' :: CreatePredictor -> Maybe EncryptionConfig
encryptionConfig} -> Maybe EncryptionConfig
encryptionConfig) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe EncryptionConfig
a -> CreatePredictor
s {$sel:encryptionConfig:CreatePredictor' :: Maybe EncryptionConfig
encryptionConfig = Maybe EncryptionConfig
a} :: CreatePredictor)

-- | 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.
createPredictor_evaluationParameters :: Lens.Lens' CreatePredictor (Prelude.Maybe EvaluationParameters)
createPredictor_evaluationParameters :: Lens' CreatePredictor (Maybe EvaluationParameters)
createPredictor_evaluationParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe EvaluationParameters
evaluationParameters :: Maybe EvaluationParameters
$sel:evaluationParameters:CreatePredictor' :: CreatePredictor -> Maybe EvaluationParameters
evaluationParameters} -> Maybe EvaluationParameters
evaluationParameters) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe EvaluationParameters
a -> CreatePredictor
s {$sel:evaluationParameters:CreatePredictor' :: Maybe EvaluationParameters
evaluationParameters = Maybe EvaluationParameters
a} :: CreatePredictor)

-- | Specifies the forecast types used to train a predictor. You can specify
-- up to five forecast types. Forecast types can be quantiles from 0.01 to
-- 0.99, by increments of 0.01 or higher. You can also specify the mean
-- forecast with @mean@.
--
-- The default value is @[\"0.10\", \"0.50\", \"0.9\"]@.
createPredictor_forecastTypes :: Lens.Lens' CreatePredictor (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
createPredictor_forecastTypes :: Lens' CreatePredictor (Maybe (NonEmpty Text))
createPredictor_forecastTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe (NonEmpty Text)
forecastTypes :: Maybe (NonEmpty Text)
$sel:forecastTypes:CreatePredictor' :: CreatePredictor -> Maybe (NonEmpty Text)
forecastTypes} -> Maybe (NonEmpty Text)
forecastTypes) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe (NonEmpty Text)
a -> CreatePredictor
s {$sel:forecastTypes:CreatePredictor' :: Maybe (NonEmpty Text)
forecastTypes = Maybe (NonEmpty Text)
a} :: CreatePredictor) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | 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.
createPredictor_hPOConfig :: Lens.Lens' CreatePredictor (Prelude.Maybe HyperParameterTuningJobConfig)
createPredictor_hPOConfig :: Lens' CreatePredictor (Maybe HyperParameterTuningJobConfig)
createPredictor_hPOConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe HyperParameterTuningJobConfig
hPOConfig :: Maybe HyperParameterTuningJobConfig
$sel:hPOConfig:CreatePredictor' :: CreatePredictor -> Maybe HyperParameterTuningJobConfig
hPOConfig} -> Maybe HyperParameterTuningJobConfig
hPOConfig) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe HyperParameterTuningJobConfig
a -> CreatePredictor
s {$sel:hPOConfig:CreatePredictor' :: Maybe HyperParameterTuningJobConfig
hPOConfig = Maybe HyperParameterTuningJobConfig
a} :: CreatePredictor)

-- | The accuracy metric used to optimize the predictor.
createPredictor_optimizationMetric :: Lens.Lens' CreatePredictor (Prelude.Maybe OptimizationMetric)
createPredictor_optimizationMetric :: Lens' CreatePredictor (Maybe OptimizationMetric)
createPredictor_optimizationMetric = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe OptimizationMetric
optimizationMetric :: Maybe OptimizationMetric
$sel:optimizationMetric:CreatePredictor' :: CreatePredictor -> Maybe OptimizationMetric
optimizationMetric} -> Maybe OptimizationMetric
optimizationMetric) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe OptimizationMetric
a -> CreatePredictor
s {$sel:optimizationMetric:CreatePredictor' :: Maybe OptimizationMetric
optimizationMetric = Maybe OptimizationMetric
a} :: CreatePredictor)

-- | 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.
createPredictor_performAutoML :: Lens.Lens' CreatePredictor (Prelude.Maybe Prelude.Bool)
createPredictor_performAutoML :: Lens' CreatePredictor (Maybe Bool)
createPredictor_performAutoML = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe Bool
performAutoML :: Maybe Bool
$sel:performAutoML:CreatePredictor' :: CreatePredictor -> Maybe Bool
performAutoML} -> Maybe Bool
performAutoML) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe Bool
a -> CreatePredictor
s {$sel:performAutoML:CreatePredictor' :: Maybe Bool
performAutoML = Maybe Bool
a} :: CreatePredictor)

-- | 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 algorithms support HPO:
--
-- -   DeepAR+
--
-- -   CNN-QR
createPredictor_performHPO :: Lens.Lens' CreatePredictor (Prelude.Maybe Prelude.Bool)
createPredictor_performHPO :: Lens' CreatePredictor (Maybe Bool)
createPredictor_performHPO = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe Bool
performHPO :: Maybe Bool
$sel:performHPO:CreatePredictor' :: CreatePredictor -> Maybe Bool
performHPO} -> Maybe Bool
performHPO) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe Bool
a -> CreatePredictor
s {$sel:performHPO:CreatePredictor' :: Maybe Bool
performHPO = Maybe Bool
a} :: CreatePredictor)

-- | 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.
createPredictor_tags :: Lens.Lens' CreatePredictor (Prelude.Maybe [Tag])
createPredictor_tags :: Lens' CreatePredictor (Maybe [Tag])
createPredictor_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreatePredictor' :: CreatePredictor -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe [Tag]
a -> CreatePredictor
s {$sel:tags:CreatePredictor' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreatePredictor) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | 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.
createPredictor_trainingParameters :: Lens.Lens' CreatePredictor (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createPredictor_trainingParameters :: Lens' CreatePredictor (Maybe (HashMap Text Text))
createPredictor_trainingParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Maybe (HashMap Text Text)
trainingParameters :: Maybe (HashMap Text Text)
$sel:trainingParameters:CreatePredictor' :: CreatePredictor -> Maybe (HashMap Text Text)
trainingParameters} -> Maybe (HashMap Text Text)
trainingParameters) (\s :: CreatePredictor
s@CreatePredictor' {} Maybe (HashMap Text Text)
a -> CreatePredictor
s {$sel:trainingParameters:CreatePredictor' :: Maybe (HashMap Text Text)
trainingParameters = Maybe (HashMap Text Text)
a} :: CreatePredictor) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A name for the predictor.
createPredictor_predictorName :: Lens.Lens' CreatePredictor Prelude.Text
createPredictor_predictorName :: Lens' CreatePredictor Text
createPredictor_predictorName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Text
predictorName :: Text
$sel:predictorName:CreatePredictor' :: CreatePredictor -> Text
predictorName} -> Text
predictorName) (\s :: CreatePredictor
s@CreatePredictor' {} Text
a -> CreatePredictor
s {$sel:predictorName:CreatePredictor' :: Text
predictorName = Text
a} :: CreatePredictor)

-- | 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.
createPredictor_forecastHorizon :: Lens.Lens' CreatePredictor Prelude.Int
createPredictor_forecastHorizon :: Lens' CreatePredictor Int
createPredictor_forecastHorizon = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {Int
forecastHorizon :: Int
$sel:forecastHorizon:CreatePredictor' :: CreatePredictor -> Int
forecastHorizon} -> Int
forecastHorizon) (\s :: CreatePredictor
s@CreatePredictor' {} Int
a -> CreatePredictor
s {$sel:forecastHorizon:CreatePredictor' :: Int
forecastHorizon = Int
a} :: CreatePredictor)

-- | Describes the dataset group that contains the data to use to train the
-- predictor.
createPredictor_inputDataConfig :: Lens.Lens' CreatePredictor InputDataConfig
createPredictor_inputDataConfig :: Lens' CreatePredictor InputDataConfig
createPredictor_inputDataConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {InputDataConfig
inputDataConfig :: InputDataConfig
$sel:inputDataConfig:CreatePredictor' :: CreatePredictor -> InputDataConfig
inputDataConfig} -> InputDataConfig
inputDataConfig) (\s :: CreatePredictor
s@CreatePredictor' {} InputDataConfig
a -> CreatePredictor
s {$sel:inputDataConfig:CreatePredictor' :: InputDataConfig
inputDataConfig = InputDataConfig
a} :: CreatePredictor)

-- | The featurization configuration.
createPredictor_featurizationConfig :: Lens.Lens' CreatePredictor FeaturizationConfig
createPredictor_featurizationConfig :: Lens' CreatePredictor FeaturizationConfig
createPredictor_featurizationConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictor' {FeaturizationConfig
featurizationConfig :: FeaturizationConfig
$sel:featurizationConfig:CreatePredictor' :: CreatePredictor -> FeaturizationConfig
featurizationConfig} -> FeaturizationConfig
featurizationConfig) (\s :: CreatePredictor
s@CreatePredictor' {} FeaturizationConfig
a -> CreatePredictor
s {$sel:featurizationConfig:CreatePredictor' :: FeaturizationConfig
featurizationConfig = FeaturizationConfig
a} :: CreatePredictor)

instance Core.AWSRequest CreatePredictor where
  type
    AWSResponse CreatePredictor =
      CreatePredictorResponse
  request :: (Service -> Service) -> CreatePredictor -> Request CreatePredictor
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreatePredictor
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreatePredictor)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text -> Int -> CreatePredictorResponse
CreatePredictorResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"PredictorArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreatePredictor where
  hashWithSalt :: Int -> CreatePredictor -> Int
hashWithSalt Int
_salt CreatePredictor' {Int
Maybe Bool
Maybe [Tag]
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe AutoMLOverrideStrategy
Maybe EncryptionConfig
Maybe EvaluationParameters
Maybe OptimizationMetric
Maybe HyperParameterTuningJobConfig
Text
FeaturizationConfig
InputDataConfig
featurizationConfig :: FeaturizationConfig
inputDataConfig :: InputDataConfig
forecastHorizon :: Int
predictorName :: Text
trainingParameters :: Maybe (HashMap Text Text)
tags :: Maybe [Tag]
performHPO :: Maybe Bool
performAutoML :: Maybe Bool
optimizationMetric :: Maybe OptimizationMetric
hPOConfig :: Maybe HyperParameterTuningJobConfig
forecastTypes :: Maybe (NonEmpty Text)
evaluationParameters :: Maybe EvaluationParameters
encryptionConfig :: Maybe EncryptionConfig
autoMLOverrideStrategy :: Maybe AutoMLOverrideStrategy
algorithmArn :: Maybe Text
$sel:featurizationConfig:CreatePredictor' :: CreatePredictor -> FeaturizationConfig
$sel:inputDataConfig:CreatePredictor' :: CreatePredictor -> InputDataConfig
$sel:forecastHorizon:CreatePredictor' :: CreatePredictor -> Int
$sel:predictorName:CreatePredictor' :: CreatePredictor -> Text
$sel:trainingParameters:CreatePredictor' :: CreatePredictor -> Maybe (HashMap Text Text)
$sel:tags:CreatePredictor' :: CreatePredictor -> Maybe [Tag]
$sel:performHPO:CreatePredictor' :: CreatePredictor -> Maybe Bool
$sel:performAutoML:CreatePredictor' :: CreatePredictor -> Maybe Bool
$sel:optimizationMetric:CreatePredictor' :: CreatePredictor -> Maybe OptimizationMetric
$sel:hPOConfig:CreatePredictor' :: CreatePredictor -> Maybe HyperParameterTuningJobConfig
$sel:forecastTypes:CreatePredictor' :: CreatePredictor -> Maybe (NonEmpty Text)
$sel:evaluationParameters:CreatePredictor' :: CreatePredictor -> Maybe EvaluationParameters
$sel:encryptionConfig:CreatePredictor' :: CreatePredictor -> Maybe EncryptionConfig
$sel:autoMLOverrideStrategy:CreatePredictor' :: CreatePredictor -> Maybe AutoMLOverrideStrategy
$sel:algorithmArn:CreatePredictor' :: CreatePredictor -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
algorithmArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EncryptionConfig
encryptionConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EvaluationParameters
evaluationParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
forecastTypes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe HyperParameterTuningJobConfig
hPOConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe OptimizationMetric
optimizationMetric
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
performAutoML
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
performHPO
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
trainingParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
predictorName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Int
forecastHorizon
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` InputDataConfig
inputDataConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` FeaturizationConfig
featurizationConfig

instance Prelude.NFData CreatePredictor where
  rnf :: CreatePredictor -> ()
rnf CreatePredictor' {Int
Maybe Bool
Maybe [Tag]
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe AutoMLOverrideStrategy
Maybe EncryptionConfig
Maybe EvaluationParameters
Maybe OptimizationMetric
Maybe HyperParameterTuningJobConfig
Text
FeaturizationConfig
InputDataConfig
featurizationConfig :: FeaturizationConfig
inputDataConfig :: InputDataConfig
forecastHorizon :: Int
predictorName :: Text
trainingParameters :: Maybe (HashMap Text Text)
tags :: Maybe [Tag]
performHPO :: Maybe Bool
performAutoML :: Maybe Bool
optimizationMetric :: Maybe OptimizationMetric
hPOConfig :: Maybe HyperParameterTuningJobConfig
forecastTypes :: Maybe (NonEmpty Text)
evaluationParameters :: Maybe EvaluationParameters
encryptionConfig :: Maybe EncryptionConfig
autoMLOverrideStrategy :: Maybe AutoMLOverrideStrategy
algorithmArn :: Maybe Text
$sel:featurizationConfig:CreatePredictor' :: CreatePredictor -> FeaturizationConfig
$sel:inputDataConfig:CreatePredictor' :: CreatePredictor -> InputDataConfig
$sel:forecastHorizon:CreatePredictor' :: CreatePredictor -> Int
$sel:predictorName:CreatePredictor' :: CreatePredictor -> Text
$sel:trainingParameters:CreatePredictor' :: CreatePredictor -> Maybe (HashMap Text Text)
$sel:tags:CreatePredictor' :: CreatePredictor -> Maybe [Tag]
$sel:performHPO:CreatePredictor' :: CreatePredictor -> Maybe Bool
$sel:performAutoML:CreatePredictor' :: CreatePredictor -> Maybe Bool
$sel:optimizationMetric:CreatePredictor' :: CreatePredictor -> Maybe OptimizationMetric
$sel:hPOConfig:CreatePredictor' :: CreatePredictor -> Maybe HyperParameterTuningJobConfig
$sel:forecastTypes:CreatePredictor' :: CreatePredictor -> Maybe (NonEmpty Text)
$sel:evaluationParameters:CreatePredictor' :: CreatePredictor -> Maybe EvaluationParameters
$sel:encryptionConfig:CreatePredictor' :: CreatePredictor -> Maybe EncryptionConfig
$sel:autoMLOverrideStrategy:CreatePredictor' :: CreatePredictor -> Maybe AutoMLOverrideStrategy
$sel:algorithmArn:CreatePredictor' :: CreatePredictor -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
algorithmArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EncryptionConfig
encryptionConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EvaluationParameters
evaluationParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
forecastTypes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe HyperParameterTuningJobConfig
hPOConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe OptimizationMetric
optimizationMetric
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
performAutoML
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
performHPO
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
trainingParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
predictorName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
forecastHorizon
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf InputDataConfig
inputDataConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf FeaturizationConfig
featurizationConfig

instance Data.ToHeaders CreatePredictor where
  toHeaders :: CreatePredictor -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AmazonForecast.CreatePredictor" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreatePredictor where
  toJSON :: CreatePredictor -> Value
toJSON CreatePredictor' {Int
Maybe Bool
Maybe [Tag]
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe AutoMLOverrideStrategy
Maybe EncryptionConfig
Maybe EvaluationParameters
Maybe OptimizationMetric
Maybe HyperParameterTuningJobConfig
Text
FeaturizationConfig
InputDataConfig
featurizationConfig :: FeaturizationConfig
inputDataConfig :: InputDataConfig
forecastHorizon :: Int
predictorName :: Text
trainingParameters :: Maybe (HashMap Text Text)
tags :: Maybe [Tag]
performHPO :: Maybe Bool
performAutoML :: Maybe Bool
optimizationMetric :: Maybe OptimizationMetric
hPOConfig :: Maybe HyperParameterTuningJobConfig
forecastTypes :: Maybe (NonEmpty Text)
evaluationParameters :: Maybe EvaluationParameters
encryptionConfig :: Maybe EncryptionConfig
autoMLOverrideStrategy :: Maybe AutoMLOverrideStrategy
algorithmArn :: Maybe Text
$sel:featurizationConfig:CreatePredictor' :: CreatePredictor -> FeaturizationConfig
$sel:inputDataConfig:CreatePredictor' :: CreatePredictor -> InputDataConfig
$sel:forecastHorizon:CreatePredictor' :: CreatePredictor -> Int
$sel:predictorName:CreatePredictor' :: CreatePredictor -> Text
$sel:trainingParameters:CreatePredictor' :: CreatePredictor -> Maybe (HashMap Text Text)
$sel:tags:CreatePredictor' :: CreatePredictor -> Maybe [Tag]
$sel:performHPO:CreatePredictor' :: CreatePredictor -> Maybe Bool
$sel:performAutoML:CreatePredictor' :: CreatePredictor -> Maybe Bool
$sel:optimizationMetric:CreatePredictor' :: CreatePredictor -> Maybe OptimizationMetric
$sel:hPOConfig:CreatePredictor' :: CreatePredictor -> Maybe HyperParameterTuningJobConfig
$sel:forecastTypes:CreatePredictor' :: CreatePredictor -> Maybe (NonEmpty Text)
$sel:evaluationParameters:CreatePredictor' :: CreatePredictor -> Maybe EvaluationParameters
$sel:encryptionConfig:CreatePredictor' :: CreatePredictor -> Maybe EncryptionConfig
$sel:autoMLOverrideStrategy:CreatePredictor' :: CreatePredictor -> Maybe AutoMLOverrideStrategy
$sel:algorithmArn:CreatePredictor' :: CreatePredictor -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AlgorithmArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
algorithmArn,
            (Key
"AutoMLOverrideStrategy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AutoMLOverrideStrategy
autoMLOverrideStrategy,
            (Key
"EncryptionConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe EncryptionConfig
encryptionConfig,
            (Key
"EvaluationParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe EvaluationParameters
evaluationParameters,
            (Key
"ForecastTypes" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty Text)
forecastTypes,
            (Key
"HPOConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe HyperParameterTuningJobConfig
hPOConfig,
            (Key
"OptimizationMetric" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe OptimizationMetric
optimizationMetric,
            (Key
"PerformAutoML" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
performAutoML,
            (Key
"PerformHPO" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
performHPO,
            (Key
"Tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            (Key
"TrainingParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
trainingParameters,
            forall a. a -> Maybe a
Prelude.Just (Key
"PredictorName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
predictorName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ForecastHorizon" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Int
forecastHorizon),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"InputDataConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= InputDataConfig
inputDataConfig),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"FeaturizationConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= FeaturizationConfig
featurizationConfig)
          ]
      )

instance Data.ToPath CreatePredictor where
  toPath :: CreatePredictor -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery CreatePredictor where
  toQuery :: CreatePredictor -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCreatePredictorResponse' smart constructor.
data CreatePredictorResponse = CreatePredictorResponse'
  { -- | The Amazon Resource Name (ARN) of the predictor.
    CreatePredictorResponse -> Maybe Text
predictorArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreatePredictorResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreatePredictorResponse -> CreatePredictorResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreatePredictorResponse -> CreatePredictorResponse -> Bool
$c/= :: CreatePredictorResponse -> CreatePredictorResponse -> Bool
== :: CreatePredictorResponse -> CreatePredictorResponse -> Bool
$c== :: CreatePredictorResponse -> CreatePredictorResponse -> Bool
Prelude.Eq, ReadPrec [CreatePredictorResponse]
ReadPrec CreatePredictorResponse
Int -> ReadS CreatePredictorResponse
ReadS [CreatePredictorResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreatePredictorResponse]
$creadListPrec :: ReadPrec [CreatePredictorResponse]
readPrec :: ReadPrec CreatePredictorResponse
$creadPrec :: ReadPrec CreatePredictorResponse
readList :: ReadS [CreatePredictorResponse]
$creadList :: ReadS [CreatePredictorResponse]
readsPrec :: Int -> ReadS CreatePredictorResponse
$creadsPrec :: Int -> ReadS CreatePredictorResponse
Prelude.Read, Int -> CreatePredictorResponse -> ShowS
[CreatePredictorResponse] -> ShowS
CreatePredictorResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreatePredictorResponse] -> ShowS
$cshowList :: [CreatePredictorResponse] -> ShowS
show :: CreatePredictorResponse -> String
$cshow :: CreatePredictorResponse -> String
showsPrec :: Int -> CreatePredictorResponse -> ShowS
$cshowsPrec :: Int -> CreatePredictorResponse -> ShowS
Prelude.Show, forall x. Rep CreatePredictorResponse x -> CreatePredictorResponse
forall x. CreatePredictorResponse -> Rep CreatePredictorResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreatePredictorResponse x -> CreatePredictorResponse
$cfrom :: forall x. CreatePredictorResponse -> Rep CreatePredictorResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreatePredictorResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'predictorArn', 'createPredictorResponse_predictorArn' - The Amazon Resource Name (ARN) of the predictor.
--
-- 'httpStatus', 'createPredictorResponse_httpStatus' - The response's http status code.
newCreatePredictorResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreatePredictorResponse
newCreatePredictorResponse :: Int -> CreatePredictorResponse
newCreatePredictorResponse Int
pHttpStatus_ =
  CreatePredictorResponse'
    { $sel:predictorArn:CreatePredictorResponse' :: Maybe Text
predictorArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreatePredictorResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the predictor.
createPredictorResponse_predictorArn :: Lens.Lens' CreatePredictorResponse (Prelude.Maybe Prelude.Text)
createPredictorResponse_predictorArn :: Lens' CreatePredictorResponse (Maybe Text)
createPredictorResponse_predictorArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictorResponse' {Maybe Text
predictorArn :: Maybe Text
$sel:predictorArn:CreatePredictorResponse' :: CreatePredictorResponse -> Maybe Text
predictorArn} -> Maybe Text
predictorArn) (\s :: CreatePredictorResponse
s@CreatePredictorResponse' {} Maybe Text
a -> CreatePredictorResponse
s {$sel:predictorArn:CreatePredictorResponse' :: Maybe Text
predictorArn = Maybe Text
a} :: CreatePredictorResponse)

-- | The response's http status code.
createPredictorResponse_httpStatus :: Lens.Lens' CreatePredictorResponse Prelude.Int
createPredictorResponse_httpStatus :: Lens' CreatePredictorResponse Int
createPredictorResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreatePredictorResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreatePredictorResponse' :: CreatePredictorResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreatePredictorResponse
s@CreatePredictorResponse' {} Int
a -> CreatePredictorResponse
s {$sel:httpStatus:CreatePredictorResponse' :: Int
httpStatus = Int
a} :: CreatePredictorResponse)

instance Prelude.NFData CreatePredictorResponse where
  rnf :: CreatePredictorResponse -> ()
rnf CreatePredictorResponse' {Int
Maybe Text
httpStatus :: Int
predictorArn :: Maybe Text
$sel:httpStatus:CreatePredictorResponse' :: CreatePredictorResponse -> Int
$sel:predictorArn:CreatePredictorResponse' :: CreatePredictorResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
predictorArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus