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

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

-- |
-- Module      : Amazonka.SageMaker.Types.ParameterRanges
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.SageMaker.Types.ParameterRanges where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.SageMaker.Types.CategoricalParameterRange
import Amazonka.SageMaker.Types.ContinuousParameterRange
import Amazonka.SageMaker.Types.IntegerParameterRange

-- | Specifies ranges of integer, continuous, and categorical hyperparameters
-- that a hyperparameter tuning job searches. The hyperparameter tuning job
-- launches training jobs with hyperparameter values within these ranges to
-- find the combination of values that result in the training job with the
-- best performance as measured by the objective metric of the
-- hyperparameter tuning job.
--
-- The maximum number of items specified for @Array Members@ refers to the
-- maximum number of hyperparameters for each range and also the maximum
-- for the hyperparameter tuning job itself. That is, the sum of the number
-- of hyperparameters for all the ranges can\'t exceed the maximum number
-- specified.
--
-- /See:/ 'newParameterRanges' smart constructor.
data ParameterRanges = ParameterRanges'
  { -- | The array of CategoricalParameterRange objects that specify ranges of
    -- categorical hyperparameters that a hyperparameter tuning job searches.
    ParameterRanges -> Maybe [CategoricalParameterRange]
categoricalParameterRanges :: Prelude.Maybe [CategoricalParameterRange],
    -- | The array of ContinuousParameterRange objects that specify ranges of
    -- continuous hyperparameters that a hyperparameter tuning job searches.
    ParameterRanges -> Maybe [ContinuousParameterRange]
continuousParameterRanges :: Prelude.Maybe [ContinuousParameterRange],
    -- | The array of IntegerParameterRange objects that specify ranges of
    -- integer hyperparameters that a hyperparameter tuning job searches.
    ParameterRanges -> Maybe [IntegerParameterRange]
integerParameterRanges :: Prelude.Maybe [IntegerParameterRange]
  }
  deriving (ParameterRanges -> ParameterRanges -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParameterRanges -> ParameterRanges -> Bool
$c/= :: ParameterRanges -> ParameterRanges -> Bool
== :: ParameterRanges -> ParameterRanges -> Bool
$c== :: ParameterRanges -> ParameterRanges -> Bool
Prelude.Eq, ReadPrec [ParameterRanges]
ReadPrec ParameterRanges
Int -> ReadS ParameterRanges
ReadS [ParameterRanges]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ParameterRanges]
$creadListPrec :: ReadPrec [ParameterRanges]
readPrec :: ReadPrec ParameterRanges
$creadPrec :: ReadPrec ParameterRanges
readList :: ReadS [ParameterRanges]
$creadList :: ReadS [ParameterRanges]
readsPrec :: Int -> ReadS ParameterRanges
$creadsPrec :: Int -> ReadS ParameterRanges
Prelude.Read, Int -> ParameterRanges -> ShowS
[ParameterRanges] -> ShowS
ParameterRanges -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParameterRanges] -> ShowS
$cshowList :: [ParameterRanges] -> ShowS
show :: ParameterRanges -> String
$cshow :: ParameterRanges -> String
showsPrec :: Int -> ParameterRanges -> ShowS
$cshowsPrec :: Int -> ParameterRanges -> ShowS
Prelude.Show, forall x. Rep ParameterRanges x -> ParameterRanges
forall x. ParameterRanges -> Rep ParameterRanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ParameterRanges x -> ParameterRanges
$cfrom :: forall x. ParameterRanges -> Rep ParameterRanges x
Prelude.Generic)

-- |
-- Create a value of 'ParameterRanges' 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:
--
-- 'categoricalParameterRanges', 'parameterRanges_categoricalParameterRanges' - The array of CategoricalParameterRange objects that specify ranges of
-- categorical hyperparameters that a hyperparameter tuning job searches.
--
-- 'continuousParameterRanges', 'parameterRanges_continuousParameterRanges' - The array of ContinuousParameterRange objects that specify ranges of
-- continuous hyperparameters that a hyperparameter tuning job searches.
--
-- 'integerParameterRanges', 'parameterRanges_integerParameterRanges' - The array of IntegerParameterRange objects that specify ranges of
-- integer hyperparameters that a hyperparameter tuning job searches.
newParameterRanges ::
  ParameterRanges
newParameterRanges :: ParameterRanges
newParameterRanges =
  ParameterRanges'
    { $sel:categoricalParameterRanges:ParameterRanges' :: Maybe [CategoricalParameterRange]
categoricalParameterRanges =
        forall a. Maybe a
Prelude.Nothing,
      $sel:continuousParameterRanges:ParameterRanges' :: Maybe [ContinuousParameterRange]
continuousParameterRanges = forall a. Maybe a
Prelude.Nothing,
      $sel:integerParameterRanges:ParameterRanges' :: Maybe [IntegerParameterRange]
integerParameterRanges = forall a. Maybe a
Prelude.Nothing
    }

-- | The array of CategoricalParameterRange objects that specify ranges of
-- categorical hyperparameters that a hyperparameter tuning job searches.
parameterRanges_categoricalParameterRanges :: Lens.Lens' ParameterRanges (Prelude.Maybe [CategoricalParameterRange])
parameterRanges_categoricalParameterRanges :: Lens' ParameterRanges (Maybe [CategoricalParameterRange])
parameterRanges_categoricalParameterRanges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ParameterRanges' {Maybe [CategoricalParameterRange]
categoricalParameterRanges :: Maybe [CategoricalParameterRange]
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [CategoricalParameterRange]
categoricalParameterRanges} -> Maybe [CategoricalParameterRange]
categoricalParameterRanges) (\s :: ParameterRanges
s@ParameterRanges' {} Maybe [CategoricalParameterRange]
a -> ParameterRanges
s {$sel:categoricalParameterRanges:ParameterRanges' :: Maybe [CategoricalParameterRange]
categoricalParameterRanges = Maybe [CategoricalParameterRange]
a} :: ParameterRanges) 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 array of ContinuousParameterRange objects that specify ranges of
-- continuous hyperparameters that a hyperparameter tuning job searches.
parameterRanges_continuousParameterRanges :: Lens.Lens' ParameterRanges (Prelude.Maybe [ContinuousParameterRange])
parameterRanges_continuousParameterRanges :: Lens' ParameterRanges (Maybe [ContinuousParameterRange])
parameterRanges_continuousParameterRanges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ParameterRanges' {Maybe [ContinuousParameterRange]
continuousParameterRanges :: Maybe [ContinuousParameterRange]
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [ContinuousParameterRange]
continuousParameterRanges} -> Maybe [ContinuousParameterRange]
continuousParameterRanges) (\s :: ParameterRanges
s@ParameterRanges' {} Maybe [ContinuousParameterRange]
a -> ParameterRanges
s {$sel:continuousParameterRanges:ParameterRanges' :: Maybe [ContinuousParameterRange]
continuousParameterRanges = Maybe [ContinuousParameterRange]
a} :: ParameterRanges) 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 array of IntegerParameterRange objects that specify ranges of
-- integer hyperparameters that a hyperparameter tuning job searches.
parameterRanges_integerParameterRanges :: Lens.Lens' ParameterRanges (Prelude.Maybe [IntegerParameterRange])
parameterRanges_integerParameterRanges :: Lens' ParameterRanges (Maybe [IntegerParameterRange])
parameterRanges_integerParameterRanges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ParameterRanges' {Maybe [IntegerParameterRange]
integerParameterRanges :: Maybe [IntegerParameterRange]
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [IntegerParameterRange]
integerParameterRanges} -> Maybe [IntegerParameterRange]
integerParameterRanges) (\s :: ParameterRanges
s@ParameterRanges' {} Maybe [IntegerParameterRange]
a -> ParameterRanges
s {$sel:integerParameterRanges:ParameterRanges' :: Maybe [IntegerParameterRange]
integerParameterRanges = Maybe [IntegerParameterRange]
a} :: ParameterRanges) 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

instance Data.FromJSON ParameterRanges where
  parseJSON :: Value -> Parser ParameterRanges
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"ParameterRanges"
      ( \Object
x ->
          Maybe [CategoricalParameterRange]
-> Maybe [ContinuousParameterRange]
-> Maybe [IntegerParameterRange]
-> ParameterRanges
ParameterRanges'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CategoricalParameterRanges"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ContinuousParameterRanges"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"IntegerParameterRanges"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable ParameterRanges where
  hashWithSalt :: Int -> ParameterRanges -> Int
hashWithSalt Int
_salt ParameterRanges' {Maybe [CategoricalParameterRange]
Maybe [ContinuousParameterRange]
Maybe [IntegerParameterRange]
integerParameterRanges :: Maybe [IntegerParameterRange]
continuousParameterRanges :: Maybe [ContinuousParameterRange]
categoricalParameterRanges :: Maybe [CategoricalParameterRange]
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [IntegerParameterRange]
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [ContinuousParameterRange]
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [CategoricalParameterRange]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CategoricalParameterRange]
categoricalParameterRanges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ContinuousParameterRange]
continuousParameterRanges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [IntegerParameterRange]
integerParameterRanges

instance Prelude.NFData ParameterRanges where
  rnf :: ParameterRanges -> ()
rnf ParameterRanges' {Maybe [CategoricalParameterRange]
Maybe [ContinuousParameterRange]
Maybe [IntegerParameterRange]
integerParameterRanges :: Maybe [IntegerParameterRange]
continuousParameterRanges :: Maybe [ContinuousParameterRange]
categoricalParameterRanges :: Maybe [CategoricalParameterRange]
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [IntegerParameterRange]
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [ContinuousParameterRange]
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [CategoricalParameterRange]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [CategoricalParameterRange]
categoricalParameterRanges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ContinuousParameterRange]
continuousParameterRanges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [IntegerParameterRange]
integerParameterRanges

instance Data.ToJSON ParameterRanges where
  toJSON :: ParameterRanges -> Value
toJSON ParameterRanges' {Maybe [CategoricalParameterRange]
Maybe [ContinuousParameterRange]
Maybe [IntegerParameterRange]
integerParameterRanges :: Maybe [IntegerParameterRange]
continuousParameterRanges :: Maybe [ContinuousParameterRange]
categoricalParameterRanges :: Maybe [CategoricalParameterRange]
$sel:integerParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [IntegerParameterRange]
$sel:continuousParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [ContinuousParameterRange]
$sel:categoricalParameterRanges:ParameterRanges' :: ParameterRanges -> Maybe [CategoricalParameterRange]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CategoricalParameterRanges" 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 [CategoricalParameterRange]
categoricalParameterRanges,
            (Key
"ContinuousParameterRanges" 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 [ContinuousParameterRange]
continuousParameterRanges,
            (Key
"IntegerParameterRanges" 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 [IntegerParameterRange]
integerParameterRanges
          ]
      )