diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright Jiasen Wu (c) 2018 + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Author name here nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,14 @@ +# mxnet-hs +## build ++ LD_LIBRARY_PATH= stack build fei-base + +## generate MXNet operators ++ the repository ships pre-generated operators for various version MXNet. ++ You can generate your own with the utility `mxnet-op-gen`: + + `LD_LIBRARY_PATH= mxnet-op-gen -o ` + +## see also ++ https://github.com/pierric/fei-nn ++ https://github.com/pierric/fei-dataiter ++ https://github.com/pierric/fei-cocoapi ++ https://github.com/pierric/fei-examples diff --git a/c-apis/MXNet/Base.hs b/c-apis/MXNet/Base.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base.hs @@ -0,0 +1,17 @@ +module MXNet.Base( + module MXNet.Base.Types, + module MXNet.Base.Raw, + module MXNet.Base.Symbol, + module MXNet.Base.NDArray, + module MXNet.Base.Executor, + module MXNet.Base.Spec.HMap, + module MXNet.Base.Spec.Operator , +) where + +import MXNet.Base.Types +import MXNet.Base.Raw +import MXNet.Base.Symbol +import MXNet.Base.NDArray +import MXNet.Base.Executor +import MXNet.Base.Spec.HMap +import MXNet.Base.Spec.Operator diff --git a/c-apis/MXNet/Base/Executor.hs b/c-apis/MXNet/Base/Executor.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Executor.hs @@ -0,0 +1,10 @@ +module MXNet.Base.Executor where + +import qualified MXNet.Base.Raw as I +import MXNet.Base.Types (ForeignData(..)) + + +newtype Executor a = Executor { unExecutor :: I.ExecutorHandle } + +instance ForeignData (Executor a) where + touch = I.touchExecutorHandle . unExecutor diff --git a/c-apis/MXNet/Base/NDArray.hs b/c-apis/MXNet/Base/NDArray.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/NDArray.hs @@ -0,0 +1,94 @@ +{-# LANGUAGE ScopedTypeVariables #-} +module MXNet.Base.NDArray where + +import Foreign.Ptr (castPtr) +import Foreign.Storable (Storable(..)) +import Data.Vector.Storable (Vector) +import qualified Data.Vector.Storable as V +import qualified Data.Vector.Storable.Mutable as VMut +import qualified Data.Vector.Unboxed as UV +import qualified Data.Array.Repa as Repa +import qualified Data.Array.Repa.Eval as Repa + +import qualified MXNet.Base.Raw as I +import MXNet.Base.Types (Context(..), contextCPU, DType(..), ForeignData(..)) + +newtype NDArray a = NDArray { unNDArray :: I.NDArrayHandle} + +instance ForeignData (NDArray a) where + touch = I.touchNDArrayHandle . unNDArray + +makeEmptyNDArray :: forall a. DType a => [Int] -> Context -> IO (NDArray a) +makeEmptyNDArray shape ctx = do + array <- I.mxNDArrayCreateEx shape (_device_type ctx) (_device_id ctx) False (flag (undefined :: a)) + return $ NDArray array + +makeNDArray :: forall a. DType a => [Int] -> Context -> Vector a -> IO (NDArray a) +makeNDArray shape ctx vec = do + array <- I.mxNDArrayCreateEx shape (_device_type ctx) (_device_id ctx) False (flag (undefined :: a)) + V.unsafeWith vec $ \p -> do + I.mxNDArraySyncCopyFromCPU array (castPtr p) (V.length vec) + return $ NDArray array + +makeNDArrayLike :: DType a => NDArray a -> Context -> IO (NDArray a) +makeNDArrayLike src cxt = do + shape <- ndshape src + makeEmptyNDArray shape cxt + +ndshape :: DType a => NDArray a -> IO [Int] +ndshape = I.mxNDArrayGetShape . unNDArray + +ndsize :: DType a => NDArray a -> IO Int +ndsize arr = product <$> ndshape arr + +full :: DType a => a -> [Int] -> IO (NDArray a) +full value shape = makeNDArray shape contextCPU $ V.replicate (product shape) value + +ones :: DType a => [Int] -> IO (NDArray a) +ones = full 1 + +zeros :: DType a => [Int] -> IO (NDArray a) +zeros = full 1 + +fromVector :: DType a => [Int] -> Vector a -> IO (NDArray a) +fromVector shape = makeNDArray shape contextCPU + +copyFromVector :: DType a => NDArray a -> Vector a -> IO () +copyFromVector arr vec = do + sz <- ndsize arr + if (sz /= V.length vec) + then error "" + else do + V.unsafeWith vec $ \p -> do + I.mxNDArraySyncCopyFromCPU (unNDArray arr) (castPtr p) sz + +copyFromRepa :: (Repa.Shape sh, DType a, UV.Unbox a, Repa.Load r sh a) => NDArray a -> Repa.Array r sh a -> IO () +copyFromRepa arr repa = do + let vec = UV.convert $ Repa.toUnboxed $ Repa.computeS repa + copyFromVector arr vec + +toVector :: DType a => NDArray a -> IO (Vector a) +toVector arr = do + nlen <- ndsize arr + mvec <- VMut.new nlen + VMut.unsafeWith mvec $ \p -> I.mxNDArraySyncCopyToCPU (unNDArray arr) (castPtr p) nlen + V.unsafeFreeze mvec + +toRepa :: (Repa.Shape sh, DType a, UV.Unbox a) => NDArray a -> IO (Repa.Array Repa.U sh a) +toRepa arr = do + shp <- ndshape arr + vec <- toVector arr + return $ Repa.fromUnboxed (Repa.shapeOfList (reverse shp)) (UV.convert vec) + +context :: DType a => NDArray a -> IO Context +context (NDArray handle) = do + cxt <- I.mxNDArrayGetContext handle + return $ uncurry Context cxt + +waitToRead :: DType a => NDArray a -> IO () +waitToRead (NDArray hdl) = I.mxNDArrayWaitToRead hdl + +waitToWrite :: DType a => NDArray a -> IO () +waitToWrite (NDArray hdl) = I.mxNDArrayWaitToWrite hdl + +waitAll = I.mxNDArrayWaitAll diff --git a/c-apis/MXNet/Base/Raw.hs b/c-apis/MXNet/Base/Raw.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Raw.hs @@ -0,0 +1,13 @@ +module MXNet.Base.Raw ( + module MXNet.Base.Raw.Common, + module MXNet.Base.Raw.NDArray, + module MXNet.Base.Raw.Symbol, + module MXNet.Base.Raw.Executor, + module MXNet.Base.Raw.DataIter +) where + +import MXNet.Base.Raw.Common +import MXNet.Base.Raw.NDArray +import MXNet.Base.Raw.Symbol +import MXNet.Base.Raw.Executor +import MXNet.Base.Raw.DataIter diff --git a/c-apis/MXNet/Base/Raw/Common.chs b/c-apis/MXNet/Base/Raw/Common.chs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Raw/Common.chs @@ -0,0 +1,227 @@ +module MXNet.Base.Raw.Common where + +import Control.Exception.Base (Exception, throwIO) +import Data.Typeable (Typeable) +import Data.Tuple.Ops (Unconsable, uncons) +import Foreign.Marshal (alloca, peekArray, withArray) +import Foreign.Storable (Storable(..)) +import Foreign.C (withCString) +import Foreign.C.Types +import Foreign.Ptr +import C2HS.C.Extra.Marshal (peekString, peekStringArray) +import GHC.Generics (Generic) +import Data.Word (Word64) + +type MX_UINT = C2HSImp.CUInt +type MX_CCHAR = C2HSImp.CChar + +data MXNetError = MXNetError String + deriving Typeable +instance Exception MXNetError + +instance Show MXNetError where + show (MXNetError msg) = "an error occurred in MXNet.\n" ++ msg + +deriving instance Generic C2HSImp.CInt +deriving instance Generic C2HSImp.CUInt + +checked :: Unconsable t CInt r => IO t -> IO r +checked call = do + (res, ret) <- uncons <$> call + if res < 0 + then do err <- mxGetLastError + throwIO $ MXNetError err + else return ret + +withStringArray :: [String] -> (Ptr (Ptr CChar) -> IO a) -> IO a +withStringArray strs act = go strs [] + where + go [] all = withArray (reverse all) act + go (s:ss) all = withCString s (go ss . (:all)) + +#include +#include + +{# +fun MXGetVersion as mxGetVersion_ + { + alloca- `CInt' peek* + } -> `CInt' +#} + +mxGetVersion :: IO Int +mxGetVersion = fromIntegral <$> checked mxGetVersion_ + +{# +fun MXListAllOpNames as mxListAllOpNames_ + { + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr MX_CCHAR)' peek* + } -> `CInt' +#} + +mxListAllOpNames :: IO [String] +mxListAllOpNames = do + (cnt, ptr) <- checked mxListAllOpNames_ + peekStringArray (fromIntegral cnt :: Int) ptr + +{# +fun MXGetLastError as mxGetLastError + { + } -> `String' +#} + +{# +pointer AtomicSymbolCreator newtype +#} + +deriving instance Storable AtomicSymbolCreator + +fromOpHandle :: OpHandle -> AtomicSymbolCreator +fromOpHandle (OpHandle ptr) = AtomicSymbolCreator (C2HSImp.castPtr ptr) + +{# +fun MXSymbolListAtomicSymbolCreators as mxSymbolListAtomicSymbolCreators_ + { + alloca- `MX_UINT' peek*, + alloca- `Ptr AtomicSymbolCreator' peek* + } -> `CInt' +#} + +mxSymbolListAtomicSymbolCreators :: IO [AtomicSymbolCreator] +mxSymbolListAtomicSymbolCreators = do + (cnt, ptr) <- checked $ mxSymbolListAtomicSymbolCreators_ + peekArray (fromIntegral cnt) ptr + +mxSymbolGetAtomicSymbolCreatorAt :: Int -> IO AtomicSymbolCreator +mxSymbolGetAtomicSymbolCreatorAt idx = do + (cnt, ptr) <- checked $ mxSymbolListAtomicSymbolCreators_ + peekElemOff ptr idx + +{# +fun MXSymbolGetAtomicSymbolName as mxSymbolGetAtomicSymbolName_ + { + `AtomicSymbolCreator', + alloca- `String' peekString* + } -> `CInt' +#} + +mxSymbolGetAtomicSymbolName :: AtomicSymbolCreator -> IO String +mxSymbolGetAtomicSymbolName = checked . mxSymbolGetAtomicSymbolName_ + +{# +fun MXSymbolGetAtomicSymbolInfo as mxSymbolGetAtomicSymbolInfo_ + { + `AtomicSymbolCreator', + alloca- `String' peekString*, + alloca- `String' peekString*, + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `String' peekString*, + alloca- `String' peekString* + } -> `CInt' +#} + +mxSymbolGetAtomicSymbolInfo :: AtomicSymbolCreator + -> IO (String, + String, + [String], + [String], + [String], + String, + String) +mxSymbolGetAtomicSymbolInfo creator = do + (name, desc, argcnt, argname, argtype, argdesc, key_var_num_args, rettyp) <- checked $ mxSymbolGetAtomicSymbolInfo_ creator + let n = fromIntegral argcnt + argname <- peekStringArray n argname + argtype <- peekStringArray n argtype + argdesc <- peekStringArray n argdesc + return (name, desc, argname, argtype, argdesc, key_var_num_args, rettyp) + +{# +fun MXNotifyShutdown as mxNotifyShutdown_ + { + } -> `CInt' +#} + +mxNotifyShutdown :: IO () +mxNotifyShutdown = checked mxNotifyShutdown_ + +--------------------------------------------------- +type NN_UINT = C2HSImp.CUInt + +{# pointer OpHandle newtype #} +deriving instance Storable OpHandle +deriving instance Generic OpHandle + +{# pointer GraphHandle newtype #} +deriving instance Storable GraphHandle +deriving instance Generic GraphHandle + +{# +fun NNListAllOpNames as nnListAllOpNames_ + { + alloca- `NN_UINT' peek*, + alloca- `Ptr (Ptr MX_CCHAR)' peek* + } -> `CInt' +#} + +nnListAllOpNames :: IO [String] +nnListAllOpNames = do + (cnt, ptr) <- checked nnListAllOpNames_ + peekStringArray (fromIntegral cnt :: Int) ptr + +{# +fun NNListUniqueOps as nnListUniqueOps_ + { + alloca- `NN_UINT' peek*, + alloca- `Ptr OpHandle' peek* + } -> `CInt' +#} + +nnListUniqueOps :: IO [OpHandle] +nnListUniqueOps = do + (cnt, ptr) <- checked (nnListUniqueOps_ :: IO (CInt, NN_UINT, Ptr OpHandle)) + peekArray (fromIntegral cnt :: Int) (ptr :: Ptr OpHandle) + +{# +fun NNGetOpHandle as nnGetOpHandle_ + { + `String', + alloca- `OpHandle' peek* + } -> `CInt' +#} + +nnGetOpHandle :: String -> IO OpHandle +nnGetOpHandle = checked . nnGetOpHandle_ + +{# +fun NNGetOpInfo as nnGetOpInfo_ + { + `OpHandle', + alloca- `String' peekString*, + alloca- `String' peekString*, + alloca- `NN_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `String' peekString* + } -> `CInt' +#} + +nnGetOpInfo :: OpHandle -> IO (String, String, [String], [String], [String], String) +nnGetOpInfo op = do + (name, desc, num_args, ptr_arg_names, ptr_arg_types, ptr_arg_descs, ret_type) <- checked $ nnGetOpInfo_ op + let num_args_ = fromIntegral num_args + arg_names <- peekStringArray num_args_ ptr_arg_names + arg_types <- peekStringArray num_args_ ptr_arg_types + arg_descs <- peekStringArray num_args_ ptr_arg_descs + return (name, desc, arg_names, arg_types, arg_descs, ret_type) + +{# +fun NNGetLastError as nnGetLastError + { + } -> `String' +#} diff --git a/c-apis/MXNet/Base/Raw/DataIter.chs b/c-apis/MXNet/Base/Raw/DataIter.chs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Raw/DataIter.chs @@ -0,0 +1,182 @@ +module MXNet.Base.Raw.DataIter where + +import Data.Typeable (Typeable) +import Foreign.Marshal (alloca, peekArray) +import Foreign.Storable (Storable(..)) +import Foreign.Concurrent (newForeignPtr) +import Foreign.ForeignPtr (finalizeForeignPtr) +import Foreign.C.Types +import Foreign.Ptr +import Data.Word (Word64) +import C2HS.C.Extra.Marshal (peekString, peekStringArray, peekIntegralArray) +import GHC.Generics (Generic) +import Control.Monad ((>=>)) + +{# import MXNet.Base.Raw.Common #} +{# import MXNet.Base.Raw.NDArray #} + +#include + +{# typedef mx_uint MX_UINT#} +{# default in `MX_UINT' [mx_uint] id #} + +{# typedef uint64_t Word64#} +{# default in `Word64' [uint64_t] id #} + +{# +pointer DataIterCreator newtype +#} + +deriving instance Storable DataIterCreator + +{# +pointer DataIterHandle foreign newtype +#} + +deriving instance Generic DataIterHandle + +type DataIterHandlePtr = Ptr DataIterHandle + +newDataIterHandle :: DataIterHandlePtr -> IO DataIterHandle +newDataIterHandle ptr = newForeignPtr ptr (mxDataIterFree ptr) >>= return . DataIterHandle + +peekDataIterHandle :: Ptr DataIterHandlePtr -> IO DataIterHandle +peekDataIterHandle = peek >=> newDataIterHandle + +finalizeDataIterHandle :: DataIterHandle -> IO () +finalizeDataIterHandle (DataIterHandle fptr) = finalizeForeignPtr fptr + +{# +fun MXDataIterFree as mxDataIterFree_ + { + id `DataIterHandlePtr' + } -> `CInt' +#} + +mxDataIterFree :: DataIterHandlePtr -> IO () +mxDataIterFree = checked . mxDataIterFree_ + + +{# +fun MXListDataIters as mxListDataIters_ + { + alloca- `MX_UINT' peek*, + alloca- `Ptr DataIterCreator' peek* + } -> `CInt' +#} + +mxListDataIters :: IO [DataIterCreator] +mxListDataIters = do + (cnt, ptr) <- checked mxListDataIters_ + peekArray (fromIntegral cnt :: Int) ptr + +{# +fun MXDataIterGetIterInfo as mxDataIterGetIterInfo_ + { + `DataIterCreator', + alloca- `String' peekString*, + alloca- `String' peekString*, + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `Ptr (Ptr CChar)' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} + +mxDataIterGetIterInfo :: DataIterCreator -> IO (String, String, [String], [String], [String]) +mxDataIterGetIterInfo dataitercreator = do + (name, descr, num_args, arg_names, arg_type_infos, arg_descs) <- checked $ mxDataIterGetIterInfo_ dataitercreator + let num_args_ = fromIntegral num_args + arg_names_ <- peekStringArray num_args_ arg_names + arg_type_infos_ <- peekStringArray num_args_ arg_type_infos + arg_descs_ <- peekStringArray num_args_ arg_descs + return (name, descr, arg_names_, arg_type_infos_, arg_descs_) + +{# +fun MXDataIterCreateIter as mxDataIterCreateIter_ + { + `DataIterCreator', + `MX_UINT', + withStringArray* `[String]', + withStringArray* `[String]', + alloca- `DataIterHandle' peekDataIterHandle* + } -> `CInt' +#} + +mxDataIterCreateIter :: DataIterCreator -> [String] -> [String] -> IO DataIterHandle +mxDataIterCreateIter dataitercreator keys vals = do + let num_args = fromIntegral (length keys) + checked $ mxDataIterCreateIter_ dataitercreator num_args keys vals + +{# +fun MXDataIterNext as mxDataIterNext_ + { + `DataIterHandle', + alloca- `CInt' peek* + } -> `CInt' +#} + +mxDataIterNext :: DataIterHandle -> IO Int +mxDataIterNext dataiter = do + next <- checked $ mxDataIterNext_ dataiter + return $ fromIntegral next + +{# +fun MXDataIterBeforeFirst as mxDataIterBeforeFirst_ + { + `DataIterHandle' + } -> `CInt' +#} + +mxDataIterBeforeFirst :: DataIterHandle -> IO () +mxDataIterBeforeFirst = checked . mxDataIterBeforeFirst_ + +{# +fun MXDataIterGetData as mxDataIterGetData_ + { + `DataIterHandle', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxDataIterGetData :: DataIterHandle -> IO NDArrayHandle +mxDataIterGetData = checked . mxDataIterGetData_ + +{# +fun MXDataIterGetIndex as mxDataIterGetIndex_ + { + `DataIterHandle', + alloca- `Ptr Word64' peek*, + alloca- `Word64' peek* + } -> `CInt' +#} + +mxDataIterGetIndex :: DataIterHandle -> IO [Integer] +mxDataIterGetIndex dataiter = do + (ptr, cnt) <- checked $ mxDataIterGetIndex_ dataiter + peekIntegralArray (fromIntegral cnt) ptr + +{# +fun MXDataIterGetPadNum as mxDataIterGetPadNum_ + { + `DataIterHandle', + alloca- `CInt' peek* + } -> `CInt' +#} + +mxDataIterGetPadNum :: DataIterHandle -> IO Int +mxDataIterGetPadNum dataiter = do + next <- checked $ mxDataIterGetPadNum_ dataiter + return $ fromIntegral next + +{# +fun MXDataIterGetLabel as mxDataIterGetLabel_ + { + `DataIterHandle', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxDataIterGetLabel :: DataIterHandle -> IO NDArrayHandle +mxDataIterGetLabel = checked . mxDataIterGetLabel_ + diff --git a/c-apis/MXNet/Base/Raw/Executor.chs b/c-apis/MXNet/Base/Raw/Executor.chs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Raw/Executor.chs @@ -0,0 +1,414 @@ +{-# LANGUAGE ScopedTypeVariables #-} +module MXNet.Base.Raw.Executor where + +import Foreign.Marshal (alloca, withArray, peekArray) +import Foreign.Storable (Storable(..)) +import Foreign.Concurrent (newForeignPtr) +import Foreign.ForeignPtr (newForeignPtr_, touchForeignPtr) +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +import Foreign.Ptr +import Foreign.C.Types +import C2HS.C.Extra.Marshal (withIntegralArray, peekIntegralArray, peekString, peekStringArray) +import GHC.Generics (Generic) +import Control.Monad ((>=>)) +import Data.Maybe (fromMaybe) + +{# import MXNet.Base.Raw.Common #} +{# import MXNet.Base.Raw.NDArray #} +{# import MXNet.Base.Raw.Symbol #} + +#include + +{# typedef size_t CSize#} +{# default in `CSize' [size_t] fromIntegral #} +{# typedef mx_uint MX_UINT#} +{# default in `MX_UINT' [mx_uint] id #} + +{# +pointer ExecutorHandle foreign newtype +#} + +deriving instance Generic ExecutorHandle + +type ExecutorHandlePtr = Ptr ExecutorHandle + +touchExecutorHandle :: ExecutorHandle -> IO () +touchExecutorHandle (ExecutorHandle fptr) = touchForeignPtr fptr + +newExecutorHandle :: ExecutorHandlePtr -> IO ExecutorHandle +newExecutorHandle ptr = newForeignPtr ptr (mxExecutorFree ptr) >>= return . ExecutorHandle + +peekExecutorHandle :: Ptr ExecutorHandlePtr -> IO ExecutorHandle +peekExecutorHandle = peek >=> newExecutorHandle + +withExecutorHandleArray :: [ExecutorHandle] -> (Ptr ExecutorHandlePtr -> IO r) -> IO r +withExecutorHandleArray array io = do + let unExecutorHandle (ExecutorHandle fptr) = fptr + r <- withArray (map (unsafeForeignPtrToPtr . unExecutorHandle) array) io + mapM_ (touchForeignPtr . unExecutorHandle) array + return r + +{# +fun MXExecutorFree as mxExecutorFree_ + { + id `ExecutorHandlePtr' + } -> `CInt' +#} + +mxExecutorFree :: ExecutorHandlePtr -> IO () +mxExecutorFree = checked . mxExecutorFree_ + +{# +fun MXExecutorPrint as mxExecutorPrint_ + { + `ExecutorHandle', + alloca- `String' peekString* + } -> `CInt' +#} + +mxExecutorPrint :: ExecutorHandle -> IO String +mxExecutorPrint = checked . mxExecutorPrint_ + +{# +fun MXExecutorForward as mxExecutorForward_ + { + `ExecutorHandle', + `CInt' + } -> `CInt' +#} + +mxExecutorForward :: ExecutorHandle -> Bool -> IO () +mxExecutorForward exec train = checked $ mxExecutorForward_ exec is_train + where + is_train = if train then 1 else 0 + +{# +fun MXExecutorBackward as mxExecutorBackward_ + { + `ExecutorHandle', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]' + } -> `CInt' +#} + +mxExecutorBackward :: ExecutorHandle -> [NDArrayHandle] -> IO () +mxExecutorBackward exec head_grads = checked $ mxExecutorBackward_ exec cnt head_grads + where + cnt = fromIntegral $ length head_grads + +{# +fun MXExecutorBackwardEx as mxExecutorBackwardEx_ + { + `ExecutorHandle', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + `CInt' + } -> `CInt' +#} + +mxExecutorBackwardEx :: ExecutorHandle -> [NDArrayHandle] -> Bool -> IO () +mxExecutorBackwardEx exec head_grads train = checked $ mxExecutorBackwardEx_ exec cnt head_grads is_train + where + cnt = fromIntegral $ length head_grads + is_train = if train then 1 else 0 + +{# +fun MXExecutorOutputs as mxExecutorOutputs_ + { + `ExecutorHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr NDArrayHandlePtr' peek* + } -> `CInt' +#} + +mxExecutorOutputs :: ExecutorHandle -> IO [NDArrayHandle] +mxExecutorOutputs handle = do + (cnt, ptr) <- checked $ mxExecutorOutputs_ handle + handle_ptrs <- peekArray (fromIntegral cnt) ptr + mapM newNDArrayHandle handle_ptrs + +{# +fun MXExecutorBind as mxExecutorBind_ + { + `SymbolHandle', + `CInt', + `CInt', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + withNDArrayHandleArray* `[NDArrayHandle]', + withArray* `[MX_UINT]', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + alloca- `ExecutorHandle' peekExecutorHandle* + } -> `CInt' +#} + +makeNullNDArrayHandle = NDArrayHandle <$> newForeignPtr_ C2HSImp.nullPtr + +mxExecutorBind :: SymbolHandle + -> Int + -> Int + -> [NDArrayHandle] + -> [Maybe NDArrayHandle] + -> [Int] + -> [NDArrayHandle] + -> IO ExecutorHandle +mxExecutorBind symbol devtype devid in_args arg_grad_store grad_req_type aux_states = do + nullNDArrayHandle <- makeNullNDArrayHandle + let arg_grad_store_ = map (fromMaybe nullNDArrayHandle) arg_grad_store + checked $ mxExecutorBind_ symbol devtype_ devid_ cnt_args in_args arg_grad_store_ grad_req_type_ cnt_auxs aux_states + where + devtype_ = fromIntegral devtype + devid_ = fromIntegral devid + cnt_args = fromIntegral $ length arg_grad_store + cnt_auxs = fromIntegral $ length aux_states + grad_req_type_ = map fromIntegral grad_req_type + +{# +fun MXExecutorBindX as mxExecutorBindX_ + { + `SymbolHandle', + `CInt', + `CInt', + `MX_UINT', + withStringArray* `[String]', + withArray* `[CInt]', + withArray* `[CInt]', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + withNDArrayHandleArray* `[NDArrayHandle]', + withArray* `[MX_UINT]', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + alloca- `ExecutorHandle' peekExecutorHandle* + } -> `CInt' +#} + +mxExecutorBindX :: SymbolHandle + -> Int + -> Int + -> [String] + -> [Int] + -> [Int] + -> [NDArrayHandle] + -> [Maybe NDArrayHandle] + -> [Int] + -> [NDArrayHandle] + -> IO ExecutorHandle +mxExecutorBindX symbol devtype devid map_keys map_dev_types map_dev_ids in_args arg_grad_store grad_req_type aux_states = do + nullNDArrayHandle <- makeNullNDArrayHandle + let arg_grad_store_ = map (fromMaybe nullNDArrayHandle) arg_grad_store + checked $ mxExecutorBindX_ symbol devtype_ devid_ cnt_maps map_keys map_dev_types_ map_dev_ids_ cnt_args in_args arg_grad_store_ grad_req_type_ cnt_auxs aux_states + where + devtype_ = fromIntegral devtype + devid_ = fromIntegral devid + cnt_maps = fromIntegral $ length map_keys + map_dev_types_ = map fromIntegral map_dev_types + map_dev_ids_ = map fromIntegral map_dev_ids + cnt_args = fromIntegral $ length arg_grad_store + cnt_auxs = fromIntegral $ length aux_states + grad_req_type_ = map fromIntegral grad_req_type + +{# +fun MXExecutorBindEX as mxExecutorBindEX_ + { + `SymbolHandle', + `CInt', + `CInt', + `MX_UINT', + withStringArray* `[String]', + withArray* `[CInt]', + withArray* `[CInt]', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + withNDArrayHandleArray* `[NDArrayHandle]', + withArray* `[MX_UINT]', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + `ExecutorHandle', + alloca- `ExecutorHandle' peekExecutorHandle* + } -> `CInt' +#} + +mxExecutorBindEX :: SymbolHandle + -> Int + -> Int + -> [String] + -> [Int] + -> [Int] + -> [NDArrayHandle] + -> [Maybe NDArrayHandle] + -> [Int] + -> [NDArrayHandle] + -> ExecutorHandle + -> IO ExecutorHandle +mxExecutorBindEX symbol devtype devid map_keys map_dev_types map_dev_ids in_args arg_grad_store grad_req_type aux_states shared_exec = do + nullNDArrayHandle <- makeNullNDArrayHandle + let arg_grad_store_ = map (fromMaybe nullNDArrayHandle) arg_grad_store + checked $ mxExecutorBindEX_ symbol devtype_ devid_ cnt_maps map_keys map_dev_types_ map_dev_ids_ cnt_args in_args arg_grad_store_ grad_req_type_ cnt_auxs aux_states shared_exec + where + devtype_ = fromIntegral devtype + devid_ = fromIntegral devid + cnt_maps = fromIntegral $ length map_keys + map_dev_types_ = map fromIntegral map_dev_types + map_dev_ids_ = map fromIntegral map_dev_ids + cnt_args = fromIntegral $ length arg_grad_store + cnt_auxs = fromIntegral $ length aux_states + grad_req_type_ = map fromIntegral grad_req_type + +{# +fun MXExecutorSimpleBind as mxExecutorSimpleBind_ + { + `SymbolHandle', + `CInt', + `CInt', + `MX_UINT', + withStringArray* `[String]', + withArray* `[CInt]', + withArray* `[CInt]', + `MX_UINT', + withStringArray* `[String]', + withStringArray* `[String]', + `MX_UINT', + withStringArray* `[String]', + withArray* `[MX_UINT]', + withArray* `[MX_UINT]', + `MX_UINT', + withStringArray* `[String]', + withArray* `[CInt]', + `MX_UINT', + withStringArray* `[String]', + withArray* `[CInt]', + `MX_UINT', + withStringArray* `[String]', + id `Ptr CInt', -- [in/out] shared_buffer_len + id `Ptr (Ptr CChar)', -- [in, optional] shared_buffer_name_list + id `Ptr NDArrayHandlePtr', -- [in, optional] shared_buffer_handle_list + alloca- `Ptr (Ptr CChar)' peek*, -- [out] updated_shared_buffer_name_list + alloca- `Ptr NDArrayHandlePtr' peek*, -- [out] updated_shared_buffer_handle_list + alloca- `MX_UINT' peek*, + alloca- `Ptr NDArrayHandlePtr' peek*, + alloca- `Ptr NDArrayHandlePtr' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr NDArrayHandlePtr' peek*, + `ExecutorHandle', + alloca- `ExecutorHandle' peekExecutorHandle* + } -> `CInt' +#} + +mxExecutorSimpleBind :: SymbolHandle + -> Int -> Int -- device + -> [String] -> [Int] -> [Int] -- g2c + -> [String] -> [String] -- provided_grad_req_list + -> [String] -> [Int] -> [Int] -- provided_arg_shapes + -> [String] -> [Int] -- provided_arg_dtypes + -> [String] -> [Int] -- provided_arg_stypes + -> [String] -- shared_arg_names + -> Maybe ([String], [NDArrayHandle]) -- shared_buffer + -> ExecutorHandle -- shared_exec_handle + -> IO (Maybe ([String], [NDArrayHandle]), -- updated_shared_buffer + [NDArrayHandle], -- arg_array + [NDArrayHandle], -- grad_array + [NDArrayHandle], -- aux_array + ExecutorHandle) +mxExecutorSimpleBind symbol + devtype devid + g2c_keys g2c_dev_types g2c_dev_ids + provided_grad_req_names + provided_grad_req_types + provided_arg_shape_names provided_arg_shape_data provided_arg_shape_idx + provided_arg_dtype_names provided_arg_dtypes + provided_arg_stype_names provided_arg_stypes + shared_arg_name_list + shared_buffer + shared_exec_handle = + case shared_buffer of + + Nothing -> alloca (\ptr_shared_buffer_len -> do + poke ptr_shared_buffer_len (-1) + (_, _, num_in_args, in_args, arg_grads, num_aux_states, aux_states, out) <- checked $ mxExecutorSimpleBind_ + symbol devtype_ devid_ + cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_ + cnt_provided_grad_req_list provided_grad_req_names provided_grad_req_types + cnt_provided_arg_shapes provided_arg_shape_names provided_arg_shape_data_ provided_arg_shape_idx_ + cnt_provided_arg_dtypes provided_arg_dtype_names provided_arg_dtypes_ + cnt_provided_arg_stypes provided_arg_stype_names provided_arg_stypes_ + cnt_shared_arg_names shared_arg_name_list + ptr_shared_buffer_len C2HSImp.nullPtr C2HSImp.nullPtr + shared_exec_handle + arg_array <- peekArray (fromIntegral num_in_args) in_args >>= mapM newNDArrayHandle + grad_array <- peekArray (fromIntegral num_in_args) arg_grads >>= mapM newNDArrayHandle + aux_array <- peekArray (fromIntegral num_aux_states) aux_states >>= mapM newNDArrayHandle + return (Nothing, arg_array, grad_array, aux_array, out)) + + Just (shared_buffer_name_list, shared_buffer_handle_list) -> alloca (\ptr_shared_buffer_len -> do + poke ptr_shared_buffer_len (fromIntegral $ length shared_buffer_name_list) + withStringArray shared_buffer_name_list (\ptr_shared_buffer_name_list -> + withNDArrayHandleArray shared_buffer_handle_list (\ptr_shared_buffer_handle_list -> do + (ptr_updated_shared_buffer_name_list, ptr_updated_shared_buffer_handle_list, num_in_args, in_args, arg_grads, num_aux_states, aux_states, out) <- checked $ mxExecutorSimpleBind_ + symbol devtype_ devid_ + cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_ + cnt_provided_grad_req_list provided_grad_req_names provided_grad_req_types + cnt_provided_arg_shapes provided_arg_shape_names provided_arg_shape_data_ provided_arg_shape_idx_ + cnt_provided_arg_dtypes provided_arg_dtype_names provided_arg_dtypes_ + cnt_provided_arg_stypes provided_arg_stype_names provided_arg_stypes_ + cnt_shared_arg_names shared_arg_name_list + ptr_shared_buffer_len ptr_shared_buffer_name_list ptr_shared_buffer_handle_list + shared_exec_handle + arg_array <- peekArray (fromIntegral num_in_args) in_args >>= mapM newNDArrayHandle + grad_array <- peekArray (fromIntegral num_in_args) arg_grads >>= mapM newNDArrayHandle + aux_array <- peekArray (fromIntegral num_aux_states) aux_states >>= mapM newNDArrayHandle + update_shared_buffer_len <- fromIntegral <$> peek ptr_shared_buffer_len + updated_shared_buffer_name_list <- peekStringArray update_shared_buffer_len ptr_updated_shared_buffer_name_list + updated_shared_buffer_handle_list <- peekArray update_shared_buffer_len ptr_updated_shared_buffer_handle_list >>= mapM newNDArrayHandle + return (Just (updated_shared_buffer_name_list, updated_shared_buffer_handle_list), arg_array, grad_array, aux_array, out) + ))) + + where + devtype_ = fromIntegral devtype + devid_ = fromIntegral devid + cnt_g2c = fromIntegral $ length g2c_keys + g2c_dev_types_ = map fromIntegral g2c_dev_types + g2c_dev_ids_ = map fromIntegral g2c_dev_ids + cnt_provided_grad_req_list = fromIntegral $ length provided_grad_req_names + cnt_provided_arg_shapes = fromIntegral $ length provided_arg_shape_names + provided_arg_shape_data_ = map fromIntegral provided_arg_shape_data + provided_arg_shape_idx_ = map fromIntegral provided_arg_shape_idx + cnt_provided_arg_dtypes = fromIntegral $ length provided_arg_dtype_names + provided_arg_dtypes_ = map fromIntegral provided_arg_dtypes + cnt_provided_arg_stypes = fromIntegral $ length provided_arg_stype_names + provided_arg_stypes_ = map fromIntegral $ provided_arg_stypes + cnt_shared_arg_names = fromIntegral $ length shared_arg_name_list + +-- {# +-- fun MXExecutorReshape as mxExecutorReshape_ +-- { +-- `CInt', +-- `CInt', +-- `CInt', +-- `CInt', +-- `MX_UINT', +-- withStringArray* `[String]', +-- withArray* `[CInt]', +-- withArray* `[CInt]', +-- `MX_UINT', +-- withStringArray* `[String]', +-- withArray* `[MX_UINT]', +-- withArray* `[MX_UINT]', +-- alloca- `MX_UINT' peek*, +-- alloca- `Ptr NDArrayHandlePtr' peek*, +-- alloca- `Ptr NDArrayHandlePtr' peek*, +-- alloca- `MX_UINT' peek*, +-- alloca- `Ptr NDArrayHandlePtr' peek*, +-- `ExecutorHandle', +-- alloca- `ExecutorHandle' peekExecutorHandle* +-- } -> `CInt' +-- #} + +-- {# +-- fun MXExecutorGetOptimizedSymbol as mxExecutorGetOptimizedSymbol_ +-- { +-- `ExecutorHandle', +-- alloca- `SymbolHandle' peekSymbolHandle* +-- } -> `CInt' +-- #} diff --git a/c-apis/MXNet/Base/Raw/NDArray.chs b/c-apis/MXNet/Base/Raw/NDArray.chs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Raw/NDArray.chs @@ -0,0 +1,353 @@ +{-# LANGUAGE ScopedTypeVariables #-} +module MXNet.Base.Raw.NDArray where + +import Foreign.Marshal (alloca, withArray, peekArray) +import Foreign.Storable (Storable(..)) +import Foreign.Concurrent (newForeignPtr) +import Foreign.ForeignPtr (touchForeignPtr) +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +import Foreign.C.Types +import Foreign.Ptr +import C2HS.C.Extra.Marshal (withIntegralArray, peekStringArray) +import GHC.Generics (Generic) +import Control.Monad ((>=>)) + +{# import MXNet.Base.Raw.Common #} + +#include + +{# typedef size_t CSize#} +{# default in `CSize' [size_t] fromIntegral #} +{# typedef mx_uint MX_UINT#} +{# default in `MX_UINT' [mx_uint] id #} + +-- NDArray +{# +pointer NDArrayHandle foreign newtype +#} + +deriving instance Generic NDArrayHandle +deriving instance Show NDArrayHandle +type NDArrayHandlePtr = Ptr NDArrayHandle + +touchNDArrayHandle :: NDArrayHandle -> IO () +touchNDArrayHandle (NDArrayHandle fptr) = touchForeignPtr fptr + +newNDArrayHandle :: NDArrayHandlePtr -> IO NDArrayHandle +newNDArrayHandle ptr = do + hdl <- newForeignPtr ptr (mxNDArrayFree ptr) + return $ NDArrayHandle hdl + +peekNDArrayHandle :: Ptr NDArrayHandlePtr -> IO NDArrayHandle +peekNDArrayHandle = peek >=> newNDArrayHandle + +withNDArrayHandleArray :: [NDArrayHandle] -> (Ptr NDArrayHandlePtr -> IO r) -> IO r +withNDArrayHandleArray array io = do + let unNDArrayHandle (NDArrayHandle fptr) = fptr + r <- withArray (map (unsafeForeignPtrToPtr . unNDArrayHandle) array) io + mapM_ (touchForeignPtr . unNDArrayHandle) array + return r + +{# +fun MXNDArrayFree as mxNDArrayFree_ + { + id `NDArrayHandlePtr' + } -> `CInt' +#} + +mxNDArrayFree :: NDArrayHandlePtr -> IO () +mxNDArrayFree = checked . mxNDArrayFree_ + +{# +fun MXNDArrayCreateNone as mxNDArrayCreateNone_ + { + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxNDArrayCreateNone :: IO NDArrayHandle +mxNDArrayCreateNone = checked mxNDArrayCreateNone_ + +{# +fun MXNDArrayCreate as mxNDArrayCreate_ + { + withArray* `[MX_UINT]', + id `MX_UINT', + `CInt', + `CInt', + `CInt', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxNDArrayCreate :: [Int] -> Int -> Int -> Bool -> IO NDArrayHandle +mxNDArrayCreate shape devtype devid delay_alloc = do + let shape_ = fromIntegral <$> shape + dim_ = fromIntegral (length shape_) + devtype_ = fromIntegral devtype + devid_ = fromIntegral devid + checked $ mxNDArrayCreate_ shape_ dim_ devtype_ devid_ (if delay_alloc then 1 else 0) + +{# +fun MXNDArrayCreateEx as mxNDArrayCreateEx_ + { + withArray* `[MX_UINT]', + id `MX_UINT', + `CInt', + `CInt', + `CInt', + `CInt', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxNDArrayCreateEx :: [Int] -> Int -> Int -> Bool -> Int -> IO NDArrayHandle +mxNDArrayCreateEx shape devtype devid delay_alloc dtype = do + let shape_ = fromIntegral <$> shape + dim_ = fromIntegral (length shape_) + devtype_ = fromIntegral devtype + devid_ = fromIntegral devid + dtype_ = fromIntegral dtype + checked $ mxNDArrayCreateEx_ shape_ dim_ devtype_ devid_ (if delay_alloc then 1 else 0) dtype_ + + +{# +fun MXNDArraySyncCopyFromCPU as mxNDArraySyncCopyFromCPU_ + { + `NDArrayHandle', + id `Ptr ()', + `CSize' + } -> `CInt' +#} + +mxNDArraySyncCopyFromCPU :: NDArrayHandle -> Ptr () -> Int -> IO () +mxNDArraySyncCopyFromCPU array ptr size = + checked $ mxNDArraySyncCopyFromCPU_ array ptr (fromIntegral size) + +{# +fun MXNDArraySyncCopyToCPU as mxNDArraySyncCopyToCPU_ + { + `NDArrayHandle', + id `Ptr ()', + `CSize' + } -> `CInt' +#} + +mxNDArraySyncCopyToCPU :: NDArrayHandle -> Ptr () -> Int -> IO () +mxNDArraySyncCopyToCPU array ptr size = + checked $ mxNDArraySyncCopyToCPU_ array ptr (fromIntegral size) + +{# +fun MXNDArraySyncCopyFromNDArray as mxNDArraySyncCopyFromNDArray_ + { + `NDArrayHandle', + `NDArrayHandle', + `CInt' + } -> `CInt' +#} + +mxNDArraySyncCopyFromNDArray :: NDArrayHandle -> NDArrayHandle -> Int -> IO () +mxNDArraySyncCopyFromNDArray array_dst array_src blob = + checked $ mxNDArraySyncCopyFromNDArray_ array_dst array_src (fromIntegral blob) + +{# +fun MXNDArrayWaitToRead as mxNDArrayWaitToRead_ + { + `NDArrayHandle' + } -> `CInt' +#} + +mxNDArrayWaitToRead :: NDArrayHandle -> IO () +mxNDArrayWaitToRead = checked . mxNDArrayWaitToRead_ + +{# +fun MXNDArrayWaitToWrite as mxNDArrayWaitToWrite_ + { + `NDArrayHandle' + } -> `CInt' +#} + +mxNDArrayWaitToWrite :: NDArrayHandle -> IO () +mxNDArrayWaitToWrite = checked . mxNDArrayWaitToWrite_ + +{# +fun MXNDArrayWaitAll as mxNDArrayWaitAll_ + { + } -> `CInt' +#} + +mxNDArrayWaitAll :: IO () +mxNDArrayWaitAll = checked mxNDArrayWaitAll_ + +{# +fun MXNDArraySlice as mxNDArraySlice_ + { + `NDArrayHandle', + `MX_UINT', + `MX_UINT', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxNDArraySlice :: NDArrayHandle -> Int -> Int -> IO NDArrayHandle +mxNDArraySlice array begin end = do + let begin_ = fromIntegral begin + end_ = fromIntegral end + checked $ mxNDArraySlice_ array begin_ end_ + +{# +fun MXNDArrayAt as mxNDArrayAt_ + { + `NDArrayHandle', + `MX_UINT', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxNDArrayAt :: NDArrayHandle -> Int -> IO NDArrayHandle +mxNDArrayAt array index = do + checked $ mxNDArrayAt_ array (fromIntegral index) + +{# +fun MXNDArrayGetStorageType as mxNDArrayGetStorageType_ + { + `NDArrayHandle', + alloca- `CInt' peek* + } -> `CInt' +#} + +mxNDArrayGetStorageType :: NDArrayHandle -> IO Int +mxNDArrayGetStorageType array = do + storageType <- checked $ mxNDArrayGetStorageType_ array + return $ fromIntegral storageType + +{# +fun MXNDArrayReshape as mxNDArrayReshape_ + { + `NDArrayHandle', + `CInt', + withIntegralArray* `[CInt]', + alloca- `NDArrayHandle' peekNDArrayHandle* + } -> `CInt' +#} + +mxNDArrayReshape :: NDArrayHandle -> [Int] -> IO NDArrayHandle +mxNDArrayReshape array shape = do + let shape_ = fromIntegral <$> shape + num_ = fromIntegral $ length shape_ + checked $ mxNDArrayReshape_ array num_ shape_ + +{# +fun MXNDArrayGetShape as mxNDArrayGetShape_ + { + `NDArrayHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek* + } -> `CInt' +#} + +mxNDArrayGetShape :: NDArrayHandle -> IO [Int] +mxNDArrayGetShape array = do + (size, ptr) <- checked $ mxNDArrayGetShape_ array + shape <- peekArray (fromIntegral size) ptr + return $ fromIntegral <$> shape + +-- MXImperativeInvoke is hacky. +-- num-outputs +-- 0: create new NDArrayHandler in the array-of-NDArrayHandle +-- length of array-of-NDArrayHandle (non-0): reuse NDArrayHandler in the array-of-NDArrayHandle +{# +fun MXImperativeInvoke as mxImperativeInvoke_ + { + `AtomicSymbolCreator', + `CInt', + withNDArrayHandleArray* `[NDArrayHandle]', + id `Ptr CInt', -- num-outputs + id `Ptr (Ptr NDArrayHandlePtr)', -- array-of-NDArrayHandle + `CInt', + withStringArray* `[String]', + withStringArray* `[String]' + } -> `CInt' +#} + +-- | Invoke a nnvm op and imperative function. +mxImperativeInvoke :: AtomicSymbolCreator + -> [NDArrayHandle] + -> [(String, String)] + -> Maybe [NDArrayHandle] + -> IO [NDArrayHandle] +mxImperativeInvoke creator inputs params outputs = do + let (keys, values) = unzip params + ninput = fromIntegral $ length inputs + nparam = fromIntegral $ length params + case outputs of + Nothing -> alloca $ \(pn :: Ptr CInt) -> + alloca $ \(pp :: Ptr (Ptr NDArrayHandlePtr)) -> do + poke pn 0 + poke pp C2HSImp.nullPtr + checked $ mxImperativeInvoke_ creator ninput inputs pn pp nparam keys values + n' <- peek pn + p' <- peek pp + if n' == 0 + then return [] + else do + pa <- peekArray (fromIntegral n') (p' :: Ptr NDArrayHandlePtr) + mapM newNDArrayHandle pa + Just out -> alloca $ \(pn :: Ptr CInt) -> + alloca $ \(pp :: Ptr (Ptr NDArrayHandlePtr)) -> do + n' <- withNDArrayHandleArray out $ \p' -> do + poke pn (fromIntegral $ length out) + poke pp p' + checked $ mxImperativeInvoke_ creator ninput inputs pn pp nparam keys values + peek pn + return $ take (fromIntegral n') out + +{# +fun MXNDArrayGetContext as mxNDArrayGetContext_ + { + `NDArrayHandle', + alloca- `CInt' peek*, + alloca- `CInt' peek* + } -> `CInt' +#} + +mxNDArrayGetContext :: NDArrayHandle -> IO (Int, Int) +mxNDArrayGetContext handle = do + (devtyp, devidx) <- checked $ mxNDArrayGetContext_ handle + return (fromIntegral devtyp, fromIntegral devidx) + + +{# +fun MXNDArraySave as mxNDArraySave_ + { + `String', + `MX_UINT', + withNDArrayHandleArray* `[NDArrayHandle]', + withStringArray* `[String]' + } -> `CInt' +#} + +mxNDArraySave :: String -> [(String, NDArrayHandle)] -> IO () +mxNDArraySave filename keyvals = do + let num = length keyvals + (keys, vals) = unzip keyvals + checked $ mxNDArraySave_ filename (fromIntegral num) vals keys + +{# +fun MXNDArrayLoad as mxNDArrayLoad_ + { + `String', + alloca- `MX_UINT' peek*, + alloca- `Ptr NDArrayHandlePtr' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} + +mxNDArrayLoad :: String -> IO [(String, NDArrayHandle)] +mxNDArrayLoad path = do + (numArrays, ptrArrays, numNames, ptrNames) <- checked $ mxNDArrayLoad_ path + pa <- peekArray (fromIntegral numArrays) ptrArrays + arrays <- mapM newNDArrayHandle pa + names <- peekStringArray numNames ptrNames + return $ zip names arrays diff --git a/c-apis/MXNet/Base/Raw/Symbol.chs b/c-apis/MXNet/Base/Raw/Symbol.chs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Raw/Symbol.chs @@ -0,0 +1,561 @@ +{-# LANGUAGE ScopedTypeVariables #-} +module MXNet.Base.Raw.Symbol where + +import Foreign.Marshal (alloca, withArray, peekArray, allocaBytesAligned) +import Foreign.Storable (Storable(..)) +import Foreign.Ptr (FunPtr) +import Foreign.C.Types +import Foreign.C.String +import Foreign.Ptr +import Foreign.Concurrent (newForeignPtr) +import Foreign.ForeignPtr (touchForeignPtr) +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +import C2HS.C.Extra.Marshal (withIntegralArray, peekIntegralArray, peekString, peekStringArray) +import GHC.Generics (Generic) +import Control.Monad ((>=>)) + +{# import MXNet.Base.Raw.Common #} +{# import MXNet.Base.Raw.NDArray #} + +#include + +{# typedef size_t CSize#} +{# default in `CSize' [size_t] fromIntegral #} +{# typedef mx_uint MX_UINT#} +{# default in `MX_UINT' [mx_uint] id #} + +{# +pointer SymbolHandle foreign newtype +#} + +deriving instance Generic SymbolHandle +deriving instance Show SymbolHandle +type SymbolHandlePtr = Ptr SymbolHandle + +touchSymbolHandle :: SymbolHandle -> IO () +touchSymbolHandle (SymbolHandle fptr) = touchForeignPtr fptr + +newSymbolHandle :: SymbolHandlePtr -> IO SymbolHandle +newSymbolHandle ptr = newForeignPtr ptr (mxSymbolFree ptr) >>= return . SymbolHandle + +peekSymbolHandle :: Ptr SymbolHandlePtr -> IO SymbolHandle +peekSymbolHandle = peek >=> newSymbolHandle + +withSymbolHandleArray :: [SymbolHandle] -> (Ptr SymbolHandlePtr -> IO r) -> IO r +withSymbolHandleArray array io = do + let unSymbolHandle (SymbolHandle fptr) = fptr + r <- withArray (map (unsafeForeignPtrToPtr . unSymbolHandle) array) io + mapM_ (touchForeignPtr . unSymbolHandle) array + return r + +{# +fun MXSymbolFree as mxSymbolFree_ + { + id `SymbolHandlePtr' + } -> `CInt' +#} + +mxSymbolFree :: SymbolHandlePtr -> IO () +mxSymbolFree = checked . mxSymbolFree_ + +{# +fun MXSymbolCreateAtomicSymbol as mxSymbolCreateAtomicSymbol_ + { + `AtomicSymbolCreator', + `MX_UINT', + withStringArray* `[String]', + withStringArray* `[String]', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolCreateAtomicSymbol :: AtomicSymbolCreator + -> [String] + -> [String] + -> IO SymbolHandle +mxSymbolCreateAtomicSymbol creator keys vals = do + let argcnt = fromIntegral $ length keys + checked $ mxSymbolCreateAtomicSymbol_ creator argcnt keys vals + +{# +fun MXSymbolCreateVariable as mxSymbolCreateVariable_ + { + `String', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolCreateVariable :: String -> IO SymbolHandle +mxSymbolCreateVariable = checked . mxSymbolCreateVariable_ + +{# +fun MXSymbolCreateGroup as mxSymbolCreateGroup_ + { + `MX_UINT', + withSymbolHandleArray* `[SymbolHandle]', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolCreateGroup :: [SymbolHandle] -> IO SymbolHandle +mxSymbolCreateGroup syms = checked $ mxSymbolCreateGroup_ (fromIntegral $ length syms) syms + +{# +fun MXSymbolCreateFromJSON as mxSymbolCreateFromJSON_ + { + `String', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolCreateFromJSON :: String -> IO SymbolHandle +mxSymbolCreateFromJSON = checked . mxSymbolCreateFromJSON_ + +{# +fun MXSymbolSaveToJSON as mxSymbolSaveToJSON_ + { + `SymbolHandle', + alloca- `String' peekString* + } -> `CInt' +#} + +mxSymbolSaveToJSON :: SymbolHandle -> IO String +mxSymbolSaveToJSON = checked . mxSymbolSaveToJSON_ + +{# +fun MXSymbolCopy as mxSymbolCopy_ + { + `SymbolHandle', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolCopy :: SymbolHandle -> IO SymbolHandle +mxSymbolCopy = checked . mxSymbolCopy_ + +{# +fun MXSymbolPrint as mxSymbolPrint_ + { + `SymbolHandle', + alloca- `String' peekString* + } -> `CInt' +#} + +mxSymbolPrint :: SymbolHandle -> IO String +mxSymbolPrint = checked . mxSymbolPrint_ + +{# +fun MXSymbolGetName as mxSymbolGetName_ + { + `SymbolHandle', + alloca- `Ptr (Ptr CChar)' id, + alloca- `CInt' peek* + } -> `CInt' +#} + +mxSymbolGetName :: SymbolHandle -> IO (Maybe String) +mxSymbolGetName symbol = do + (out, succ) <- checked $ mxSymbolGetName_ symbol + if succ == 0 then + Just <$> peekString out + else + return Nothing + +{# +fun MXSymbolGetAttr as mxSymbolGetAttr_ + { + `SymbolHandle', + `String', + alloca- `Ptr (Ptr CChar)' id, + alloca- `CInt' peek* + } -> `CInt' +#} + +mxSymbolGetAttr :: SymbolHandle + -> String + -> IO (Maybe String) +mxSymbolGetAttr symbol key = do + (pstr, succ) <- checked $ mxSymbolGetAttr_ symbol key + if succ == 0 then + Just <$> peekString pstr + else + return Nothing + +{# +fun MXSymbolSetAttr as mxSymbolSetAttr_ + { + `SymbolHandle', + `String', + `String' + } -> `CInt' +#} + +mxSymbolSetAttr :: SymbolHandle + -> String + -> String + -> IO () +mxSymbolSetAttr symbol key val = checked $ mxSymbolSetAttr_ symbol key val + +{# +fun MXSymbolListAttr as mxSymbolListAttr_ + { + `SymbolHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} + +mxSymbolListAttr :: SymbolHandle + -> IO [String] +mxSymbolListAttr symbol = do + (cnt, ptr) <- checked $ mxSymbolListAttr_ symbol + peekStringArray (fromIntegral cnt) ptr + +{# +fun MXSymbolListAttrShallow as mxSymbolListAttrShallow_ + { + `SymbolHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} + +mxSymbolListAttrShallow :: SymbolHandle + -> IO [String] +mxSymbolListAttrShallow symbol = do + (cnt, ptr) <- checked $ mxSymbolListAttrShallow_ symbol + peekStringArray (fromIntegral cnt) ptr + +{# +fun MXSymbolListArguments as mxSymbolListArguments_ + { + `SymbolHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} + +mxSymbolListArguments :: SymbolHandle + -> IO [String] +mxSymbolListArguments symbol = do + (cnt, ptr) <- checked $ mxSymbolListArguments_ symbol + peekStringArray (fromIntegral cnt) ptr + +{# +fun MXSymbolListOutputs as mxSymbolListOutputs_ + { + `SymbolHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} + +mxSymbolListOutputs :: SymbolHandle + -> IO [String] +mxSymbolListOutputs symbol = do + (cnt, ptr) <- checked $ mxSymbolListOutputs_ symbol + peekStringArray (fromIntegral cnt) ptr + +{# +fun MXSymbolGetInternals as mxSymbolGetInternals_ + { + `SymbolHandle', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolGetInternals :: SymbolHandle -> IO SymbolHandle +mxSymbolGetInternals = checked . mxSymbolGetInternals_ + +{# +fun MXSymbolGetChildren as mxSymbolGetChildren_ + { + `SymbolHandle', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} + +mxSymbolGetChildren :: SymbolHandle -> IO SymbolHandle +mxSymbolGetChildren = checked . mxSymbolGetChildren_ + +{# +fun MXSymbolGetOutput as mxSymbolGetOutput_ + { + `SymbolHandle', + `MX_UINT', + alloca- `SymbolHandle' peekSymbolHandle* + } -> `CInt' +#} +mxSymbolGetOutput :: SymbolHandle + -> Int + -> IO SymbolHandle +mxSymbolGetOutput symbol ind = + checked $ mxSymbolGetOutput_ symbol (fromIntegral ind) + +{# +fun MXSymbolListAuxiliaryStates as mxSymbolListAuxiliaryStates_ + { + `SymbolHandle', + alloca- `MX_UINT' peek*, + alloca- `Ptr (Ptr CChar)' peek* + } -> `CInt' +#} +mxSymbolListAuxiliaryStates :: SymbolHandle -> IO [String] +mxSymbolListAuxiliaryStates symbol = do + (cnt, ptr) <- checked $ mxSymbolListAuxiliaryStates_ symbol + peekStringArray (fromIntegral cnt) ptr + +{# +fun MXSymbolCompose as mxSymbolCompose_ + { + `SymbolHandle', + `String', + `MX_UINT', + id `Ptr (Ptr CChar)', + withSymbolHandleArray* `[SymbolHandle]' + } -> `CInt' +#} + +mxSymbolCompose :: SymbolHandle + -> String + -> Maybe [String] + -> [SymbolHandle] + -> IO () +mxSymbolCompose symbol name maybekeys args = do + let len = fromIntegral $ length args + case maybekeys of + Nothing -> checked $ mxSymbolCompose_ symbol name len C2HSImp.nullPtr args + Just keys -> withStringArray keys $ \pkeys -> checked $ mxSymbolCompose_ symbol name len pkeys args + +{# +fun MXSymbolInferShape as mxSymbolInferShape_ + { + `SymbolHandle', + `MX_UINT', + withStringArray* `[String]', + withArray* `[MX_UINT]', + withArray* `[MX_UINT]', + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek*, + alloca- `Ptr (Ptr MX_UINT)' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek*, + alloca- `Ptr (Ptr MX_UINT)' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek*, + alloca- `Ptr (Ptr MX_UINT)' peek*, + alloca- `CInt' peek* + } -> `CInt' +#} + +mxSymbolInferShape :: SymbolHandle + -> [String] + -> [Int] + -> [Int] + -> IO ([[Int]], [[Int]], [[Int]], Bool) +mxSymbolInferShape symbol keys arg_ind arg_shape = do + let num_args' = fromIntegral (length keys) + arg_ind' = map fromIntegral arg_ind + arg_shape'= map fromIntegral arg_shape + (inshape_size , inshape_ndim , inshape_data , + outshape_size, outshape_ndim, outshape_data, + auxshape_size, auxshape_ndim, auxshape_data, + complete) <- checked $ mxSymbolInferShape_ symbol num_args' keys arg_ind' arg_shape' + let inshape_size' = fromIntegral inshape_size + inshape_ndim' <- peekArray inshape_size' inshape_ndim + inshape_data' <- peekArray inshape_size' inshape_data + inshape_data_ret <- mapM (uncurry peekArrayOfUInt) (zip inshape_ndim' inshape_data') + let outshape_size'= fromIntegral outshape_size + outshape_ndim' <- peekArray outshape_size' outshape_ndim + outshape_data' <- peekArray outshape_size' outshape_data + outshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip outshape_ndim' outshape_data') + let auxshape_size'= fromIntegral auxshape_size + auxshape_ndim' <- peekArray auxshape_size' auxshape_ndim + auxshape_data' <- peekArray auxshape_size' auxshape_data + auxshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip auxshape_ndim' auxshape_data') + return (inshape_data_ret, outshape_data_ret, auxshape_data_ret, complete == 1) + +{# +fun MXSymbolInferShapePartial as mxSymbolInferShapePartial_ + { + `SymbolHandle', + `MX_UINT', + withStringArray* `[String]', + withArray* `[MX_UINT]', + withArray* `[MX_UINT]', + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek*, + alloca- `Ptr (Ptr MX_UINT)' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek*, + alloca- `Ptr (Ptr MX_UINT)' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr MX_UINT' peek*, + alloca- `Ptr (Ptr MX_UINT)' peek*, + alloca- `CInt' peek* + } -> `CInt' +#} + +mxSymbolInferShapePartial :: SymbolHandle + -> [String] + -> [Int] + -> [Int] + -> IO ([[Int]], [[Int]], [[Int]], Bool) +mxSymbolInferShapePartial symbol keys arg_ind arg_shape = do + let num_args' = fromIntegral (length keys) + arg_ind' = map fromIntegral arg_ind + arg_shape'= map fromIntegral arg_shape + (inshape_size , inshape_ndim , inshape_data , + outshape_size, outshape_ndim, outshape_data, + auxshape_size, auxshape_ndim, auxshape_data, + complete) <- checked $ mxSymbolInferShapePartial_ symbol num_args' keys arg_ind' arg_shape' + let inshape_size' = fromIntegral inshape_size + inshape_ndim' <- peekArray inshape_size' inshape_ndim + inshape_data' <- peekArray inshape_size' inshape_data + inshape_data_ret <- mapM (uncurry peekArrayOfUInt) (zip inshape_ndim' inshape_data') + let outshape_size'= fromIntegral outshape_size + outshape_ndim' <- peekArray outshape_size' outshape_ndim + outshape_data' <- peekArray outshape_size' outshape_data + outshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip outshape_ndim' outshape_data') + let auxshape_size'= fromIntegral auxshape_size + auxshape_ndim' <- peekArray auxshape_size' auxshape_ndim + auxshape_data' <- peekArray auxshape_size' auxshape_data + auxshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip auxshape_ndim' auxshape_data') + return (inshape_data_ret, outshape_data_ret, auxshape_data_ret, complete == 1) + +peekArrayOfUInt cnt ptr = peekIntegralArray (fromIntegral cnt) ptr + +{# +fun MXSymbolInferType as mxSymbolInferType_ + { + `SymbolHandle', + `MX_UINT', + withStringArray* `[String]', + withArray* `[CInt]', + alloca- `MX_UINT' peek*, + alloca- `Ptr CInt' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr CInt' peek*, + alloca- `MX_UINT' peek*, + alloca- `Ptr CInt' peek*, + alloca- `CInt' peek* + } -> `CInt' +#} + +mxSymbolInferType :: SymbolHandle + -> [String] + -> [Int] + -> IO (Maybe ([Int], [Int], [Int])) +mxSymbolInferType symbol keys arg_type = do + let num_args = fromIntegral (length keys) + arg_type'= map fromIntegral arg_type + (inshape_size , inshape_data , + outshape_size, outshape_data, + auxshape_size, auxshape_data, + succ) <- checked $ mxSymbolInferType_ symbol num_args keys arg_type' + if succ == 0 then do + inshape_data_ret <- peekIntegralArray (fromIntegral inshape_size) inshape_data + outshape_data_ret <- peekIntegralArray (fromIntegral outshape_size) outshape_data + auxshape_data_ret <- peekIntegralArray (fromIntegral auxshape_size) auxshape_data + return $ Just (inshape_data_ret, outshape_data_ret, auxshape_data_ret) + else + return Nothing + +{# +fun MXSymbolSaveToFile as mxSymbolSaveToFile_ + { + `SymbolHandle', + `String' + } -> `CInt' +#} + +mxSymbolSaveToFile :: String -> SymbolHandle -> IO () +mxSymbolSaveToFile filename sym = do + checked $ mxSymbolSaveToFile_ sym filename + +data MXCallbackList = MXCallbackList Int (Ptr (FunPtr (IO CInt))) (Ptr (Ptr ())) + +instance Storable MXCallbackList where + sizeOf _ = {#sizeof MXCallbackList#} + alignment _ = {#alignof MXCallbackList#} + peek ptr = do + n <- {#get MXCallbackList.num_callbacks#} ptr + callbacks <- {#get MXCallbackList.callbacks#} ptr + contexts <- {#get MXCallbackList.contexts#} ptr + return (MXCallbackList (fromIntegral n) callbacks contexts) + poke ptr (MXCallbackList n callbacks contexts) = do + {#set MXCallbackList.num_callbacks#} ptr (fromIntegral n) + {#set MXCallbackList.callbacks#} ptr callbacks + {#set MXCallbackList.contexts#} ptr contexts + +type CustomOpPropCreator = CString -> CInt -> Ptr CString -> Ptr CString -> Ptr () -> IO CInt +type CustomOpFBFunc = CInt -> Ptr (Ptr ()) -> Ptr CInt -> Ptr CInt -> CInt -> Ptr () -> IO CInt +type CustomOpDelFunc = Ptr () -> IO CInt +type CustomOpListFunc = Ptr (Ptr CString) -> Ptr () -> IO CInt +type CustomOpInferShapeFunc = CInt -> Ptr CInt -> Ptr (Ptr CInt) -> Ptr () -> IO CInt +type CustomOpInferStorageTypeFunc = CInt -> Ptr CInt -> Ptr () -> IO CInt +type CustomOpBackwardInferStorageTypeFunc = CInt -> Ptr CInt -> Ptr CInt -> Ptr () -> IO CInt +type CustomOpInferTypeFunc = CInt -> Ptr CInt -> Ptr () -> IO CInt +type CustomOpBwdDepFunc = Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Ptr CInt) -> Ptr () -> IO CInt +type CustomOpCreateFunc = CString -> CInt -> Ptr (Ptr CUInt) -> Ptr CInt -> Ptr CInt -> Ptr MXCallbackList -> Ptr () -> IO CInt +type CustomFunctionBwdFunc = CInt -> Ptr (Ptr NDArrayHandle) -> Ptr CInt -> Ptr CInt -> CInt -> Ptr () -> IO CInt +type CustomFunctionDelFunc = Ptr () -> IO CInt + +foreign import ccall "wrapper" mkCustomOpPropCreator :: CustomOpPropCreator -> IO (FunPtr CustomOpPropCreator) +foreign import ccall "wrapper" mkCustomOpFBFunc :: CustomOpFBFunc -> IO (FunPtr CustomOpFBFunc) +foreign import ccall "wrapper" mkCustomOpDelFunc :: CustomOpDelFunc -> IO (FunPtr CustomOpDelFunc) +foreign import ccall "wrapper" mkCustomOpListFunc :: CustomOpListFunc -> IO (FunPtr CustomOpListFunc) +foreign import ccall "wrapper" mkCustomOpInferShapeFunc :: CustomOpInferShapeFunc -> IO (FunPtr CustomOpInferShapeFunc) +foreign import ccall "wrapper" mkCustomOpInferStorageTypeFunc :: CustomOpInferStorageTypeFunc -> IO (FunPtr CustomOpInferStorageTypeFunc) +foreign import ccall "wrapper" mkCustomOpBackwardInferStorageTypeFunc :: CustomOpBackwardInferStorageTypeFunc -> IO (FunPtr CustomOpBackwardInferStorageTypeFunc) +foreign import ccall "wrapper" mkCustomOpInferTypeFunc :: CustomOpInferTypeFunc -> IO (FunPtr CustomOpInferTypeFunc) +foreign import ccall "wrapper" mkCustomOpBwdDepFunc :: CustomOpBwdDepFunc -> IO (FunPtr CustomOpBwdDepFunc) +foreign import ccall "wrapper" mkCustomOpCreateFunc :: CustomOpCreateFunc -> IO (FunPtr CustomOpCreateFunc) +foreign import ccall "wrapper" mkCustomFunctionBwdFunc :: CustomFunctionBwdFunc -> IO (FunPtr CustomFunctionBwdFunc) +foreign import ccall "wrapper" mkCustomFunctionDelFunc :: CustomFunctionDelFunc -> IO (FunPtr CustomFunctionDelFunc) + +{# +fun MXCustomOpRegister as mxCustomOpRegister_ + { + `String', + id `FunPtr CustomOpPropCreator' + } -> `CInt' +#} + +mxCustomOpRegister :: String -> FunPtr CustomOpPropCreator -> IO () +mxCustomOpRegister op cr = checked $ mxCustomOpRegister_ op cr + +-- {# +-- fun MXSymbolGetInputSymbols as mxSymbolGetInputSymbols_ +-- { +-- `SymbolHandle', +-- alloca- `Ptr SymbolHandlePtr' peek*, +-- alloca- `CInt' peek* +-- } -> `CInt' +-- #} +-- +{# +fun MXSymbolGetNumOutputs as mxSymbolGetNumOutputs_ + { + `SymbolHandle', + alloca- `MX_UINT' peek* + } -> `CInt' +#} + +mxSymbolGetNumOutputs :: SymbolHandle -> IO Int +mxSymbolGetNumOutputs symbol = do + cnt <- checked $ mxSymbolGetNumOutputs_ symbol + return $ fromIntegral (cnt :: MX_UINT) +-- +-- {# +-- fun MXQuantizeSymbol as mxQuantizeSymbol_ +-- { +-- `SymbolHandle', +-- alloca- `Ptr SymbolHandlePtr' peekSymbolHandle*, +-- `MX_UINT', +-- withSymbolHandleArray* `[SymbolHandle]', +-- `MX_UINT', +-- withStringArray* `[String]', +-- `String' +-- } -> `CInt' +-- #} diff --git a/c-apis/MXNet/Base/Spec/HMap.hs b/c-apis/MXNet/Base/Spec/HMap.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Spec/HMap.hs @@ -0,0 +1,112 @@ +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE ConstraintKinds #-} +module MXNet.Base.Spec.HMap where + +import GHC.TypeLits +import Data.Proxy +import Data.Typeable (Typeable) +import Data.Maybe +import Data.Constraint (Dict(..)) +import Type.Reflection (someTypeRep) +import Unsafe.Coerce (unsafeCoerce) + +class Pair (p :: Symbol -> * -> *) where + key :: p k v -> Proxy k + value :: p k v -> v + +data HMap (p :: Symbol -> * -> *) (kvs :: [*]) where + Nil :: Pair p => HMap p '[] + Cons :: Pair p => p k v -> HMap p kvs -> HMap p (p k v ': kvs) + +infixr 0 .& +kv .& other = Cons kv other + +class Access (b :: Bool) p k v kvs | k kvs -> v where + get' :: Proxy b -> HMap p kvs -> Proxy k -> v + +instance Access True p k v (p k v ': kvs) where + get' _ (Cons pair _) _ = value pair + +instance Access (MatchHead p k v kvs) p k v kvs => Access False p k v (kv ': kvs) where + get' _ (Cons _ n) k = get' (Proxy :: Proxy (MatchHead p k v kvs)) n k + +get :: forall p k v kvs. Access (MatchHead p k v kvs) p k v kvs => HMap p kvs -> Proxy k -> v +get = get' (Proxy :: Proxy (MatchHead p k v kvs)) + +---- +type family InHMap p k kvs :: Bool where + InHMap p k '[] = False + InHMap p k (p k v ': _) = True + InHMap p k (_ ': kvs) = InHMap p k kvs + +type family MatchHead p k v kvs where + MatchHead p k v (p k v ': kvs) = True + MatchHead p k v (_ ': kvs) = False + MatchHead p k v '[] = False + +type family MatchHeadKey p k kvs where + MatchHeadKey p k (p k v ': kvs) = True + MatchHeadKey p k (_ ': kvs) = False + MatchHeadKey p k '[] = False + +-- class Query (b :: Bool) p k v kvs where +-- query' :: Proxy b -> HMap p kvs -> Proxy k -> Maybe v + +-- instance Access (MatchHead p k v kvs) p k v kvs => Query True p k v kvs where +-- query' _ hmap key = Just $ hmap ! key + +-- instance Query False p k v kvs where +-- query' _ hmap key = Nothing + +class Query (b :: Bool) p k v kvs where + query' :: Proxy b -> HMap p kvs -> Proxy k -> Maybe v + +instance Query True p k v (p k v ': kvs) where + query' _ (Cons pair _) key = Just (value pair) + +instance Query False p k v '[] where + query' _ Nil key = Nothing + +instance Query (MatchHead p k v kvs) p k v kvs => Query False p k v (kv ': kvs) where + query' _ (Cons _ n) key = query' (Proxy :: Proxy (MatchHead p k v kvs)) n key + +query :: forall p k v kvs. Query (MatchHead p k v kvs) p k v kvs => HMap p kvs -> Proxy k -> Maybe v +query = query' (Proxy :: Proxy (MatchHead p k v kvs)) + +-- note this definition 'isJust (hmap !? key)' wouldn't work, because the result type cannot +-- be inferenced. +hasKey :: forall p (k :: Symbol) kvs. KnownSymbol k => HMap p kvs -> Proxy k -> Bool +hasKey hmap key = case axiomInHMapTypeable hmap key of + Dict -> someTypeRep (Proxy :: Proxy (InHMap p k kvs)) == someTypeRep (Proxy :: Proxy True) + +-- pop one key from the HMap +class PopKey_ (b :: Bool) p k (kvs :: [*]) where + type PopResult_ b k kvs :: [*] + pop' :: Proxy b -> HMap p kvs -> Proxy k -> HMap p (PopResult_ b k kvs) + +instance PopKey_ False p k '[] where + type PopResult_ False k '[] = '[] + pop' _ Nil _ = Nil + +instance PopKey_ True p k (p k v ': kvs) where + type PopResult_ True k (p k v ': kvs) = kvs + pop' _ (Cons _ rest) _ = rest + +instance PopKey_ (MatchHeadKey p k kvs) p k kvs => PopKey_ False p k (p k' v' ': kvs) where + type PopResult_ False k (p k' v' ': kvs) = p k' v' ': PopResult_ (MatchHeadKey p k kvs) k kvs + pop' _ (Cons pair rest) key = Cons pair (pop' (Proxy :: Proxy (MatchHeadKey p k kvs)) rest key) + +type PopKey p kvs k = PopKey_ (MatchHeadKey p k kvs) p k kvs +type PopResult p kvs k = HMap p (PopResult_ (MatchHeadKey p k kvs) k kvs) + +pop :: forall p (k :: Symbol) kvs. PopKey p kvs k => HMap p kvs -> Proxy k -> PopResult p kvs k +pop = pop' (Proxy :: Proxy (MatchHeadKey p k kvs)) + +axiomInHMapTypeable :: KnownSymbol k => HMap p kvs -> Proxy k -> Dict (Typeable (InHMap p k kvs)) +axiomInHMapTypeable _ _ = unsafeCoerce (Dict :: Dict ()) diff --git a/c-apis/MXNet/Base/Spec/Operator.hs b/c-apis/MXNet/Base/Spec/Operator.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Spec/Operator.hs @@ -0,0 +1,253 @@ +{-# LANGUAGE OverloadedLabels #-} +{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies #-} +{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-} +{-# LANGUAGE GADTs, TypeOperators #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE PartialTypeSignatures #-} +{-# LANGUAGE ConstraintKinds #-} +{-# LANGUAGE ScopedTypeVariables #-} +module MXNet.Base.Spec.Operator where + +import GHC.OverloadedLabels +import GHC.TypeLits +import GHC.Exts (Constraint) +import Data.Proxy +import Data.List (intersperse) +import Data.Constraint +import MXNet.Base.Spec.HMap + +instance a ~ b => IsLabel a (Proxy b) where + fromLabel = Proxy + +data EnumType (e :: [Symbol]) where + EnumType :: (KnownSymbol v, HasEnum v e) => Proxy v -> EnumType e + +type family HasEnum v e :: Constraint where + HasEnum v e = IfThenElse (HasElement v e) (() :: Constraint) (TypeError (Text "\"" :<>: Text v :<>: Text "\" is not a valid value for the enum: [" :<>: FormatEnum e :<>: Text "]")) + +type family FormatEnum (l :: [Symbol]) :: ErrorMessage where + FormatEnum (s ': m ': n) = Text s :<>: Text ", " :<>: FormatEnum (m ': n) + FormatEnum (s ': '[]) = Text s + FormatEnum ('[]) = Text "" + +instance (KnownSymbol v, HasEnum v e) => IsLabel v (EnumType e) where + fromLabel = EnumType (Proxy :: Proxy v) + +---- +type family ParameterList (s :: Symbol) :: [(Symbol, Attr)] + +data Attr where + AttrReq :: (a :: *) -> Attr + AttrOpt :: (a :: *) -> Attr + +type family ParameterType (a :: Attr) :: * where + ParameterType (AttrReq a) = a + ParameterType (AttrOpt a) = a + +type family ResolveParameter (s :: Symbol) (k :: Symbol) :: Attr where + ResolveParameter s k = FindKey k (ParameterList s) (Text "Parameter '" :<>: + Text k :<>: + Text " not found") + +type family FindKey (s :: Symbol) (l :: [(Symbol, k)]) (e :: ErrorMessage) :: k where + FindKey s ('(s,i) ': _) _ = i + FindKey s ('(z,_) ': n) e = FindKey s n e + FindKey s '[] e = TypeError e + +---- + +data ArgOf s k v where + (:=) :: (info ~ ResolveParameter s k) => Proxy k -> ParameterType info -> ArgOf s k (ParameterType info) + (:≅) :: Proxy k -> a -> ArgOf s k a + +instance Pair (ArgOf s) where + key (k := v) = k + key (k :≅ v) = k + value (k := v) = v + value (k :≅ v) = v + +infix 5 !, !? +infix 1 :=, :≅ + +(!) :: Access (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs + => ArgsHMap s kvs -> Proxy k -> v +(!) = get + +(!?) :: (ParameterType (ResolveParameter s k) ~ v, Query (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs) + => ArgsHMap s kvs -> Proxy k -> Maybe v +(!?) = query + +type ArgsHMap s kvs = HMap (ArgOf s) kvs +---- +class Value a where + showValue :: a -> String + +instance Value (EnumType e) where + showValue (EnumType v) = symbolVal v + +instance Value Int where + showValue = show + +instance Value Bool where + showValue = show + +instance Value Float where + showValue = show + +instance Value Double where + showValue = show + +instance Value a => Value (Maybe a) where + showValue Nothing = "None" + showValue (Just a) = showValue a + +instance ValueList (IsChar a) [a] => Value [a] where + showValue = showValueList (Proxy :: Proxy (IsChar a)) + +class ValueList (str :: Bool) as where + showValueList :: Proxy str -> as -> String + +instance ValueList True String where + showValueList _ = id + +instance Value a => ValueList False [a] where + showValueList _ as = "[" ++ concat (intersperse "," (map showValue as)) ++ "]" + +type family IsChar a :: Bool where + IsChar Char = True + IsChar x = False + +class Dump a where + dump :: a -> [(String, String)] + +instance Dump (ArgsHMap s '[]) where + dump = const [] + +instance (Dump (ArgsHMap s kvs), KnownSymbol k, Value v) => Dump (ArgsHMap s (ArgOf s k v ': kvs)) where + dump (Cons (k := v) kvs) = (symbolVal k, showValue v) : dump kvs + dump (Cons (k :≅ v) kvs) = (symbolVal k, showValue v) : dump kvs + +---- +type family Subset (s1 :: [(Symbol, *)]) (s2 :: [(Symbol, *)]) :: Constraint where + Subset '[] _ = () + Subset ('(a, t) ': s1) s2 = ( IfThenElse (HasElement '(a,t) s2) + (() :: Constraint) + (TypeError (Text "Argument '" :<>: Text a :<>: Text "' is required.")) + , Subset s1 s2) + Subset a b = TypeError (Text "xx") + +type family AsKVs (a :: [*]) :: [(Symbol, *)] where + AsKVs (ArgOf s k v ': args) = '(k, v) ': AsKVs args + AsKVs '[] = '[] + +type family GenAccess s kvs (req :: [(Symbol, *)]) :: Constraint where + GenAccess s kvs '[] = () + GenAccess s kvs ('(k, v) ': req) = (Access (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs, GenAccess s kvs req) + +type family GenQuery s kvs (req :: [(Symbol, *)]) :: Constraint where + GenQuery s kvs '[] = () + GenQuery s kvs ('(k, v) ': req) = (Query (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs, GenQuery s kvs req) + + +type family FilterRequired (pl :: [(k, Attr)]) :: [(k, *)] where + FilterRequired '[] = '[] + FilterRequired ('(s, AttrReq t) ': pl) = '(s,t) ': FilterRequired pl + FilterRequired (_ ': pl) = FilterRequired pl + + +type family AllArgs (pl :: [(k, Attr)]) :: [(k, *)] where + AllArgs '[] = '[] + AllArgs ('(s, AttrReq t) ': pl) = '(s,t) ': AllArgs pl + AllArgs ('(s, AttrOpt t) ': pl) = '(s,t) ': AllArgs pl + +type family Fullfilled (s :: Symbol) (args :: [*]) :: Constraint where + Fullfilled s args = ( Subset ( FilterRequired (ParameterList s)) (AsKVs args) + , GenAccess s args (FilterRequired (ParameterList s)) + , GenQuery s args (AllArgs (ParameterList s))) + +-- type family HasOptArg (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where +-- HasOptArg s args '[] = () +-- HasOptArg s args (k0 ': ks) = ( Query (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args) +-- (ArgOf s) +-- k0 +-- (ParameterType (ResolveParameter s k0)) +-- args +-- , HasOptArg s args ks) + +-- type family HasReqArg (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where +-- HasReqArg s args '[] = () +-- HasReqArg s args (k0 ': ks) = ( Access (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args) +-- (ArgOf s) +-- k0 +-- (ParameterType (ResolveParameter s k0)) +-- args +-- , HasElement '(k0, ParameterType (ResolveParameter s k0)) (AsKVs args) ~ True +-- , Query (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args) +-- (ArgOf s) +-- k0 +-- (ParameterType (ResolveParameter s k0)) +-- args +-- , HasReqArg s args ks) + +type family HasArgsGen p i k args :: Constraint where + HasArgsGen p (AttrOpt t) k args = Query (MatchHead p k t args) p k t args + HasArgsGen p (AttrReq t) k args = (Access (MatchHead p k t args) p k t args + ,HasElement '(k, t) (AsKVs args) ~ True + ,Query (MatchHead p k t args) p k t args) + +type family HasArgs (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where + HasArgs s args '[] = () + HasArgs s args (k0 ': ks) = (HasArgsGen (ArgOf s) (ResolveParameter s k0) k0 args, HasArgs s args ks) + +type family WithoutArgsGen p t k args :: Constraint where + WithoutArgsGen p t k args = (Query (MatchHead p k t args) p k t args + ,HasElement '(k, t) (AsKVs args) ~ False) + +type family WithoutArgs (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where + WithoutArgs s args '[] = () + WithoutArgs s args (k0 ': ks) = (WithoutArgsGen (ArgOf s) (ParameterType (ResolveParameter s k0)) k0 args, WithoutArgs s args ks) +---- +type family HasElement (s :: k) (l :: [k]) :: Bool where + HasElement s (s ': _) = True + HasElement s (z ': n) = HasElement s n + HasElement s '[] = False + +type family IfThenElse (b :: Bool) (t :: k) (f :: k) :: k where + IfThenElse True t f = t + IfThenElse False t f = f + +------------------------------------- + +type instance ParameterList "fn" = [ + '("a", AttrReq Int), + '("b", AttrOpt String), + '("c", AttrReq (EnumType '["c1","c2"])), + '("d", AttrOpt (Maybe (EnumType '["c1","c2"]))) + ] +args1 :: ArgsHMap "fn" _ +args1 = Nil + +args2 :: ArgsHMap "fn" _ +args2 = #a := 3 .& Nil + +args3 :: ArgsHMap "fn" _ +args3 = #a := 3 .& #b := "Hello" .& Nil + +args4 :: ArgsHMap "fn" _ +args4 = #a := 3 .& #c := #c1 .& Nil + +args5 :: ArgsHMap "fn" _ +args5 = #a := 3 .& #c := #c1 .& #d := Just #c2 .& Nil + +fn1 :: Fullfilled "fn" args => ArgsHMap "fn" args -> _ +fn1 args = args !? #b + +fn2 :: GenQuery "fn" args '[ '("b", String), '("d", (Maybe (EnumType '["c1","c2"])))] + => ArgsHMap "fn" args -> _ +fn2 args = fn1 (#a := 3 .& #c := #c1 .& args) + +fn3 :: (HasArgs "fn" args '["b", "c", "d"]) => ArgsHMap "fn" args -> _ +fn3 args = fn1 (#a := 3 .& args) + +fn4 :: (HasArgs "fn" args '["c", "b", "d"], WithoutArgs "fn" args '["a"]) => ArgsHMap "fn" args -> _ +fn4 args = fn1 (#a := 3 .& args) diff --git a/c-apis/MXNet/Base/Symbol.hs b/c-apis/MXNet/Base/Symbol.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Symbol.hs @@ -0,0 +1,418 @@ +{-# LANGUAGE TypeFamilies #-} +module MXNet.Base.Symbol where + +import Foreign.Marshal.Array +import Foreign.Marshal.Alloc +import Foreign.Storable +import Foreign.Ptr +import Foreign.C.String +import Foreign.C.Types +import Control.Monad +import Control.Exception.Base (assert, Exception, throwIO) +import Data.List (groupBy) +import Data.Function +import Data.Maybe +import Text.Printf (printf) +import Control.Concurrent.MVar +import qualified Data.Vector as V +import qualified Data.Vector.Mutable as VM +import Data.Typeable (Typeable) +import Control.Exception.Base (Exception, throwIO) + +import qualified MXNet.Base.Raw as I +import MXNet.Base.Types (ForeignData(..)) +import Debug.Trace + +newtype Symbol a = Symbol { unSymbol :: I.SymbolHandle } + +instance ForeignData (Symbol a) where + touch = I.touchSymbolHandle . unSymbol + +data SymbolException = SymbolIndexOutOfBound Int Int + | SymbolNameNotFound String + deriving (Typeable, Show) +instance Exception SymbolException + +class SymbolClass s where + getName :: s -> IO (Maybe String) + listArguments :: s -> IO [String] + listOutputs :: s -> IO [String] + listAuxiliaryStates :: s -> IO [String] + numOutputs :: s -> IO Int + at :: s -> Int -> IO s + group :: [s] -> IO s + internals :: s -> IO s + inferShape :: s -> [(String, [Int])] ->IO ([(String, [Int])], [(String, [Int])], [(String, [Int])], Bool) + + at' :: s -> String -> IO s + at' sym name = do + all_names <- listOutputs sym + case V.findIndex (== name) $ V.fromList all_names of + Just idx -> at sym idx + Nothing -> throwIO (SymbolNameNotFound name) + +instance SymbolClass I.SymbolHandle where + getName = I.mxSymbolGetName + listArguments = I.mxSymbolListArguments + listOutputs = I.mxSymbolListOutputs + listAuxiliaryStates = I.mxSymbolListAuxiliaryStates + numOutputs = I.mxSymbolGetNumOutputs + at sym index = do + max <- numOutputs sym + if index < 0 || index >= max then + throwIO (SymbolIndexOutOfBound index max) + else + I.mxSymbolGetOutput sym index + group = I.mxSymbolCreateGroup + internals = I.mxSymbolGetInternals + + inferShape sym known = do + let (names, shapes) = unzip known + arg_ind = scanl (+) 0 $ map length shapes + arg_shp = concat shapes + (inp_shp, out_shp, aux_shp, complete) <- I.mxSymbolInferShapePartial sym names arg_ind arg_shp + inps <- listArguments sym + outs <- listOutputs sym + auxs <- listAuxiliaryStates sym + return (pair inps inp_shp, pair outs out_shp, pair auxs aux_shp, complete) + where + pair names shapes = filter (not . null . snd) $ zip names shapes + +instance SymbolClass (Symbol a) where + getName = getName . unSymbol + listArguments = listArguments . unSymbol + listOutputs = listOutputs . unSymbol + listAuxiliaryStates = listAuxiliaryStates . unSymbol + numOutputs = numOutputs . unSymbol + at (Symbol s) = (Symbol <$>) . at s + group = (Symbol <$>) . group . map unSymbol + internals = (Symbol <$>) . internals . unSymbol + inferShape = inferShape . unSymbol + + +data StorageType = StorageTypeUndefined -- -1 + | StorageTypeDefault -- 0 + | StorageTypeRowSparse -- 1 + | StorageTypeCSR -- 2 + deriving (Eq, Bounded, Enum, Show) + +toStorageType :: Integral a => a -> StorageType +toStorageType = toEnum . (+1) . fromIntegral + +fromStorageType :: Integral a => StorageType -> a +fromStorageType = fromIntegral . (subtract 1) . fromEnum + +data MXDType = TyNone -- -1 + | TyFloat32 -- 0 + | TyFloat64 -- 1 + | TyFloat16 -- 2 + | TyUInt8 -- 3 + | TyInt32 -- 4 + | TyInt8 -- 5 + | TyInt64 -- 6 + deriving (Eq, Bounded, Enum, Show) + +toMXDType :: Integral a => a -> MXDType +toMXDType = toEnum . (+1) . fromIntegral + +fromMXDType :: Integral a => MXDType -> a +fromMXDType = fromIntegral . (subtract 1) . fromEnum + +class CustomOperation (Operation prop) => CustomOperationProp prop where + -- list the names of inputs + prop_list_arguments :: prop -> [String] + -- list the names of outputs + prop_list_outputs :: prop -> [String] + -- list the names of axiliary states + prop_list_auxiliary_states :: prop -> [String] + -- infer the shape. + -- params: shapes of each inputs + -- return: shapes of inputs, outputs, auxiliary states + prop_infer_shape :: prop -> [[Int]] -> ([[Int]], [[Int]], [[Int]]) + -- declare the dependency of symbols + -- params: unique indices of inputs, outputs, auxiliary states + -- return: dependant indices. + prop_declare_backward_dependency :: prop -> [Int] -> [Int] -> [Int] -> [Int] + prop_infer_storage_type :: prop -> [StorageType] -> ([StorageType], [StorageType], [StorageType]) + prop_infer_storage_type prop in_stype = + let out_stype = replicate (length (prop_list_outputs prop)) StorageTypeDefault + aux_stype = replicate (length (prop_list_auxiliary_states prop)) StorageTypeDefault + withAssert = assert (all (==StorageTypeDefault) in_stype) + in withAssert (in_stype, out_stype, aux_stype) + prop_infer_storage_type_backward :: prop -> + [StorageType] -> + [StorageType] -> + [StorageType] -> + [StorageType] -> + [StorageType] -> + ([StorageType], [StorageType], [StorageType], [StorageType], [StorageType]) + prop_infer_storage_type_backward prop ograd_stype in_stype out_stype igrad_stype aux_stype = + let ograd_stype' = replicate (length ograd_stype) StorageTypeDefault + in_stype' = replicate (length in_stype) StorageTypeDefault + out_stype' = replicate (length out_stype) StorageTypeDefault + igrad_stype' = replicate (length igrad_stype) StorageTypeDefault + aux_stype' = replicate (length aux_stype) StorageTypeDefault + withAssert = let allDefault = all (==StorageTypeDefault) + in assert (allDefault ograd_stype && allDefault igrad_stype) + in withAssert (ograd_stype', in_stype', out_stype', igrad_stype', aux_stype') + prop_infer_type :: prop -> [MXDType] -> ([MXDType],[MXDType], [MXDType]) + prop_infer_type prop in_type = + let t0 = head in_type + out_type = replicate (length (prop_list_outputs prop)) t0 + aux_type = replicate (length (prop_list_auxiliary_states prop)) t0 + in (in_type, out_type, aux_type) + + data Operation prop :: * + prop_create_operator :: prop -> [[Int]] -> [MXDType] -> IO (Operation prop) + +class CustomOperation op where + forward :: op -> [ReqEnum] + -> [I.NDArrayHandle] + -> [I.NDArrayHandle] + -> [I.NDArrayHandle] + -> Bool + -> IO () + backward :: op -> [ReqEnum] + -> [I.NDArrayHandle] + -> [I.NDArrayHandle] + -> [I.NDArrayHandle] + -> [I.NDArrayHandle] + -> [I.NDArrayHandle] + -> IO () + +data ReqEnum = ReqNull | ReqWrite | ReqInplace | ReqAdd + deriving (Bounded, Enum) + +registerCustomOperator :: CustomOperationProp op => (String, [(String, String)] -> IO op) -> IO () +registerCustomOperator (op_type, op_ctor) = do + ptr_creator <- I.mkCustomOpPropCreator creator + I.mxCustomOpRegister op_type ptr_creator + where + creator name argc keys values ret = do + let argc' = fromIntegral argc + keys_ <- peekArray argc' keys >>= mapM peekCString + vals_ <- peekArray argc' values >>= mapM peekCString + prop <- op_ctor $ zip keys_ vals_ + + args <- mapM newCString (prop_list_arguments prop) + ptr_args <- newArray $ args ++ [nullPtr] + + outs <- mapM newCString (prop_list_outputs prop) + ptr_outs <- newArray $ outs ++ [nullPtr] + + auxs <- mapM newCString (prop_list_auxiliary_states prop) + ptr_auxs <- newArray $ auxs ++ [nullPtr] + + let size = 10 + ptr_callbacks <- mallocArray size + ptr_contexts <- newArray (replicate size nullPtr) + + allocList <- newMVar $ [castPtr ptr_args, + castPtr ptr_outs, + castPtr ptr_auxs, + castPtr ptr_callbacks, + castPtr ptr_contexts] + ++ map castPtr args + ++ map castPtr outs + ++ map castPtr auxs + + ptr_delete_entry <- I.mkCustomOpDelFunc (delete_entry allocList) + ptr_list_arguments_entry <- I.mkCustomOpListFunc (list_entry ptr_args) + ptr_list_outputs_entry <- I.mkCustomOpListFunc (list_entry ptr_outs) + ptr_list_auxiliary_states_entry <- I.mkCustomOpListFunc (list_entry ptr_auxs) + ptr_infer_shape_entry <- I.mkCustomOpInferShapeFunc (infer_shape_entry allocList prop) + ptr_declare_backward_dependency_entry <- I.mkCustomOpBwdDepFunc (declare_backward_dependency_entry allocList prop) + ptr_create_operator_entry <- I.mkCustomOpCreateFunc (create_operator_entry prop) + ptr_infer_type_entry <- I.mkCustomOpInferTypeFunc (infer_type_entry prop) + ptr_infer_storage_type_entry <- I.mkCustomOpInferStorageTypeFunc (infer_storage_type_entry prop) + ptr_infer_storage_type_backward_entry <- I.mkCustomOpBackwardInferStorageTypeFunc (infer_storage_type_backward_entry prop) + + pokeArray ptr_callbacks [ + castFunPtr ptr_delete_entry, + castFunPtr ptr_list_arguments_entry, + castFunPtr ptr_list_outputs_entry, + castFunPtr ptr_list_auxiliary_states_entry, + castFunPtr ptr_infer_shape_entry, + castFunPtr ptr_declare_backward_dependency_entry, + castFunPtr ptr_create_operator_entry, + castFunPtr ptr_infer_type_entry, + castFunPtr ptr_infer_storage_type_entry, + castFunPtr ptr_infer_storage_type_backward_entry] + + poke (castPtr ret) (I.MXCallbackList size ptr_callbacks ptr_contexts) + return 1 + + delete_entry allocList _ = do + list <- takeMVar allocList + mapM_ free list + return 1 + + list_entry cstr out_cstr x = do + poke out_cstr cstr + return 1 + + infer_shape_entry allocList prop num_tensor in_out_dim_tensor in_out_shapes_tensor _ = do + let num_inp = length (prop_list_arguments prop) + num_out = length (prop_list_outputs prop) + num_aux = length (prop_list_auxiliary_states prop) + num_tensor' = fromIntegral num_tensor + + assert (num_inp + num_out + num_aux == num_tensor') (return ()) + + -- read dimensions of inputs + inp_dim_0 <- peekArray num_inp in_out_dim_tensor + -- read each shape of each input + inp_shape_0 <- zipWithM (\i j -> do ptr <- peekElemOff in_out_shapes_tensor i + arr <- peekArray j ptr + return $ map fromIntegral arr) + [0..] (map fromIntegral inp_dim_0) + + let (inp_shape, out_shape, aux_shape) = prop_infer_shape prop inp_shape_0 + all_shape = inp_shape ++ out_shape ++ aux_shape + all_shape_sizes = map length all_shape + + assert (length all_shape == num_tensor') (return ()) + + pokeArray in_out_dim_tensor (map fromIntegral all_shape_sizes) + -- no need to allocate new dimensions of inputs/outputs/auxiliaries + -- only need to allocate new shapes for each + ptr_0 <- newArray (map fromIntegral (concat all_shape) :: [CInt]) + modifyMVar_ allocList (return . (castPtr ptr_0 :)) + + let size_UINT = sizeOf (undefined :: I.MX_UINT) + -- all the first num_tensor' ptr refers to the shape. + -- the last one is the end marker. + offsets = take num_tensor' $ scanl (+) 0 $ map (size_UINT *) all_shape_sizes + ptrs = map (plusPtr ptr_0) offsets + pokeArray in_out_shapes_tensor ptrs + return 1 + + declare_backward_dependency_entry allocList prop grad_out data_in data_out out_num_dep out_deps _ = do + let num_inp = length (prop_list_arguments prop) + num_out = length (prop_list_outputs prop) + grad_out_inds <- peekArray num_out grad_out + data_in_inds <- peekArray num_inp data_in + data_out_inds <- peekArray num_out data_out + let deps = prop_declare_backward_dependency prop + (map fromIntegral grad_out_inds) + (map fromIntegral data_in_inds) + (map fromIntegral data_out_inds) + poke out_num_dep (fromIntegral $ length deps) + ptr_deps <- newArray (map fromIntegral deps) + modifyMVar_ allocList (return . (castPtr ptr_deps :)) + + poke out_deps ptr_deps + return 1 + + infer_type_entry prop num_tensor tensor_types _ = do + let num_inp = length (prop_list_arguments prop) + num_out = length (prop_list_outputs prop) + num_aux = length (prop_list_auxiliary_states prop) + num_tensor' = fromIntegral num_tensor + assert (num_inp + num_out + num_aux == num_tensor') (return ()) + + inp_types0 <- map toMXDType <$> peekArray num_inp tensor_types + let (inp_types, out_types, aux_types) = prop_infer_type prop inp_types0 + all_types = map fromMXDType $ inp_types ++ out_types ++ aux_types + pokeArray tensor_types all_types + return 1 + + infer_storage_type_entry prop num_tensor tensor_stypes _ = do + let num_inp = length (prop_list_arguments prop) + num_out = length (prop_list_outputs prop) + num_aux = length (prop_list_auxiliary_states prop) + num_tensor' = fromIntegral num_tensor + assert (num_inp + num_out + num_aux == num_tensor') (return ()) + + inp_stypes0 <- map toStorageType <$> peekArray num_inp tensor_stypes + let (inp_stypes, out_stypes, aux_stypes) = prop_infer_storage_type prop inp_stypes0 + all_stypes = map fromStorageType $ inp_stypes ++ out_stypes ++ aux_stypes + pokeArray tensor_stypes all_stypes + return 1 + + infer_storage_type_backward_entry prop num_tensor tensor_stypes tags _ = do + let num_inp = length (prop_list_arguments prop) + num_out = length (prop_list_outputs prop) + num_aux = length (prop_list_auxiliary_states prop) + num_tensor' = fromIntegral num_tensor + tags' <- peekArray num_tensor' tags + tensor_types' <- peekArray num_tensor' tensor_stypes + let tensors = groupBy ((==) `on` fst) (zip tags' tensor_types') + tensors_table = map (\t -> (fst (head t), map (toStorageType . snd) t)) tensors + [ograd0, input0, output0, igrad0, aux0] = map (fromMaybe [] . flip lookup tensors_table) [3, 0, 1, 2, 4] + (ograd, input, output, igrad, aux) = prop_infer_storage_type_backward prop ograd0 input0 output0 igrad0 aux0 + all_stypes = map fromStorageType $ ograd ++ input ++ output ++ igrad ++ aux + + assert (length tensors == 5) (return ()) + pokeArray tensor_stypes all_stypes + return 1 + + create_operator_entry prop ctx num_inputs shapes ndims dtypes ret _ = do + let num_inputs_ = fromIntegral num_inputs + ndims <- map fromIntegral <$> peekArray num_inputs_ ndims + dtypes <- map toMXDType <$> peekArray num_inputs_ dtypes + ptrs <- peekArray num_inputs_ shapes + shapes <- mapM ((map fromIntegral <$>) . uncurry peekArray) (zip ndims ptrs) + op <- prop_create_operator prop shapes dtypes + + let size = 3 + ptr_callbacks <- mallocArray size + ptr_contexts <- newArray (replicate size nullPtr) + allocList <- newMVar $ [castPtr ptr_callbacks, castPtr ptr_contexts] + + ptr_delete_entry <- I.mkCustomFunctionDelFunc (delete_entry allocList) + ptr_func_forward_entry <- I.mkCustomFunctionBwdFunc (func_forward_entry op) + ptr_func_backward_entry <- I.mkCustomFunctionBwdFunc (func_backward_entry op) + pokeArray ptr_callbacks [ + castFunPtr ptr_delete_entry, + castFunPtr ptr_func_forward_entry, + castFunPtr ptr_func_backward_entry] + + poke ret (I.MXCallbackList size ptr_callbacks ptr_contexts) + return 1 + + func_forward_entry op num_ndarray ndarrays tags reqs is_train _ = do + let num_ndarray_ = fromIntegral num_ndarray + ndarrays <- peekArray num_ndarray_ ndarrays >>= mapM I.newNDArrayHandle + tags <- peekArray num_ndarray_ tags + + let tensors = V.map reverse $ V.create $ do + vec <- VM.replicate 5 [] + forM (zip tags ndarrays) $ \(ind, hdl) -> do + let ind_ = fromIntegral ind + lst <- VM.read vec ind_ + VM.write vec ind_ (hdl : lst) + return vec + + let in_data = tensors ! 0 + out_data = tensors ! 1 + aux = tensors ! 4 + + reqs <- map (toEnum . fromIntegral) <$> peekArray (length out_data) reqs :: IO [ReqEnum] + forward op reqs in_data out_data aux (is_train == 1) + return 1 + + func_backward_entry op num_ndarray ndarrays tags reqs is_train _ = do + let num_ndarray_ = fromIntegral num_ndarray + ndarrays <- peekArray num_ndarray_ ndarrays >>= mapM I.newNDArrayHandle + tags <- peekArray num_ndarray_ tags + + let tensors = V.map reverse $ V.create $ do + vec <- VM.replicate 5 [] + forM (zip tags ndarrays) $ \(ind, hdl) -> do + let ind_ = fromIntegral ind + lst <- VM.read vec ind_ + VM.write vec ind_ (hdl : lst) + return vec + + let in_data = tensors ! 0 + out_data = tensors ! 1 + in_grad = tensors ! 2 + out_grad = tensors ! 3 + aux = tensors ! 4 + + reqs <- map (toEnum . fromIntegral) <$> peekArray (length out_data) reqs + backward op reqs in_data out_data in_grad out_grad aux + return 1 + + (!) = (V.!) diff --git a/c-apis/MXNet/Base/Types.hs b/c-apis/MXNet/Base/Types.hs new file mode 100644 --- /dev/null +++ b/c-apis/MXNet/Base/Types.hs @@ -0,0 +1,35 @@ +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE TypeFamilies #-} +module MXNet.Base.Types where + +import Foreign.Storable (Storable) +import Data.Vector.Unboxed (Unbox) +import Data.Proxy (Proxy(..)) +import GHC.TypeLits (Symbol, KnownSymbol) + +data Context = Context { _device_type :: Int, _device_id :: Int } + deriving (Eq, Show) + +class (Storable a, Unbox a, Show a, Num a, Floating a, Real a, RealFrac a, KnownSymbol (DTypeName a)) => DType a where + type DTypeName a :: Symbol + typename :: a -> Proxy (DTypeName a) + typename a = Proxy + + flag :: a -> Int + +instance DType Float where + type DTypeName Float = "float32" + flag _ = 0 -- mshadow::kFloat32 + +instance DType Double where + type DTypeName Double = "float64" + flag _ = 1 -- mshadow::kFloat64 + +contextCPU :: Context +contextCPU = Context 1 0 + +contextGPU0 :: Context +contextGPU0 = Context 2 0 + +class ForeignData a where + touch :: a -> IO () diff --git a/cmdline/Main.hs b/cmdline/Main.hs new file mode 100644 --- /dev/null +++ b/cmdline/Main.hs @@ -0,0 +1,417 @@ +module Main where + +import Options.Applicative hiding (optional) +import Data.Semigroup ((<>)) +import Language.Haskell.Exts +import qualified Data.Text as T +import System.Log.Logger +import Control.Monad +import Control.Monad.Writer (Writer, execWriter, tell) +import Data.Either +import Data.Char (toLower, isUpper, isSpace, isAlphaNum) +import Text.Printf (printf) +import Text.ParserCombinators.ReadP +import System.FilePath +import System.Directory + +import MXNet.Base.Raw + +_module_ = "Main" + +data Arguments = Arguments { + output_dir :: FilePath +} + +args_spec = Arguments + <$> strOption (long "output" <> short 'o' <> value "operators" <> metavar "OUTPUT-DIR") + +main = do + updateGlobalLogger _module_ (setLevel INFO) + args <- execParser opts + let base = output_dir args "MXNet" "Base" "Operators" + createDirectoryIfMissing True base + + ops <- mxSymbolListAtomicSymbolCreators + + infoM _module_ "Generating Symbol operators..." + symbols <- concat <$> mapM genSymOp ops + writeFile (base "Symbol.hs") $ prettyPrint (modSymbol symbols) + + infoM _module_ "Generating NDArray operators..." + arrays <- concat <$> mapM genArrOp ops + writeFile (base "NDArray.hs") $ prettyPrint (modArray arrays) + + where + opts = info (args_spec <**> helper) (fullDesc <> progDesc "Generate MXNet operators") + modSymbol = Module () (Just $ ModuleHead () (ModuleName () "MXNet.Base.Operators.Symbol") Nothing Nothing) [] + [ simpleImport "MXNet.Base.Raw" + , simpleImport "MXNet.Base.Spec.Operator" + , simpleImport "MXNet.Base.Spec.HMap" + , simpleImportVars "Data.Maybe" ["catMaybes", "fromMaybe"]] + modArray = Module () (Just $ ModuleHead () (ModuleName () "MXNet.Base.Operators.NDArray") Nothing Nothing) [] + [ simpleImport "MXNet.Base.Raw" + , simpleImport "MXNet.Base.Spec.Operator" + , simpleImport "MXNet.Base.Spec.HMap" + , simpleImportVars "Data.Maybe" ["catMaybes", "fromMaybe"]] + +makeParamInst :: String -> [ResolvedType] -> Bool -> Decl () +makeParamInst symname typs symbolapi = + TypeInsDecl () (tyApp (tyCon $ unQual $ name "ParameterList") (tyPromotedStr symname_with_appendix)) + (tyPromotedList paramList) + where + symname_with_appendix = symname ++ (if symbolapi then "(symbol)" else "(ndarray)") + paramList = map (\(name, typ1, typ2) -> tyPromotedTuple [tyPromotedStr name, tyApp typ1 typ2]) typs + +data GenFlag = GenSymbolOp | GenNDArrayReturn | GenNDArrayUpdate + +makeSignature :: String -> GenFlag -> [Asst ()]-> Decl () +makeSignature symname flag extra_constraints = + let (funname, appendix, rettype, maketype) = + case flag of + GenSymbolOp -> (symname, "(symbol)", tyCon $ unQual $ name "SymbolHandle", tyFun (tyCon $ unQual $ name "String")) + GenNDArrayReturn -> (symname, "(ndarray)", tyList $ tyCon $ unQual $ name "NDArrayHandle", id) + GenNDArrayUpdate -> (symname ++ "_upd", "(ndarray)", unit_tycon (), tyFun (tyList $ tyCon $ unQual $ name "NDArrayHandle")) + symname_with_appendix = symname ++ appendix + cxfullfill = appA (name "Fullfilled") [tyPromotedStr symname_with_appendix, tyVarIdent "args"] + cx_all = if null extra_constraints then cxSingle cxfullfill else cxTuple (cxfullfill : extra_constraints) + fun = tyFun (tyApp (tyApp (tyCon $ unQual $ name "ArgsHMap") (tyPromotedStr symname_with_appendix)) (tyVarIdent "args")) + (tyApp (tyCon $ unQual $ name "IO") rettype) + in tySig [name funname] $ tyForall [unkindedVar (name "args")] cx_all $ (maketype fun) + +genSymOp :: AtomicSymbolCreator -> IO [Decl ()] +genSymOp sc = do + (symname, desc, argname, argtype, argdesc, key_var_num_args, rettyp) <- mxSymbolGetAtomicSymbolInfo sc + if symname `elem` ["_Native", "_NDArray"] then + return [] + else do + let symname_ = normalizeName symname + (errs, scalarTypes, tensorTypes, arrayTypes) = execWriter $ zipWithM_ (resolveHaskellType True) argname argtype + + if not (null errs) then do + forM errs $ \(name, msg) -> + errorM _module_ (printf "Function: %s %s" symname msg) + return [] + else if (length arrayTypes >= 2) then do + errorM _module_ (printf "Function: %s has more than one Symbol[] argument." symname) + return [] + else if (not (null tensorTypes) && not (null arrayTypes)) then do + errorM _module_ (printf "Function: %s is varadic, but it also has Symbol argument." symname) + return [] + else do + let paramListInst = makeParamInst symname_ (scalarTypes ++ tensorTypes ++ arrayTypes) True + sig = makeSignature symname_ GenSymbolOp $ + -- the "Custom" is a little special, because it allow extra arguments + if symname == "Custom" + -- PopKey (ArgOf "_Custom(symbol)") args "data", + -- Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) + then let argOfCustom = tyParen $ tyApp (tyCon $ unQual $ name "ArgOf") (tyPromotedStr "_Custom(symbol)") + in [appA (name "PopKey") [argOfCustom, tyVarIdent "args", tyPromotedStr "data"], + appA (name "Dump") [ tyParen $ + (tyCon $ unQual $ name "PopResult") `tyApp` + argOfCustom `tyApp` + tyVarIdent "args" `tyApp` + tyPromotedStr "data"]] + else [] + let fun = sfun (name symname_) [name "name", name "args"] (UnGuardedRhs () body) Nothing + make_scalar_values = + if symname == "Custom" + -- dump (pop args #data) + then function "dump" `app` ( + function "pop" `app` (var $ name "args") `app` (OverloadedLabel () "data")) + -- catMaybes + -- [("KEY",) . showValue <$> (args !? #KEY :: Maybe VALUE_TYPE), + -- ... ] + else function "catMaybes" `app` listE + [ infixApp (infixApp (tupleSection [Just $ strE argkey, Nothing]) + (op $ sym ".") + (function "showValue")) + (op $ sym "<$>") $ + ExpTypeSig () (infixApp (var $ name "args") + (op $ sym "!?") + (OverloadedLabel () argkey)) + (tyApp (tyCon $ unQual $ name "Maybe") typ) + | (argkey, _, typ) <- scalarTypes] + body = letE ([ + patBind (pvar $ name "scalarArgs") make_scalar_values + , patBind (pTuple [pvar $ name "scalarkeys", pvar $ name "scalarvals"]) (app (function "unzip") $ var $ name "scalarArgs") + , patBind (pvar $ name "tensorArgs") (function "catMaybes" + `app` listE [ + infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym "<$>") $ + ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- tensorTypes]) + , patBind (pTuple [pvar $ name "tensorkeys", pvar $ name "tensorvals"]) (app (function "unzip") $ var $ name "tensorArgs")] + ++ + case arrayTypes of + [(argkey,_,_)] -> [patBind (pvar $ name "array") $ function "fromMaybe" + `app` eList + `app` ExpTypeSig () + (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) + (tyApp (tyCon $ unQual $ name "Maybe") (tyList $ tyCon $ unQual $ name "SymbolHandle"))] + _ -> []) + (doE $ + [ genStmt (pvar $ name "op") $ function "nnGetOpHandle"`app` strE symname ] ++ + ( if null arrayTypes then + [ genStmt (pvar $ name "sym") $ function "mxSymbolCreateAtomicSymbol" + `app` (function "fromOpHandle" `app` (var $ name "op")) + `app` (var $ name "scalarkeys") + `app` (var $ name "scalarvals") + , qualStmt $ function "mxSymbolCompose" + `app` (var $ name "sym") + `app` (var $ name "name") + `app` ((con $ unQual $ name "Just") `app` (var $ name "tensorkeys")) + `app` (var $ name "tensorvals") ] + else if null key_var_num_args then + -- the size of array are determined pragmatically (e.g. Custom) + [ genStmt (pvar $ name "sym") $ function "mxSymbolCreateAtomicSymbol" + `app` (function "fromOpHandle" `app` (var $ name "op")) + `app` (var $ name "scalarkeys") + `app` (var $ name "scalarvals") + , qualStmt $ function "mxSymbolCompose" + `app` (var $ name "sym") + `app` (var $ name "name") + `app` (con $ unQual $ name "Nothing") + `app` (var $ name "array") ] + else + -- the size of array should be provided in the arg named `key_var_num_args` + -- but it is sometimes optional when calling the symbol. If it is not given + -- explicitly, calculate its length. + [ genStmt (pvar $ name "sym") $ + If () (function "hasKey" `app` (var $ name "args") `app` (OverloadedLabel () key_var_num_args)) + (function "mxSymbolCreateAtomicSymbol" + `app` (function "fromOpHandle" `app` (var $ name "op")) + `app` (var $ name "scalarkeys") + `app` (var $ name "scalarvals")) + (function "mxSymbolCreateAtomicSymbol" + `app` (function "fromOpHandle" `app` (var $ name "op")) + `app` (infixApp (strE key_var_num_args) (QConOp () $ Special () $ Cons ()) (var $ name "scalarkeys")) + `app` (infixApp (function "showValue" `app` (function "length" `app` (var $ name "array"))) (QConOp () $ Special () $ Cons ()) (var $ name "scalarvals"))) + , qualStmt $ function "mxSymbolCompose" + `app` (var $ name "sym") + `app` (var $ name "name") + `app` (con $ unQual $ name "Nothing") + `app` (var $ name "array")] ) ++ + [ qualStmt $ function "return" `app` (var $ name "sym") ]) + return [paramListInst, sig, fun] + +genArrOp :: AtomicSymbolCreator -> IO [Decl ()] +genArrOp sc = do + (symname, desc, argname0, argtype0, argdesc, key_var_num_args, rettyp) <- mxSymbolGetAtomicSymbolInfo sc + + -- some ops (names like *_mkl_*) are malformed. They declare zero args, but actually has the "data" and "num_args" + let (argname, argtype) = if not (null key_var_num_args) && null argname0 then + (["data","num_args"], ["NDArray-or-Symbol[]","int, required"]) + else + (argname0, argtype0) + + if symname `elem` ["_Native", "_NDArray", "Custom"] then + return [] + else do + let symname_ = normalizeName symname + (errs, scalarTypes, tensorTypes, arrayTypes) = execWriter $ zipWithM_ (resolveHaskellType False) argname argtype + + if not (null errs) then do + forM errs $ \(name, msg) -> + errorM _module_ (printf "Function: %s %s" symname msg) + return [] + else if (length arrayTypes >= 2) then do + errorM _module_ (printf "Function: %s has more than Symbol[] argument." symname) + return [] + else if (not (null tensorTypes) && not (null arrayTypes)) then do + errorM _module_ (printf "Function: %s is varadic, but it also has Symbol argument." symname) + return [] + else do + let paramListInst = makeParamInst symname_ (scalarTypes ++ tensorTypes ++ arrayTypes) False + sig1 = makeSignature symname_ GenNDArrayReturn [] + sig2 = makeSignature symname_ GenNDArrayUpdate [] + let fun1 = sfun (name symname_) [name "args"] + (UnGuardedRhs () (body (lastArgOfInvoke GenNDArrayReturn) True)) Nothing + fun2 = sfun (name $ symname_ ++ "_upd") [name "outputs", name "args"] + (UnGuardedRhs () (body (lastArgOfInvoke GenNDArrayUpdate) False)) Nothing + lastArgOfInvoke GenNDArrayReturn = con $ unQual $ name "Nothing" + lastArgOfInvoke GenNDArrayUpdate = (con $ unQual $ name "Just") `app` (var $ name "outputs") + body lastarg retval = + letE ([ + patBind (pvar $ name "scalarArgs") (function "catMaybes" + `app` listE [ + infixApp (infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym ".") (function "showValue")) (op $ sym "<$>") $ + ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- scalarTypes]) + -- , patBind (pTuple [pvar $ name "scalarkeys", pvar $ name "scalarvals"]) (app (function "unzip") $ var $ name "scalarArgs") + , patBind (pvar $ name "tensorArgs") (function "catMaybes" + `app` listE [ + infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym "<$>") $ + ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- tensorTypes]) + , patBind (pTuple [pvar $ name "tensorkeys", pvar $ name "tensorvals"]) (app (function "unzip") $ var $ name "tensorArgs")] + ++ + case arrayTypes of + [(argkey,_,_)] -> [patBind (pvar $ name "array") $ function "fromMaybe" + `app` eList + `app` ExpTypeSig () + (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) + (tyApp (tyCon $ unQual $ name "Maybe") (tyList $ tyCon $ unQual $ name "NDArrayHandle"))] + _ -> []) + (doE $ + [ genStmt (pvar $ name "op") $ function "nnGetOpHandle"`app` strE symname ] ++ + ( if null key_var_num_args then + [ genStmt (pvar $ name "listndarr") $ function "mxImperativeInvoke" + `app` (function "fromOpHandle" `app` (var $ name "op")) + `app` (var $ name "tensorvals") + `app` (var $ name $ "scalarArgs") + `app` lastarg + ] + else + [ letStmt [ + patBind (pvar $ name "scalarArgs'") ( + If () (function "hasKey" `app` (var $ name "args") `app` (OverloadedLabel () key_var_num_args)) + (var $ name $ "scalarArgs") + (let key_var = Con () (Special () (TupleCon () Boxed 2)) + `app` (strE key_var_num_args) + `app` (function "showValue" `app` (function "length" `app` (var $ name "array"))) + in infixApp key_var (QConOp () $ Special () $ Cons ()) (var $ name $ "scalarArgs")) + )] + , genStmt (pvar $ name "listndarr") $ function "mxImperativeInvoke" + `app` (function "fromOpHandle" `app` (var $ name "op")) + `app` (var $ name "array") + `app` (var $ name $ "scalarArgs'") + `app` lastarg + ]) ++ + [ qualStmt $ function "return" `app` (if retval then var $ name "listndarr" else unit_con ()) ]) + return [paramListInst, sig1, fun1, sig2, fun2] + +normalizeName :: String -> String +normalizeName name@(c:cs) + | isUpper c = '_' : name + | name == "where" = "_where" + | otherwise = name + +data ParamDesc = ParamDescItem String | ParamDescList Bool [String] deriving (Eq, Show) + +type ResolvedType = (String, Type (), Type ()) +resolveHaskellType :: Bool -> String -> String -> Writer ([(String, String)], [ResolvedType], [ResolvedType], [ResolvedType]) () +resolveHaskellType asSymbol symname desc = do + let fail msg = tell ([(symname, msg)], [], [], []) + case readP_to_S typedesc desc of + [(fields, "")] -> do + let required = ParamDescItem "required" `elem` fields + attr = tyCon $ unQual $ name $ if required then "AttrReq" else "AttrOpt" + scalar hstyp = tell ([], [(symname_, attr, hstyp)], [], []) + symbol hstyp = tell ([], [], [(symname_, attr, hstyp)], []) + array hstyp = tell ([], [], [], [(symname_, attr, hstyp)]) + symname_ = normalizeName symname + -- + -- symbol operators + -- + -- operator can have only one argument of the type symbol or ndarray array + -- and not having any other argument of symbol or ndarray + -- besides the operator's info must definitely have a key_var_num_args, which + -- indicates an (might be additional) argument which should be passed to mxSymbolCreateAtomicSymbol. + handleSymbol (ParamDescItem "Symbol") = symbol $ tyCon $ unQual $ name "SymbolHandle" + handleSymbol (ParamDescItem "NDArray-or-Symbol") = symbol $ tyCon $ unQual $ name "SymbolHandle" + handleSymbol (ParamDescItem "Symbol[]") = array $ tyList $ tyCon $ unQual $ name "SymbolHandle" + handleSymbol (ParamDescItem "NDArray-or-Symbol[]") = array $ tyList $ tyCon $ unQual $ name "SymbolHandle" + handleSymbol (ParamDescItem "Symbol or Symbol[]") = array $ tyList $ tyCon $ unQual $ name "SymbolHandle" + handleSymbol (ParamDescItem "NDArray") = fail $ printf "NDArrayHandle arg: %s" symname + handleSymbol t = fallThrough t + -- + -- ndarray operators + -- + handleNDArray (ParamDescItem "NDArray-or-Symbol") = symbol $ tyCon $ unQual $ name "NDArrayHandle" + handleNDArray (ParamDescItem "NDArray-or-Symbol[]") = array $ tyList $ tyCon $ unQual $ name "NDArrayHandle" + handleNDArray (ParamDescItem "Symbol or Symbol[]") = array $ tyList $ tyCon $ unQual $ name "NDArrayHandle" + handleNDArray (ParamDescItem "NDArray") = symbol $ tyCon $ unQual $ name "NDArrayHandle" + handleNDArray (ParamDescItem "Symbol") = fail $ printf "SymbolHandle arg: %s" symname + handleNDArray (ParamDescItem "Symbol[]") = fail $ printf "SymbolHandle[] arg: %s" symname + handleNDArray t = fallThrough t + + fallThrough t = fail $ printf "Unknown type: arg %s(%s)." symname desc + + case head fields of + ParamDescItem "Shape(tuple)" -> scalar $ tyList $ tyCon $ unQual $ name "Int" + ParamDescItem "int" -> scalar $ tyCon $ unQual $ name "Int" + ParamDescItem "int (non-negative)" -> scalar $ tyCon $ unQual $ name "Int" + ParamDescItem "long (non-negative)" -> scalar $ tyCon $ unQual $ name "Int" + ParamDescItem "boolean" -> scalar $ tyCon $ unQual $ name "Bool" + ParamDescItem "float" -> scalar $ tyCon $ unQual $ name "Float" + ParamDescItem "double" -> scalar $ tyCon $ unQual $ name "Double" + ParamDescItem "float32" -> scalar $ tyCon $ unQual $ name "Float" + -- real_t (from mshadow) is by default float. + ParamDescItem "real_t" -> scalar $ tyCon $ unQual $ name "Float" + ParamDescItem "string" -> scalar $ tyCon $ unQual $ name "String" + ParamDescItem "int or None" -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Int") + ParamDescItem "float or None" -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Float") + ParamDescItem "double or None" -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Double") + ParamDescItem "boolean or None" -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Bool") + ParamDescItem "Shape or None" -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyList $ tyCon $ unQual $ name "Int") + ParamDescItem "tuple of " -> scalar $ tyList $ tyCon $ unQual $ name "Float" + ParamDescItem "tuple of " -> scalar $ tyList $ tyCon $ unQual $ name "Double" + ParamDescList hasnone vs -> do + let vsprom = map tyPromotedStr vs + typ1 = tyApp (tyCon $ unQual $ name "EnumType") (tyPromotedList vsprom) + typ2 = tyApp (tyCon $ unQual $ name "Maybe") typ1 + scalar $ if hasnone then typ2 else typ1 + t -> (if asSymbol then handleSymbol else handleNDArray) t + other -> fail (printf "cannot parse type description: %s" desc) + +typedesc = do + -- since 1.3, there are types starting with ',', and it implies 'int' type. + def <- (char ',' >> return [ParamDescItem "int"]) <++ return [] + ds <- sepBy (skipSpaces >> (list1 +++ list2 +++ item)) (char ',') + eof + return $ def ++ ds + where + list1 = ParamDescList True <$> between (string "{None,") (char '}') (sepBy (skipSpaces >> listItem) (char ',')) + list2 = ParamDescList False <$> between (string "{") (char '}') (sepBy (skipSpaces >> listItem) (char ',')) + listItem = between (char '\'') (char '\'') (munch1 (\c -> isAlphaNum c || c `elem` "_")) + item = ParamDescItem <$> munch1 (\c -> isAlphaNum c || c `elem` " _-()=[]<>'.") + +unQual = UnQual () +unkindedVar = UnkindedVar () + +tyCon = TyCon () +tyVarSymbol = TyVar () . Symbol () +tyVarIdent = TyVar () . Ident () +tyApp = TyApp () +tyFun = TyFun () +tySig names types = TypeSig () names types +tyList = TyList () +tyVar = TyVar () +tyParen = TyParen () + +tyPromotedInteger s = TyPromoted () (PromotedInteger () s (show s)) +tyPromotedStr s = TyPromoted () (PromotedString () s s) +tyPromotedList s = TyPromoted () (PromotedList () True s) +tyPromotedTuple s = TyPromoted () (PromotedTuple () s) + +tyForall vars cxt typ = TyForall () vars_ cxt_ typ + where + vars_ = if null vars then Nothing else Just vars + cxt_ = if cxt == CxEmpty () then Nothing else Just cxt + +cxSingle = CxSingle () +cxTuple = CxTuple () + +appA = AppA () + +tupleSection = TupleSection () Boxed + +con = Con () + +simpleImport mod = ImportDecl { + importAnn = (), + importModule = ModuleName () mod, + importQualified = False, + importSrc = False, + importSafe = False, + importPkg = Nothing, + importAs = Nothing, + importSpecs = Nothing +} + +simpleImportVars mod vars = ImportDecl { + importAnn = (), + importModule = ModuleName () mod, + importQualified = False, + importSrc = False, + importSafe = False, + importPkg = Nothing, + importAs = Nothing, + importSpecs = Just $ ImportSpecList () False [IVar () $ Ident () var | var <- vars] +} diff --git a/fei-base.cabal b/fei-base.cabal new file mode 100644 --- /dev/null +++ b/fei-base.cabal @@ -0,0 +1,105 @@ +cabal-version: 2.2 +name: fei-base +version: 0.2.0.0 +synopsis: FFI to MXNet +description: This package provides a FFI wrap of MXNet, including c-apis and symbol/array/executor operations. +homepage: +license: BSD-3-Clause +license-file: LICENSE +author: Jiasen Wu +maintainer: jiasenwu@hotmail.com +copyright: 2018 Jiasen Wu +category: Machine Learning, AI +build-type: Simple +extra-source-files: README.md + +Flag MXNet_1_5 { + Description: With MXNet 1.5.x operators + Default: True +} + +Flag MXNet_1_4 { + Description: With MXNet 1.4.x operators + Default: False +} + +Flag MXNet_1_3 { + Description: With MXNet 1.3.x operators + Default: False +} + +Flag MXNet_1_0 { + Description: With MXNet 1.0.x operators + Default: False +} + +library + hs-source-dirs: c-apis + if flag(MXNet_1_0) { + hs-source-dirs: ops/1.0 + } + elif flag(MXNet_1_3) { + hs-source-dirs: ops/1.3 + } + elif flag(MXNet_1_4) { + hs-source-dirs: ops/1.4 + } + elif flag(MXNet_1_5) { + hs-source-dirs: ops/1.5 + } + build-depends: base >= 4.7 && < 5, + c2hs-extra == 0.1.0.1, + tuple-ops == 0.0.0.3, + vector >= 0.11 && < 0.13, + constraints, + repa + default-language: Haskell2010 + Build-tools: c2hs + default-extensions: FlexibleContexts, + GADTs, + StandaloneDeriving, + DeriveGeneric, + GeneralizedNewtypeDeriving, + ExplicitForAll, + DataKinds, + TypeFamilies, + OverloadedLabels, + TupleSections + exposed-modules: MXNet.Base, + MXNet.Base.Raw, + MXNet.Base.Types, + MXNet.Base.Symbol, + MXNet.Base.NDArray, + MXNet.Base.Executor, + MXNet.Base.Spec.Operator, + MXNet.Base.Spec.HMap + if flag(MXNet_1_0) || flag(MXNet_1_3) || flag(MXNet_1_4) || flag(MXnet_1_5) { + exposed-modules: MXNet.Base.Operators.Symbol, + MXNet.Base.Operators.NDArray + } + other-modules: MXNet.Base.Raw.Common, + MXNet.Base.Raw.NDArray, + MXNet.Base.Raw.Symbol, + MXNet.Base.Raw.Executor, + MXNet.Base.Raw.DataIter + extra-libraries: mxnet + +executable mxnet-op-gen + hs-source-dirs: cmdline + main-is: Main.hs + build-depends: base >= 4.7 && < 5, + optparse-applicative >= 0.14 && < 0.15, + haskell-src-exts >= 1.20, + hslogger >= 1.2, + text >= 1.2.0 && < 1.3, + mtl, + filepath >= 1.4 && < 1.5, + directory >= 1.3 && < 1.4, + fei-base + default-language: Haskell2010 + default-extensions: FlexibleContexts + extra-libraries: mxnet + +source-repository head + type: git + location: https://github.com/pierric/fei-base diff --git a/ops/1.0/MXNet/Base/Operators/NDArray.hs b/ops/1.0/MXNet/Base/Operators/NDArray.hs new file mode 100644 --- /dev/null +++ b/ops/1.0/MXNet/Base/Operators/NDArray.hs @@ -0,0 +1,16434 @@ +module MXNet.Base.Operators.NDArray where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "broadcast_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle] +broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_power_upd :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_power(ndarray)" args -> IO () +broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_power(ndarray)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + ArgsHMap "_backward_broadcast_power(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_power_upd :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO () +_backward_broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle] +broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_maximum_upd :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_maximum(ndarray)" args -> IO () +broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_maximum(ndarray)" + = '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_maximum_upd :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO () +_backward_broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle] +broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_minimum_upd :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_minimum(ndarray)" args -> IO () +broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_minimum(ndarray)" + = '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_minimum_upd :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO () +_backward_broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle] +broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_hypot_upd :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_hypot(ndarray)" args -> IO () +broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_hypot(ndarray)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_hypot_upd :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO () +_backward_broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_equal :: + forall args . Fullfilled "_equal(ndarray)" args => + ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle] +_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_upd :: + forall args . Fullfilled "_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO () +_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(ndarray)" args => + ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle] +_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_upd :: + forall args . Fullfilled "_not_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO () +_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater :: + forall args . Fullfilled "_greater(ndarray)" args => + ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle] +_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_upd :: + forall args . Fullfilled "_greater(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO () +_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle] +_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_upd :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO () +_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(ndarray)" args => + ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle] +_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_upd :: + forall args . Fullfilled "_lesser(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO () +_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_upd :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO () +_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_power :: + forall args . Fullfilled "_power(ndarray)" args => + ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle] +_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_upd :: + forall args . Fullfilled "_power(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO () +_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power(ndarray)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(ndarray)" args => + ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle] +_backward_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_upd :: + forall args . Fullfilled "_backward_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power(ndarray)" args -> IO () +_backward_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(ndarray)" args => + ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle] +_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_upd :: + forall args . Fullfilled "_maximum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO () +_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum(ndarray)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle] +_backward_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_upd :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum(ndarray)" args -> IO () +_backward_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(ndarray)" args => + ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle] +_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_upd :: + forall args . Fullfilled "_minimum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO () +_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum(ndarray)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle] +_backward_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_upd :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum(ndarray)" args -> IO () +_backward_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(ndarray)" args => + ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle] +_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_upd :: + forall args . Fullfilled "_hypot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO () +_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot(ndarray)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle] +_backward_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_upd :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot(ndarray)" args -> IO () +_backward_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_square_sum(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(ndarray)" args => + ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle] +_square_sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_square_sum_upd :: + forall args . Fullfilled "_square_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO () +_square_sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square_sum(ndarray)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_square_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_sum_upd :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square_sum(ndarray)" args -> IO () +_backward_square_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "add_n(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +add_n :: + forall args . Fullfilled "add_n(ndarray)" args => + ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle] +add_n args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +add_n_upd :: + forall args . Fullfilled "add_n(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO () +add_n_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_zeros(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(ndarray)" args => + ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle] +_zeros args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_zeros_upd :: + forall args . Fullfilled "_zeros(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO () +_zeros_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ones(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(ndarray)" args => + ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle] +_ones args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ones_upd :: + forall args . Fullfilled "_ones(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO () +_ones_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_full(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(ndarray)" args => + ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle] +_full args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_full_upd :: + forall args . Fullfilled "_full(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO () +_full_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_arange(ndarray)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(ndarray)" args => + ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle] +_arange args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_arange_upd :: + forall args . Fullfilled "_arange(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO () +_arange_upd outputs args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "zeros_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(ndarray)" args => + ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle] +zeros_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +zeros_like_upd :: + forall args . Fullfilled "zeros_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO () +zeros_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ones_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(ndarray)" args => + ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle] +ones_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ones_like_upd :: + forall args . Fullfilled "ones_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO () +ones_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle] +broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_add_upd :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO () +broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_add(ndarray)" = + '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + ArgsHMap "_backward_broadcast_add(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_add_upd :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO () +_backward_broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle] +broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_sub_upd :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO () +broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_sub(ndarray)" = + '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_sub_upd :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO () +_backward_broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle] +broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mul_upd :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO () +broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mul(ndarray)" = + '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mul_upd :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO () +_backward_broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle] +broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_div_upd :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO () +broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_div(ndarray)" = + '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + ArgsHMap "_backward_broadcast_div(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_div_upd :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO () +_backward_broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle] +broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mod_upd :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO () +broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mod(ndarray)" = + '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mod_upd :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO () +_backward_broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle), + '("_C", AttrOpt NDArrayHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm_upd :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO () +_linalg_gemm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm_upd :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO () +_backward_linalg_gemm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm2(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm2 args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm2_upd :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO () +_linalg_gemm2_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm2 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm2_upd :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO () +_backward_linalg_gemm2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potrf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle] +_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potrf_upd :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO () +_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potrf_upd :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO () +_backward_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potri(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle] +_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potri_upd :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO () +_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potri(ndarray)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + ArgsHMap "_backward_linalg_potri(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potri_upd :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO () +_backward_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trmm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trmm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trmm_upd :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO () +_linalg_trmm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trmm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trmm_upd :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO () +_backward_linalg_trmm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trsm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trsm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trsm_upd :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO () +_linalg_trsm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trsm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trsm_upd :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO () +_backward_linalg_trsm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_sumlogdiag(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle] +_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_sumlogdiag_upd :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO () +_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)" + = '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_sumlogdiag_upd :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO () +_backward_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syrk(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle] +_linalg_syrk args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syrk_upd :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO () +_linalg_syrk_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syrk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syrk_upd :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO () +_backward_linalg_syrk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gelqf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle] +_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gelqf_upd :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO () +_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gelqf_upd :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO () +_backward_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syevd(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle] +_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syevd_upd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO () +_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syevd_upd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO () +_backward_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cast_storage(ndarray)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt NDArrayHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(ndarray)" args => + ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle] +cast_storage args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cast_storage_upd :: + forall args . Fullfilled "cast_storage(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO () +cast_storage_upd outputs args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_scalar_upd :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO () +_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_not_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_scalar_upd :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO () +_not_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle] +_greater_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_scalar_upd :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_scalar(ndarray)" args -> IO () +_greater_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + ArgsHMap "_greater_equal_scalar(ndarray)" args -> + IO [NDArrayHandle] +_greater_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_scalar_upd :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO () +_greater_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_scalar_upd :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO () +_lesser_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_scalar_upd :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO () +_lesser_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "relu(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +relu :: + forall args . Fullfilled "relu(ndarray)" args => + ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle] +relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +relu_upd :: + forall args . Fullfilled "relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO () +relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_relu(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle] +_backward_relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_relu_upd :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO () +_backward_relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sigmoid(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(ndarray)" args => + ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle] +sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sigmoid_upd :: + forall args . Fullfilled "sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO () +sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sigmoid(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle] +_backward_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sigmoid_upd :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO () +_backward_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copy :: + forall args . Fullfilled "_copy(ndarray)" args => + ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle] +_copy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copy_upd :: + forall args . Fullfilled "_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO () +_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_copy(ndarray)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle] +_backward_copy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_copy_upd :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO () +_backward_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BlockGrad(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle] +_BlockGrad args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BlockGrad_upd :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO () +_BlockGrad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "make_loss(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(ndarray)" args => + ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle] +make_loss args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +make_loss_upd :: + forall args . Fullfilled "make_loss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO () +make_loss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_identity_with_attr_like_rhs(ndarray)" + = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> + IO [NDArrayHandle] +_identity_with_attr_like_rhs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_identity_with_attr_like_rhs_upd :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO () +_identity_with_attr_like_rhs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reshape_like(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(ndarray)" args => + ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle] +reshape_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reshape_like_upd :: + forall args . Fullfilled "reshape_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO () +reshape_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Cast(ndarray)" = + '[ '("dtype", + AttrReq + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(ndarray)" args => + ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle] +_Cast args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Cast_upd :: + forall args . Fullfilled "_Cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO () +_Cast_upd outputs args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cast(ndarray)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle] +_backward_cast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cast_upd :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO () +_backward_cast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "negative(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +negative :: + forall args . Fullfilled "negative(ndarray)" args => + ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle] +negative args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +negative_upd :: + forall args . Fullfilled "negative(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO () +negative_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reciprocal(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(ndarray)" args => + ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle] +reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reciprocal_upd :: + forall args . Fullfilled "reciprocal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO () +reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reciprocal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle] +_backward_reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reciprocal_upd :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO () +_backward_reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "abs(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +abs :: + forall args . Fullfilled "abs(ndarray)" args => + ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle] +abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +abs_upd :: + forall args . Fullfilled "abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO () +abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_abs(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle] +_backward_abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_abs_upd :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO () +_backward_abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sign :: + forall args . Fullfilled "sign(ndarray)" args => + ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle] +sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sign_upd :: + forall args . Fullfilled "sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO () +sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle] +_backward_sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sign_upd :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO () +_backward_sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "round(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +round :: + forall args . Fullfilled "round(ndarray)" args => + ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle] +round args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +round_upd :: + forall args . Fullfilled "round(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO () +round_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rint(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rint :: + forall args . Fullfilled "rint(ndarray)" args => + ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle] +rint args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rint_upd :: + forall args . Fullfilled "rint(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO () +rint_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ceil(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ceil :: + forall args . Fullfilled "ceil(ndarray)" args => + ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle] +ceil args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ceil_upd :: + forall args . Fullfilled "ceil(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO () +ceil_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "floor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +floor :: + forall args . Fullfilled "floor(ndarray)" args => + ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle] +floor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +floor_upd :: + forall args . Fullfilled "floor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO () +floor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "trunc(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +trunc :: + forall args . Fullfilled "trunc(ndarray)" args => + ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle] +trunc args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +trunc_upd :: + forall args . Fullfilled "trunc(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO () +trunc_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fix(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +fix :: + forall args . Fullfilled "fix(ndarray)" args => + ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle] +fix args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fix_upd :: + forall args . Fullfilled "fix(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO () +fix_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "square(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +square :: + forall args . Fullfilled "square(ndarray)" args => + ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle] +square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +square_upd :: + forall args . Fullfilled "square(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO () +square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(ndarray)" args => + ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle] +_backward_square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_upd :: + forall args . Fullfilled "_backward_square(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square(ndarray)" args -> IO () +_backward_square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(ndarray)" args => + ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle] +sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sqrt_upd :: + forall args . Fullfilled "sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO () +sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sqrt_upd :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO () +_backward_sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rsqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(ndarray)" args => + ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle] +rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rsqrt_upd :: + forall args . Fullfilled "rsqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO () +rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rsqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rsqrt_upd :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO () +_backward_rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(ndarray)" args => + ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle] +cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cbrt_upd :: + forall args . Fullfilled "cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO () +cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cbrt_upd :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO () +_backward_cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rcbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(ndarray)" args => + ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle] +rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rcbrt_upd :: + forall args . Fullfilled "rcbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO () +rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rcbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rcbrt_upd :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO () +_backward_rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "exp(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +exp :: + forall args . Fullfilled "exp(ndarray)" args => + ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle] +exp args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +exp_upd :: + forall args . Fullfilled "exp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO () +exp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log :: + forall args . Fullfilled "log(ndarray)" args => + ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle] +log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_upd :: + forall args . Fullfilled "log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO () +log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log10(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log10 :: + forall args . Fullfilled "log10(ndarray)" args => + ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle] +log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log10_upd :: + forall args . Fullfilled "log10(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO () +log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log2(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log2 :: + forall args . Fullfilled "log2(ndarray)" args => + ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle] +log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log2_upd :: + forall args . Fullfilled "log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO () +log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(ndarray)" args => + ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle] +_backward_log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_upd :: + forall args . Fullfilled "_backward_log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO () +_backward_log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log10(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle] +_backward_log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log10_upd :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log10(ndarray)" args -> IO () +_backward_log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log2(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle] +_backward_log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log2_upd :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO () +_backward_log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log1p(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log1p :: + forall args . Fullfilled "log1p(ndarray)" args => + ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle] +log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log1p_upd :: + forall args . Fullfilled "log1p(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO () +log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log1p(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle] +_backward_log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log1p_upd :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log1p(ndarray)" args -> IO () +_backward_log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expm1(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +expm1 :: + forall args . Fullfilled "expm1(ndarray)" args => + ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle] +expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expm1_upd :: + forall args . Fullfilled "expm1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO () +expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_expm1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle] +_backward_expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_expm1_upd :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_expm1(ndarray)" args -> IO () +_backward_expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gamma(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gamma :: + forall args . Fullfilled "gamma(ndarray)" args => + ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle] +gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gamma_upd :: + forall args . Fullfilled "gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO () +gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gamma(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle] +_backward_gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gamma_upd :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gamma(ndarray)" args -> IO () +_backward_gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gammaln(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(ndarray)" args => + ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle] +gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gammaln_upd :: + forall args . Fullfilled "gammaln(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO () +gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gammaln(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle] +_backward_gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gammaln_upd :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gammaln(ndarray)" args -> IO () +_backward_gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sum(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +sum :: + forall args . Fullfilled "sum(ndarray)" args => + ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle] +sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sum_upd :: + forall args . Fullfilled "sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO () +sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sum(ndarray)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sum_upd :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO () +_backward_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mean(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +mean :: + forall args . Fullfilled "mean(ndarray)" args => + ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle] +mean args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mean_upd :: + forall args . Fullfilled "mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO () +mean_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mean(ndarray)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle] +_backward_mean args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mean_upd :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO () +_backward_mean_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "prod(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +prod :: + forall args . Fullfilled "prod(ndarray)" args => + ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle] +prod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +prod_upd :: + forall args . Fullfilled "prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO () +prod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_prod(ndarray)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle] +_backward_prod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_prod_upd :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO () +_backward_prod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nansum(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nansum :: + forall args . Fullfilled "nansum(ndarray)" args => + ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle] +nansum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nansum_upd :: + forall args . Fullfilled "nansum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO () +nansum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nansum(ndarray)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle] +_backward_nansum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nansum_upd :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nansum(ndarray)" args -> IO () +_backward_nansum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nanprod(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(ndarray)" args => + ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle] +nanprod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nanprod_upd :: + forall args . Fullfilled "nanprod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO () +nanprod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nanprod(ndarray)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle] +_backward_nanprod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nanprod_upd :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nanprod(ndarray)" args -> IO () +_backward_nanprod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "max(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +max :: + forall args . Fullfilled "max(ndarray)" args => + ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle] +max args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +max_upd :: + forall args . Fullfilled "max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO () +max_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_max(ndarray)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(ndarray)" args => + ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle] +_backward_max args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_max_upd :: + forall args . Fullfilled "_backward_max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO () +_backward_max_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "min(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +min :: + forall args . Fullfilled "min(ndarray)" args => + ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle] +min args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +min_upd :: + forall args . Fullfilled "min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO () +min_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_min(ndarray)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(ndarray)" args => + ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle] +_backward_min args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_min_upd :: + forall args . Fullfilled "_backward_min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO () +_backward_min_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_axis(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle] +broadcast_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_axis_upd :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO () +broadcast_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_to(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle] +broadcast_to args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_to_upd :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO () +broadcast_to_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_broadcast_backward(ndarray)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle] +_broadcast_backward args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_broadcast_backward_upd :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_broadcast_backward(ndarray)" args -> IO () +_broadcast_backward_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "norm(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +norm :: + forall args . Fullfilled "norm(ndarray)" args => + ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle] +norm args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +norm_upd :: + forall args . Fullfilled "norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO () +norm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle] +elemwise_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_add_upd :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO () +elemwise_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_grad_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(ndarray)" args => + ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle] +_grad_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_grad_add_upd :: + forall args . Fullfilled "_grad_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO () +_grad_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_add(ndarray)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(ndarray)" args => + ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle] +_backward_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_add_upd :: + forall args . Fullfilled "_backward_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO () +_backward_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle] +elemwise_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_sub_upd :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO () +elemwise_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sub(ndarray)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle] +_backward_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sub_upd :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO () +_backward_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle] +elemwise_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_mul_upd :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO () +elemwise_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul(ndarray)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle] +_backward_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_upd :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO () +_backward_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle] +elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_div_upd :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO () +elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div(ndarray)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(ndarray)" args => + ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle] +_backward_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_upd :: + forall args . Fullfilled "_backward_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO () +_backward_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_mod :: + forall args . Fullfilled "_mod(ndarray)" args => + ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle] +_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_upd :: + forall args . Fullfilled "_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO () +_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod(ndarray)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle] +_backward_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_upd :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO () +_backward_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_plus_scalar_upd :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO () +_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle] +_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minus_scalar_upd :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO () +_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rminus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle] +_rminus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rminus_scalar_upd :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO () +_rminus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mul_scalar_upd :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO () +_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_scalar_upd :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO () +_backward_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_div_scalar_upd :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO () +_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_scalar_upd :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO () +_backward_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle] +_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rdiv_scalar_upd :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO () +_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rdiv_scalar_upd :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO () +_backward_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_scalar_upd :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO () +_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_scalar_upd :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO () +_backward_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle] +_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rmod_scalar_upd :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO () +_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rmod_scalar_upd :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO () +_backward_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> + IO [NDArrayHandle] +_scatter_elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_elemwise_div_upd :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO () +_scatter_elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_scatter_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_plus_scalar_upd :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO () +_scatter_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> + IO [NDArrayHandle] +_scatter_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_minus_scalar_upd :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO () +_scatter_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Embedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(ndarray)" args => + ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle] +_Embedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Embedding_upd :: + forall args . Fullfilled "_Embedding(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO () +_Embedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SparseEmbedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_contrib_SparseEmbedding :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SparseEmbedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SparseEmbedding_upd :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO () +_contrib_SparseEmbedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Embedding(ndarray)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle] +_backward_Embedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Embedding_upd :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Embedding(ndarray)" args -> IO () +_backward_Embedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SparseEmbedding(ndarray)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_backward_SparseEmbedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SparseEmbedding_upd :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO () +_backward_SparseEmbedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "take(ndarray)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)] + +take :: + forall args . Fullfilled "take(ndarray)" args => + ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle] +take args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +take_upd :: + forall args . Fullfilled "take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO () +take_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_take(ndarray)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(ndarray)" args => + ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle] +_backward_take args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_take_upd :: + forall args . Fullfilled "_backward_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO () +_backward_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_take(ndarray)" = + '[ '("a", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(ndarray)" args => + ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle] +batch_take args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_take_upd :: + forall args . Fullfilled "batch_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO () +batch_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "one_hot(ndarray)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("indices", AttrOpt NDArrayHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(ndarray)" args => + ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle] +one_hot args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +one_hot_upd :: + forall args . Fullfilled "one_hot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO () +one_hot_upd outputs args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gather_nd(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle] +gather_nd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gather_nd_upd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO () +gather_nd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "scatter_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle] +scatter_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +scatter_nd_upd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO () +scatter_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_set_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle] +_scatter_set_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_set_nd_upd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO () +_scatter_set_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_equal_upd :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_equal(ndarray)" args -> IO () +broadcast_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_not_equal_upd :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO () +broadcast_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle] +broadcast_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_upd :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater(ndarray)" args -> IO () +broadcast_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + ArgsHMap "broadcast_greater_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_equal_upd :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO () +broadcast_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle] +broadcast_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_upd :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser(ndarray)" args -> IO () +broadcast_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_equal_upd :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO () +broadcast_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmax :: + forall args . Fullfilled "argmax(ndarray)" args => + ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle] +argmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_upd :: + forall args . Fullfilled "argmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO () +argmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmin(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmin :: + forall args . Fullfilled "argmin(ndarray)" args => + ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle] +argmin args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmin_upd :: + forall args . Fullfilled "argmin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO () +argmin_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax_channel(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle] +argmax_channel args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_channel_upd :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO () +argmax_channel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "pick(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("index", AttrOpt NDArrayHandle)] + +pick :: + forall args . Fullfilled "pick(ndarray)" args => + ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle] +pick args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +pick_upd :: + forall args . Fullfilled "pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO () +pick_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_pick(ndarray)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle] +_backward_pick args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_pick_upd :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO () +_backward_pick_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_retain(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle] +_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_retain_upd :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO () +_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sparse_retain(ndarray)" = + '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + ArgsHMap "_backward_sparse_retain(ndarray)" args -> + IO [NDArrayHandle] +_backward_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sparse_retain_upd :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO () +_backward_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_where(ndarray)" = + '[ '("condition", AttrOpt NDArrayHandle), + '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)] + +_where :: + forall args . Fullfilled "_where(ndarray)" args => + ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle] +_where args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_where_upd :: + forall args . Fullfilled "_where(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO () +_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_where(ndarray)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(ndarray)" args => + ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle] +_backward_where args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_where_upd :: + forall args . Fullfilled "_backward_where(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_where(ndarray)" args -> IO () +_backward_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle] +_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_scalar_upd :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_maximum_scalar(ndarray)" args -> IO () +_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_maximum_scalar :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_scalar_upd :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO () +_backward_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle] +_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_scalar_upd :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_minimum_scalar(ndarray)" args -> IO () +_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_minimum_scalar :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_scalar_upd :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO () +_backward_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle] +_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_scalar_upd :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO () +_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + ArgsHMap "_backward_power_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_scalar_upd :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power_scalar(ndarray)" args -> IO () +_backward_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle] +_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rpower_scalar_upd :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO () +_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rpower_scalar_upd :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO () +_backward_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle] +_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_scalar_upd :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO () +_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_scalar_upd :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO () +_backward_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "smooth_l1(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle] +smooth_l1 args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +smooth_l1_upd :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO () +smooth_l1_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_smooth_l1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle] +_backward_smooth_l1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_smooth_l1_upd :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO () +_backward_smooth_l1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "topk(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +topk :: + forall args . Fullfilled "topk(ndarray)" args => + ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle] +topk args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +topk_upd :: + forall args . Fullfilled "topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO () +topk_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_topk(ndarray)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle] +_backward_topk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_topk_upd :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO () +_backward_topk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +sort :: + forall args . Fullfilled "sort(ndarray)" args => + ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle] +sort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sort_upd :: + forall args . Fullfilled "sort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO () +sort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argsort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argsort :: + forall args . Fullfilled "argsort(ndarray)" args => + ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle] +argsort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argsort_upd :: + forall args . Fullfilled "argsort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO () +argsort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Reshape(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(ndarray)" args => + ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle] +_Reshape args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Reshape_upd :: + forall args . Fullfilled "_Reshape(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO () +_Reshape_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(ndarray)" args => + ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle] +_Flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Flatten_upd :: + forall args . Fullfilled "_Flatten(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO () +_Flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "transpose(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +transpose :: + forall args . Fullfilled "transpose(ndarray)" args => + ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle] +transpose args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +transpose_upd :: + forall args . Fullfilled "transpose(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO () +transpose_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expand_dims(ndarray)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(ndarray)" args => + ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle] +expand_dims args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expand_dims_upd :: + forall args . Fullfilled "expand_dims(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO () +expand_dims_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +slice :: + forall args . Fullfilled "slice(ndarray)" args => + ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle] +slice args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_upd :: + forall args . Fullfilled "slice(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO () +slice_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice(ndarray)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle] +_backward_slice args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_upd :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice(ndarray)" args -> IO () +_backward_slice_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle] +_slice_assign args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_upd :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO () +_slice_assign_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle] +_slice_assign_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_scalar_upd :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO () +_slice_assign_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_axis(ndarray)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(ndarray)" args => + ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle] +slice_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_axis_upd :: + forall args . Fullfilled "slice_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO () +slice_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_axis(ndarray)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_axis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_axis_upd :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO () +_backward_slice_axis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "clip(ndarray)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +clip :: + forall args . Fullfilled "clip(ndarray)" args => + ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle] +clip args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +clip_upd :: + forall args . Fullfilled "clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO () +clip_upd outputs args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_clip(ndarray)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle] +_backward_clip args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_clip_upd :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO () +_backward_clip_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "repeat(ndarray)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +repeat :: + forall args . Fullfilled "repeat(ndarray)" args => + ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle] +repeat args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +repeat_upd :: + forall args . Fullfilled "repeat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO () +repeat_upd outputs args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_repeat(ndarray)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle] +_backward_repeat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_repeat_upd :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_repeat(ndarray)" args -> IO () +_backward_repeat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tile(ndarray)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +tile :: + forall args . Fullfilled "tile(ndarray)" args => + ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle] +tile args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tile_upd :: + forall args . Fullfilled "tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO () +tile_upd outputs args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tile(ndarray)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle] +_backward_tile args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tile_upd :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO () +_backward_tile_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reverse(ndarray)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +reverse :: + forall args . Fullfilled "reverse(ndarray)" args => + ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle] +reverse args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reverse_upd :: + forall args . Fullfilled "reverse(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO () +reverse_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reverse(ndarray)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle] +_backward_reverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reverse_upd :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reverse(ndarray)" args -> IO () +_backward_reverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "stack(ndarray)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [NDArrayHandle])] + +stack :: + forall args . Fullfilled "stack(ndarray)" args => + ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle] +stack args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +stack_upd :: + forall args . Fullfilled "stack(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO () +stack_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_stack(ndarray)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle] +_backward_stack args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_stack_upd :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_stack(ndarray)" args -> IO () +_backward_stack_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +dot :: + forall args . Fullfilled "dot(ndarray)" args => + ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle] +dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +dot_upd :: + forall args . Fullfilled "dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO () +dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool)] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_dot_upd :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO () +_backward_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(ndarray)" args => + ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle] +batch_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_dot_upd :: + forall args . Fullfilled "batch_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO () +batch_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_batch_dot(ndarray)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_batch_dot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_batch_dot_upd :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO () +_backward_batch_dot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sin :: + forall args . Fullfilled "sin(ndarray)" args => + ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle] +sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sin_upd :: + forall args . Fullfilled "sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO () +sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle] +_backward_sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sin_upd :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO () +_backward_sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cos :: + forall args . Fullfilled "cos(ndarray)" args => + ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle] +cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cos_upd :: + forall args . Fullfilled "cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO () +cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle] +_backward_cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cos_upd :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO () +_backward_cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tan :: + forall args . Fullfilled "tan(ndarray)" args => + ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle] +tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tan_upd :: + forall args . Fullfilled "tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO () +tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle] +_backward_tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tan_upd :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO () +_backward_tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(ndarray)" args => + ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle] +arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsin_upd :: + forall args . Fullfilled "arcsin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO () +arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsin_upd :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsin(ndarray)" args -> IO () +_backward_arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccos :: + forall args . Fullfilled "arccos(ndarray)" args => + ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle] +arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccos_upd :: + forall args . Fullfilled "arccos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO () +arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle] +_backward_arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccos_upd :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccos(ndarray)" args -> IO () +_backward_arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctan :: + forall args . Fullfilled "arctan(ndarray)" args => + ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle] +arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctan_upd :: + forall args . Fullfilled "arctan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO () +arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle] +_backward_arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctan_upd :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctan(ndarray)" args -> IO () +_backward_arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "degrees(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +degrees :: + forall args . Fullfilled "degrees(ndarray)" args => + ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle] +degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +degrees_upd :: + forall args . Fullfilled "degrees(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO () +degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_degrees(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle] +_backward_degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_degrees_upd :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_degrees(ndarray)" args -> IO () +_backward_degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "radians(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +radians :: + forall args . Fullfilled "radians(ndarray)" args => + ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle] +radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +radians_upd :: + forall args . Fullfilled "radians(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO () +radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_radians(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle] +_backward_radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_radians_upd :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_radians(ndarray)" args -> IO () +_backward_radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sinh :: + forall args . Fullfilled "sinh(ndarray)" args => + ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle] +sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sinh_upd :: + forall args . Fullfilled "sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO () +sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle] +_backward_sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sinh_upd :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO () +_backward_sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cosh :: + forall args . Fullfilled "cosh(ndarray)" args => + ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle] +cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cosh_upd :: + forall args . Fullfilled "cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO () +cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle] +_backward_cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cosh_upd :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO () +_backward_cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tanh :: + forall args . Fullfilled "tanh(ndarray)" args => + ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle] +tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tanh_upd :: + forall args . Fullfilled "tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO () +tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle] +_backward_tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tanh_upd :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO () +_backward_tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(ndarray)" args => + ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle] +arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsinh_upd :: + forall args . Fullfilled "arcsinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO () +arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsinh_upd :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO () +_backward_arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(ndarray)" args => + ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle] +arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccosh_upd :: + forall args . Fullfilled "arccosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO () +arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle] +_backward_arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccosh_upd :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccosh(ndarray)" args -> IO () +_backward_arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(ndarray)" args => + ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle] +arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctanh_upd :: + forall args . Fullfilled "arctanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO () +arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle] +_backward_arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctanh_upd :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctanh(ndarray)" args -> IO () +_backward_arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_dequantize(ndarray)" = + '[ '("out_type", AttrReq (EnumType '["float32"])), + '("input", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_dequantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("input",) <$> (args !? #input :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_dequantize_upd :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO () +_contrib_dequantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("input",) <$> (args !? #input :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_CTCLoss(ndarray)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("data_lengths", AttrOpt NDArrayHandle), + '("label_lengths", AttrOpt NDArrayHandle)] + +_contrib_CTCLoss :: + forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args => + ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO [NDArrayHandle] +_contrib_CTCLoss args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_CTCLoss_upd :: + forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO () +_contrib_CTCLoss_upd outputs args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["uint8"])), + '("input", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_quantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["uint8"]))] + tensorArgs + = catMaybes + [("input",) <$> (args !? #input :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantize_upd :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantize(ndarray)" args -> IO () +_contrib_quantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["uint8"]))] + tensorArgs + = catMaybes + [("input",) <$> (args !? #input :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Custom(ndarray)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle] +_backward_Custom args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Custom_upd :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Custom(ndarray)" args -> IO () +_backward_Custom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_multinomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", AttrOpt (EnumType '["int32"])), + '("data", AttrOpt NDArrayHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle] +_sample_multinomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["int32"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_multinomial_upd :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_multinomial(ndarray)" args -> IO () +_sample_multinomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["int32"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sample_multinomial(ndarray)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> + IO [NDArrayHandle] +_backward_sample_multinomial args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sample_multinomial_upd :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO () +_backward_sample_multinomial_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_uniform(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle] +_sample_uniform args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_uniform_upd :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_uniform(ndarray)" args -> IO () +_sample_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_normal(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle] +_sample_normal args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_normal_upd :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO () +_sample_normal_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_gamma(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle] +_sample_gamma args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_gamma_upd :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO () +_sample_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_exponential(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle] +_sample_exponential args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_exponential_upd :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_exponential(ndarray)" args -> IO () +_sample_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_poisson(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle] +_sample_poisson args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_poisson_upd :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_poisson(ndarray)" args -> IO () +_sample_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + ArgsHMap "_sample_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_sample_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_negative_binomial_upd :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO () +_sample_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_sample_generalized_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_sample_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_sample_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_sample_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_sample_generalized_negative_binomial(ndarray)" + args + -> IO () +_sample_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_uniform(ndarray)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle] +_random_uniform args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_uniform_upd :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_uniform(ndarray)" args -> IO () +_random_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_normal(ndarray)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(ndarray)" args => + ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle] +_random_normal args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_normal_upd :: + forall args . Fullfilled "_random_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO () +_random_normal_upd outputs args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_gamma(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle] +_random_gamma args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_gamma_upd :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO () +_random_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_exponential(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle] +_random_exponential args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_exponential_upd :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_exponential(ndarray)" args -> IO () +_random_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_poisson(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle] +_random_poisson args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_poisson_upd :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_poisson(ndarray)" args -> IO () +_random_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_negative_binomial(ndarray)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + ArgsHMap "_random_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_random_negative_binomial args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_negative_binomial_upd :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_negative_binomial(ndarray)" args -> IO () +_random_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_generalized_negative_binomial(ndarray)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_random_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_random_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_random_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_random_generalized_negative_binomial(ndarray)" + args + -> IO () +_random_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax(ndarray)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +softmax :: + forall args . Fullfilled "softmax(ndarray)" args => + ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle] +softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_upd :: + forall args . Fullfilled "softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO () +softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softmax(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_softmax args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_upd :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax(ndarray)" args -> IO () +_backward_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log_softmax(ndarray)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(ndarray)" args => + ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle] +log_softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_softmax_upd :: + forall args . Fullfilled "log_softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO () +log_softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log_softmax(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + ArgsHMap "_backward_log_softmax(ndarray)" args -> + IO [NDArrayHandle] +_backward_log_softmax args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_softmax_upd :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log_softmax(ndarray)" args -> IO () +_backward_log_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimdecode(ndarray)" = + '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool), + '("buf", AttrOpt NDArrayHandle)] + +_cvimdecode :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle] +_cvimdecode args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimdecode_upd :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO () +_cvimdecode_upd outputs args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimread(ndarray)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(ndarray)" args => + ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle] +_cvimread args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimread_upd :: + forall args . Fullfilled "_cvimread(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO () +_cvimread_upd outputs args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimresize(ndarray)" = + '[ '("w", AttrReq Int), '("h", AttrReq Int), + '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)] + +_cvimresize :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle] +_cvimresize args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimresize_upd :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO () +_cvimresize_upd outputs args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvcopyMakeBorder(ndarray)" = + '[ '("top", AttrReq Int), '("bot", AttrReq Int), + '("left", AttrReq Int), '("right", AttrReq Int), + '("type", AttrOpt Int), '("value", AttrOpt Double), + '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)] + +_cvcopyMakeBorder :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle] +_cvcopyMakeBorder args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvcopyMakeBorder_upd :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO () +_cvcopyMakeBorder_upd outputs args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_NoGradient(ndarray)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle] +_NoGradient args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_NoGradient_upd :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO () +_NoGradient_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CachedOp(ndarray)" = '[] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CachedOp_upd :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO () +_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CachedOp(ndarray)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_backward_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CachedOp_upd :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO () +_backward_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copyto(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copyto :: + forall args . Fullfilled "_copyto(ndarray)" args => + ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle] +_copyto args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copyto_upd :: + forall args . Fullfilled "_copyto(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO () +_copyto_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SwapAxis(ndarray)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_SwapAxis args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SwapAxis_upd :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO () +_SwapAxis_upd outputs args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pad(ndarray)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt NDArrayHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(ndarray)" args => + ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle] +_Pad args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pad_upd :: + forall args . Fullfilled "_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO () +_Pad_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm_v1(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm_v1 args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_v1_upd :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO () +_BatchNorm_v1_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(ndarray)" args => + ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle] +sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_update_upd :: + forall args . Fullfilled "sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO () +sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_mom_update_upd :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO () +sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_update_upd :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO () +mp_sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_mom_update_upd :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO () +mp_sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "adam_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle), + '("var", AttrOpt NDArrayHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(ndarray)" args => + ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle] +adam_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +adam_update_upd :: + forall args . Fullfilled "adam_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO () +adam_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmsprop_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle] +rmsprop_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmsprop_update_upd :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO () +rmsprop_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmspropalex_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle), + '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle] +rmspropalex_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmspropalex_update_upd :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "rmspropalex_update(ndarray)" args -> IO () +rmspropalex_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftrl_update(ndarray)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle), + '("n", AttrOpt NDArrayHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle] +ftrl_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftrl_update_upd :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO () +ftrl_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LeakyReLU(ndarray)" = + '[ '("act_type", + AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_LeakyReLU args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LeakyReLU_upd :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO () +_LeakyReLU_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> + IO [NDArrayHandle] +_IdentityAttachKLSparseReg args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO () +_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_UpSampling(ndarray)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_UpSampling args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_UpSampling_upd :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO () +_UpSampling_upd outputs args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_SliceChannel(ndarray)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle] +_SliceChannel args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SliceChannel_upd :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO () +_SliceChannel_upd outputs args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CuDNNBatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_CuDNNBatchNorm :: + forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args => + ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle] +_CuDNNBatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CuDNNBatchNorm_upd :: + forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO () +_CuDNNBatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax_cross_entropy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + ArgsHMap "softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_cross_entropy_upd :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO () +softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +_backward_softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_cross_entropy_upd :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO () +_backward_softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(ndarray)" args => + ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle] +_Concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Concat_upd :: + forall args . Fullfilled "_Concat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO () +_Concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_BatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_upd :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO () +_BatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CustomFunction(ndarray)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle] +_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CustomFunction_upd :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CustomFunction(ndarray)" args -> IO () +_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CustomFunction(ndarray)" = + '[] + +_backward_CustomFunction :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + ArgsHMap "_backward_CustomFunction(ndarray)" args -> + IO [NDArrayHandle] +_backward_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CustomFunction_upd :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO () +_backward_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), + '("anchor", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("cls_pred", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxTarget args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxTarget_upd :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO () +_contrib_MultiBoxTarget_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxTarget args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxTarget_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args + -> IO () +_backward__contrib_MultiBoxTarget_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_Proposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle] +_contrib_Proposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_Proposal_upd :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO () +_contrib_Proposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_Proposal(ndarray)" + = '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_Proposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_Proposal_upd :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO () +_backward__contrib_Proposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_count_sketch(ndarray)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle), + '("s", AttrOpt NDArrayHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + ArgsHMap "_contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_contrib_count_sketch args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_count_sketch_upd :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO () +_contrib_count_sketch_upd outputs args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_count_sketch(ndarray)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_count_sketch args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_count_sketch_upd :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO () +_backward__contrib_count_sketch_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle), + '("loc_pred", AttrOpt NDArrayHandle), + '("anchor", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxDetection args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO () +_contrib_MultiBoxDetection_upd outputs args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)" + args => + ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args + -> IO [NDArrayHandle] +_backward__contrib_MultiBoxDetection args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled + "_backward__contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_MultiBoxDetection(ndarray)" + args + -> IO () +_backward__contrib_MultiBoxDetection_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_PSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_PSROIPooling_upd :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO () +_backward__contrib_PSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)" + = '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformablePSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformablePSROIPooling_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO () +_backward__contrib_DeformablePSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_CTCLoss(ndarray)" = + '[] + +_backward__contrib_CTCLoss :: + forall args . + Fullfilled "_backward__contrib_CTCLoss(ndarray)" args => + ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_CTCLoss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_CTCLoss_upd :: + forall args . + Fullfilled "_backward__contrib_CTCLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> IO () +_backward__contrib_CTCLoss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiProposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiProposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiProposal_upd :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO () +_contrib_MultiProposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" args => + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiProposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiProposal_upd :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args + -> IO () +_backward__contrib_MultiProposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxPrior args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxPrior_upd :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO () +_contrib_MultiBoxPrior_upd outputs args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxPrior args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxPrior_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args + -> IO () +_backward__contrib_MultiBoxPrior_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_fft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle] +_contrib_fft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_fft_upd :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO () +_contrib_fft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_fft(ndarray)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + ArgsHMap "_backward__contrib_fft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_fft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_fft_upd :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO () +_backward__contrib_fft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_DeformableConvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt NDArrayHandle), + '("offset", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO [NDArrayHandle] +_contrib_DeformableConvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_DeformableConvolution_upd :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO () +_contrib_DeformableConvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformableConvolution(ndarray)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformableConvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformableConvolution_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO () +_backward__contrib_DeformableConvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_ifft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle] +_contrib_ifft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ifft_upd :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO () +_contrib_ifft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_ifft(ndarray)" = + '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_ifft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_ifft_upd :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO () +_backward__contrib_ifft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__Native(ndarray)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle] +_backward__Native args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__Native_upd :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__Native(ndarray)" args -> IO () +_backward__Native_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__NDArray(ndarray)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle] +_backward__NDArray args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__NDArray_upd :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__NDArray(ndarray)" args -> IO () +_backward__NDArray_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_InstanceNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle] +_InstanceNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_InstanceNorm_upd :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO () +_InstanceNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_InstanceNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_InstanceNorm_upd :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO () +_backward_InstanceNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SVMOutput(ndarray)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_SVMOutput args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SVMOutput_upd :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO () +_SVMOutput_upd outputs args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SVMOutput(ndarray)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_backward_SVMOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SVMOutput_upd :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO () +_backward_SVMOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling(ndarray)" = + '[ '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("kernel", AttrReq [Int]), + '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(ndarray)" args => + ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle] +_Pooling args + = let scalarArgs + = catMaybes + [("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_upd :: + forall args . Fullfilled "_Pooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO () +_Pooling_upd outputs args + = let scalarArgs + = catMaybes + [("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling(ndarray)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_upd :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling(ndarray)" args -> IO () +_backward_Pooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution_v1(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle] +_Convolution_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_v1_upd :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_Convolution_v1(ndarray)" args -> IO () +_Convolution_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution_v1(ndarray)" = + '[] + +_backward_Convolution_v1 :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_v1_upd :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO () +_backward_Convolution_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Crop(ndarray)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [NDArrayHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(ndarray)" args => + ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle] +_Crop args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Crop_upd :: + forall args . Fullfilled "_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO () +_Crop_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Crop(ndarray)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle] +_backward_Crop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Crop_upd :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO () +_backward_Crop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SpatialTransformer(ndarray)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle] +_SpatialTransformer args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SpatialTransformer_upd :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO () +_SpatialTransformer_upd outputs args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SpatialTransformer(ndarray)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> + IO [NDArrayHandle] +_backward_SpatialTransformer args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SpatialTransformer_upd :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO () +_backward_SpatialTransformer_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SwapAxis(ndarray)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_backward_SwapAxis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SwapAxis_upd :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO () +_backward_SwapAxis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LinearRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LinearRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LinearRegressionOutput_upd :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO () +_LinearRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_LinearRegressionOutput(ndarray)" = '[] + +_backward_LinearRegressionOutput :: + forall args . + Fullfilled "_backward_LinearRegressionOutput(ndarray)" args => + ArgsHMap "_backward_LinearRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_LinearRegressionOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LinearRegressionOutput_upd :: + forall args . + Fullfilled "_backward_LinearRegressionOutput(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_LinearRegressionOutput(ndarray)" args + -> IO () +_backward_LinearRegressionOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MAERegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle] +_MAERegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MAERegressionOutput_upd :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO () +_MAERegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_MAERegressionOutput(ndarray)" = '[] + +_backward_MAERegressionOutput :: + forall args . + Fullfilled "_backward_MAERegressionOutput(ndarray)" args => + ArgsHMap "_backward_MAERegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_MAERegressionOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_MAERegressionOutput_upd :: + forall args . + Fullfilled "_backward_MAERegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_MAERegressionOutput(ndarray)" args -> + IO () +_backward_MAERegressionOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LogisticRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LogisticRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LogisticRegressionOutput_upd :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO () +_LogisticRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_LogisticRegressionOutput(ndarray)" = '[] + +_backward_LogisticRegressionOutput :: + forall args . + Fullfilled "_backward_LogisticRegressionOutput(ndarray)" + args => + ArgsHMap "_backward_LogisticRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_LogisticRegressionOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LogisticRegressionOutput_upd :: + forall args . + Fullfilled "_backward_LogisticRegressionOutput(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_LogisticRegressionOutput(ndarray)" + args + -> IO () +_backward_LogisticRegressionOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pad(ndarray)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle] +_backward_Pad args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pad_upd :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO () +_backward_Pad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SoftmaxOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxOutput_upd :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO () +_SoftmaxOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxOutput(ndarray)" = + '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxOutput_upd :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO () +_backward_SoftmaxOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Softmax(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_Softmax :: + forall args . Fullfilled "_Softmax(ndarray)" args => + ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle] +_Softmax args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Softmax_upd :: + forall args . Fullfilled "_Softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO () +_Softmax_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Softmax(ndarray)" = '[] + +_backward_Softmax :: + forall args . Fullfilled "_backward_Softmax(ndarray)" args => + ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_Softmax args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Softmax_upd :: + forall args . Fullfilled "_backward_Softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Softmax(ndarray)" args -> IO () +_backward_Softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceReverse(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle] +_SequenceReverse args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceReverse_upd :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SequenceReverse(ndarray)" args -> IO () +_SequenceReverse_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceReverse(ndarray)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceReverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceReverse_upd :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO () +_backward_SequenceReverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_BatchNorm_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_v1_upd :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO () +_backward_BatchNorm_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceLast(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle] +_SequenceLast args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceLast_upd :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO () +_SequenceLast_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceLast(ndarray)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + ArgsHMap "_backward_SequenceLast(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceLast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceLast_upd :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO () +_backward_SequenceLast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Correlation(ndarray)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle), + '("data2", AttrOpt NDArrayHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(ndarray)" args => + ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle] +_Correlation args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Correlation_upd :: + forall args . Fullfilled "_Correlation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO () +_Correlation_upd outputs args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Correlation(ndarray)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + ArgsHMap "_backward_Correlation(ndarray)" args -> + IO [NDArrayHandle] +_backward_Correlation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Correlation_upd :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Correlation(ndarray)" args -> IO () +_backward_Correlation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MakeLoss(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt NDArrayHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_MakeLoss args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MakeLoss_upd :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO () +_MakeLoss_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_MakeLoss(ndarray)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_backward_MakeLoss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_MakeLoss_upd :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO () +_backward_MakeLoss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LRN(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(ndarray)" args => + ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle] +_LRN args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LRN_upd :: + forall args . Fullfilled "_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO () +_LRN_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LRN(ndarray)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle] +_backward_LRN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LRN_upd :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO () +_backward_LRN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceMask(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle] +_SequenceMask args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceMask_upd :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO () +_SequenceMask_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceMask(ndarray)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + ArgsHMap "_backward_SequenceMask(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceMask args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceMask_upd :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO () +_backward_SequenceMask_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_GridGenerator(ndarray)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle] +_GridGenerator args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_GridGenerator_upd :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO () +_GridGenerator_upd outputs args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_GridGenerator(ndarray)" = + '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + ArgsHMap "_backward_GridGenerator(ndarray)" args -> + IO [NDArrayHandle] +_backward_GridGenerator args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_GridGenerator_upd :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO () +_backward_GridGenerator_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling_v1(ndarray)" = + '[ '("global_pool", AttrOpt Bool), '("kernel", AttrReq [Int]), + '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_Pooling_v1 args + = let scalarArgs + = catMaybes + [("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_v1_upd :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO () +_Pooling_v1_upd outputs args + = let scalarArgs + = catMaybes + [("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_v1_upd :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO () +_backward_Pooling_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_backward_LeakyReLU args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LeakyReLU_upd :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO () +_backward_LeakyReLU_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args + -> IO [NDArrayHandle] +_backward_IdentityAttachKLSparseReg args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" + args + -> IO () +_backward_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Activation(ndarray)" = + '[ '("act_type", + AttrReq (EnumType '["relu", "sigmoid", "softrelu", "tanh"])), + '("data", AttrOpt NDArrayHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(ndarray)" args => + ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle] +_Activation args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Activation_upd :: + forall args . Fullfilled "_Activation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO () +_Activation_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Activation(ndarray)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle] +_backward_Activation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Activation_upd :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Activation(ndarray)" args -> IO () +_backward_Activation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_UpSampling(ndarray)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_backward_UpSampling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_UpSampling_upd :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO () +_backward_UpSampling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Deconvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle] +_Deconvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Deconvolution_upd :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO () +_Deconvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Deconvolution(ndarray)" = + '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + ArgsHMap "_backward_Deconvolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Deconvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Deconvolution_upd :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO () +_backward_Deconvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BilinearSampler(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("grid", AttrOpt NDArrayHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle] +_BilinearSampler args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BilinearSampler_upd :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_BilinearSampler(ndarray)" args -> IO () +_BilinearSampler_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BilinearSampler(ndarray)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> + IO [NDArrayHandle] +_backward_BilinearSampler args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BilinearSampler_upd :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO () +_backward_BilinearSampler_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ROIPooling(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_ROIPooling args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ROIPooling_upd :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO () +_ROIPooling_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIPooling(ndarray)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIPooling_upd :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO () +_backward_ROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SliceChannel(ndarray)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + ArgsHMap "_backward_SliceChannel(ndarray)" args -> + IO [NDArrayHandle] +_backward_SliceChannel args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SliceChannel_upd :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO () +_backward_SliceChannel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" = + '[] + +_backward_CuDNNBatchNorm :: + forall args . + Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args => + ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_CuDNNBatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CuDNNBatchNorm_upd :: + forall args . + Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO () +_backward_CuDNNBatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_FullyConnected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle] +_FullyConnected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_FullyConnected_upd :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_FullyConnected(ndarray)" args -> IO () +_FullyConnected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_FullyConnected(ndarray)" = + '[] + +_backward_FullyConnected :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + ArgsHMap "_backward_FullyConnected(ndarray)" args -> + IO [NDArrayHandle] +_backward_FullyConnected args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_FullyConnected_upd :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO () +_backward_FullyConnected_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(ndarray)" args => + ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle] +_Convolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_upd :: + forall args . Fullfilled "_Convolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO () +_Convolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution(ndarray)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + ArgsHMap "_backward_Convolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_upd :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution(ndarray)" args -> IO () +_backward_Convolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_L2Normalization(ndarray)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt NDArrayHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle] +_L2Normalization args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_L2Normalization_upd :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_L2Normalization(ndarray)" args -> IO () +_L2Normalization_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_L2Normalization(ndarray)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + ArgsHMap "_backward_L2Normalization(ndarray)" args -> + IO [NDArrayHandle] +_backward_L2Normalization args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_L2Normalization_upd :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO () +_backward_L2Normalization_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Concat(ndarray)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle] +_backward_Concat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Concat_upd :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Concat(ndarray)" args -> IO () +_backward_Concat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_RNN(ndarray)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("parameters", AttrOpt NDArrayHandle), + '("state", AttrOpt NDArrayHandle), + '("state_cell", AttrOpt NDArrayHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(ndarray)" args => + ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle] +_RNN args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_RNN_upd :: + forall args . Fullfilled "_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO () +_RNN_upd outputs args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_RNN(ndarray)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle] +_backward_RNN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_RNN_upd :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO () +_backward_RNN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm(ndarray)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_BatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_upd :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO () +_backward_BatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Dropout(ndarray)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("data", AttrOpt NDArrayHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(ndarray)" args => + ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle] +_Dropout args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Dropout_upd :: + forall args . Fullfilled "_Dropout(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO () +_Dropout_upd outputs args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Dropout(ndarray)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle] +_backward_Dropout args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Dropout_upd :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Dropout(ndarray)" args -> IO () +_backward_Dropout_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle] +_CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CrossDeviceCopy_upd :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO () +_CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> + IO [NDArrayHandle] +_backward__CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__CrossDeviceCopy_upd :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO () +_backward__CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SoftmaxActivation(ndarray)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt NDArrayHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxActivation args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxActivation_upd :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO () +_SoftmaxActivation_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxActivation(ndarray)" + = '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxActivation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxActivation_upd :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO () +_backward_SoftmaxActivation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_set_value(ndarray)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(ndarray)" args => + ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle] +_set_value args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_set_value_upd :: + forall args . Fullfilled "_set_value(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO () +_set_value_upd outputs args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_onehot_encode(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_onehot_encode :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle] +_onehot_encode args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_onehot_encode_upd :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO () +_onehot_encode_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "choose_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +choose_element_0index :: + forall args . Fullfilled "choose_element_0index(ndarray)" args => + ArgsHMap "choose_element_0index(ndarray)" args -> + IO [NDArrayHandle] +choose_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "choose_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +choose_element_0index_upd :: + forall args . Fullfilled "choose_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "choose_element_0index(ndarray)" args -> IO () +choose_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "choose_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fill_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +fill_element_0index :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle] +fill_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fill_element_0index_upd :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "fill_element_0index(ndarray)" args -> IO () +fill_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_imdecode(ndarray)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt NDArrayHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(ndarray)" args => + ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle] +_imdecode args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_imdecode_upd :: + forall args . Fullfilled "_imdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO () +_imdecode_upd outputs args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () diff --git a/ops/1.0/MXNet/Base/Operators/Symbol.hs b/ops/1.0/MXNet/Base/Operators/Symbol.hs new file mode 100644 --- /dev/null +++ b/ops/1.0/MXNet/Base/Operators/Symbol.hs @@ -0,0 +1,9339 @@ +module MXNet.Base.Operators.Symbol where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "broadcast_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(symbol)" args => + String -> + ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle +broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_power(symbol)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_power(symbol)" args -> + IO SymbolHandle +_backward_broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(symbol)" args => + String -> + ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle +broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_maximum(symbol)" = + '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_maximum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(symbol)" args => + String -> + ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle +broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_minimum(symbol)" = + '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_minimum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(symbol)" args => + String -> + ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle +broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_hypot(symbol)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_hypot(symbol)" args -> + IO SymbolHandle +_backward_broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_equal :: + forall args . Fullfilled "_equal(symbol)" args => + String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle +_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(symbol)" args => + String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle +_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater :: + forall args . Fullfilled "_greater(symbol)" args => + String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle +_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(symbol)" args => + String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle +_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(symbol)" args => + String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle +_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(symbol)" args => + String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle +_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_power :: + forall args . Fullfilled "_power(symbol)" args => + String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle +_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power(symbol)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(symbol)" args => + String -> + ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle +_backward_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(symbol)" args => + String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle +_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum(symbol)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(symbol)" args => + String -> + ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle +_backward_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(symbol)" args => + String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle +_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum(symbol)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(symbol)" args => + String -> + ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle +_backward_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(symbol)" args => + String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle +_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot(symbol)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(symbol)" args => + String -> + ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle +_backward_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_square_sum(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(symbol)" args => + String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle +_square_sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square_sum(symbol)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(symbol)" args => + String -> + ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle +_backward_square_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "add_n(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +add_n :: + forall args . Fullfilled "add_n(symbol)" args => + String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle +add_n name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "add_n" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_zeros(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(symbol)" args => + String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle +_zeros name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ones(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(symbol)" args => + String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle +_ones name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_full(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(symbol)" args => + String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle +_full name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_arange(symbol)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(symbol)" args => + String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle +_arange name args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "zeros_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(symbol)" args => + String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle +zeros_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ones_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(symbol)" args => + String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle +ones_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(symbol)" args => + String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle +broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_add(symbol)" = '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle +_backward_broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(symbol)" args => + String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle +broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_sub(symbol)" = '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle +_backward_broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(symbol)" args => + String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle +broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mul(symbol)" = '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle +_backward_broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(symbol)" args => + String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle +broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_div(symbol)" = '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle +_backward_broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(symbol)" args => + String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle +broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mod(symbol)" = '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle +_backward_broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle), + '("_C", AttrOpt SymbolHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(symbol)" args => + String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle +_linalg_gemm name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle), + ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm(symbol)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm2(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(symbol)" args => + String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle +_linalg_gemm2 name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potrf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(symbol)" args => + String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle +_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potrf(symbol)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle +_backward_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potri(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(symbol)" args => + String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle +_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potri(symbol)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle +_backward_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trmm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(symbol)" args => + String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle +_linalg_trmm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trmm(symbol)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle +_backward_linalg_trmm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trsm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(symbol)" args => + String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle +_linalg_trsm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trsm(symbol)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle +_backward_linalg_trsm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_sumlogdiag(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle +_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" = + '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args -> + IO SymbolHandle +_backward_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syrk(symbol)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(symbol)" args => + String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle +_linalg_syrk name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syrk(symbol)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle +_backward_linalg_syrk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gelqf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(symbol)" args => + String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle +_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle +_backward_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syevd(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(symbol)" args => + String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle +_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syevd(symbol)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle +_backward_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cast_storage(symbol)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt SymbolHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(symbol)" args => + String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle +cast_storage name args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(symbol)" args => + String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle +_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(symbol)" args => + String -> + ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle +_not_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(symbol)" args => + String -> + ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle +_greater_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(symbol)" args => + String -> + ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle +_greater_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(symbol)" args => + String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle +_lesser_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(symbol)" args => + String -> + ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle +_lesser_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "relu(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +relu :: + forall args . Fullfilled "relu(symbol)" args => + String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle +relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_relu(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(symbol)" args => + String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle +_backward_relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sigmoid(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(symbol)" args => + String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle +sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sigmoid(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle +_backward_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_copy(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_copy :: + forall args . Fullfilled "_copy(symbol)" args => + String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle +_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_copy(symbol)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(symbol)" args => + String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle +_backward_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BlockGrad(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(symbol)" args => + String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle +_BlockGrad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "make_loss(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(symbol)" args => + String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle +make_loss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_identity_with_attr_like_rhs(symbol)" + = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(symbol)" args => + String -> + ArgsHMap "_identity_with_attr_like_rhs(symbol)" args -> + IO SymbolHandle +_identity_with_attr_like_rhs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reshape_like(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(symbol)" args => + String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle +reshape_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Cast(symbol)" = + '[ '("dtype", + AttrReq + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(symbol)" args => + String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle +_Cast name args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cast(symbol)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(symbol)" args => + String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle +_backward_cast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "negative(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +negative :: + forall args . Fullfilled "negative(symbol)" args => + String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle +negative name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reciprocal(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(symbol)" args => + String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle +reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reciprocal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(symbol)" args => + String -> + ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle +_backward_reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "abs(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +abs :: + forall args . Fullfilled "abs(symbol)" args => + String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle +abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_abs(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(symbol)" args => + String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle +_backward_abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sign :: + forall args . Fullfilled "sign(symbol)" args => + String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle +sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(symbol)" args => + String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle +_backward_sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "round(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +round :: + forall args . Fullfilled "round(symbol)" args => + String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle +round name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rint(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rint :: + forall args . Fullfilled "rint(symbol)" args => + String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle +rint name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ceil(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ceil :: + forall args . Fullfilled "ceil(symbol)" args => + String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle +ceil name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "floor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +floor :: + forall args . Fullfilled "floor(symbol)" args => + String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle +floor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "trunc(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +trunc :: + forall args . Fullfilled "trunc(symbol)" args => + String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle +trunc name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "fix(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +fix :: + forall args . Fullfilled "fix(symbol)" args => + String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle +fix name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "square(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +square :: + forall args . Fullfilled "square(symbol)" args => + String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle +square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(symbol)" args => + String -> + ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle +_backward_square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(symbol)" args => + String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle +sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(symbol)" args => + String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle +_backward_sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rsqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(symbol)" args => + String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle +rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rsqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(symbol)" args => + String -> + ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle +_backward_rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(symbol)" args => + String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle +cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(symbol)" args => + String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle +_backward_cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rcbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(symbol)" args => + String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle +rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rcbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(symbol)" args => + String -> + ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle +_backward_rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "exp(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +exp :: + forall args . Fullfilled "exp(symbol)" args => + String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle +exp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log :: + forall args . Fullfilled "log(symbol)" args => + String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle +log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log10(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log10 :: + forall args . Fullfilled "log10(symbol)" args => + String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle +log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log2(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log2 :: + forall args . Fullfilled "log2(symbol)" args => + String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle +log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(symbol)" args => + String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle +_backward_log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log10(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(symbol)" args => + String -> + ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle +_backward_log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log2(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(symbol)" args => + String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle +_backward_log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log1p(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log1p :: + forall args . Fullfilled "log1p(symbol)" args => + String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle +log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log1p(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(symbol)" args => + String -> + ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle +_backward_log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expm1(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +expm1 :: + forall args . Fullfilled "expm1(symbol)" args => + String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle +expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_expm1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(symbol)" args => + String -> + ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle +_backward_expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gamma(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gamma :: + forall args . Fullfilled "gamma(symbol)" args => + String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle +gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gamma(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(symbol)" args => + String -> + ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle +_backward_gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gammaln(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(symbol)" args => + String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle +gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gammaln(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(symbol)" args => + String -> + ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle +_backward_gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sum(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +sum :: + forall args . Fullfilled "sum(symbol)" args => + String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle +sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sum(symbol)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(symbol)" args => + String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle +_backward_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mean(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +mean :: + forall args . Fullfilled "mean(symbol)" args => + String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle +mean name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mean(symbol)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(symbol)" args => + String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle +_backward_mean name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "prod(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +prod :: + forall args . Fullfilled "prod(symbol)" args => + String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle +prod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_prod(symbol)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(symbol)" args => + String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle +_backward_prod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nansum(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nansum :: + forall args . Fullfilled "nansum(symbol)" args => + String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle +nansum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nansum(symbol)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(symbol)" args => + String -> + ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle +_backward_nansum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nanprod(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(symbol)" args => + String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle +nanprod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nanprod(symbol)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(symbol)" args => + String -> + ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle +_backward_nanprod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "max(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +max :: + forall args . Fullfilled "max(symbol)" args => + String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle +max name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_max(symbol)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(symbol)" args => + String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle +_backward_max name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "min(symbol)" = + '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +min :: + forall args . Fullfilled "min(symbol)" args => + String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle +min name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_min(symbol)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(symbol)" args => + String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle +_backward_min name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_axis(symbol)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(symbol)" args => + String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle +broadcast_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_to(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(symbol)" args => + String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle +broadcast_to name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_broadcast_backward(symbol)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(symbol)" args => + String -> + ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle +_broadcast_backward name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "norm(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +norm :: + forall args . Fullfilled "norm(symbol)" args => + String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle +norm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(symbol)" args => + String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle +elemwise_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_grad_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(symbol)" args => + String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle +_grad_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_add(symbol)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(symbol)" args => + String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle +_backward_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(symbol)" args => + String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle +elemwise_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sub(symbol)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(symbol)" args => + String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle +_backward_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(symbol)" args => + String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle +elemwise_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul(symbol)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(symbol)" args => + String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle +_backward_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(symbol)" args => + String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle +elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div(symbol)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(symbol)" args => + String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle +_backward_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_mod :: + forall args . Fullfilled "_mod(symbol)" args => + String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle +_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod(symbol)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(symbol)" args => + String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle +_backward_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(symbol)" args => + String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle +_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(symbol)" args => + String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle +_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rminus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(symbol)" args => + String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle +_rminus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(symbol)" args => + String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle +_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle +_backward_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(symbol)" args => + String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle +_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(symbol)" args => + String -> + ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle +_backward_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(symbol)" args => + String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle +_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle +_backward_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(symbol)" args => + String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle +_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle +_backward_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(symbol)" args => + String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle +_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle +_backward_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(symbol)" args => + String -> + ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle +_scatter_elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle +_scatter_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle +_scatter_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Embedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(symbol)" args => + String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle +_Embedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SparseEmbedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle)] + +_contrib_SparseEmbedding :: + forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle +_contrib_SparseEmbedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Embedding(symbol)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(symbol)" args => + String -> + ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle +_backward_Embedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SparseEmbedding(symbol)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_backward_SparseEmbedding(symbol)" args -> + IO SymbolHandle +_backward_SparseEmbedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "take(symbol)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +take :: + forall args . Fullfilled "take(symbol)" args => + String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle +take name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_take(symbol)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(symbol)" args => + String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle +_backward_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_take(symbol)" = + '[ '("a", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(symbol)" args => + String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle +batch_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "one_hot(symbol)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("indices", AttrOpt SymbolHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(symbol)" args => + String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle +one_hot name args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gather_nd(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(symbol)" args => + String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle +gather_nd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "scatter_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(symbol)" args => + String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle +scatter_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_set_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(symbol)" args => + String -> + ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle +_scatter_set_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(symbol)" args => + String -> + ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle +broadcast_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(symbol)" args => + String -> + ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle +broadcast_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(symbol)" args => + String -> + ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle +broadcast_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(symbol)" args => + String -> + ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle +broadcast_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(symbol)" args => + String -> + ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle +broadcast_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(symbol)" args => + String -> + ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle +broadcast_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmax :: + forall args . Fullfilled "argmax(symbol)" args => + String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle +argmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmin(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmin :: + forall args . Fullfilled "argmin(symbol)" args => + String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle +argmin name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax_channel(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(symbol)" args => + String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle +argmax_channel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "pick(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)] + +pick :: + forall args . Fullfilled "pick(symbol)" args => + String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle +pick name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("index",) <$> (args !? #index :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_pick(symbol)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(symbol)" args => + String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle +_backward_pick name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_retain(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(symbol)" args => + String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle +_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sparse_retain(symbol)" = '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(symbol)" args => + String -> + ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle +_backward_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_where(symbol)" = + '[ '("condition", AttrOpt SymbolHandle), + '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)] + +_where :: + forall args . Fullfilled "_where(symbol)" args => + String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle +_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe SymbolHandle), + ("x",) <$> (args !? #x :: Maybe SymbolHandle), + ("y",) <$> (args !? #y :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_where(symbol)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(symbol)" args => + String -> + ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle +_backward_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle +_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_maximum_scalar :: + forall args . Fullfilled "_backward_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle +_backward_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle +_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_minimum_scalar :: + forall args . Fullfilled "_backward_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle +_backward_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(symbol)" args => + String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle +_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(symbol)" args => + String -> + ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle +_backward_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(symbol)" args => + String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle +_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle +_backward_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(symbol)" args => + String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle +_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(symbol)" args => + String -> + ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle +_backward_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "smooth_l1(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(symbol)" args => + String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle +smooth_l1 name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_smooth_l1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(symbol)" args => + String -> + ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle +_backward_smooth_l1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "topk(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +topk :: + forall args . Fullfilled "topk(symbol)" args => + String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle +topk name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_topk(symbol)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(symbol)" args => + String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle +_backward_topk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +sort :: + forall args . Fullfilled "sort(symbol)" args => + String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle +sort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argsort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argsort :: + forall args . Fullfilled "argsort(symbol)" args => + String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle +argsort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Reshape(symbol)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(symbol)" args => + String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle +_Reshape name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(symbol)" args => + String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle +_Flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "transpose(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +transpose :: + forall args . Fullfilled "transpose(symbol)" args => + String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle +transpose name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expand_dims(symbol)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(symbol)" args => + String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle +expand_dims name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +slice :: + forall args . Fullfilled "slice(symbol)" args => + String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle +slice name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice(symbol)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(symbol)" args => + String -> + ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle +_backward_slice name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(symbol)" args => + String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle +_slice_assign name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(symbol)" args => + String -> + ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle +_slice_assign_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_axis(symbol)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(symbol)" args => + String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle +slice_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_axis(symbol)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(symbol)" args => + String -> + ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle +_backward_slice_axis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "clip(symbol)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +clip :: + forall args . Fullfilled "clip(symbol)" args => + String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle +clip name args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_clip(symbol)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(symbol)" args => + String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle +_backward_clip name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "repeat(symbol)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt SymbolHandle)] + +repeat :: + forall args . Fullfilled "repeat(symbol)" args => + String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle +repeat name args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_repeat(symbol)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(symbol)" args => + String -> + ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle +_backward_repeat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tile(symbol)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +tile :: + forall args . Fullfilled "tile(symbol)" args => + String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle +tile name args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tile(symbol)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(symbol)" args => + String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle +_backward_tile name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reverse(symbol)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +reverse :: + forall args . Fullfilled "reverse(symbol)" args => + String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle +reverse name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reverse(symbol)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(symbol)" args => + String -> + ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle +_backward_reverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "stack(symbol)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [SymbolHandle])] + +stack :: + forall args . Fullfilled "stack(symbol)" args => + String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle +stack name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "stack" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_stack(symbol)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(symbol)" args => + String -> + ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle +_backward_stack name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +dot :: + forall args . Fullfilled "dot(symbol)" args => + String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle +dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool)] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(symbol)" args => + String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle +_backward_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(symbol)" args => + String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle +batch_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_batch_dot(symbol)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(symbol)" args => + String -> + ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle +_backward_batch_dot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sin :: + forall args . Fullfilled "sin(symbol)" args => + String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle +sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(symbol)" args => + String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle +_backward_sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cos :: + forall args . Fullfilled "cos(symbol)" args => + String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle +cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(symbol)" args => + String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle +_backward_cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tan :: + forall args . Fullfilled "tan(symbol)" args => + String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle +tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(symbol)" args => + String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle +_backward_tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(symbol)" args => + String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle +arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(symbol)" args => + String -> + ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle +_backward_arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccos :: + forall args . Fullfilled "arccos(symbol)" args => + String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle +arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(symbol)" args => + String -> + ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle +_backward_arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctan :: + forall args . Fullfilled "arctan(symbol)" args => + String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle +arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(symbol)" args => + String -> + ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle +_backward_arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "degrees(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +degrees :: + forall args . Fullfilled "degrees(symbol)" args => + String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle +degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_degrees(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(symbol)" args => + String -> + ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle +_backward_degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "radians(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +radians :: + forall args . Fullfilled "radians(symbol)" args => + String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle +radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_radians(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(symbol)" args => + String -> + ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle +_backward_radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sinh :: + forall args . Fullfilled "sinh(symbol)" args => + String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle +sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(symbol)" args => + String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle +_backward_sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cosh :: + forall args . Fullfilled "cosh(symbol)" args => + String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle +cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(symbol)" args => + String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle +_backward_cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tanh :: + forall args . Fullfilled "tanh(symbol)" args => + String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle +tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(symbol)" args => + String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle +_backward_tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(symbol)" args => + String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle +arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(symbol)" args => + String -> + ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle +_backward_arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(symbol)" args => + String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle +arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(symbol)" args => + String -> + ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle +_backward_arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(symbol)" args => + String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle +arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(symbol)" args => + String -> + ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle +_backward_arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_dequantize(symbol)" = + '[ '("out_type", AttrReq (EnumType '["float32"])), + '("input", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(symbol)" args => + String -> + ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle +_contrib_dequantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("input",) <$> (args !? #input :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_CTCLoss(symbol)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle), + '("data_lengths", AttrOpt SymbolHandle), + '("label_lengths", AttrOpt SymbolHandle)] + +_contrib_CTCLoss :: + forall args . Fullfilled "_contrib_CTCLoss(symbol)" args => + String -> + ArgsHMap "_contrib_CTCLoss(symbol)" args -> IO SymbolHandle +_contrib_CTCLoss name args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe SymbolHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_CTCLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["uint8"])), + '("input", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(symbol)" args => + String -> + ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle +_contrib_quantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("input",) <$> (args !? #input :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Custom(symbol)" = + '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])] + +_Custom :: + forall args . + (Fullfilled "_Custom(symbol)" args, + PopKey (ArgOf "_Custom(symbol)") args "data", + Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) => + String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle +_Custom name args + = let scalarArgs = dump (pop args #data) + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Custom(symbol)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(symbol)" args => + String -> + ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle +_backward_Custom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_multinomial(symbol)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", AttrOpt (EnumType '["int32"])), + '("data", AttrOpt SymbolHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle +_sample_multinomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["int32"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sample_multinomial(symbol)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_backward_sample_multinomial(symbol)" args -> + IO SymbolHandle +_backward_sample_multinomial name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_uniform(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(symbol)" args => + String -> + ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle +_sample_uniform name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe SymbolHandle), + ("high",) <$> (args !? #high :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_normal(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(symbol)" args => + String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle +_sample_normal name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_gamma(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(symbol)" args => + String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle +_sample_gamma name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_exponential(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(symbol)" args => + String -> + ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle +_sample_exponential name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_poisson(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(symbol)" args => + String -> + ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle +_sample_poisson name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(symbol)" args => + String -> + ArgsHMap "_sample_negative_binomial(symbol)" args -> + IO SymbolHandle +_sample_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe SymbolHandle), + ("p",) <$> (args !? #p :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_sample_generalized_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_sample_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_sample_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_uniform(symbol)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(symbol)" args => + String -> + ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle +_random_uniform name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_normal(symbol)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(symbol)" args => + String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle +_random_normal name args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_gamma(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(symbol)" args => + String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle +_random_gamma name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_exponential(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(symbol)" args => + String -> + ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle +_random_exponential name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_poisson(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(symbol)" args => + String -> + ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle +_random_poisson name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_negative_binomial(symbol)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(symbol)" args => + String -> + ArgsHMap "_random_negative_binomial(symbol)" args -> + IO SymbolHandle +_random_negative_binomial name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_generalized_negative_binomial(symbol)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_random_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_random_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax(symbol)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +softmax :: + forall args . Fullfilled "softmax(symbol)" args => + String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle +softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softmax(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(symbol)" args => + String -> + ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle +_backward_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log_softmax(symbol)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(symbol)" args => + String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle +log_softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log_softmax(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(symbol)" args => + String -> + ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle +_backward_log_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_cvimread(symbol)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(symbol)" args => + String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle +_cvimread name args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_NoGradient(symbol)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(symbol)" args => + String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle +_NoGradient name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CachedOp(symbol)" = '[] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(symbol)" args => + String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle +_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CachedOp(symbol)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(symbol)" args => + String -> + ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle +_backward_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SwapAxis(symbol)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt SymbolHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(symbol)" args => + String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle +_SwapAxis name args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pad(symbol)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt SymbolHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(symbol)" args => + String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle +_Pad name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm_v1(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(symbol)" args => + String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_BatchNorm_v1 name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(symbol)" args => + String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle +sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(symbol)" args => + String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle +sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(symbol)" args => + String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle +mp_sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(symbol)" args => + String -> + ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle +mp_sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "adam_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(symbol)" args => + String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle +adam_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mean",) <$> (args !? #mean :: Maybe SymbolHandle), + ("var",) <$> (args !? #var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmsprop_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(symbol)" args => + String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle +rmsprop_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmspropalex_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle), + '("delta", AttrOpt SymbolHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(symbol)" args => + String -> + ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle +rmspropalex_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle), + ("g",) <$> (args !? #g :: Maybe SymbolHandle), + ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftrl_update(symbol)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(symbol)" args => + String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle +ftrl_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LeakyReLU(symbol)" = + '[ '("act_type", + AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(symbol)" args => + String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle +_LeakyReLU name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(symbol)" args => + String -> + ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args -> + IO SymbolHandle +_IdentityAttachKLSparseReg name args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_UpSampling(symbol)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(symbol)" args => + String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle +_UpSampling name args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "UpSampling" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_SliceChannel(symbol)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(symbol)" args => + String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle +_SliceChannel name args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CuDNNBatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_CuDNNBatchNorm :: + forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args => + String -> + ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle +_CuDNNBatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax_cross_entropy(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle +softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_softmax_cross_entropy(symbol)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "_backward_softmax_cross_entropy(symbol)" args -> + IO SymbolHandle +_backward_softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(symbol)" args => + String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle +_Concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_BatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(symbol)" args => + String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle +_BatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CustomFunction(symbol)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(symbol)" args => + String -> + ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle +_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CustomFunction(symbol)" = + '[] + +_backward_CustomFunction :: + forall args . Fullfilled "_backward_CustomFunction(symbol)" args => + String -> + ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle +_backward_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxTarget(symbol)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle), + '("cls_pred", AttrOpt SymbolHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxTarget name args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxTarget name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_Proposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle +_contrib_Proposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_score",) <$> (args !? #cls_score :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_Proposal(symbol)" = + '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_Proposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_Proposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_count_sketch(symbol)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle), + '("s", AttrOpt SymbolHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle +_contrib_count_sketch name args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("h",) <$> (args !? #h :: Maybe SymbolHandle), + ("s",) <$> (args !? #s :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_count_sketch(symbol)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_backward__contrib_count_sketch(symbol)" args -> + IO SymbolHandle +_backward__contrib_count_sketch name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxDetection(symbol)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle), + '("loc_pred", AttrOpt SymbolHandle), + '("anchor", AttrOpt SymbolHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxDetection(symbol)" args -> + IO SymbolHandle +_contrib_MultiBoxDetection name args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle), + ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(symbol)" + args => + String -> + ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)" + args + -> IO SymbolHandle +_backward__contrib_MultiBoxDetection name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_PSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_PSROIPooling :: + forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle +_contrib_PSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args -> + IO SymbolHandle +_backward__contrib_PSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformablePSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("group_size", AttrReq Int), '("pooled_size", AttrReq Int), + '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int), + '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle), + '("trans", AttrOpt SymbolHandle)] + +_contrib_DeformablePSROIPooling :: + forall args . + Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args -> + IO SymbolHandle +_contrib_DeformablePSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int), + ("sample_per_part",) . showValue <$> + (args !? #sample_per_part :: Maybe Int), + ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float), + ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle), + ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" = + '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformablePSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_CTCLoss(symbol)" = + '[] + +_backward__contrib_CTCLoss :: + forall args . + Fullfilled "_backward__contrib_CTCLoss(symbol)" args => + String -> + ArgsHMap "_backward__contrib_CTCLoss(symbol)" args -> + IO SymbolHandle +_backward__contrib_CTCLoss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_CTCLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiProposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle +_contrib_MultiProposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_score",) <$> (args !? #cls_score :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiProposal(symbol)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiProposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiProposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxPrior(symbol)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxPrior name args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxPrior name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_fft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(symbol)" args => + String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle +_contrib_fft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_fft(symbol)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle +_backward__contrib_fft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformableConvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(symbol)" args => + String -> + ArgsHMap "_contrib_DeformableConvolution(symbol)" args -> + IO SymbolHandle +_contrib_DeformableConvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("offset",) <$> (args !? #offset :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformableConvolution(symbol)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformableConvolution(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformableConvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_ifft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(symbol)" args => + String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle +_contrib_ifft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_ifft(symbol)" = '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle +_backward__contrib_ifft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__Native(symbol)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(symbol)" args => + String -> + ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle +_backward__Native name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__NDArray(symbol)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(symbol)" args => + String -> + ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle +_backward__NDArray name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_InstanceNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(symbol)" args => + String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle +_InstanceNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_InstanceNorm(symbol)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(symbol)" args => + String -> + ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle +_backward_InstanceNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SVMOutput(symbol)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(symbol)" args => + String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle +_SVMOutput name args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SVMOutput(symbol)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(symbol)" args => + String -> + ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle +_backward_SVMOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling(symbol)" = + '[ '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("kernel", AttrReq [Int]), + '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(symbol)" args => + String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle +_Pooling name args + = let scalarArgs + = catMaybes + [("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling(symbol)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(symbol)" args => + String -> + ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle +_backward_Pooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution_v1(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle +_Convolution_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution_v1(symbol)" = + '[] + +_backward_Convolution_v1 :: + forall args . Fullfilled "_backward_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle +_backward_Convolution_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Crop(symbol)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [SymbolHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(symbol)" args => + String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle +_Crop name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Crop" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Crop(symbol)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(symbol)" args => + String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle +_backward_Crop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SpatialTransformer(symbol)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle +_SpatialTransformer name args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SpatialTransformer(symbol)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_backward_SpatialTransformer(symbol)" args -> + IO SymbolHandle +_backward_SpatialTransformer name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SwapAxis(symbol)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(symbol)" args => + String -> + ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle +_backward_SwapAxis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LinearRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle +_LinearRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_LinearRegressionOutput(symbol)" = '[] + +_backward_LinearRegressionOutput :: + forall args . + Fullfilled "_backward_LinearRegressionOutput(symbol)" args => + String -> + ArgsHMap "_backward_LinearRegressionOutput(symbol)" args -> + IO SymbolHandle +_backward_LinearRegressionOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LinearRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MAERegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(symbol)" args => + String -> + ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle +_MAERegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_MAERegressionOutput(symbol)" + = '[] + +_backward_MAERegressionOutput :: + forall args . + Fullfilled "_backward_MAERegressionOutput(symbol)" args => + String -> + ArgsHMap "_backward_MAERegressionOutput(symbol)" args -> + IO SymbolHandle +_backward_MAERegressionOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MAERegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LogisticRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LogisticRegressionOutput(symbol)" args -> + IO SymbolHandle +_LogisticRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_LogisticRegressionOutput(symbol)" = '[] + +_backward_LogisticRegressionOutput :: + forall args . + Fullfilled "_backward_LogisticRegressionOutput(symbol)" args => + String -> + ArgsHMap "_backward_LogisticRegressionOutput(symbol)" args -> + IO SymbolHandle +_backward_LogisticRegressionOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LogisticRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pad(symbol)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(symbol)" args => + String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle +_backward_Pad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SoftmaxOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(symbol)" args => + String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_SoftmaxOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_backward_SoftmaxOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Softmax(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_Softmax :: + forall args . Fullfilled "_Softmax(symbol)" args => + String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle +_Softmax name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Softmax(symbol)" = '[] + +_backward_Softmax :: + forall args . Fullfilled "_backward_Softmax(symbol)" args => + String -> + ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle +_backward_Softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceReverse(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle +_SequenceReverse name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceReverse(symbol)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_backward_SequenceReverse(symbol)" args -> + IO SymbolHandle +_backward_SequenceReverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_backward_BatchNorm_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceLast(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(symbol)" args => + String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle +_SequenceLast name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceLast(symbol)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(symbol)" args => + String -> + ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle +_backward_SequenceLast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Correlation(symbol)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle), + '("data2", AttrOpt SymbolHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(symbol)" args => + String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle +_Correlation name args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle), + ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Correlation(symbol)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(symbol)" args => + String -> + ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle +_backward_Correlation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MakeLoss(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt SymbolHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(symbol)" args => + String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle +_MakeLoss name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_MakeLoss(symbol)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(symbol)" args => + String -> + ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle +_backward_MakeLoss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LRN(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(symbol)" args => + String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle +_LRN name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LRN(symbol)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(symbol)" args => + String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle +_backward_LRN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceMask(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(symbol)" args => + String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle +_SequenceMask name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceMask(symbol)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(symbol)" args => + String -> + ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle +_backward_SequenceMask name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_GridGenerator(symbol)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(symbol)" args => + String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle +_GridGenerator name args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_GridGenerator(symbol)" = '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(symbol)" args => + String -> + ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle +_backward_GridGenerator name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling_v1(symbol)" = + '[ '("global_pool", AttrOpt Bool), '("kernel", AttrReq [Int]), + '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(symbol)" args => + String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle +_Pooling_v1 name args + = let scalarArgs + = catMaybes + [("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling_v1(symbol)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(symbol)" args => + String -> + ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle +_backward_Pooling_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LeakyReLU(symbol)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(symbol)" args => + String -> + ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle +_backward_LeakyReLU name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)" + args => + String -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args + -> IO SymbolHandle +_backward_IdentityAttachKLSparseReg name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Activation(symbol)" = + '[ '("act_type", + AttrReq (EnumType '["relu", "sigmoid", "softrelu", "tanh"])), + '("data", AttrOpt SymbolHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(symbol)" args => + String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle +_Activation name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Activation(symbol)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(symbol)" args => + String -> + ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle +_backward_Activation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_UpSampling(symbol)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(symbol)" args => + String -> + ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle +_backward_UpSampling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Deconvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(symbol)" args => + String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle +_Deconvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Deconvolution(symbol)" = '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(symbol)" args => + String -> + ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle +_backward_Deconvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BilinearSampler(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("grid", AttrOpt SymbolHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle +_BilinearSampler name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BilinearSampler(symbol)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_backward_BilinearSampler(symbol)" args -> + IO SymbolHandle +_backward_BilinearSampler name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ROIPooling(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle), + '("rois", AttrOpt SymbolHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(symbol)" args => + String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle +_ROIPooling name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIPooling(symbol)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(symbol)" args => + String -> + ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle +_backward_ROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SliceChannel(symbol)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(symbol)" args => + String -> + ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle +_backward_SliceChannel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" = + '[] + +_backward_CuDNNBatchNorm :: + forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle +_backward_CuDNNBatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_FullyConnected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(symbol)" args => + String -> + ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle +_FullyConnected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_FullyConnected(symbol)" = + '[] + +_backward_FullyConnected :: + forall args . Fullfilled "_backward_FullyConnected(symbol)" args => + String -> + ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle +_backward_FullyConnected name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(symbol)" args => + String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle +_Convolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution(symbol)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(symbol)" args => + String -> + ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle +_backward_Convolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_L2Normalization(symbol)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt SymbolHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(symbol)" args => + String -> + ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle +_L2Normalization name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_L2Normalization(symbol)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(symbol)" args => + String -> + ArgsHMap "_backward_L2Normalization(symbol)" args -> + IO SymbolHandle +_backward_L2Normalization name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Concat(symbol)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(symbol)" args => + String -> + ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle +_backward_Concat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_RNN(symbol)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), + '("parameters", AttrOpt SymbolHandle), + '("state", AttrOpt SymbolHandle), + '("state_cell", AttrOpt SymbolHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(symbol)" args => + String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle +_RNN name args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle), + ("state",) <$> (args !? #state :: Maybe SymbolHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_RNN(symbol)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(symbol)" args => + String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle +_backward_RNN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm(symbol)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle +_backward_BatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Dropout(symbol)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("data", AttrOpt SymbolHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(symbol)" args => + String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle +_Dropout name args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Dropout(symbol)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(symbol)" args => + String -> + ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle +_backward_Dropout name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CrossDeviceCopy(symbol)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle +_CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__CrossDeviceCopy(symbol)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_backward__CrossDeviceCopy(symbol)" args -> + IO SymbolHandle +_backward__CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SoftmaxActivation(symbol)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt SymbolHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle +_SoftmaxActivation name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxActivation(symbol)" = + '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxActivation(symbol)" args -> + IO SymbolHandle +_backward_SoftmaxActivation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_set_value(symbol)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(symbol)" args => + String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle +_set_value name args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_imdecode(symbol)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt SymbolHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(symbol)" args => + String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle +_imdecode name args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym diff --git a/ops/1.3/MXNet/Base/Operators/NDArray.hs b/ops/1.3/MXNet/Base/Operators/NDArray.hs new file mode 100644 --- /dev/null +++ b/ops/1.3/MXNet/Base/Operators/NDArray.hs @@ -0,0 +1,20011 @@ +module MXNet.Base.Operators.NDArray where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "_sample_multinomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle] +_sample_multinomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_multinomial_upd :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_multinomial(ndarray)" args -> IO () +_sample_multinomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sample_multinomial(ndarray)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> + IO [NDArrayHandle] +_backward_sample_multinomial args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sample_multinomial_upd :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO () +_backward_sample_multinomial_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_uniform(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle] +_sample_uniform args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_uniform_upd :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_uniform(ndarray)" args -> IO () +_sample_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_normal(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle] +_sample_normal args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_normal_upd :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO () +_sample_normal_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_gamma(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle] +_sample_gamma args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_gamma_upd :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO () +_sample_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_exponential(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle] +_sample_exponential args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_exponential_upd :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_exponential(ndarray)" args -> IO () +_sample_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_poisson(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle] +_sample_poisson args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_poisson_upd :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_poisson(ndarray)" args -> IO () +_sample_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + ArgsHMap "_sample_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_sample_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_negative_binomial_upd :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO () +_sample_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_sample_generalized_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_sample_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_sample_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_sample_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_sample_generalized_negative_binomial(ndarray)" + args + -> IO () +_sample_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_unique_zipfian(ndarray)" = + '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])] + +_sample_unique_zipfian :: + forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args => + ArgsHMap "_sample_unique_zipfian(ndarray)" args -> + IO [NDArrayHandle] +_sample_unique_zipfian args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_unique_zipfian_upd :: + forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO () +_sample_unique_zipfian_upd outputs args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_uniform(ndarray)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle] +_random_uniform args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_uniform_upd :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_uniform(ndarray)" args -> IO () +_random_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_normal(ndarray)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(ndarray)" args => + ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle] +_random_normal args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_normal_upd :: + forall args . Fullfilled "_random_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO () +_random_normal_upd outputs args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_gamma(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle] +_random_gamma args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_gamma_upd :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO () +_random_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_exponential(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle] +_random_exponential args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_exponential_upd :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_exponential(ndarray)" args -> IO () +_random_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_poisson(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle] +_random_poisson args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_poisson_upd :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_poisson(ndarray)" args -> IO () +_random_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_negative_binomial(ndarray)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + ArgsHMap "_random_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_random_negative_binomial args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_negative_binomial_upd :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_negative_binomial(ndarray)" args -> IO () +_random_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_generalized_negative_binomial(ndarray)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_random_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_random_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_random_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_random_generalized_negative_binomial(ndarray)" + args + -> IO () +_random_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_shuffle(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_shuffle :: + forall args . Fullfilled "_shuffle(ndarray)" args => + ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle] +_shuffle args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_shuffle_upd :: + forall args . Fullfilled "_shuffle(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO () +_shuffle_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Custom(ndarray)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle] +_backward_Custom args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Custom_upd :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Custom(ndarray)" args -> IO () +_backward_Custom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle] +broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_power_upd :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_power(ndarray)" args -> IO () +broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_power(ndarray)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + ArgsHMap "_backward_broadcast_power(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_power_upd :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO () +_backward_broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle] +broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_maximum_upd :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_maximum(ndarray)" args -> IO () +broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_maximum(ndarray)" + = '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_maximum_upd :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO () +_backward_broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle] +broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_minimum_upd :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_minimum(ndarray)" args -> IO () +broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_minimum(ndarray)" + = '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_minimum_upd :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO () +_backward_broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle] +broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_hypot_upd :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_hypot(ndarray)" args -> IO () +broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_hypot(ndarray)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_hypot_upd :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO () +_backward_broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_equal :: + forall args . Fullfilled "_equal(ndarray)" args => + ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle] +_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_upd :: + forall args . Fullfilled "_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO () +_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(ndarray)" args => + ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle] +_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_upd :: + forall args . Fullfilled "_not_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO () +_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater :: + forall args . Fullfilled "_greater(ndarray)" args => + ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle] +_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_upd :: + forall args . Fullfilled "_greater(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO () +_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle] +_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_upd :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO () +_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(ndarray)" args => + ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle] +_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_upd :: + forall args . Fullfilled "_lesser(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO () +_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_upd :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO () +_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_and(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_and :: + forall args . Fullfilled "_logical_and(ndarray)" args => + ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle] +_logical_and args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_and_upd :: + forall args . Fullfilled "_logical_and(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO () +_logical_and_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_or(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_or :: + forall args . Fullfilled "_logical_or(ndarray)" args => + ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle] +_logical_or args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_or_upd :: + forall args . Fullfilled "_logical_or(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO () +_logical_or_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_xor(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_xor :: + forall args . Fullfilled "_logical_xor(ndarray)" args => + ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle] +_logical_xor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_xor_upd :: + forall args . Fullfilled "_logical_xor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO () +_logical_xor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_power :: + forall args . Fullfilled "_power(ndarray)" args => + ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle] +_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_upd :: + forall args . Fullfilled "_power(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO () +_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power(ndarray)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(ndarray)" args => + ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle] +_backward_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_upd :: + forall args . Fullfilled "_backward_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power(ndarray)" args -> IO () +_backward_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(ndarray)" args => + ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle] +_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_upd :: + forall args . Fullfilled "_maximum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO () +_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum(ndarray)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle] +_backward_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_upd :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum(ndarray)" args -> IO () +_backward_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(ndarray)" args => + ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle] +_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_upd :: + forall args . Fullfilled "_minimum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO () +_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum(ndarray)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle] +_backward_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_upd :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum(ndarray)" args -> IO () +_backward_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(ndarray)" args => + ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle] +_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_upd :: + forall args . Fullfilled "_hypot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO () +_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot(ndarray)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle] +_backward_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_upd :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot(ndarray)" args -> IO () +_backward_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_square_sum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(ndarray)" args => + ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle] +_square_sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_square_sum_upd :: + forall args . Fullfilled "_square_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO () +_square_sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square_sum(ndarray)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_square_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_sum_upd :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square_sum(ndarray)" args -> IO () +_backward_square_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "add_n(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +add_n :: + forall args . Fullfilled "add_n(ndarray)" args => + ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle] +add_n args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +add_n_upd :: + forall args . Fullfilled "add_n(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO () +add_n_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_zeros(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(ndarray)" args => + ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle] +_zeros args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_zeros_upd :: + forall args . Fullfilled "_zeros(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO () +_zeros_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_eye(ndarray)" = + '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_eye :: + forall args . Fullfilled "_eye(ndarray)" args => + ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle] +_eye args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_eye_upd :: + forall args . Fullfilled "_eye(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO () +_eye_upd outputs args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ones(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(ndarray)" args => + ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle] +_ones args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ones_upd :: + forall args . Fullfilled "_ones(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO () +_ones_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_full(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(ndarray)" args => + ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle] +_full args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_full_upd :: + forall args . Fullfilled "_full(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO () +_full_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_arange(ndarray)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(ndarray)" args => + ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle] +_arange args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_arange_upd :: + forall args . Fullfilled "_arange(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO () +_arange_upd outputs args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "zeros_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(ndarray)" args => + ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle] +zeros_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +zeros_like_upd :: + forall args . Fullfilled "zeros_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO () +zeros_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ones_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(ndarray)" args => + ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle] +ones_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ones_like_upd :: + forall args . Fullfilled "ones_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO () +ones_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle] +broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_add_upd :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO () +broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_add(ndarray)" = + '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + ArgsHMap "_backward_broadcast_add(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_add_upd :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO () +_backward_broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle] +broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_sub_upd :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO () +broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_sub(ndarray)" = + '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_sub_upd :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO () +_backward_broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle] +broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mul_upd :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO () +broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mul(ndarray)" = + '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mul_upd :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO () +_backward_broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle] +broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_div_upd :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO () +broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_div(ndarray)" = + '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + ArgsHMap "_backward_broadcast_div(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_div_upd :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO () +_backward_broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle] +broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mod_upd :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO () +broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mod(ndarray)" = + '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mod_upd :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO () +_backward_broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm_upd :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO () +_linalg_gemm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm_upd :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO () +_backward_linalg_gemm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm2(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("axis", AttrOpt Int), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm2 args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm2_upd :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO () +_linalg_gemm2_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm2 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm2_upd :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO () +_backward_linalg_gemm2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potrf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle] +_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potrf_upd :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO () +_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potrf_upd :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO () +_backward_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potri(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle] +_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potri_upd :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO () +_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potri(ndarray)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + ArgsHMap "_backward_linalg_potri(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potri_upd :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO () +_backward_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trmm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trmm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trmm_upd :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO () +_linalg_trmm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trmm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trmm_upd :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO () +_backward_linalg_trmm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trsm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trsm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trsm_upd :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO () +_linalg_trsm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trsm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trsm_upd :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO () +_backward_linalg_trsm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_sumlogdiag(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle] +_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_sumlogdiag_upd :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO () +_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)" + = '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_sumlogdiag_upd :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO () +_backward_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syrk(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle] +_linalg_syrk args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syrk_upd :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO () +_linalg_syrk_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syrk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syrk_upd :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO () +_backward_linalg_syrk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gelqf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle] +_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gelqf_upd :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO () +_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gelqf_upd :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO () +_backward_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syevd(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle] +_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syevd_upd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO () +_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syevd_upd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO () +_backward_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_histogram(ndarray)" = + '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)] + +_histogram :: + forall args . Fullfilled "_histogram(ndarray)" args => + ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle] +_histogram args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_histogram_upd :: + forall args . Fullfilled "_histogram(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO () +_histogram_upd outputs args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cast_storage(ndarray)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt NDArrayHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(ndarray)" args => + ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle] +cast_storage args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cast_storage_upd :: + forall args . Fullfilled "cast_storage(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO () +cast_storage_upd outputs args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_scalar_upd :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO () +_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_not_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_scalar_upd :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO () +_not_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle] +_greater_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_scalar_upd :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_scalar(ndarray)" args -> IO () +_greater_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + ArgsHMap "_greater_equal_scalar(ndarray)" args -> + IO [NDArrayHandle] +_greater_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_scalar_upd :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO () +_greater_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_scalar_upd :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO () +_lesser_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_scalar_upd :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO () +_lesser_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_and_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_and_scalar :: + forall args . Fullfilled "_logical_and_scalar(ndarray)" args => + ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_and_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_and_scalar_upd :: + forall args . Fullfilled "_logical_and_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_and_scalar(ndarray)" args -> IO () +_logical_and_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_or_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_or_scalar :: + forall args . Fullfilled "_logical_or_scalar(ndarray)" args => + ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_or_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_or_scalar_upd :: + forall args . Fullfilled "_logical_or_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_or_scalar(ndarray)" args -> IO () +_logical_or_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_xor_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_xor_scalar :: + forall args . Fullfilled "_logical_xor_scalar(ndarray)" args => + ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_xor_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_xor_scalar_upd :: + forall args . Fullfilled "_logical_xor_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO () +_logical_xor_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "relu(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +relu :: + forall args . Fullfilled "relu(ndarray)" args => + ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle] +relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +relu_upd :: + forall args . Fullfilled "relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO () +relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_relu(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle] +_backward_relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_relu_upd :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO () +_backward_relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sigmoid(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(ndarray)" args => + ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle] +sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sigmoid_upd :: + forall args . Fullfilled "sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO () +sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sigmoid(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle] +_backward_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sigmoid_upd :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO () +_backward_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "hard_sigmoid(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +hard_sigmoid :: + forall args . Fullfilled "hard_sigmoid(ndarray)" args => + ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle] +hard_sigmoid args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +hard_sigmoid_upd :: + forall args . Fullfilled "hard_sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO () +hard_sigmoid_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[] + +_backward_hard_sigmoid :: + forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args => + ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> + IO [NDArrayHandle] +_backward_hard_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hard_sigmoid_upd :: + forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO () +_backward_hard_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softsign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +softsign :: + forall args . Fullfilled "softsign(ndarray)" args => + ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle] +softsign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softsign_upd :: + forall args . Fullfilled "softsign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO () +softsign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softsign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softsign :: + forall args . Fullfilled "_backward_softsign(ndarray)" args => + ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle] +_backward_softsign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softsign_upd :: + forall args . Fullfilled "_backward_softsign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softsign(ndarray)" args -> IO () +_backward_softsign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copy :: + forall args . Fullfilled "_copy(ndarray)" args => + ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle] +_copy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copy_upd :: + forall args . Fullfilled "_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO () +_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_copy(ndarray)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle] +_backward_copy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_copy_upd :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO () +_backward_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BlockGrad(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle] +_BlockGrad args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BlockGrad_upd :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO () +_BlockGrad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "make_loss(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(ndarray)" args => + ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle] +make_loss args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +make_loss_upd :: + forall args . Fullfilled "make_loss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO () +make_loss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_identity_with_attr_like_rhs(ndarray)" + = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> + IO [NDArrayHandle] +_identity_with_attr_like_rhs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_identity_with_attr_like_rhs_upd :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO () +_identity_with_attr_like_rhs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reshape_like(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(ndarray)" args => + ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle] +reshape_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reshape_like_upd :: + forall args . Fullfilled "reshape_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO () +reshape_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "shape_array(ndarray)" = + '[ '("lhs_begin", AttrOpt (Maybe Int)), + '("lhs_end", AttrOpt (Maybe Int)), + '("rhs_begin", AttrOpt (Maybe Int)), + '("rhs_end", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +shape_array :: + forall args . Fullfilled "shape_array(ndarray)" args => + ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle] +shape_array args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +shape_array_upd :: + forall args . Fullfilled "shape_array(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO () +shape_array_upd outputs args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "size_array(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +size_array :: + forall args . Fullfilled "size_array(ndarray)" args => + ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle] +size_array args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +size_array_upd :: + forall args . Fullfilled "size_array(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO () +size_array_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Cast(ndarray)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(ndarray)" args => + ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle] +_Cast args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Cast_upd :: + forall args . Fullfilled "_Cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO () +_Cast_upd outputs args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cast(ndarray)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle] +_backward_cast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cast_upd :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO () +_backward_cast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "negative(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +negative :: + forall args . Fullfilled "negative(ndarray)" args => + ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle] +negative args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +negative_upd :: + forall args . Fullfilled "negative(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO () +negative_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reciprocal(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(ndarray)" args => + ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle] +reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reciprocal_upd :: + forall args . Fullfilled "reciprocal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO () +reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reciprocal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle] +_backward_reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reciprocal_upd :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO () +_backward_reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "abs(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +abs :: + forall args . Fullfilled "abs(ndarray)" args => + ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle] +abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +abs_upd :: + forall args . Fullfilled "abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO () +abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_abs(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle] +_backward_abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_abs_upd :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO () +_backward_abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sign :: + forall args . Fullfilled "sign(ndarray)" args => + ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle] +sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sign_upd :: + forall args . Fullfilled "sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO () +sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle] +_backward_sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sign_upd :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO () +_backward_sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "round(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +round :: + forall args . Fullfilled "round(ndarray)" args => + ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle] +round args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +round_upd :: + forall args . Fullfilled "round(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO () +round_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rint(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rint :: + forall args . Fullfilled "rint(ndarray)" args => + ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle] +rint args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rint_upd :: + forall args . Fullfilled "rint(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO () +rint_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ceil(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ceil :: + forall args . Fullfilled "ceil(ndarray)" args => + ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle] +ceil args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ceil_upd :: + forall args . Fullfilled "ceil(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO () +ceil_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "floor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +floor :: + forall args . Fullfilled "floor(ndarray)" args => + ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle] +floor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +floor_upd :: + forall args . Fullfilled "floor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO () +floor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "trunc(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +trunc :: + forall args . Fullfilled "trunc(ndarray)" args => + ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle] +trunc args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +trunc_upd :: + forall args . Fullfilled "trunc(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO () +trunc_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fix(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +fix :: + forall args . Fullfilled "fix(ndarray)" args => + ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle] +fix args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fix_upd :: + forall args . Fullfilled "fix(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO () +fix_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "square(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +square :: + forall args . Fullfilled "square(ndarray)" args => + ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle] +square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +square_upd :: + forall args . Fullfilled "square(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO () +square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(ndarray)" args => + ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle] +_backward_square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_upd :: + forall args . Fullfilled "_backward_square(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square(ndarray)" args -> IO () +_backward_square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(ndarray)" args => + ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle] +sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sqrt_upd :: + forall args . Fullfilled "sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO () +sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sqrt_upd :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO () +_backward_sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rsqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(ndarray)" args => + ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle] +rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rsqrt_upd :: + forall args . Fullfilled "rsqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO () +rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rsqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rsqrt_upd :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO () +_backward_rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(ndarray)" args => + ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle] +cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cbrt_upd :: + forall args . Fullfilled "cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO () +cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cbrt_upd :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO () +_backward_cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rcbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(ndarray)" args => + ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle] +rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rcbrt_upd :: + forall args . Fullfilled "rcbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO () +rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rcbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rcbrt_upd :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO () +_backward_rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "exp(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +exp :: + forall args . Fullfilled "exp(ndarray)" args => + ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle] +exp args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +exp_upd :: + forall args . Fullfilled "exp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO () +exp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log :: + forall args . Fullfilled "log(ndarray)" args => + ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle] +log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_upd :: + forall args . Fullfilled "log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO () +log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log10(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log10 :: + forall args . Fullfilled "log10(ndarray)" args => + ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle] +log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log10_upd :: + forall args . Fullfilled "log10(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO () +log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log2(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log2 :: + forall args . Fullfilled "log2(ndarray)" args => + ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle] +log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log2_upd :: + forall args . Fullfilled "log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO () +log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(ndarray)" args => + ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle] +_backward_log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_upd :: + forall args . Fullfilled "_backward_log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO () +_backward_log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log10(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle] +_backward_log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log10_upd :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log10(ndarray)" args -> IO () +_backward_log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log2(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle] +_backward_log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log2_upd :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO () +_backward_log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log1p(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log1p :: + forall args . Fullfilled "log1p(ndarray)" args => + ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle] +log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log1p_upd :: + forall args . Fullfilled "log1p(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO () +log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log1p(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle] +_backward_log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log1p_upd :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log1p(ndarray)" args -> IO () +_backward_log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expm1(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +expm1 :: + forall args . Fullfilled "expm1(ndarray)" args => + ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle] +expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expm1_upd :: + forall args . Fullfilled "expm1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO () +expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_expm1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle] +_backward_expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_expm1_upd :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_expm1(ndarray)" args -> IO () +_backward_expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gamma(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gamma :: + forall args . Fullfilled "gamma(ndarray)" args => + ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle] +gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gamma_upd :: + forall args . Fullfilled "gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO () +gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gamma(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle] +_backward_gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gamma_upd :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gamma(ndarray)" args -> IO () +_backward_gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gammaln(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(ndarray)" args => + ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle] +gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gammaln_upd :: + forall args . Fullfilled "gammaln(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO () +gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gammaln(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle] +_backward_gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gammaln_upd :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gammaln(ndarray)" args -> IO () +_backward_gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "logical_not(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +logical_not :: + forall args . Fullfilled "logical_not(ndarray)" args => + ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle] +logical_not args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +logical_not_upd :: + forall args . Fullfilled "logical_not(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO () +logical_not_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +sum :: + forall args . Fullfilled "sum(ndarray)" args => + ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle] +sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sum_upd :: + forall args . Fullfilled "sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO () +sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sum(ndarray)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sum_upd :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO () +_backward_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mean(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +mean :: + forall args . Fullfilled "mean(ndarray)" args => + ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle] +mean args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mean_upd :: + forall args . Fullfilled "mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO () +mean_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mean(ndarray)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle] +_backward_mean args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mean_upd :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO () +_backward_mean_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "prod(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +prod :: + forall args . Fullfilled "prod(ndarray)" args => + ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle] +prod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +prod_upd :: + forall args . Fullfilled "prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO () +prod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_prod(ndarray)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle] +_backward_prod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_prod_upd :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO () +_backward_prod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nansum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nansum :: + forall args . Fullfilled "nansum(ndarray)" args => + ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle] +nansum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nansum_upd :: + forall args . Fullfilled "nansum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO () +nansum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nansum(ndarray)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle] +_backward_nansum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nansum_upd :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nansum(ndarray)" args -> IO () +_backward_nansum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nanprod(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(ndarray)" args => + ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle] +nanprod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nanprod_upd :: + forall args . Fullfilled "nanprod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO () +nanprod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nanprod(ndarray)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle] +_backward_nanprod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nanprod_upd :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nanprod(ndarray)" args -> IO () +_backward_nanprod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "max(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +max :: + forall args . Fullfilled "max(ndarray)" args => + ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle] +max args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +max_upd :: + forall args . Fullfilled "max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO () +max_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_max(ndarray)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(ndarray)" args => + ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle] +_backward_max args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_max_upd :: + forall args . Fullfilled "_backward_max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO () +_backward_max_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "min(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +min :: + forall args . Fullfilled "min(ndarray)" args => + ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle] +min args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +min_upd :: + forall args . Fullfilled "min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO () +min_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_min(ndarray)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(ndarray)" args => + ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle] +_backward_min args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_min_upd :: + forall args . Fullfilled "_backward_min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO () +_backward_min_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_axis(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle] +broadcast_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_axis_upd :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO () +broadcast_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_to(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle] +broadcast_to args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_to_upd :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO () +broadcast_to_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_broadcast_backward(ndarray)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle] +_broadcast_backward args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_broadcast_backward_upd :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_broadcast_backward(ndarray)" args -> IO () +_broadcast_backward_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_like(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_like :: + forall args . Fullfilled "broadcast_like(ndarray)" args => + ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle] +broadcast_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_like_upd :: + forall args . Fullfilled "broadcast_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO () +broadcast_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "norm(ndarray)" = + '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])), + '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +norm :: + forall args . Fullfilled "norm(ndarray)" args => + ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle] +norm args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +norm_upd :: + forall args . Fullfilled "norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO () +norm_upd outputs args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_norm(ndarray)" = '[] + +_backward_norm :: + forall args . Fullfilled "_backward_norm(ndarray)" args => + ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle] +_backward_norm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_norm_upd :: + forall args . Fullfilled "_backward_norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO () +_backward_norm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle] +elemwise_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_add_upd :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO () +elemwise_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_grad_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(ndarray)" args => + ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle] +_grad_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_grad_add_upd :: + forall args . Fullfilled "_grad_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO () +_grad_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_add(ndarray)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(ndarray)" args => + ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle] +_backward_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_add_upd :: + forall args . Fullfilled "_backward_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO () +_backward_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle] +elemwise_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_sub_upd :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO () +elemwise_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sub(ndarray)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle] +_backward_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sub_upd :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO () +_backward_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle] +elemwise_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_mul_upd :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO () +elemwise_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul(ndarray)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle] +_backward_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_upd :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO () +_backward_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle] +elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_div_upd :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO () +elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div(ndarray)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(ndarray)" args => + ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle] +_backward_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_upd :: + forall args . Fullfilled "_backward_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO () +_backward_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_mod :: + forall args . Fullfilled "_mod(ndarray)" args => + ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle] +_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_upd :: + forall args . Fullfilled "_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO () +_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod(ndarray)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle] +_backward_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_upd :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO () +_backward_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> + IO [NDArrayHandle] +_scatter_elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_elemwise_div_upd :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO () +_scatter_elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_scatter_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_plus_scalar_upd :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO () +_scatter_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> + IO [NDArrayHandle] +_scatter_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_minus_scalar_upd :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO () +_scatter_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Embedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(ndarray)" args => + ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle] +_Embedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Embedding_upd :: + forall args . Fullfilled "_Embedding(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO () +_Embedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SparseEmbedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_contrib_SparseEmbedding :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SparseEmbedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SparseEmbedding_upd :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO () +_contrib_SparseEmbedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Embedding(ndarray)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle] +_backward_Embedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Embedding_upd :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Embedding(ndarray)" args -> IO () +_backward_Embedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SparseEmbedding(ndarray)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_backward_SparseEmbedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SparseEmbedding_upd :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO () +_backward_SparseEmbedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "take(ndarray)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)] + +take :: + forall args . Fullfilled "take(ndarray)" args => + ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle] +take args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +take_upd :: + forall args . Fullfilled "take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO () +take_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_take(ndarray)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(ndarray)" args => + ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle] +_backward_take args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_take_upd :: + forall args . Fullfilled "_backward_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO () +_backward_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_take(ndarray)" = + '[ '("a", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(ndarray)" args => + ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle] +batch_take args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_take_upd :: + forall args . Fullfilled "batch_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO () +batch_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "one_hot(ndarray)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("indices", AttrOpt NDArrayHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(ndarray)" args => + ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle] +one_hot args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +one_hot_upd :: + forall args . Fullfilled "one_hot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO () +one_hot_upd outputs args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gather_nd(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle] +gather_nd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gather_nd_upd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO () +gather_nd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "scatter_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle] +scatter_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +scatter_nd_upd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO () +scatter_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gather_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_backward_gather_nd :: + forall args . Fullfilled "_backward_gather_nd(ndarray)" args => + ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle] +_backward_gather_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gather_nd_upd :: + forall args . Fullfilled "_backward_gather_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gather_nd(ndarray)" args -> IO () +_backward_gather_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_set_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle] +_scatter_set_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_set_nd_upd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO () +_scatter_set_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_equal_upd :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_equal(ndarray)" args -> IO () +broadcast_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_not_equal_upd :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO () +broadcast_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle] +broadcast_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_upd :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater(ndarray)" args -> IO () +broadcast_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + ArgsHMap "broadcast_greater_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_equal_upd :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO () +broadcast_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle] +broadcast_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_upd :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser(ndarray)" args -> IO () +broadcast_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_equal_upd :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO () +broadcast_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_and(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_and :: + forall args . Fullfilled "broadcast_logical_and(ndarray)" args => + ArgsHMap "broadcast_logical_and(ndarray)" args -> + IO [NDArrayHandle] +broadcast_logical_and args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_and_upd :: + forall args . Fullfilled "broadcast_logical_and(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_and(ndarray)" args -> IO () +broadcast_logical_and_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_or(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_or :: + forall args . Fullfilled "broadcast_logical_or(ndarray)" args => + ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle] +broadcast_logical_or args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_or_upd :: + forall args . Fullfilled "broadcast_logical_or(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_or(ndarray)" args -> IO () +broadcast_logical_or_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_xor(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_xor :: + forall args . Fullfilled "broadcast_logical_xor(ndarray)" args => + ArgsHMap "broadcast_logical_xor(ndarray)" args -> + IO [NDArrayHandle] +broadcast_logical_xor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_xor_upd :: + forall args . Fullfilled "broadcast_logical_xor(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO () +broadcast_logical_xor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_plus_scalar_upd :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO () +_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle] +_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minus_scalar_upd :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO () +_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rminus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle] +_rminus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rminus_scalar_upd :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO () +_rminus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mul_scalar_upd :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO () +_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_scalar_upd :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO () +_backward_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_div_scalar_upd :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO () +_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_scalar_upd :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO () +_backward_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle] +_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rdiv_scalar_upd :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO () +_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rdiv_scalar_upd :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO () +_backward_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_scalar_upd :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO () +_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_scalar_upd :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO () +_backward_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle] +_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rmod_scalar_upd :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO () +_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rmod_scalar_upd :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO () +_backward_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ravel_multi_index(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_ravel_multi_index :: + forall args . Fullfilled "_ravel_multi_index(ndarray)" args => + ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle] +_ravel_multi_index args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ravel_multi_index_upd :: + forall args . Fullfilled "_ravel_multi_index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_ravel_multi_index(ndarray)" args -> IO () +_ravel_multi_index_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_unravel_index(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_unravel_index :: + forall args . Fullfilled "_unravel_index(ndarray)" args => + ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle] +_unravel_index args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_unravel_index_upd :: + forall args . Fullfilled "_unravel_index(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO () +_unravel_index_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmax :: + forall args . Fullfilled "argmax(ndarray)" args => + ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle] +argmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_upd :: + forall args . Fullfilled "argmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO () +argmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmin(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmin :: + forall args . Fullfilled "argmin(ndarray)" args => + ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle] +argmin args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmin_upd :: + forall args . Fullfilled "argmin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO () +argmin_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax_channel(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle] +argmax_channel args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_channel_upd :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO () +argmax_channel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "pick(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("mode", AttrOpt (EnumType '["clip", "wrap"])), + '("data", AttrOpt NDArrayHandle), + '("index", AttrOpt NDArrayHandle)] + +pick :: + forall args . Fullfilled "pick(ndarray)" args => + ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle] +pick args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +pick_upd :: + forall args . Fullfilled "pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO () +pick_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_pick(ndarray)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle] +_backward_pick args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_pick_upd :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO () +_backward_pick_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_retain(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle] +_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_retain_upd :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO () +_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sparse_retain(ndarray)" = + '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + ArgsHMap "_backward_sparse_retain(ndarray)" args -> + IO [NDArrayHandle] +_backward_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sparse_retain_upd :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO () +_backward_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_where(ndarray)" = + '[ '("condition", AttrOpt NDArrayHandle), + '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)] + +_where :: + forall args . Fullfilled "_where(ndarray)" args => + ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle] +_where args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_where_upd :: + forall args . Fullfilled "_where(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO () +_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_where(ndarray)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(ndarray)" args => + ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle] +_backward_where args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_where_upd :: + forall args . Fullfilled "_backward_where(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_where(ndarray)" args -> IO () +_backward_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "diag(ndarray)" = + '[ '("k", AttrOpt (Maybe Int)), '("data", AttrOpt NDArrayHandle)] + +diag :: + forall args . Fullfilled "diag(ndarray)" args => + ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle] +diag args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +diag_upd :: + forall args . Fullfilled "diag(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO () +diag_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_diag(ndarray)" = '[] + +_backward_diag :: + forall args . Fullfilled "_backward_diag(ndarray)" args => + ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle] +_backward_diag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_diag_upd :: + forall args . Fullfilled "_backward_diag(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO () +_backward_diag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle] +_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_scalar_upd :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_maximum_scalar(ndarray)" args -> IO () +_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_maximum_scalar :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_scalar_upd :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO () +_backward_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle] +_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_scalar_upd :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_minimum_scalar(ndarray)" args -> IO () +_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_minimum_scalar :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_scalar_upd :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO () +_backward_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle] +_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_scalar_upd :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO () +_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + ArgsHMap "_backward_power_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_scalar_upd :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power_scalar(ndarray)" args -> IO () +_backward_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle] +_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rpower_scalar_upd :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO () +_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rpower_scalar_upd :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO () +_backward_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle] +_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_scalar_upd :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO () +_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_scalar_upd :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO () +_backward_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "smooth_l1(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle] +smooth_l1 args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +smooth_l1_upd :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO () +smooth_l1_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_smooth_l1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle] +_backward_smooth_l1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_smooth_l1_upd :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO () +_backward_smooth_l1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "topk(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +topk :: + forall args . Fullfilled "topk(ndarray)" args => + ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle] +topk args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +topk_upd :: + forall args . Fullfilled "topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO () +topk_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_topk(ndarray)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle] +_backward_topk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_topk_upd :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO () +_backward_topk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +sort :: + forall args . Fullfilled "sort(ndarray)" args => + ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle] +sort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sort_upd :: + forall args . Fullfilled "sort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO () +sort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argsort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +argsort :: + forall args . Fullfilled "argsort(ndarray)" args => + ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle] +argsort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argsort_upd :: + forall args . Fullfilled "argsort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO () +argsort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Reshape(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(ndarray)" args => + ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle] +_Reshape args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Reshape_upd :: + forall args . Fullfilled "_Reshape(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO () +_Reshape_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(ndarray)" args => + ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle] +_Flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Flatten_upd :: + forall args . Fullfilled "_Flatten(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO () +_Flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "transpose(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +transpose :: + forall args . Fullfilled "transpose(ndarray)" args => + ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle] +transpose args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +transpose_upd :: + forall args . Fullfilled "transpose(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO () +transpose_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expand_dims(ndarray)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(ndarray)" args => + ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle] +expand_dims args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expand_dims_upd :: + forall args . Fullfilled "expand_dims(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO () +expand_dims_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +slice :: + forall args . Fullfilled "slice(ndarray)" args => + ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle] +slice args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_upd :: + forall args . Fullfilled "slice(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO () +slice_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice(ndarray)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle] +_backward_slice args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_upd :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice(ndarray)" args -> IO () +_backward_slice_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle] +_slice_assign args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_upd :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO () +_slice_assign_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle] +_slice_assign_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_scalar_upd :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO () +_slice_assign_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_axis(ndarray)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(ndarray)" args => + ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle] +slice_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_axis_upd :: + forall args . Fullfilled "slice_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO () +slice_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_axis(ndarray)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_axis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_axis_upd :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO () +_backward_slice_axis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_like(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle), + '("shape_like", AttrOpt NDArrayHandle)] + +slice_like :: + forall args . Fullfilled "slice_like(ndarray)" args => + ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle] +slice_like args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_like_upd :: + forall args . Fullfilled "slice_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO () +slice_like_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_like(ndarray)" = '[] + +_backward_slice_like :: + forall args . Fullfilled "_backward_slice_like(ndarray)" args => + ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_like args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_like_upd :: + forall args . Fullfilled "_backward_slice_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_like(ndarray)" args -> IO () +_backward_slice_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "clip(ndarray)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +clip :: + forall args . Fullfilled "clip(ndarray)" args => + ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle] +clip args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +clip_upd :: + forall args . Fullfilled "clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO () +clip_upd outputs args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_clip(ndarray)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle] +_backward_clip args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_clip_upd :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO () +_backward_clip_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "repeat(ndarray)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +repeat :: + forall args . Fullfilled "repeat(ndarray)" args => + ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle] +repeat args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +repeat_upd :: + forall args . Fullfilled "repeat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO () +repeat_upd outputs args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_repeat(ndarray)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle] +_backward_repeat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_repeat_upd :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_repeat(ndarray)" args -> IO () +_backward_repeat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tile(ndarray)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +tile :: + forall args . Fullfilled "tile(ndarray)" args => + ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle] +tile args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tile_upd :: + forall args . Fullfilled "tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO () +tile_upd outputs args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tile(ndarray)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle] +_backward_tile args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tile_upd :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO () +_backward_tile_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reverse(ndarray)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +reverse :: + forall args . Fullfilled "reverse(ndarray)" args => + ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle] +reverse args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reverse_upd :: + forall args . Fullfilled "reverse(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO () +reverse_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reverse(ndarray)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle] +_backward_reverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reverse_upd :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reverse(ndarray)" args -> IO () +_backward_reverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "stack(ndarray)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [NDArrayHandle])] + +stack :: + forall args . Fullfilled "stack(ndarray)" args => + ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle] +stack args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +stack_upd :: + forall args . Fullfilled "stack(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO () +stack_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_stack(ndarray)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle] +_backward_stack args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_stack_upd :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_stack(ndarray)" args -> IO () +_backward_stack_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "squeeze(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), + '("data", AttrOpt [NDArrayHandle])] + +squeeze :: + forall args . Fullfilled "squeeze(ndarray)" args => + ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle] +squeeze args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +squeeze_upd :: + forall args . Fullfilled "squeeze(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO () +squeeze_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_squeeze(ndarray)" = '[] + +_backward_squeeze :: + forall args . Fullfilled "_backward_squeeze(ndarray)" args => + ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle] +_backward_squeeze args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_squeeze_upd :: + forall args . Fullfilled "_backward_squeeze(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_squeeze(ndarray)" args -> IO () +_backward_squeeze_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "depth_to_space(ndarray)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +depth_to_space :: + forall args . Fullfilled "depth_to_space(ndarray)" args => + ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle] +depth_to_space args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +depth_to_space_upd :: + forall args . Fullfilled "depth_to_space(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO () +depth_to_space_upd outputs args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "space_to_depth(ndarray)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +space_to_depth :: + forall args . Fullfilled "space_to_depth(ndarray)" args => + ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle] +space_to_depth args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +space_to_depth_upd :: + forall args . Fullfilled "space_to_depth(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO () +space_to_depth_upd outputs args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +dot :: + forall args . Fullfilled "dot(ndarray)" args => + ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle] +dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +dot_upd :: + forall args . Fullfilled "dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO () +dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_dot_upd :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO () +_backward_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(ndarray)" args => + ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle] +batch_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_dot_upd :: + forall args . Fullfilled "batch_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO () +batch_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_batch_dot(ndarray)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_batch_dot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_batch_dot_upd :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO () +_backward_batch_dot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sin :: + forall args . Fullfilled "sin(ndarray)" args => + ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle] +sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sin_upd :: + forall args . Fullfilled "sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO () +sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle] +_backward_sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sin_upd :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO () +_backward_sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cos :: + forall args . Fullfilled "cos(ndarray)" args => + ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle] +cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cos_upd :: + forall args . Fullfilled "cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO () +cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle] +_backward_cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cos_upd :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO () +_backward_cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tan :: + forall args . Fullfilled "tan(ndarray)" args => + ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle] +tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tan_upd :: + forall args . Fullfilled "tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO () +tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle] +_backward_tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tan_upd :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO () +_backward_tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(ndarray)" args => + ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle] +arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsin_upd :: + forall args . Fullfilled "arcsin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO () +arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsin_upd :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsin(ndarray)" args -> IO () +_backward_arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccos :: + forall args . Fullfilled "arccos(ndarray)" args => + ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle] +arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccos_upd :: + forall args . Fullfilled "arccos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO () +arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle] +_backward_arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccos_upd :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccos(ndarray)" args -> IO () +_backward_arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctan :: + forall args . Fullfilled "arctan(ndarray)" args => + ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle] +arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctan_upd :: + forall args . Fullfilled "arctan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO () +arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle] +_backward_arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctan_upd :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctan(ndarray)" args -> IO () +_backward_arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "degrees(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +degrees :: + forall args . Fullfilled "degrees(ndarray)" args => + ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle] +degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +degrees_upd :: + forall args . Fullfilled "degrees(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO () +degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_degrees(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle] +_backward_degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_degrees_upd :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_degrees(ndarray)" args -> IO () +_backward_degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "radians(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +radians :: + forall args . Fullfilled "radians(ndarray)" args => + ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle] +radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +radians_upd :: + forall args . Fullfilled "radians(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO () +radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_radians(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle] +_backward_radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_radians_upd :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_radians(ndarray)" args -> IO () +_backward_radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sinh :: + forall args . Fullfilled "sinh(ndarray)" args => + ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle] +sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sinh_upd :: + forall args . Fullfilled "sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO () +sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle] +_backward_sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sinh_upd :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO () +_backward_sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cosh :: + forall args . Fullfilled "cosh(ndarray)" args => + ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle] +cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cosh_upd :: + forall args . Fullfilled "cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO () +cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle] +_backward_cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cosh_upd :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO () +_backward_cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tanh :: + forall args . Fullfilled "tanh(ndarray)" args => + ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle] +tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tanh_upd :: + forall args . Fullfilled "tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO () +tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle] +_backward_tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tanh_upd :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO () +_backward_tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(ndarray)" args => + ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle] +arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsinh_upd :: + forall args . Fullfilled "arcsinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO () +arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsinh_upd :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO () +_backward_arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(ndarray)" args => + ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle] +arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccosh_upd :: + forall args . Fullfilled "arccosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO () +arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle] +_backward_arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccosh_upd :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccosh(ndarray)" args -> IO () +_backward_arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(ndarray)" args => + ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle] +arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctanh_upd :: + forall args . Fullfilled "arctanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO () +arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle] +_backward_arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctanh_upd :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctanh(ndarray)" args -> IO () +_backward_arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_CTCLoss(ndarray)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("data_lengths", AttrOpt NDArrayHandle), + '("label_lengths", AttrOpt NDArrayHandle)] + +_contrib_CTCLoss :: + forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args => + ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO [NDArrayHandle] +_contrib_CTCLoss args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_CTCLoss_upd :: + forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO () +_contrib_CTCLoss_upd outputs args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quadratic(ndarray)" = + '[ '("a", AttrOpt Float), '("b", AttrOpt Float), + '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_contrib_quadratic :: + forall args . Fullfilled "_contrib_quadratic(ndarray)" args => + ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle] +_contrib_quadratic args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quadratic_upd :: + forall args . Fullfilled "_contrib_quadratic(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quadratic(ndarray)" args -> IO () +_contrib_quadratic_upd outputs args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_backward_quadratic(ndarray)" + = '[] + +_contrib_backward_quadratic :: + forall args . + Fullfilled "_contrib_backward_quadratic(ndarray)" args => + ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> + IO [NDArrayHandle] +_contrib_backward_quadratic args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_quadratic_upd :: + forall args . + Fullfilled "_contrib_backward_quadratic(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO () +_contrib_backward_quadratic_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_contrib_div_sqrt_dim :: + forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args => + ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> + IO [NDArrayHandle] +_contrib_div_sqrt_dim args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_div_sqrt_dim_upd :: + forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO () +_contrib_div_sqrt_dim_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "khatri_rao(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +khatri_rao :: + forall args . Fullfilled "khatri_rao(ndarray)" args => + ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle] +khatri_rao args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +khatri_rao_upd :: + forall args . Fullfilled "khatri_rao(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO () +khatri_rao_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_contrib_ROIAlign(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_contrib_ROIAlign :: + forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args => + ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle] +_contrib_ROIAlign args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ROIAlign_upd :: + forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO () +_contrib_ROIAlign_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIAlign(ndarray)" = '[] + +_backward_ROIAlign :: + forall args . Fullfilled "_backward_ROIAlign(ndarray)" args => + ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIAlign args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIAlign_upd :: + forall args . Fullfilled "_backward_ROIAlign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO () +_backward_ROIAlign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_box_nms(ndarray)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"])), + '("data", AttrOpt NDArrayHandle)] + +_contrib_box_nms :: + forall args . Fullfilled "_contrib_box_nms(ndarray)" args => + ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle] +_contrib_box_nms args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_box_nms_upd :: + forall args . Fullfilled "_contrib_box_nms(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_box_nms(ndarray)" args -> IO () +_contrib_box_nms_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_contrib_box_nms(ndarray)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_nms :: + forall args . + Fullfilled "_backward_contrib_box_nms(ndarray)" args => + ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_box_nms args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_box_nms_upd :: + forall args . + Fullfilled "_backward_contrib_box_nms(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO () +_backward_contrib_box_nms_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_box_iou(ndarray)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"])), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +_contrib_box_iou :: + forall args . Fullfilled "_contrib_box_iou(ndarray)" args => + ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle] +_contrib_box_iou args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_box_iou_upd :: + forall args . Fullfilled "_contrib_box_iou(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_box_iou(ndarray)" args -> IO () +_contrib_box_iou_upd outputs args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_contrib_box_iou(ndarray)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_iou :: + forall args . + Fullfilled "_backward_contrib_box_iou(ndarray)" args => + ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_box_iou args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_box_iou_upd :: + forall args . + Fullfilled "_backward_contrib_box_iou(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO () +_backward_contrib_box_iou_upd outputs args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_bipartite_matching(ndarray)" + = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +_contrib_bipartite_matching :: + forall args . + Fullfilled "_contrib_bipartite_matching(ndarray)" args => + ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> + IO [NDArrayHandle] +_contrib_bipartite_matching args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_bipartite_matching_upd :: + forall args . + Fullfilled "_contrib_bipartite_matching(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO () +_contrib_bipartite_matching_upd outputs args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_bipartite_matching(ndarray)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int)] + +_backward_contrib_bipartite_matching :: + forall args . + Fullfilled "_backward_contrib_bipartite_matching(ndarray)" + args => + ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args + -> IO [NDArrayHandle] +_backward_contrib_bipartite_matching args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_bipartite_matching_upd :: + forall args . + Fullfilled + "_backward_contrib_bipartite_matching(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward_contrib_bipartite_matching(ndarray)" + args + -> IO () +_backward_contrib_bipartite_matching_upd outputs args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_BilinearResize2D(ndarray)" = + '[ '("height", AttrReq Int), '("width", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_BilinearResize2D :: + forall args . + Fullfilled "_contrib_BilinearResize2D(ndarray)" args => + ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> + IO [NDArrayHandle] +_contrib_BilinearResize2D args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_BilinearResize2D_upd :: + forall args . + Fullfilled "_contrib_BilinearResize2D(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO () +_contrib_BilinearResize2D_upd outputs args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[] + +_backward_contrib_BilinearResize2D :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(ndarray)" + args => + ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_BilinearResize2D args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_BilinearResize2D_upd :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" + args + -> IO () +_backward_contrib_BilinearResize2D_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int), + '("key", AttrOpt String), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_contrib_SyncBatchNorm :: + forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args => + ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SyncBatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SyncBatchNorm_upd :: + forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO () +_contrib_SyncBatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" = + '[ '("output_size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args => + ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args -> + IO [NDArrayHandle] +_contrib_AdaptiveAvgPooling2D args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_AdaptiveAvgPooling2D_upd :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args -> + IO () +_contrib_AdaptiveAvgPooling2D_upd outputs args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" = + '[] + +_backward_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args => + ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args + -> IO [NDArrayHandle] +_backward_contrib_AdaptiveAvgPooling2D args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_AdaptiveAvgPooling2D_upd :: + forall args . + Fullfilled + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args + -> IO () +_backward_contrib_AdaptiveAvgPooling2D_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_to_tensor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_to_tensor :: + forall args . Fullfilled "_image_to_tensor(ndarray)" args => + ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle] +_image_to_tensor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_to_tensor_upd :: + forall args . Fullfilled "_image_to_tensor(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_to_tensor(ndarray)" args -> IO () +_image_to_tensor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_normalize(ndarray)" = + '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]), + '("data", AttrOpt NDArrayHandle)] + +_image_normalize :: + forall args . Fullfilled "_image_normalize(ndarray)" args => + ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle] +_image_normalize args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_normalize_upd :: + forall args . Fullfilled "_image_normalize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_normalize(ndarray)" args -> IO () +_image_normalize_upd outputs args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_flip_left_right(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_flip_left_right :: + forall args . Fullfilled "_image_flip_left_right(ndarray)" args => + ArgsHMap "_image_flip_left_right(ndarray)" args -> + IO [NDArrayHandle] +_image_flip_left_right args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_flip_left_right_upd :: + forall args . Fullfilled "_image_flip_left_right(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_flip_left_right(ndarray)" args -> IO () +_image_flip_left_right_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_image_random_flip_left_right(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_random_flip_left_right :: + forall args . + Fullfilled "_image_random_flip_left_right(ndarray)" args => + ArgsHMap "_image_random_flip_left_right(ndarray)" args -> + IO [NDArrayHandle] +_image_random_flip_left_right args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_flip_left_right_upd :: + forall args . + Fullfilled "_image_random_flip_left_right(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_flip_left_right(ndarray)" args -> + IO () +_image_random_flip_left_right_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_flip_top_bottom(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_flip_top_bottom :: + forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args => + ArgsHMap "_image_flip_top_bottom(ndarray)" args -> + IO [NDArrayHandle] +_image_flip_top_bottom args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_flip_top_bottom_upd :: + forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO () +_image_flip_top_bottom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_image_random_flip_top_bottom(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_random_flip_top_bottom :: + forall args . + Fullfilled "_image_random_flip_top_bottom(ndarray)" args => + ArgsHMap "_image_random_flip_top_bottom(ndarray)" args -> + IO [NDArrayHandle] +_image_random_flip_top_bottom args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_flip_top_bottom_upd :: + forall args . + Fullfilled "_image_random_flip_top_bottom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_flip_top_bottom(ndarray)" args -> + IO () +_image_random_flip_top_bottom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_brightness(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_brightness :: + forall args . + Fullfilled "_image_random_brightness(ndarray)" args => + ArgsHMap "_image_random_brightness(ndarray)" args -> + IO [NDArrayHandle] +_image_random_brightness args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_brightness_upd :: + forall args . + Fullfilled "_image_random_brightness(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_brightness(ndarray)" args -> IO () +_image_random_brightness_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_contrast(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_contrast :: + forall args . Fullfilled "_image_random_contrast(ndarray)" args => + ArgsHMap "_image_random_contrast(ndarray)" args -> + IO [NDArrayHandle] +_image_random_contrast args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_contrast_upd :: + forall args . Fullfilled "_image_random_contrast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_contrast(ndarray)" args -> IO () +_image_random_contrast_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_saturation(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_saturation :: + forall args . + Fullfilled "_image_random_saturation(ndarray)" args => + ArgsHMap "_image_random_saturation(ndarray)" args -> + IO [NDArrayHandle] +_image_random_saturation args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_saturation_upd :: + forall args . + Fullfilled "_image_random_saturation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_saturation(ndarray)" args -> IO () +_image_random_saturation_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_hue(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_hue :: + forall args . Fullfilled "_image_random_hue(ndarray)" args => + ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle] +_image_random_hue args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_hue_upd :: + forall args . Fullfilled "_image_random_hue(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_hue(ndarray)" args -> IO () +_image_random_hue_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_color_jitter(ndarray)" = + '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float), + '("saturation", AttrReq Float), '("hue", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_color_jitter :: + forall args . + Fullfilled "_image_random_color_jitter(ndarray)" args => + ArgsHMap "_image_random_color_jitter(ndarray)" args -> + IO [NDArrayHandle] +_image_random_color_jitter args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_color_jitter_upd :: + forall args . + Fullfilled "_image_random_color_jitter(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO () +_image_random_color_jitter_upd outputs args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_adjust_lighting(ndarray)" = + '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)] + +_image_adjust_lighting :: + forall args . Fullfilled "_image_adjust_lighting(ndarray)" args => + ArgsHMap "_image_adjust_lighting(ndarray)" args -> + IO [NDArrayHandle] +_image_adjust_lighting args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_adjust_lighting_upd :: + forall args . Fullfilled "_image_adjust_lighting(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO () +_image_adjust_lighting_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_lighting(ndarray)" = + '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_image_random_lighting :: + forall args . Fullfilled "_image_random_lighting(ndarray)" args => + ArgsHMap "_image_random_lighting(ndarray)" args -> + IO [NDArrayHandle] +_image_random_lighting args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_lighting_upd :: + forall args . Fullfilled "_image_random_lighting(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_lighting(ndarray)" args -> IO () +_image_random_lighting_upd outputs args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt NDArrayHandle)] + +softmax :: + forall args . Fullfilled "softmax(ndarray)" args => + ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle] +softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_upd :: + forall args . Fullfilled "softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO () +softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softmax(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_softmax args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_upd :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax(ndarray)" args -> IO () +_backward_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log_softmax(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt NDArrayHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(ndarray)" args => + ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle] +log_softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_softmax_upd :: + forall args . Fullfilled "log_softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO () +log_softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log_softmax(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + ArgsHMap "_backward_log_softmax(ndarray)" args -> + IO [NDArrayHandle] +_backward_log_softmax args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_softmax_upd :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log_softmax(ndarray)" args -> IO () +_backward_log_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(ndarray)" args => + ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle] +_Pooling args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_upd :: + forall args . Fullfilled "_Pooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO () +_Pooling_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling(ndarray)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_upd :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling(ndarray)" args -> IO () +_backward_Pooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Deconvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle] +_Deconvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Deconvolution_upd :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO () +_Deconvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Deconvolution(ndarray)" = + '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + ArgsHMap "_backward_Deconvolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Deconvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Deconvolution_upd :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO () +_backward_Deconvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Activation(ndarray)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt NDArrayHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(ndarray)" args => + ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle] +_Activation args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Activation_upd :: + forall args . Fullfilled "_Activation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO () +_Activation_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Activation(ndarray)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle] +_backward_Activation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Activation_upd :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Activation(ndarray)" args -> IO () +_backward_Activation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_UpSampling(ndarray)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_UpSampling args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_UpSampling_upd :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO () +_UpSampling_upd outputs args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_UpSampling(ndarray)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_backward_UpSampling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_UpSampling_upd :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO () +_backward_UpSampling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_upd :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO () +_BatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm(ndarray)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_BatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_upd :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO () +_backward_BatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_FullyConnected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle] +_FullyConnected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_FullyConnected_upd :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_FullyConnected(ndarray)" args -> IO () +_FullyConnected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_FullyConnected(ndarray)" = + '[] + +_backward_FullyConnected :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + ArgsHMap "_backward_FullyConnected(ndarray)" args -> + IO [NDArrayHandle] +_backward_FullyConnected args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_FullyConnected_upd :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO () +_backward_FullyConnected_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(ndarray)" args => + ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle] +_Convolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_upd :: + forall args . Fullfilled "_Convolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO () +_Convolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution(ndarray)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + ArgsHMap "_backward_Convolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_upd :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution(ndarray)" args -> IO () +_backward_Convolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LayerNorm(ndarray)" = + '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_LayerNorm :: + forall args . Fullfilled "_LayerNorm(ndarray)" args => + ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle] +_LayerNorm args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LayerNorm_upd :: + forall args . Fullfilled "_LayerNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO () +_LayerNorm_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LayerNorm(ndarray)" = '[] + +_backward_LayerNorm :: + forall args . Fullfilled "_backward_LayerNorm(ndarray)" args => + ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_LayerNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LayerNorm_upd :: + forall args . Fullfilled "_backward_LayerNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO () +_backward_LayerNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(ndarray)" args => + ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle] +_Concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Concat_upd :: + forall args . Fullfilled "_Concat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO () +_Concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Concat(ndarray)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle] +_backward_Concat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Concat_upd :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Concat(ndarray)" args -> IO () +_backward_Concat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rnn_param_concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_rnn_param_concat :: + forall args . Fullfilled "_rnn_param_concat(ndarray)" args => + ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle] +_rnn_param_concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_rnn_param_concat_upd :: + forall args . Fullfilled "_rnn_param_concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_rnn_param_concat(ndarray)" args -> IO () +_rnn_param_concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_SoftmaxActivation(ndarray)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt NDArrayHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxActivation args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxActivation_upd :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO () +_SoftmaxActivation_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxActivation(ndarray)" + = '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxActivation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxActivation_upd :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO () +_backward_SoftmaxActivation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LRN(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(ndarray)" args => + ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle] +_LRN args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LRN_upd :: + forall args . Fullfilled "_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO () +_LRN_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LRN(ndarray)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle] +_backward_LRN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LRN_upd :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO () +_backward_LRN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Dropout(ndarray)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(ndarray)" args => + ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle] +_Dropout args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Dropout_upd :: + forall args . Fullfilled "_Dropout(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO () +_Dropout_upd outputs args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Dropout(ndarray)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle] +_backward_Dropout args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Dropout_upd :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Dropout(ndarray)" args -> IO () +_backward_Dropout_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_dequantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["float32"])), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_dequantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_dequantize_upd :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO () +_contrib_dequantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_flatten :: + forall args . + Fullfilled "_contrib_quantized_flatten(ndarray)" args => + ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_flatten_upd :: + forall args . + Fullfilled "_contrib_quantized_flatten(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO () +_contrib_quantized_flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_conv(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle), + '("min_weight", AttrOpt NDArrayHandle), + '("max_weight", AttrOpt NDArrayHandle), + '("min_bias", AttrOpt NDArrayHandle), + '("max_bias", AttrOpt NDArrayHandle)] + +_contrib_quantized_conv :: + forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args => + ArgsHMap "_contrib_quantized_conv(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_conv args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_conv_upd :: + forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO () +_contrib_quantized_conv_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_quantized_fully_connected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle), + '("min_weight", AttrOpt NDArrayHandle), + '("max_weight", AttrOpt NDArrayHandle), + '("min_bias", AttrOpt NDArrayHandle), + '("max_bias", AttrOpt NDArrayHandle)] + +_contrib_quantized_fully_connected :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(ndarray)" + args => + ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_fully_connected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_fully_connected_upd :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_fully_connected(ndarray)" + args + -> IO () +_contrib_quantized_fully_connected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_pooling(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_pooling :: + forall args . + Fullfilled "_contrib_quantized_pooling(ndarray)" args => + ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_pooling args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_pooling_upd :: + forall args . + Fullfilled "_contrib_quantized_pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO () +_contrib_quantized_pooling_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_requantize(ndarray)" = + '[ '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_requantize :: + forall args . Fullfilled "_contrib_requantize(ndarray)" args => + ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_requantize args + = let scalarArgs + = catMaybes + [("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_requantize_upd :: + forall args . Fullfilled "_contrib_requantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_requantize(ndarray)" args -> IO () +_contrib_requantize_upd outputs args + = let scalarArgs + = catMaybes + [("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_quantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantize_upd :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantize(ndarray)" args -> IO () +_contrib_quantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimdecode(ndarray)" = + '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool), + '("buf", AttrOpt NDArrayHandle)] + +_cvimdecode :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle] +_cvimdecode args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimdecode_upd :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO () +_cvimdecode_upd outputs args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimread(ndarray)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(ndarray)" args => + ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle] +_cvimread args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimread_upd :: + forall args . Fullfilled "_cvimread(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO () +_cvimread_upd outputs args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimresize(ndarray)" = + '[ '("w", AttrReq Int), '("h", AttrReq Int), + '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)] + +_cvimresize :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle] +_cvimresize args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimresize_upd :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO () +_cvimresize_upd outputs args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvcopyMakeBorder(ndarray)" = + '[ '("top", AttrReq Int), '("bot", AttrReq Int), + '("left", AttrReq Int), '("right", AttrReq Int), + '("type", AttrOpt Int), '("value", AttrOpt Double), + '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)] + +_cvcopyMakeBorder :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle] +_cvcopyMakeBorder args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvcopyMakeBorder_upd :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO () +_cvcopyMakeBorder_upd outputs args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_NoGradient(ndarray)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle] +_NoGradient args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_NoGradient_upd :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO () +_NoGradient_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CachedOp(ndarray)" = '[] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CachedOp_upd :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO () +_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CachedOp(ndarray)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_backward_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CachedOp_upd :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO () +_backward_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copyto(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copyto :: + forall args . Fullfilled "_copyto(ndarray)" args => + ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle] +_copyto args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copyto_upd :: + forall args . Fullfilled "_copyto(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO () +_copyto_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax_cross_entropy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + ArgsHMap "softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_cross_entropy_upd :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO () +softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +_backward_softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_cross_entropy_upd :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO () +_backward_softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pad(ndarray)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt NDArrayHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(ndarray)" args => + ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle] +_Pad args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pad_upd :: + forall args . Fullfilled "_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO () +_Pad_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_foreach(ndarray)" = '[] + +_backward_foreach :: + forall args . Fullfilled "_backward_foreach(ndarray)" args => + ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle] +_backward_foreach args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_foreach_upd :: + forall args . Fullfilled "_backward_foreach(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_foreach(ndarray)" args -> IO () +_backward_foreach_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_while_loop(ndarray)" = '[] + +_backward_while_loop :: + forall args . Fullfilled "_backward_while_loop(ndarray)" args => + ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle] +_backward_while_loop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_while_loop_upd :: + forall args . Fullfilled "_backward_while_loop(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_while_loop(ndarray)" args -> IO () +_backward_while_loop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cond(ndarray)" = '[] + +_backward_cond :: + forall args . Fullfilled "_backward_cond(ndarray)" args => + ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle] +_backward_cond args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cond_upd :: + forall args . Fullfilled "_backward_cond(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO () +_backward_cond_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LeakyReLU(ndarray)" = + '[ '("act_type", + AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_LeakyReLU args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LeakyReLU_upd :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO () +_LeakyReLU_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SwapAxis(ndarray)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_SwapAxis args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SwapAxis_upd :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO () +_SwapAxis_upd outputs args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> + IO [NDArrayHandle] +_IdentityAttachKLSparseReg args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO () +_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SliceChannel(ndarray)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle] +_SliceChannel args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SliceChannel_upd :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO () +_SliceChannel_upd outputs args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm_v1(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm_v1 args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_v1_upd :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO () +_BatchNorm_v1_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "signsgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +signsgd_update :: + forall args . Fullfilled "signsgd_update(ndarray)" args => + ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle] +signsgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +signsgd_update_upd :: + forall args . Fullfilled "signsgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO () +signsgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "signum_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +signum_update :: + forall args . Fullfilled "signum_update(ndarray)" args => + ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle] +signum_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +signum_update_upd :: + forall args . Fullfilled "signum_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO () +signum_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(ndarray)" args => + ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle] +sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_update_upd :: + forall args . Fullfilled "sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO () +sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_mom_update_upd :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO () +sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_update_upd :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO () +mp_sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_mom_update_upd :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO () +mp_sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftml_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double), + '("t", AttrReq Int), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle), + '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)] + +ftml_update :: + forall args . Fullfilled "ftml_update(ndarray)" args => + ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle] +ftml_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("d",) <$> (args !? #d :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftml_update_upd :: + forall args . Fullfilled "ftml_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO () +ftml_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("d",) <$> (args !? #d :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "adam_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle), + '("var", AttrOpt NDArrayHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(ndarray)" args => + ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle] +adam_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +adam_update_upd :: + forall args . Fullfilled "adam_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO () +adam_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmsprop_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle] +rmsprop_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmsprop_update_upd :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO () +rmsprop_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmspropalex_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle), + '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle] +rmspropalex_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmspropalex_update_upd :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "rmspropalex_update(ndarray)" args -> IO () +rmspropalex_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftrl_update(ndarray)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle), + '("n", AttrOpt NDArrayHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle] +ftrl_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftrl_update_upd :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO () +ftrl_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_adagrad_update(ndarray)" = + '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("history", AttrOpt NDArrayHandle)] + +_sparse_adagrad_update :: + forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args => + ArgsHMap "_sparse_adagrad_update(ndarray)" args -> + IO [NDArrayHandle] +_sparse_adagrad_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_adagrad_update_upd :: + forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO () +_sparse_adagrad_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LinearRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LinearRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LinearRegressionOutput_upd :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO () +_LinearRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linear_reg_out(ndarray)" = + '[] + +_backward_linear_reg_out :: + forall args . + Fullfilled "_backward_linear_reg_out(ndarray)" args => + ArgsHMap "_backward_linear_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_linear_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linear_reg_out_upd :: + forall args . + Fullfilled "_backward_linear_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO () +_backward_linear_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MAERegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle] +_MAERegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MAERegressionOutput_upd :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO () +_MAERegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[] + +_backward_mae_reg_out :: + forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args => + ArgsHMap "_backward_mae_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_mae_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mae_reg_out_upd :: + forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO () +_backward_mae_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LogisticRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LogisticRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LogisticRegressionOutput_upd :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO () +_LogisticRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_logistic_reg_out(ndarray)" = + '[] + +_backward_logistic_reg_out :: + forall args . + Fullfilled "_backward_logistic_reg_out(ndarray)" args => + ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_logistic_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_logistic_reg_out_upd :: + forall args . + Fullfilled "_backward_logistic_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO () +_backward_logistic_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CustomFunction(ndarray)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle] +_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CustomFunction_upd :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CustomFunction(ndarray)" args -> IO () +_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CustomFunction(ndarray)" = + '[] + +_backward_CustomFunction :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + ArgsHMap "_backward_CustomFunction(ndarray)" args -> + IO [NDArrayHandle] +_backward_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CustomFunction_upd :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO () +_backward_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__Native(ndarray)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle] +_backward__Native args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__Native_upd :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__Native(ndarray)" args -> IO () +_backward__Native_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__NDArray(ndarray)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle] +_backward__NDArray args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__NDArray_upd :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__NDArray(ndarray)" args -> IO () +_backward__NDArray_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), + '("anchor", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("cls_pred", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxTarget args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxTarget_upd :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO () +_contrib_MultiBoxTarget_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxTarget args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxTarget_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args + -> IO () +_backward__contrib_MultiBoxTarget_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_Proposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle] +_contrib_Proposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_Proposal_upd :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO () +_contrib_Proposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_Proposal(ndarray)" + = '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_Proposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_Proposal_upd :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO () +_backward__contrib_Proposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_count_sketch(ndarray)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle), + '("s", AttrOpt NDArrayHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + ArgsHMap "_contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_contrib_count_sketch args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_count_sketch_upd :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO () +_contrib_count_sketch_upd outputs args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_count_sketch(ndarray)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_count_sketch args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_count_sketch_upd :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO () +_backward__contrib_count_sketch_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle), + '("loc_pred", AttrOpt NDArrayHandle), + '("anchor", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxDetection args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO () +_contrib_MultiBoxDetection_upd outputs args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)" + args => + ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args + -> IO [NDArrayHandle] +_backward__contrib_MultiBoxDetection args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled + "_backward__contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_MultiBoxDetection(ndarray)" + args + -> IO () +_backward__contrib_MultiBoxDetection_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)" + = '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformablePSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformablePSROIPooling_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO () +_backward__contrib_DeformablePSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_CTCLoss(ndarray)" = + '[] + +_backward__contrib_CTCLoss :: + forall args . + Fullfilled "_backward__contrib_CTCLoss(ndarray)" args => + ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_CTCLoss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_CTCLoss_upd :: + forall args . + Fullfilled "_backward__contrib_CTCLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> IO () +_backward__contrib_CTCLoss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiProposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiProposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiProposal_upd :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO () +_contrib_MultiProposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" args => + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiProposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiProposal_upd :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args + -> IO () +_backward__contrib_MultiProposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxPrior args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxPrior_upd :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO () +_contrib_MultiBoxPrior_upd outputs args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxPrior args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxPrior_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args + -> IO () +_backward__contrib_MultiBoxPrior_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_fft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle] +_contrib_fft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_fft_upd :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO () +_contrib_fft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_fft(ndarray)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + ArgsHMap "_backward__contrib_fft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_fft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_fft_upd :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO () +_backward__contrib_fft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_PSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_PSROIPooling_upd :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO () +_backward__contrib_PSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_DeformableConvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt NDArrayHandle), + '("offset", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO [NDArrayHandle] +_contrib_DeformableConvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_DeformableConvolution_upd :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO () +_contrib_DeformableConvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformableConvolution(ndarray)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformableConvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformableConvolution_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO () +_backward__contrib_DeformableConvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_ifft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle] +_contrib_ifft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ifft_upd :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO () +_contrib_ifft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_ifft(ndarray)" = + '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_ifft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_ifft_upd :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO () +_backward__contrib_ifft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[] + +_backward__contrib_SyncBatchNorm :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args => + ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_SyncBatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_SyncBatchNorm_upd :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args + -> IO () +_backward__contrib_SyncBatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_InstanceNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle] +_InstanceNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_InstanceNorm_upd :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO () +_InstanceNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_InstanceNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_InstanceNorm_upd :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO () +_backward_InstanceNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SVMOutput(ndarray)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_SVMOutput args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SVMOutput_upd :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO () +_SVMOutput_upd outputs args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SVMOutput(ndarray)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_backward_SVMOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SVMOutput_upd :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO () +_backward_SVMOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_GridGenerator(ndarray)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle] +_GridGenerator args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_GridGenerator_upd :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO () +_GridGenerator_upd outputs args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_GridGenerator(ndarray)" = + '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + ArgsHMap "_backward_GridGenerator(ndarray)" args -> + IO [NDArrayHandle] +_backward_GridGenerator args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_GridGenerator_upd :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO () +_backward_GridGenerator_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pad(ndarray)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle] +_backward_Pad args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pad_upd :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO () +_backward_Pad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution_v1(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle] +_Convolution_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_v1_upd :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_Convolution_v1(ndarray)" args -> IO () +_Convolution_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution_v1(ndarray)" = + '[] + +_backward_Convolution_v1 :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_v1_upd :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO () +_backward_Convolution_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceReverse(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle] +_SequenceReverse args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceReverse_upd :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SequenceReverse(ndarray)" args -> IO () +_SequenceReverse_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceReverse(ndarray)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceReverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceReverse_upd :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO () +_backward_SequenceReverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SoftmaxOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxOutput_upd :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO () +_SoftmaxOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxOutput(ndarray)" = + '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxOutput_upd :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO () +_backward_SoftmaxOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Softmax(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_Softmax :: + forall args . Fullfilled "_Softmax(ndarray)" args => + ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle] +_Softmax args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Softmax_upd :: + forall args . Fullfilled "_Softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO () +_Softmax_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Softmax(ndarray)" = '[] + +_backward_Softmax :: + forall args . Fullfilled "_backward_Softmax(ndarray)" args => + ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_Softmax args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Softmax_upd :: + forall args . Fullfilled "_backward_Softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Softmax(ndarray)" args -> IO () +_backward_Softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BilinearSampler(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("grid", AttrOpt NDArrayHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle] +_BilinearSampler args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BilinearSampler_upd :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_BilinearSampler(ndarray)" args -> IO () +_BilinearSampler_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BilinearSampler(ndarray)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> + IO [NDArrayHandle] +_backward_BilinearSampler args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BilinearSampler_upd :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO () +_backward_BilinearSampler_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_backward_LeakyReLU args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LeakyReLU_upd :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO () +_backward_LeakyReLU_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Crop(ndarray)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [NDArrayHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(ndarray)" args => + ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle] +_Crop args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Crop_upd :: + forall args . Fullfilled "_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO () +_Crop_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Crop(ndarray)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle] +_backward_Crop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Crop_upd :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO () +_backward_Crop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ROIPooling(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_ROIPooling args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ROIPooling_upd :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO () +_ROIPooling_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIPooling(ndarray)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIPooling_upd :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO () +_backward_ROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceLast(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle] +_SequenceLast args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceLast_upd :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO () +_SequenceLast_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceLast(ndarray)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + ArgsHMap "_backward_SequenceLast(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceLast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceLast_upd :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO () +_backward_SequenceLast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle] +_CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CrossDeviceCopy_upd :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO () +_CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> + IO [NDArrayHandle] +_backward__CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__CrossDeviceCopy_upd :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO () +_backward__CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SpatialTransformer(ndarray)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle] +_SpatialTransformer args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SpatialTransformer_upd :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO () +_SpatialTransformer_upd outputs args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SpatialTransformer(ndarray)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> + IO [NDArrayHandle] +_backward_SpatialTransformer args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SpatialTransformer_upd :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO () +_backward_SpatialTransformer_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SwapAxis(ndarray)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_backward_SwapAxis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SwapAxis_upd :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO () +_backward_SwapAxis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_L2Normalization(ndarray)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt NDArrayHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle] +_L2Normalization args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_L2Normalization_upd :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_L2Normalization(ndarray)" args -> IO () +_L2Normalization_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_L2Normalization(ndarray)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + ArgsHMap "_backward_L2Normalization(ndarray)" args -> + IO [NDArrayHandle] +_backward_L2Normalization args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_L2Normalization_upd :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO () +_backward_L2Normalization_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Correlation(ndarray)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle), + '("data2", AttrOpt NDArrayHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(ndarray)" args => + ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle] +_Correlation args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Correlation_upd :: + forall args . Fullfilled "_Correlation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO () +_Correlation_upd outputs args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Correlation(ndarray)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + ArgsHMap "_backward_Correlation(ndarray)" args -> + IO [NDArrayHandle] +_backward_Correlation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Correlation_upd :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Correlation(ndarray)" args -> IO () +_backward_Correlation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args + -> IO [NDArrayHandle] +_backward_IdentityAttachKLSparseReg args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" + args + -> IO () +_backward_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MakeLoss(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt NDArrayHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_MakeLoss args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MakeLoss_upd :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO () +_MakeLoss_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_MakeLoss(ndarray)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_backward_MakeLoss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_MakeLoss_upd :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO () +_backward_MakeLoss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SliceChannel(ndarray)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + ArgsHMap "_backward_SliceChannel(ndarray)" args -> + IO [NDArrayHandle] +_backward_SliceChannel args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SliceChannel_upd :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO () +_backward_SliceChannel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_RNN(ndarray)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("parameters", AttrOpt NDArrayHandle), + '("state", AttrOpt NDArrayHandle), + '("state_cell", AttrOpt NDArrayHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(ndarray)" args => + ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle] +_RNN args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_RNN_upd :: + forall args . Fullfilled "_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO () +_RNN_upd outputs args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_RNN(ndarray)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle] +_backward_RNN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_RNN_upd :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO () +_backward_RNN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling_v1(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])), + '("global_pool", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_Pooling_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_v1_upd :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO () +_Pooling_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_v1_upd :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO () +_backward_Pooling_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_BatchNorm_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_v1_upd :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO () +_backward_BatchNorm_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceMask(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle] +_SequenceMask args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceMask_upd :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO () +_SequenceMask_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceMask(ndarray)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + ArgsHMap "_backward_SequenceMask(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceMask args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceMask_upd :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO () +_backward_SequenceMask_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_set_value(ndarray)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(ndarray)" args => + ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle] +_set_value args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_set_value_upd :: + forall args . Fullfilled "_set_value(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO () +_set_value_upd outputs args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_onehot_encode(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_onehot_encode :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle] +_onehot_encode args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_onehot_encode_upd :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO () +_onehot_encode_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "choose_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +choose_element_0index :: + forall args . Fullfilled "choose_element_0index(ndarray)" args => + ArgsHMap "choose_element_0index(ndarray)" args -> + IO [NDArrayHandle] +choose_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "choose_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +choose_element_0index_upd :: + forall args . Fullfilled "choose_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "choose_element_0index(ndarray)" args -> IO () +choose_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "choose_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fill_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +fill_element_0index :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle] +fill_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fill_element_0index_upd :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "fill_element_0index(ndarray)" args -> IO () +fill_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_imdecode(ndarray)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt NDArrayHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(ndarray)" args => + ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle] +_imdecode args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_imdecode_upd :: + forall args . Fullfilled "_imdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO () +_imdecode_upd outputs args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () diff --git a/ops/1.3/MXNet/Base/Operators/Symbol.hs b/ops/1.3/MXNet/Base/Operators/Symbol.hs new file mode 100644 --- /dev/null +++ b/ops/1.3/MXNet/Base/Operators/Symbol.hs @@ -0,0 +1,11404 @@ +module MXNet.Base.Operators.Symbol where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "_sample_multinomial(symbol)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle +_sample_multinomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sample_multinomial(symbol)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_backward_sample_multinomial(symbol)" args -> + IO SymbolHandle +_backward_sample_multinomial name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_uniform(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(symbol)" args => + String -> + ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle +_sample_uniform name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe SymbolHandle), + ("high",) <$> (args !? #high :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_normal(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(symbol)" args => + String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle +_sample_normal name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_gamma(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(symbol)" args => + String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle +_sample_gamma name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_exponential(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(symbol)" args => + String -> + ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle +_sample_exponential name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_poisson(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(symbol)" args => + String -> + ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle +_sample_poisson name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(symbol)" args => + String -> + ArgsHMap "_sample_negative_binomial(symbol)" args -> + IO SymbolHandle +_sample_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe SymbolHandle), + ("p",) <$> (args !? #p :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_sample_generalized_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_sample_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_sample_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_unique_zipfian(symbol)" = + '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])] + +_sample_unique_zipfian :: + forall args . Fullfilled "_sample_unique_zipfian(symbol)" args => + String -> + ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle +_sample_unique_zipfian name args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_uniform(symbol)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(symbol)" args => + String -> + ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle +_random_uniform name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_normal(symbol)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(symbol)" args => + String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle +_random_normal name args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_gamma(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(symbol)" args => + String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle +_random_gamma name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_exponential(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(symbol)" args => + String -> + ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle +_random_exponential name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_poisson(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(symbol)" args => + String -> + ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle +_random_poisson name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_negative_binomial(symbol)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(symbol)" args => + String -> + ArgsHMap "_random_negative_binomial(symbol)" args -> + IO SymbolHandle +_random_negative_binomial name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_generalized_negative_binomial(symbol)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_random_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_random_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_shuffle(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_shuffle :: + forall args . Fullfilled "_shuffle(symbol)" args => + String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle +_shuffle name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Custom(symbol)" = + '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])] + +_Custom :: + forall args . + (Fullfilled "_Custom(symbol)" args, + PopKey (ArgOf "_Custom(symbol)") args "data", + Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) => + String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle +_Custom name args + = let scalarArgs = dump (pop args #data) + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Custom(symbol)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(symbol)" args => + String -> + ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle +_backward_Custom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(symbol)" args => + String -> + ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle +broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_power(symbol)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_power(symbol)" args -> + IO SymbolHandle +_backward_broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(symbol)" args => + String -> + ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle +broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_maximum(symbol)" = + '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_maximum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(symbol)" args => + String -> + ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle +broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_minimum(symbol)" = + '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_minimum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(symbol)" args => + String -> + ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle +broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_hypot(symbol)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_hypot(symbol)" args -> + IO SymbolHandle +_backward_broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_equal :: + forall args . Fullfilled "_equal(symbol)" args => + String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle +_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(symbol)" args => + String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle +_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater :: + forall args . Fullfilled "_greater(symbol)" args => + String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle +_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(symbol)" args => + String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle +_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(symbol)" args => + String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle +_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(symbol)" args => + String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle +_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_and(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_and :: + forall args . Fullfilled "_logical_and(symbol)" args => + String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle +_logical_and name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_or(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_or :: + forall args . Fullfilled "_logical_or(symbol)" args => + String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle +_logical_or name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_xor(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_xor :: + forall args . Fullfilled "_logical_xor(symbol)" args => + String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle +_logical_xor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_power :: + forall args . Fullfilled "_power(symbol)" args => + String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle +_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power(symbol)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(symbol)" args => + String -> + ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle +_backward_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(symbol)" args => + String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle +_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum(symbol)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(symbol)" args => + String -> + ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle +_backward_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(symbol)" args => + String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle +_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum(symbol)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(symbol)" args => + String -> + ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle +_backward_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(symbol)" args => + String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle +_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot(symbol)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(symbol)" args => + String -> + ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle +_backward_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_square_sum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(symbol)" args => + String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle +_square_sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square_sum(symbol)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(symbol)" args => + String -> + ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle +_backward_square_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "add_n(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +add_n :: + forall args . Fullfilled "add_n(symbol)" args => + String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle +add_n name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "add_n" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_zeros(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(symbol)" args => + String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle +_zeros name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_eye(symbol)" = + '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_eye :: + forall args . Fullfilled "_eye(symbol)" args => + String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle +_eye name args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ones(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(symbol)" args => + String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle +_ones name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_full(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(symbol)" args => + String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle +_full name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_arange(symbol)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(symbol)" args => + String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle +_arange name args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "zeros_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(symbol)" args => + String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle +zeros_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ones_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(symbol)" args => + String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle +ones_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(symbol)" args => + String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle +broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_add(symbol)" = '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle +_backward_broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(symbol)" args => + String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle +broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_sub(symbol)" = '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle +_backward_broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(symbol)" args => + String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle +broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mul(symbol)" = '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle +_backward_broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(symbol)" args => + String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle +broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_div(symbol)" = '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle +_backward_broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(symbol)" args => + String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle +broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mod(symbol)" = '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle +_backward_broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(symbol)" args => + String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle +_linalg_gemm name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle), + ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm(symbol)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm2(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("axis", AttrOpt Int), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(symbol)" args => + String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle +_linalg_gemm2 name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potrf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(symbol)" args => + String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle +_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potrf(symbol)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle +_backward_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potri(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(symbol)" args => + String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle +_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potri(symbol)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle +_backward_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trmm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(symbol)" args => + String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle +_linalg_trmm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trmm(symbol)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle +_backward_linalg_trmm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trsm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(symbol)" args => + String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle +_linalg_trsm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trsm(symbol)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle +_backward_linalg_trsm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_sumlogdiag(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle +_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" = + '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args -> + IO SymbolHandle +_backward_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syrk(symbol)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(symbol)" args => + String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle +_linalg_syrk name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syrk(symbol)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle +_backward_linalg_syrk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gelqf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(symbol)" args => + String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle +_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle +_backward_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syevd(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(symbol)" args => + String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle +_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syevd(symbol)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle +_backward_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_histogram(symbol)" = + '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)] + +_histogram :: + forall args . Fullfilled "_histogram(symbol)" args => + String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle +_histogram name args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cast_storage(symbol)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt SymbolHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(symbol)" args => + String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle +cast_storage name args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(symbol)" args => + String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle +_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(symbol)" args => + String -> + ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle +_not_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(symbol)" args => + String -> + ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle +_greater_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(symbol)" args => + String -> + ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle +_greater_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(symbol)" args => + String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle +_lesser_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(symbol)" args => + String -> + ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle +_lesser_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_and_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_and_scalar :: + forall args . Fullfilled "_logical_and_scalar(symbol)" args => + String -> + ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle +_logical_and_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_or_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_or_scalar :: + forall args . Fullfilled "_logical_or_scalar(symbol)" args => + String -> + ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle +_logical_or_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_xor_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_xor_scalar :: + forall args . Fullfilled "_logical_xor_scalar(symbol)" args => + String -> + ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle +_logical_xor_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "relu(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +relu :: + forall args . Fullfilled "relu(symbol)" args => + String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle +relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_relu(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(symbol)" args => + String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle +_backward_relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sigmoid(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(symbol)" args => + String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle +sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sigmoid(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle +_backward_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "hard_sigmoid(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +hard_sigmoid :: + forall args . Fullfilled "hard_sigmoid(symbol)" args => + String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle +hard_sigmoid name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[] + +_backward_hard_sigmoid :: + forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle +_backward_hard_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softsign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +softsign :: + forall args . Fullfilled "softsign(symbol)" args => + String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle +softsign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softsign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softsign :: + forall args . Fullfilled "_backward_softsign(symbol)" args => + String -> + ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle +_backward_softsign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_copy(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_copy :: + forall args . Fullfilled "_copy(symbol)" args => + String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle +_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_copy(symbol)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(symbol)" args => + String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle +_backward_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BlockGrad(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(symbol)" args => + String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle +_BlockGrad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "make_loss(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(symbol)" args => + String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle +make_loss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_identity_with_attr_like_rhs(symbol)" + = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(symbol)" args => + String -> + ArgsHMap "_identity_with_attr_like_rhs(symbol)" args -> + IO SymbolHandle +_identity_with_attr_like_rhs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reshape_like(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(symbol)" args => + String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle +reshape_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "shape_array(symbol)" = + '[ '("lhs_begin", AttrOpt (Maybe Int)), + '("lhs_end", AttrOpt (Maybe Int)), + '("rhs_begin", AttrOpt (Maybe Int)), + '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +shape_array :: + forall args . Fullfilled "shape_array(symbol)" args => + String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle +shape_array name args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "size_array(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +size_array :: + forall args . Fullfilled "size_array(symbol)" args => + String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle +size_array name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Cast(symbol)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(symbol)" args => + String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle +_Cast name args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cast(symbol)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(symbol)" args => + String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle +_backward_cast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "negative(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +negative :: + forall args . Fullfilled "negative(symbol)" args => + String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle +negative name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reciprocal(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(symbol)" args => + String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle +reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reciprocal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(symbol)" args => + String -> + ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle +_backward_reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "abs(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +abs :: + forall args . Fullfilled "abs(symbol)" args => + String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle +abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_abs(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(symbol)" args => + String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle +_backward_abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sign :: + forall args . Fullfilled "sign(symbol)" args => + String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle +sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(symbol)" args => + String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle +_backward_sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "round(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +round :: + forall args . Fullfilled "round(symbol)" args => + String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle +round name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rint(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rint :: + forall args . Fullfilled "rint(symbol)" args => + String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle +rint name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ceil(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ceil :: + forall args . Fullfilled "ceil(symbol)" args => + String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle +ceil name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "floor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +floor :: + forall args . Fullfilled "floor(symbol)" args => + String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle +floor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "trunc(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +trunc :: + forall args . Fullfilled "trunc(symbol)" args => + String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle +trunc name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "fix(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +fix :: + forall args . Fullfilled "fix(symbol)" args => + String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle +fix name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "square(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +square :: + forall args . Fullfilled "square(symbol)" args => + String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle +square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(symbol)" args => + String -> + ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle +_backward_square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(symbol)" args => + String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle +sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(symbol)" args => + String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle +_backward_sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rsqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(symbol)" args => + String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle +rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rsqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(symbol)" args => + String -> + ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle +_backward_rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(symbol)" args => + String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle +cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(symbol)" args => + String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle +_backward_cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rcbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(symbol)" args => + String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle +rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rcbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(symbol)" args => + String -> + ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle +_backward_rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "exp(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +exp :: + forall args . Fullfilled "exp(symbol)" args => + String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle +exp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log :: + forall args . Fullfilled "log(symbol)" args => + String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle +log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log10(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log10 :: + forall args . Fullfilled "log10(symbol)" args => + String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle +log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log2(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log2 :: + forall args . Fullfilled "log2(symbol)" args => + String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle +log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(symbol)" args => + String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle +_backward_log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log10(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(symbol)" args => + String -> + ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle +_backward_log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log2(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(symbol)" args => + String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle +_backward_log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log1p(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log1p :: + forall args . Fullfilled "log1p(symbol)" args => + String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle +log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log1p(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(symbol)" args => + String -> + ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle +_backward_log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expm1(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +expm1 :: + forall args . Fullfilled "expm1(symbol)" args => + String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle +expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_expm1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(symbol)" args => + String -> + ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle +_backward_expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gamma(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gamma :: + forall args . Fullfilled "gamma(symbol)" args => + String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle +gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gamma(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(symbol)" args => + String -> + ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle +_backward_gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gammaln(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(symbol)" args => + String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle +gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gammaln(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(symbol)" args => + String -> + ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle +_backward_gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "logical_not(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +logical_not :: + forall args . Fullfilled "logical_not(symbol)" args => + String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle +logical_not name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +sum :: + forall args . Fullfilled "sum(symbol)" args => + String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle +sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sum(symbol)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(symbol)" args => + String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle +_backward_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mean(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +mean :: + forall args . Fullfilled "mean(symbol)" args => + String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle +mean name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mean(symbol)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(symbol)" args => + String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle +_backward_mean name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "prod(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +prod :: + forall args . Fullfilled "prod(symbol)" args => + String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle +prod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_prod(symbol)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(symbol)" args => + String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle +_backward_prod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nansum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nansum :: + forall args . Fullfilled "nansum(symbol)" args => + String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle +nansum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nansum(symbol)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(symbol)" args => + String -> + ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle +_backward_nansum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nanprod(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(symbol)" args => + String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle +nanprod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nanprod(symbol)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(symbol)" args => + String -> + ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle +_backward_nanprod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "max(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +max :: + forall args . Fullfilled "max(symbol)" args => + String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle +max name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_max(symbol)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(symbol)" args => + String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle +_backward_max name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "min(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +min :: + forall args . Fullfilled "min(symbol)" args => + String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle +min name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_min(symbol)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(symbol)" args => + String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle +_backward_min name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_axis(symbol)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(symbol)" args => + String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle +broadcast_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_to(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(symbol)" args => + String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle +broadcast_to name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_broadcast_backward(symbol)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(symbol)" args => + String -> + ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle +_broadcast_backward name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_like(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_like :: + forall args . Fullfilled "broadcast_like(symbol)" args => + String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle +broadcast_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "norm(symbol)" = + '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])), + '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +norm :: + forall args . Fullfilled "norm(symbol)" args => + String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle +norm name args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_norm(symbol)" = '[] + +_backward_norm :: + forall args . Fullfilled "_backward_norm(symbol)" args => + String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle +_backward_norm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(symbol)" args => + String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle +elemwise_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_grad_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(symbol)" args => + String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle +_grad_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_add(symbol)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(symbol)" args => + String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle +_backward_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(symbol)" args => + String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle +elemwise_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sub(symbol)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(symbol)" args => + String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle +_backward_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(symbol)" args => + String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle +elemwise_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul(symbol)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(symbol)" args => + String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle +_backward_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(symbol)" args => + String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle +elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div(symbol)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(symbol)" args => + String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle +_backward_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_mod :: + forall args . Fullfilled "_mod(symbol)" args => + String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle +_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod(symbol)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(symbol)" args => + String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle +_backward_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(symbol)" args => + String -> + ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle +_scatter_elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle +_scatter_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle +_scatter_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Embedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(symbol)" args => + String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle +_Embedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SparseEmbedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle)] + +_contrib_SparseEmbedding :: + forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle +_contrib_SparseEmbedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Embedding(symbol)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(symbol)" args => + String -> + ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle +_backward_Embedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SparseEmbedding(symbol)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_backward_SparseEmbedding(symbol)" args -> + IO SymbolHandle +_backward_SparseEmbedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "take(symbol)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +take :: + forall args . Fullfilled "take(symbol)" args => + String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle +take name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_take(symbol)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(symbol)" args => + String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle +_backward_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_take(symbol)" = + '[ '("a", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(symbol)" args => + String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle +batch_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "one_hot(symbol)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("indices", AttrOpt SymbolHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(symbol)" args => + String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle +one_hot name args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gather_nd(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(symbol)" args => + String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle +gather_nd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "scatter_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(symbol)" args => + String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle +scatter_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gather_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_backward_gather_nd :: + forall args . Fullfilled "_backward_gather_nd(symbol)" args => + String -> + ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle +_backward_gather_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_set_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(symbol)" args => + String -> + ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle +_scatter_set_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(symbol)" args => + String -> + ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle +broadcast_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(symbol)" args => + String -> + ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle +broadcast_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(symbol)" args => + String -> + ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle +broadcast_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(symbol)" args => + String -> + ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle +broadcast_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(symbol)" args => + String -> + ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle +broadcast_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(symbol)" args => + String -> + ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle +broadcast_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_and(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_and :: + forall args . Fullfilled "broadcast_logical_and(symbol)" args => + String -> + ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle +broadcast_logical_and name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_or(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_or :: + forall args . Fullfilled "broadcast_logical_or(symbol)" args => + String -> + ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle +broadcast_logical_or name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_xor(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_xor :: + forall args . Fullfilled "broadcast_logical_xor(symbol)" args => + String -> + ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle +broadcast_logical_xor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(symbol)" args => + String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle +_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(symbol)" args => + String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle +_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rminus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(symbol)" args => + String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle +_rminus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(symbol)" args => + String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle +_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle +_backward_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(symbol)" args => + String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle +_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(symbol)" args => + String -> + ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle +_backward_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(symbol)" args => + String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle +_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle +_backward_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(symbol)" args => + String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle +_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle +_backward_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(symbol)" args => + String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle +_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle +_backward_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ravel_multi_index(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_ravel_multi_index :: + forall args . Fullfilled "_ravel_multi_index(symbol)" args => + String -> + ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle +_ravel_multi_index name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_unravel_index(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_unravel_index :: + forall args . Fullfilled "_unravel_index(symbol)" args => + String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle +_unravel_index name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmax :: + forall args . Fullfilled "argmax(symbol)" args => + String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle +argmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmin(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmin :: + forall args . Fullfilled "argmin(symbol)" args => + String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle +argmin name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax_channel(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(symbol)" args => + String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle +argmax_channel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "pick(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("mode", AttrOpt (EnumType '["clip", "wrap"])), + '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)] + +pick :: + forall args . Fullfilled "pick(symbol)" args => + String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle +pick name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("index",) <$> (args !? #index :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_pick(symbol)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(symbol)" args => + String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle +_backward_pick name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_retain(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(symbol)" args => + String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle +_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sparse_retain(symbol)" = '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(symbol)" args => + String -> + ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle +_backward_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_where(symbol)" = + '[ '("condition", AttrOpt SymbolHandle), + '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)] + +_where :: + forall args . Fullfilled "_where(symbol)" args => + String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle +_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe SymbolHandle), + ("x",) <$> (args !? #x :: Maybe SymbolHandle), + ("y",) <$> (args !? #y :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_where(symbol)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(symbol)" args => + String -> + ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle +_backward_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "diag(symbol)" = + '[ '("k", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +diag :: + forall args . Fullfilled "diag(symbol)" args => + String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle +diag name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_diag(symbol)" = '[] + +_backward_diag :: + forall args . Fullfilled "_backward_diag(symbol)" args => + String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle +_backward_diag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle +_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_maximum_scalar :: + forall args . Fullfilled "_backward_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle +_backward_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle +_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_minimum_scalar :: + forall args . Fullfilled "_backward_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle +_backward_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(symbol)" args => + String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle +_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(symbol)" args => + String -> + ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle +_backward_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(symbol)" args => + String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle +_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle +_backward_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(symbol)" args => + String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle +_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(symbol)" args => + String -> + ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle +_backward_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "smooth_l1(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(symbol)" args => + String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle +smooth_l1 name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_smooth_l1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(symbol)" args => + String -> + ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle +_backward_smooth_l1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "topk(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +topk :: + forall args . Fullfilled "topk(symbol)" args => + String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle +topk name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_topk(symbol)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(symbol)" args => + String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle +_backward_topk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +sort :: + forall args . Fullfilled "sort(symbol)" args => + String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle +sort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argsort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +argsort :: + forall args . Fullfilled "argsort(symbol)" args => + String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle +argsort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Reshape(symbol)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(symbol)" args => + String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle +_Reshape name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(symbol)" args => + String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle +_Flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "transpose(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +transpose :: + forall args . Fullfilled "transpose(symbol)" args => + String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle +transpose name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expand_dims(symbol)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(symbol)" args => + String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle +expand_dims name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +slice :: + forall args . Fullfilled "slice(symbol)" args => + String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle +slice name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice(symbol)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(symbol)" args => + String -> + ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle +_backward_slice name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(symbol)" args => + String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle +_slice_assign name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(symbol)" args => + String -> + ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle +_slice_assign_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_axis(symbol)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(symbol)" args => + String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle +slice_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_axis(symbol)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(symbol)" args => + String -> + ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle +_backward_slice_axis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_like(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle), + '("shape_like", AttrOpt SymbolHandle)] + +slice_like :: + forall args . Fullfilled "slice_like(symbol)" args => + String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle +slice_like name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_like(symbol)" = '[] + +_backward_slice_like :: + forall args . Fullfilled "_backward_slice_like(symbol)" args => + String -> + ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle +_backward_slice_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "clip(symbol)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +clip :: + forall args . Fullfilled "clip(symbol)" args => + String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle +clip name args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_clip(symbol)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(symbol)" args => + String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle +_backward_clip name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "repeat(symbol)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt SymbolHandle)] + +repeat :: + forall args . Fullfilled "repeat(symbol)" args => + String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle +repeat name args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_repeat(symbol)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(symbol)" args => + String -> + ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle +_backward_repeat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tile(symbol)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +tile :: + forall args . Fullfilled "tile(symbol)" args => + String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle +tile name args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tile(symbol)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(symbol)" args => + String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle +_backward_tile name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reverse(symbol)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +reverse :: + forall args . Fullfilled "reverse(symbol)" args => + String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle +reverse name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reverse(symbol)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(symbol)" args => + String -> + ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle +_backward_reverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "stack(symbol)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [SymbolHandle])] + +stack :: + forall args . Fullfilled "stack(symbol)" args => + String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle +stack name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "stack" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_stack(symbol)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(symbol)" args => + String -> + ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle +_backward_stack name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "squeeze(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), + '("data", AttrOpt [SymbolHandle])] + +squeeze :: + forall args . Fullfilled "squeeze(symbol)" args => + String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle +squeeze name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "squeeze" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_squeeze(symbol)" = '[] + +_backward_squeeze :: + forall args . Fullfilled "_backward_squeeze(symbol)" args => + String -> + ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle +_backward_squeeze name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "depth_to_space(symbol)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +depth_to_space :: + forall args . Fullfilled "depth_to_space(symbol)" args => + String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle +depth_to_space name args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "space_to_depth(symbol)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +space_to_depth :: + forall args . Fullfilled "space_to_depth(symbol)" args => + String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle +space_to_depth name args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +dot :: + forall args . Fullfilled "dot(symbol)" args => + String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle +dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(symbol)" args => + String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle +_backward_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(symbol)" args => + String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle +batch_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_batch_dot(symbol)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(symbol)" args => + String -> + ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle +_backward_batch_dot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sin :: + forall args . Fullfilled "sin(symbol)" args => + String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle +sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(symbol)" args => + String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle +_backward_sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cos :: + forall args . Fullfilled "cos(symbol)" args => + String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle +cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(symbol)" args => + String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle +_backward_cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tan :: + forall args . Fullfilled "tan(symbol)" args => + String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle +tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(symbol)" args => + String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle +_backward_tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(symbol)" args => + String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle +arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(symbol)" args => + String -> + ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle +_backward_arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccos :: + forall args . Fullfilled "arccos(symbol)" args => + String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle +arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(symbol)" args => + String -> + ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle +_backward_arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctan :: + forall args . Fullfilled "arctan(symbol)" args => + String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle +arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(symbol)" args => + String -> + ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle +_backward_arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "degrees(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +degrees :: + forall args . Fullfilled "degrees(symbol)" args => + String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle +degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_degrees(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(symbol)" args => + String -> + ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle +_backward_degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "radians(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +radians :: + forall args . Fullfilled "radians(symbol)" args => + String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle +radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_radians(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(symbol)" args => + String -> + ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle +_backward_radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sinh :: + forall args . Fullfilled "sinh(symbol)" args => + String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle +sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(symbol)" args => + String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle +_backward_sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cosh :: + forall args . Fullfilled "cosh(symbol)" args => + String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle +cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(symbol)" args => + String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle +_backward_cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tanh :: + forall args . Fullfilled "tanh(symbol)" args => + String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle +tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(symbol)" args => + String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle +_backward_tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(symbol)" args => + String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle +arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(symbol)" args => + String -> + ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle +_backward_arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(symbol)" args => + String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle +arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(symbol)" args => + String -> + ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle +_backward_arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(symbol)" args => + String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle +arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(symbol)" args => + String -> + ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle +_backward_arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_CTCLoss(symbol)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle), + '("data_lengths", AttrOpt SymbolHandle), + '("label_lengths", AttrOpt SymbolHandle)] + +_contrib_CTCLoss :: + forall args . Fullfilled "_contrib_CTCLoss(symbol)" args => + String -> + ArgsHMap "_contrib_CTCLoss(symbol)" args -> IO SymbolHandle +_contrib_CTCLoss name args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe SymbolHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_CTCLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quadratic(symbol)" = + '[ '("a", AttrOpt Float), '("b", AttrOpt Float), + '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_contrib_quadratic :: + forall args . Fullfilled "_contrib_quadratic(symbol)" args => + String -> + ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle +_contrib_quadratic name args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_backward_quadratic(symbol)" = + '[] + +_contrib_backward_quadratic :: + forall args . + Fullfilled "_contrib_backward_quadratic(symbol)" args => + String -> + ArgsHMap "_contrib_backward_quadratic(symbol)" args -> + IO SymbolHandle +_contrib_backward_quadratic name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_div_sqrt_dim(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_contrib_div_sqrt_dim :: + forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args => + String -> + ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle +_contrib_div_sqrt_dim name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "khatri_rao(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +khatri_rao :: + forall args . Fullfilled "khatri_rao(symbol)" args => + String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle +khatri_rao name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_contrib_ROIAlign(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_ROIAlign :: + forall args . Fullfilled "_contrib_ROIAlign(symbol)" args => + String -> + ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle +_contrib_ROIAlign name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIAlign(symbol)" = '[] + +_backward_ROIAlign :: + forall args . Fullfilled "_backward_ROIAlign(symbol)" args => + String -> + ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle +_backward_ROIAlign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_box_nms(symbol)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"])), + '("data", AttrOpt SymbolHandle)] + +_contrib_box_nms :: + forall args . Fullfilled "_contrib_box_nms(symbol)" args => + String -> + ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle +_contrib_box_nms name args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_contrib_box_nms(symbol)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_nms :: + forall args . + Fullfilled "_backward_contrib_box_nms(symbol)" args => + String -> + ArgsHMap "_backward_contrib_box_nms(symbol)" args -> + IO SymbolHandle +_backward_contrib_box_nms name args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_box_iou(symbol)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"])), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_contrib_box_iou :: + forall args . Fullfilled "_contrib_box_iou(symbol)" args => + String -> + ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle +_contrib_box_iou name args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_contrib_box_iou(symbol)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_iou :: + forall args . + Fullfilled "_backward_contrib_box_iou(symbol)" args => + String -> + ArgsHMap "_backward_contrib_box_iou(symbol)" args -> + IO SymbolHandle +_backward_contrib_box_iou name args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_bipartite_matching(symbol)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_bipartite_matching :: + forall args . + Fullfilled "_contrib_bipartite_matching(symbol)" args => + String -> + ArgsHMap "_contrib_bipartite_matching(symbol)" args -> + IO SymbolHandle +_contrib_bipartite_matching name args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_bipartite_matching(symbol)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int)] + +_backward_contrib_bipartite_matching :: + forall args . + Fullfilled "_backward_contrib_bipartite_matching(symbol)" + args => + String -> + ArgsHMap "_backward_contrib_bipartite_matching(symbol)" + args + -> IO SymbolHandle +_backward_contrib_bipartite_matching name args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_BilinearResize2D(symbol)" = + '[ '("height", AttrReq Int), '("width", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_contrib_BilinearResize2D :: + forall args . + Fullfilled "_contrib_BilinearResize2D(symbol)" args => + String -> + ArgsHMap "_contrib_BilinearResize2D(symbol)" args -> + IO SymbolHandle +_contrib_BilinearResize2D name args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[] + +_backward_contrib_BilinearResize2D :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args => + String -> + ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args -> + IO SymbolHandle +_backward_contrib_BilinearResize2D name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SyncBatchNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int), + '("key", AttrOpt String), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_contrib_SyncBatchNorm :: + forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args => + String -> + ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle +_contrib_SyncBatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)" + = + '[ '("output_size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args => + String -> + ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args -> + IO SymbolHandle +_contrib_AdaptiveAvgPooling2D name args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" = + '[] + +_backward_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)" + args => + String -> + ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)" + args + -> IO SymbolHandle +_backward_contrib_AdaptiveAvgPooling2D name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_to_tensor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_to_tensor :: + forall args . Fullfilled "_image_to_tensor(symbol)" args => + String -> + ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle +_image_to_tensor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_normalize(symbol)" = + '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]), + '("data", AttrOpt SymbolHandle)] + +_image_normalize :: + forall args . Fullfilled "_image_normalize(symbol)" args => + String -> + ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle +_image_normalize name args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_flip_left_right(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_flip_left_right :: + forall args . Fullfilled "_image_flip_left_right(symbol)" args => + String -> + ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle +_image_flip_left_right name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_flip_left_right(symbol)" + = '[ '("data", AttrOpt SymbolHandle)] + +_image_random_flip_left_right :: + forall args . + Fullfilled "_image_random_flip_left_right(symbol)" args => + String -> + ArgsHMap "_image_random_flip_left_right(symbol)" args -> + IO SymbolHandle +_image_random_flip_left_right name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_flip_top_bottom(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_flip_top_bottom :: + forall args . Fullfilled "_image_flip_top_bottom(symbol)" args => + String -> + ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle +_image_flip_top_bottom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_flip_top_bottom(symbol)" + = '[ '("data", AttrOpt SymbolHandle)] + +_image_random_flip_top_bottom :: + forall args . + Fullfilled "_image_random_flip_top_bottom(symbol)" args => + String -> + ArgsHMap "_image_random_flip_top_bottom(symbol)" args -> + IO SymbolHandle +_image_random_flip_top_bottom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_brightness(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_brightness :: + forall args . Fullfilled "_image_random_brightness(symbol)" args => + String -> + ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle +_image_random_brightness name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_contrast(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_contrast :: + forall args . Fullfilled "_image_random_contrast(symbol)" args => + String -> + ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle +_image_random_contrast name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_saturation(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_saturation :: + forall args . Fullfilled "_image_random_saturation(symbol)" args => + String -> + ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle +_image_random_saturation name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_hue(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_hue :: + forall args . Fullfilled "_image_random_hue(symbol)" args => + String -> + ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle +_image_random_hue name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_color_jitter(symbol)" = + '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float), + '("saturation", AttrReq Float), '("hue", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_color_jitter :: + forall args . + Fullfilled "_image_random_color_jitter(symbol)" args => + String -> + ArgsHMap "_image_random_color_jitter(symbol)" args -> + IO SymbolHandle +_image_random_color_jitter name args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_adjust_lighting(symbol)" = + '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)] + +_image_adjust_lighting :: + forall args . Fullfilled "_image_adjust_lighting(symbol)" args => + String -> + ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle +_image_adjust_lighting name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_lighting(symbol)" = + '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_image_random_lighting :: + forall args . Fullfilled "_image_random_lighting(symbol)" args => + String -> + ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle +_image_random_lighting name args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt SymbolHandle)] + +softmax :: + forall args . Fullfilled "softmax(symbol)" args => + String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle +softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softmax(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(symbol)" args => + String -> + ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle +_backward_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log_softmax(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt SymbolHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(symbol)" args => + String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle +log_softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log_softmax(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(symbol)" args => + String -> + ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle +_backward_log_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(symbol)" args => + String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle +_Pooling name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling(symbol)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(symbol)" args => + String -> + ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle +_backward_Pooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Deconvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(symbol)" args => + String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle +_Deconvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Deconvolution(symbol)" = '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(symbol)" args => + String -> + ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle +_backward_Deconvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Activation(symbol)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt SymbolHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(symbol)" args => + String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle +_Activation name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Activation(symbol)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(symbol)" args => + String -> + ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle +_backward_Activation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_UpSampling(symbol)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(symbol)" args => + String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle +_UpSampling name args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "UpSampling" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_UpSampling(symbol)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(symbol)" args => + String -> + ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle +_backward_UpSampling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(symbol)" args => + String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle +_BatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm(symbol)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle +_backward_BatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_FullyConnected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(symbol)" args => + String -> + ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle +_FullyConnected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_FullyConnected(symbol)" = + '[] + +_backward_FullyConnected :: + forall args . Fullfilled "_backward_FullyConnected(symbol)" args => + String -> + ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle +_backward_FullyConnected name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(symbol)" args => + String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle +_Convolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution(symbol)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(symbol)" args => + String -> + ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle +_backward_Convolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LayerNorm(symbol)" = + '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_LayerNorm :: + forall args . Fullfilled "_LayerNorm(symbol)" args => + String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle +_LayerNorm name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LayerNorm(symbol)" = '[] + +_backward_LayerNorm :: + forall args . Fullfilled "_backward_LayerNorm(symbol)" args => + String -> + ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle +_backward_LayerNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(symbol)" args => + String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle +_Concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Concat(symbol)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(symbol)" args => + String -> + ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle +_backward_Concat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rnn_param_concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_rnn_param_concat :: + forall args . Fullfilled "_rnn_param_concat(symbol)" args => + String -> + ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle +_rnn_param_concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_SoftmaxActivation(symbol)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt SymbolHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle +_SoftmaxActivation name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxActivation(symbol)" = + '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxActivation(symbol)" args -> + IO SymbolHandle +_backward_SoftmaxActivation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LRN(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(symbol)" args => + String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle +_LRN name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LRN(symbol)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(symbol)" args => + String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle +_backward_LRN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Dropout(symbol)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(symbol)" args => + String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle +_Dropout name args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Dropout(symbol)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(symbol)" args => + String -> + ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle +_backward_Dropout name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_dequantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["float32"])), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(symbol)" args => + String -> + ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle +_contrib_dequantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_flatten :: + forall args . + Fullfilled "_contrib_quantized_flatten(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_flatten(symbol)" args -> + IO SymbolHandle +_contrib_quantized_flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_conv(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle), + '("min_weight", AttrOpt SymbolHandle), + '("max_weight", AttrOpt SymbolHandle), + '("min_bias", AttrOpt SymbolHandle), + '("max_bias", AttrOpt SymbolHandle)] + +_contrib_quantized_conv :: + forall args . Fullfilled "_contrib_quantized_conv(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle +_contrib_quantized_conv name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_quantized_fully_connected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle), + '("min_weight", AttrOpt SymbolHandle), + '("max_weight", AttrOpt SymbolHandle), + '("min_bias", AttrOpt SymbolHandle), + '("max_bias", AttrOpt SymbolHandle)] + +_contrib_quantized_fully_connected :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_fully_connected(symbol)" args -> + IO SymbolHandle +_contrib_quantized_fully_connected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_pooling(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_pooling :: + forall args . + Fullfilled "_contrib_quantized_pooling(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_pooling(symbol)" args -> + IO SymbolHandle +_contrib_quantized_pooling name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_requantize(symbol)" = + '[ '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_requantize :: + forall args . Fullfilled "_contrib_requantize(symbol)" args => + String -> + ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle +_contrib_requantize name args + = let scalarArgs + = catMaybes + [("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(symbol)" args => + String -> + ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle +_contrib_quantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_cvimread(symbol)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(symbol)" args => + String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle +_cvimread name args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_NoGradient(symbol)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(symbol)" args => + String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle +_NoGradient name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CachedOp(symbol)" = '[] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(symbol)" args => + String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle +_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CachedOp(symbol)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(symbol)" args => + String -> + ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle +_backward_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax_cross_entropy(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle +softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_softmax_cross_entropy(symbol)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "_backward_softmax_cross_entropy(symbol)" args -> + IO SymbolHandle +_backward_softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pad(symbol)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt SymbolHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(symbol)" args => + String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle +_Pad name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_foreach(symbol)" = '[] + +_backward_foreach :: + forall args . Fullfilled "_backward_foreach(symbol)" args => + String -> + ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle +_backward_foreach name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_while_loop(symbol)" = '[] + +_backward_while_loop :: + forall args . Fullfilled "_backward_while_loop(symbol)" args => + String -> + ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle +_backward_while_loop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cond(symbol)" = '[] + +_backward_cond :: + forall args . Fullfilled "_backward_cond(symbol)" args => + String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle +_backward_cond name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LeakyReLU(symbol)" = + '[ '("act_type", + AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(symbol)" args => + String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle +_LeakyReLU name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SwapAxis(symbol)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt SymbolHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(symbol)" args => + String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle +_SwapAxis name args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(symbol)" args => + String -> + ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args -> + IO SymbolHandle +_IdentityAttachKLSparseReg name args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SliceChannel(symbol)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(symbol)" args => + String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle +_SliceChannel name args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm_v1(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(symbol)" args => + String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_BatchNorm_v1 name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "signsgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +signsgd_update :: + forall args . Fullfilled "signsgd_update(symbol)" args => + String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle +signsgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "signum_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +signum_update :: + forall args . Fullfilled "signum_update(symbol)" args => + String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle +signum_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(symbol)" args => + String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle +sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(symbol)" args => + String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle +sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(symbol)" args => + String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle +mp_sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(symbol)" args => + String -> + ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle +mp_sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftml_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double), + '("t", AttrReq Int), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle)] + +ftml_update :: + forall args . Fullfilled "ftml_update(symbol)" args => + String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle +ftml_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("d",) <$> (args !? #d :: Maybe SymbolHandle), + ("v",) <$> (args !? #v :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "adam_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(symbol)" args => + String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle +adam_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mean",) <$> (args !? #mean :: Maybe SymbolHandle), + ("var",) <$> (args !? #var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmsprop_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(symbol)" args => + String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle +rmsprop_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmspropalex_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle), + '("delta", AttrOpt SymbolHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(symbol)" args => + String -> + ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle +rmspropalex_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle), + ("g",) <$> (args !? #g :: Maybe SymbolHandle), + ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftrl_update(symbol)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(symbol)" args => + String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle +ftrl_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_adagrad_update(symbol)" = + '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("history", AttrOpt SymbolHandle)] + +_sparse_adagrad_update :: + forall args . Fullfilled "_sparse_adagrad_update(symbol)" args => + String -> + ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle +_sparse_adagrad_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("history",) <$> (args !? #history :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LinearRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle +_LinearRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linear_reg_out(symbol)" = + '[] + +_backward_linear_reg_out :: + forall args . Fullfilled "_backward_linear_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle +_backward_linear_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MAERegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(symbol)" args => + String -> + ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle +_MAERegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mae_reg_out(symbol)" = '[] + +_backward_mae_reg_out :: + forall args . Fullfilled "_backward_mae_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle +_backward_mae_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LogisticRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LogisticRegressionOutput(symbol)" args -> + IO SymbolHandle +_LogisticRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_logistic_reg_out(symbol)" = + '[] + +_backward_logistic_reg_out :: + forall args . + Fullfilled "_backward_logistic_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_logistic_reg_out(symbol)" args -> + IO SymbolHandle +_backward_logistic_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CustomFunction(symbol)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(symbol)" args => + String -> + ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle +_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CustomFunction(symbol)" = + '[] + +_backward_CustomFunction :: + forall args . Fullfilled "_backward_CustomFunction(symbol)" args => + String -> + ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle +_backward_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__Native(symbol)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(symbol)" args => + String -> + ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle +_backward__Native name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__NDArray(symbol)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(symbol)" args => + String -> + ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle +_backward__NDArray name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxTarget(symbol)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle), + '("cls_pred", AttrOpt SymbolHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxTarget name args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxTarget name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_Proposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle +_contrib_Proposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_Proposal(symbol)" = + '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_Proposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_Proposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_count_sketch(symbol)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle), + '("s", AttrOpt SymbolHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle +_contrib_count_sketch name args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("h",) <$> (args !? #h :: Maybe SymbolHandle), + ("s",) <$> (args !? #s :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_count_sketch(symbol)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_backward__contrib_count_sketch(symbol)" args -> + IO SymbolHandle +_backward__contrib_count_sketch name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxDetection(symbol)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle), + '("loc_pred", AttrOpt SymbolHandle), + '("anchor", AttrOpt SymbolHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxDetection(symbol)" args -> + IO SymbolHandle +_contrib_MultiBoxDetection name args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle), + ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(symbol)" + args => + String -> + ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)" + args + -> IO SymbolHandle +_backward__contrib_MultiBoxDetection name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformablePSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("group_size", AttrReq Int), '("pooled_size", AttrReq Int), + '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int), + '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle), + '("trans", AttrOpt SymbolHandle)] + +_contrib_DeformablePSROIPooling :: + forall args . + Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args -> + IO SymbolHandle +_contrib_DeformablePSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int), + ("sample_per_part",) . showValue <$> + (args !? #sample_per_part :: Maybe Int), + ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float), + ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle), + ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" = + '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformablePSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_CTCLoss(symbol)" = + '[] + +_backward__contrib_CTCLoss :: + forall args . + Fullfilled "_backward__contrib_CTCLoss(symbol)" args => + String -> + ArgsHMap "_backward__contrib_CTCLoss(symbol)" args -> + IO SymbolHandle +_backward__contrib_CTCLoss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_CTCLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiProposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle +_contrib_MultiProposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiProposal(symbol)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiProposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiProposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxPrior(symbol)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxPrior name args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxPrior name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_fft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(symbol)" args => + String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle +_contrib_fft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_fft(symbol)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle +_backward__contrib_fft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_PSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_PSROIPooling :: + forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle +_contrib_PSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args -> + IO SymbolHandle +_backward__contrib_PSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformableConvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(symbol)" args => + String -> + ArgsHMap "_contrib_DeformableConvolution(symbol)" args -> + IO SymbolHandle +_contrib_DeformableConvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("offset",) <$> (args !? #offset :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformableConvolution(symbol)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformableConvolution(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformableConvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_ifft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(symbol)" args => + String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle +_contrib_ifft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_ifft(symbol)" = '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle +_backward__contrib_ifft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[] + +_backward__contrib_SyncBatchNorm :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args => + String -> + ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args -> + IO SymbolHandle +_backward__contrib_SyncBatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_InstanceNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(symbol)" args => + String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle +_InstanceNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_InstanceNorm(symbol)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(symbol)" args => + String -> + ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle +_backward_InstanceNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SVMOutput(symbol)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(symbol)" args => + String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle +_SVMOutput name args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SVMOutput(symbol)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(symbol)" args => + String -> + ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle +_backward_SVMOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_GridGenerator(symbol)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(symbol)" args => + String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle +_GridGenerator name args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_GridGenerator(symbol)" = '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(symbol)" args => + String -> + ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle +_backward_GridGenerator name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pad(symbol)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(symbol)" args => + String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle +_backward_Pad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution_v1(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle +_Convolution_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution_v1(symbol)" = + '[] + +_backward_Convolution_v1 :: + forall args . Fullfilled "_backward_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle +_backward_Convolution_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceReverse(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle +_SequenceReverse name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceReverse(symbol)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_backward_SequenceReverse(symbol)" args -> + IO SymbolHandle +_backward_SequenceReverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SoftmaxOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(symbol)" args => + String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_SoftmaxOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_backward_SoftmaxOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Softmax(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_Softmax :: + forall args . Fullfilled "_Softmax(symbol)" args => + String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle +_Softmax name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Softmax(symbol)" = '[] + +_backward_Softmax :: + forall args . Fullfilled "_backward_Softmax(symbol)" args => + String -> + ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle +_backward_Softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BilinearSampler(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("grid", AttrOpt SymbolHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle +_BilinearSampler name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BilinearSampler(symbol)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_backward_BilinearSampler(symbol)" args -> + IO SymbolHandle +_backward_BilinearSampler name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LeakyReLU(symbol)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(symbol)" args => + String -> + ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle +_backward_LeakyReLU name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Crop(symbol)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [SymbolHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(symbol)" args => + String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle +_Crop name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Crop" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Crop(symbol)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(symbol)" args => + String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle +_backward_Crop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ROIPooling(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle), + '("rois", AttrOpt SymbolHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(symbol)" args => + String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle +_ROIPooling name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIPooling(symbol)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(symbol)" args => + String -> + ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle +_backward_ROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceLast(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(symbol)" args => + String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle +_SequenceLast name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceLast(symbol)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(symbol)" args => + String -> + ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle +_backward_SequenceLast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CrossDeviceCopy(symbol)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle +_CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__CrossDeviceCopy(symbol)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_backward__CrossDeviceCopy(symbol)" args -> + IO SymbolHandle +_backward__CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SpatialTransformer(symbol)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle +_SpatialTransformer name args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SpatialTransformer(symbol)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_backward_SpatialTransformer(symbol)" args -> + IO SymbolHandle +_backward_SpatialTransformer name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SwapAxis(symbol)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(symbol)" args => + String -> + ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle +_backward_SwapAxis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_L2Normalization(symbol)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt SymbolHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(symbol)" args => + String -> + ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle +_L2Normalization name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_L2Normalization(symbol)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(symbol)" args => + String -> + ArgsHMap "_backward_L2Normalization(symbol)" args -> + IO SymbolHandle +_backward_L2Normalization name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Correlation(symbol)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle), + '("data2", AttrOpt SymbolHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(symbol)" args => + String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle +_Correlation name args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle), + ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Correlation(symbol)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(symbol)" args => + String -> + ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle +_backward_Correlation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)" + args => + String -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args + -> IO SymbolHandle +_backward_IdentityAttachKLSparseReg name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MakeLoss(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt SymbolHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(symbol)" args => + String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle +_MakeLoss name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_MakeLoss(symbol)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(symbol)" args => + String -> + ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle +_backward_MakeLoss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SliceChannel(symbol)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(symbol)" args => + String -> + ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle +_backward_SliceChannel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_RNN(symbol)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), + '("parameters", AttrOpt SymbolHandle), + '("state", AttrOpt SymbolHandle), + '("state_cell", AttrOpt SymbolHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(symbol)" args => + String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle +_RNN name args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle), + ("state",) <$> (args !? #state :: Maybe SymbolHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_RNN(symbol)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(symbol)" args => + String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle +_backward_RNN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling_v1(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])), + '("global_pool", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(symbol)" args => + String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle +_Pooling_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling_v1(symbol)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(symbol)" args => + String -> + ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle +_backward_Pooling_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_backward_BatchNorm_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceMask(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(symbol)" args => + String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle +_SequenceMask name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceMask(symbol)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(symbol)" args => + String -> + ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle +_backward_SequenceMask name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_set_value(symbol)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(symbol)" args => + String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle +_set_value name args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_imdecode(symbol)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt SymbolHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(symbol)" args => + String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle +_imdecode name args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym diff --git a/ops/1.4/MXNet/Base/Operators/NDArray.hs b/ops/1.4/MXNet/Base/Operators/NDArray.hs new file mode 100644 --- /dev/null +++ b/ops/1.4/MXNet/Base/Operators/NDArray.hs @@ -0,0 +1,21107 @@ +module MXNet.Base.Operators.NDArray where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "_CuDNNBatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_CuDNNBatchNorm :: + forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args => + ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle] +_CuDNNBatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CuDNNBatchNorm_upd :: + forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO () +_CuDNNBatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" = + '[] + +_backward_CuDNNBatchNorm :: + forall args . + Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args => + ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_CuDNNBatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CuDNNBatchNorm_upd :: + forall args . + Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO () +_backward_CuDNNBatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_multinomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle] +_sample_multinomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_multinomial_upd :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_multinomial(ndarray)" args -> IO () +_sample_multinomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sample_multinomial(ndarray)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> + IO [NDArrayHandle] +_backward_sample_multinomial args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sample_multinomial_upd :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO () +_backward_sample_multinomial_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_uniform(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle] +_sample_uniform args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_uniform_upd :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_uniform(ndarray)" args -> IO () +_sample_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_normal(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle] +_sample_normal args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_normal_upd :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO () +_sample_normal_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_gamma(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle] +_sample_gamma args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_gamma_upd :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO () +_sample_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_exponential(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle] +_sample_exponential args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_exponential_upd :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_exponential(ndarray)" args -> IO () +_sample_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_poisson(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle] +_sample_poisson args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_poisson_upd :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_poisson(ndarray)" args -> IO () +_sample_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + ArgsHMap "_sample_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_sample_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_negative_binomial_upd :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO () +_sample_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_sample_generalized_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_sample_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_sample_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_sample_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_sample_generalized_negative_binomial(ndarray)" + args + -> IO () +_sample_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_unique_zipfian(ndarray)" = + '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])] + +_sample_unique_zipfian :: + forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args => + ArgsHMap "_sample_unique_zipfian(ndarray)" args -> + IO [NDArrayHandle] +_sample_unique_zipfian args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_unique_zipfian_upd :: + forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO () +_sample_unique_zipfian_upd outputs args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_uniform(ndarray)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle] +_random_uniform args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_uniform_upd :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_uniform(ndarray)" args -> IO () +_random_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_normal(ndarray)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(ndarray)" args => + ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle] +_random_normal args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_normal_upd :: + forall args . Fullfilled "_random_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO () +_random_normal_upd outputs args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_gamma(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle] +_random_gamma args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_gamma_upd :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO () +_random_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_exponential(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle] +_random_exponential args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_exponential_upd :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_exponential(ndarray)" args -> IO () +_random_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_poisson(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle] +_random_poisson args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_poisson_upd :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_poisson(ndarray)" args -> IO () +_random_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_negative_binomial(ndarray)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + ArgsHMap "_random_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_random_negative_binomial args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_negative_binomial_upd :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_negative_binomial(ndarray)" args -> IO () +_random_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_generalized_negative_binomial(ndarray)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_random_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_random_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_random_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_random_generalized_negative_binomial(ndarray)" + args + -> IO () +_random_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_randint(ndarray)" = + '[ '("low", AttrReq Int), '("high", AttrReq Int), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))] + +_random_randint :: + forall args . Fullfilled "_random_randint(ndarray)" args => + ArgsHMap "_random_randint(ndarray)" args -> IO [NDArrayHandle] +_random_randint args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Int), + ("high",) . showValue <$> (args !? #high :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_randint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_randint_upd :: + forall args . Fullfilled "_random_randint(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_randint(ndarray)" args -> IO () +_random_randint_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Int), + ("high",) . showValue <$> (args !? #high :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_randint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_uniform_like(ndarray)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_uniform_like :: + forall args . Fullfilled "_random_uniform_like(ndarray)" args => + ArgsHMap "_random_uniform_like(ndarray)" args -> IO [NDArrayHandle] +_random_uniform_like args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_uniform_like_upd :: + forall args . Fullfilled "_random_uniform_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_uniform_like(ndarray)" args -> IO () +_random_uniform_like_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_normal_like(ndarray)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_normal_like :: + forall args . Fullfilled "_random_normal_like(ndarray)" args => + ArgsHMap "_random_normal_like(ndarray)" args -> IO [NDArrayHandle] +_random_normal_like args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_normal_like_upd :: + forall args . Fullfilled "_random_normal_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_normal_like(ndarray)" args -> IO () +_random_normal_like_upd outputs args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_gamma_like(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_gamma_like :: + forall args . Fullfilled "_random_gamma_like(ndarray)" args => + ArgsHMap "_random_gamma_like(ndarray)" args -> IO [NDArrayHandle] +_random_gamma_like args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_gamma_like_upd :: + forall args . Fullfilled "_random_gamma_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_gamma_like(ndarray)" args -> IO () +_random_gamma_like_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_exponential_like(ndarray)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_random_exponential_like :: + forall args . + Fullfilled "_random_exponential_like(ndarray)" args => + ArgsHMap "_random_exponential_like(ndarray)" args -> + IO [NDArrayHandle] +_random_exponential_like args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_exponential_like_upd :: + forall args . + Fullfilled "_random_exponential_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_exponential_like(ndarray)" args -> IO () +_random_exponential_like_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_poisson_like(ndarray)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_random_poisson_like :: + forall args . Fullfilled "_random_poisson_like(ndarray)" args => + ArgsHMap "_random_poisson_like(ndarray)" args -> IO [NDArrayHandle] +_random_poisson_like args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_poisson_like_upd :: + forall args . Fullfilled "_random_poisson_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_poisson_like(ndarray)" args -> IO () +_random_poisson_like_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_negative_binomial_like(ndarray)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_negative_binomial_like :: + forall args . + Fullfilled "_random_negative_binomial_like(ndarray)" args => + ArgsHMap "_random_negative_binomial_like(ndarray)" args -> + IO [NDArrayHandle] +_random_negative_binomial_like args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_negative_binomial_like_upd :: + forall args . + Fullfilled "_random_negative_binomial_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_negative_binomial_like(ndarray)" args -> + IO () +_random_negative_binomial_like_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_generalized_negative_binomial_like(ndarray)" + = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_generalized_negative_binomial_like :: + forall args . + Fullfilled + "_random_generalized_negative_binomial_like(ndarray)" + args => + ArgsHMap + "_random_generalized_negative_binomial_like(ndarray)" + args + -> IO [NDArrayHandle] +_random_generalized_negative_binomial_like args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_generalized_negative_binomial_like_upd :: + forall args . + Fullfilled + "_random_generalized_negative_binomial_like(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_random_generalized_negative_binomial_like(ndarray)" + args + -> IO () +_random_generalized_negative_binomial_like_upd outputs args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_shuffle(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_shuffle :: + forall args . Fullfilled "_shuffle(ndarray)" args => + ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle] +_shuffle args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_shuffle_upd :: + forall args . Fullfilled "_shuffle(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO () +_shuffle_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Custom(ndarray)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle] +_backward_Custom args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Custom_upd :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Custom(ndarray)" args -> IO () +_backward_Custom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle] +broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_power_upd :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_power(ndarray)" args -> IO () +broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_power(ndarray)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + ArgsHMap "_backward_broadcast_power(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_power_upd :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO () +_backward_broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle] +broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_maximum_upd :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_maximum(ndarray)" args -> IO () +broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_maximum(ndarray)" + = '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_maximum_upd :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO () +_backward_broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle] +broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_minimum_upd :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_minimum(ndarray)" args -> IO () +broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_minimum(ndarray)" + = '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_minimum_upd :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO () +_backward_broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle] +broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_hypot_upd :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_hypot(ndarray)" args -> IO () +broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_hypot(ndarray)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_hypot_upd :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO () +_backward_broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_equal :: + forall args . Fullfilled "_equal(ndarray)" args => + ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle] +_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_upd :: + forall args . Fullfilled "_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO () +_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(ndarray)" args => + ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle] +_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_upd :: + forall args . Fullfilled "_not_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO () +_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater :: + forall args . Fullfilled "_greater(ndarray)" args => + ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle] +_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_upd :: + forall args . Fullfilled "_greater(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO () +_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle] +_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_upd :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO () +_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(ndarray)" args => + ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle] +_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_upd :: + forall args . Fullfilled "_lesser(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO () +_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_upd :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO () +_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_and(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_and :: + forall args . Fullfilled "_logical_and(ndarray)" args => + ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle] +_logical_and args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_and_upd :: + forall args . Fullfilled "_logical_and(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO () +_logical_and_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_or(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_or :: + forall args . Fullfilled "_logical_or(ndarray)" args => + ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle] +_logical_or args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_or_upd :: + forall args . Fullfilled "_logical_or(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO () +_logical_or_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_xor(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_xor :: + forall args . Fullfilled "_logical_xor(ndarray)" args => + ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle] +_logical_xor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_xor_upd :: + forall args . Fullfilled "_logical_xor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO () +_logical_xor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_power :: + forall args . Fullfilled "_power(ndarray)" args => + ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle] +_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_upd :: + forall args . Fullfilled "_power(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO () +_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power(ndarray)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(ndarray)" args => + ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle] +_backward_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_upd :: + forall args . Fullfilled "_backward_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power(ndarray)" args -> IO () +_backward_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(ndarray)" args => + ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle] +_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_upd :: + forall args . Fullfilled "_maximum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO () +_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum(ndarray)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle] +_backward_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_upd :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum(ndarray)" args -> IO () +_backward_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(ndarray)" args => + ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle] +_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_upd :: + forall args . Fullfilled "_minimum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO () +_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum(ndarray)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle] +_backward_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_upd :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum(ndarray)" args -> IO () +_backward_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(ndarray)" args => + ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle] +_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_upd :: + forall args . Fullfilled "_hypot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO () +_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot(ndarray)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle] +_backward_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_upd :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot(ndarray)" args -> IO () +_backward_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_square_sum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(ndarray)" args => + ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle] +_square_sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_square_sum_upd :: + forall args . Fullfilled "_square_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO () +_square_sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square_sum(ndarray)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_square_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_sum_upd :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square_sum(ndarray)" args -> IO () +_backward_square_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "add_n(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +add_n :: + forall args . Fullfilled "add_n(ndarray)" args => + ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle] +add_n args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +add_n_upd :: + forall args . Fullfilled "add_n(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO () +add_n_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_zeros_without_dtype(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt Int)] + +_zeros_without_dtype :: + forall args . Fullfilled "_zeros_without_dtype(ndarray)" args => + ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO [NDArrayHandle] +_zeros_without_dtype args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros_without_dtype" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_zeros_without_dtype_upd :: + forall args . Fullfilled "_zeros_without_dtype(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO () +_zeros_without_dtype_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros_without_dtype" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_zeros(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(ndarray)" args => + ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle] +_zeros args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_zeros_upd :: + forall args . Fullfilled "_zeros(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO () +_zeros_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_eye(ndarray)" = + '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_eye :: + forall args . Fullfilled "_eye(ndarray)" args => + ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle] +_eye args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_eye_upd :: + forall args . Fullfilled "_eye(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO () +_eye_upd outputs args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ones(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(ndarray)" args => + ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle] +_ones args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ones_upd :: + forall args . Fullfilled "_ones(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO () +_ones_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_full(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(ndarray)" args => + ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle] +_full args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_full_upd :: + forall args . Fullfilled "_full(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO () +_full_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_arange(ndarray)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(ndarray)" args => + ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle] +_arange args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_arange_upd :: + forall args . Fullfilled "_arange(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO () +_arange_upd outputs args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "zeros_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(ndarray)" args => + ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle] +zeros_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +zeros_like_upd :: + forall args . Fullfilled "zeros_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO () +zeros_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ones_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(ndarray)" args => + ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle] +ones_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ones_like_upd :: + forall args . Fullfilled "ones_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO () +ones_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle] +broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_add_upd :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO () +broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_add(ndarray)" = + '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + ArgsHMap "_backward_broadcast_add(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_add_upd :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO () +_backward_broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle] +broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_sub_upd :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO () +broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_sub(ndarray)" = + '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_sub_upd :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO () +_backward_broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle] +broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mul_upd :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO () +broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mul(ndarray)" = + '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mul_upd :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO () +_backward_broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle] +broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_div_upd :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO () +broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_div(ndarray)" = + '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + ArgsHMap "_backward_broadcast_div(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_div_upd :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO () +_backward_broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle] +broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mod_upd :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO () +broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mod(ndarray)" = + '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mod_upd :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO () +_backward_broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm_upd :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO () +_linalg_gemm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm_upd :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO () +_backward_linalg_gemm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm2(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("axis", AttrOpt Int), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm2 args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm2_upd :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO () +_linalg_gemm2_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm2 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm2_upd :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO () +_backward_linalg_gemm2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potrf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle] +_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potrf_upd :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO () +_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potrf_upd :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO () +_backward_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potri(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle] +_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potri_upd :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO () +_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potri(ndarray)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + ArgsHMap "_backward_linalg_potri(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potri_upd :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO () +_backward_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trmm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trmm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trmm_upd :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO () +_linalg_trmm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trmm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trmm_upd :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO () +_backward_linalg_trmm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trsm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trsm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trsm_upd :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO () +_linalg_trsm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trsm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trsm_upd :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO () +_backward_linalg_trsm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_sumlogdiag(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle] +_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_sumlogdiag_upd :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO () +_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)" + = '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_sumlogdiag_upd :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO () +_backward_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syrk(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle] +_linalg_syrk args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syrk_upd :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO () +_linalg_syrk_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syrk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syrk_upd :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO () +_backward_linalg_syrk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gelqf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle] +_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gelqf_upd :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO () +_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gelqf_upd :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO () +_backward_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syevd(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle] +_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syevd_upd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO () +_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syevd_upd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO () +_backward_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_histogram(ndarray)" = + '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)] + +_histogram :: + forall args . Fullfilled "_histogram(ndarray)" args => + ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle] +_histogram args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_histogram_upd :: + forall args . Fullfilled "_histogram(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO () +_histogram_upd outputs args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cast_storage(ndarray)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt NDArrayHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(ndarray)" args => + ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle] +cast_storage args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cast_storage_upd :: + forall args . Fullfilled "cast_storage(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO () +cast_storage_upd outputs args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_scalar_upd :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO () +_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_not_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_scalar_upd :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO () +_not_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle] +_greater_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_scalar_upd :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_scalar(ndarray)" args -> IO () +_greater_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + ArgsHMap "_greater_equal_scalar(ndarray)" args -> + IO [NDArrayHandle] +_greater_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_scalar_upd :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO () +_greater_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_scalar_upd :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO () +_lesser_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_scalar_upd :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO () +_lesser_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_and_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_and_scalar :: + forall args . Fullfilled "_logical_and_scalar(ndarray)" args => + ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_and_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_and_scalar_upd :: + forall args . Fullfilled "_logical_and_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_and_scalar(ndarray)" args -> IO () +_logical_and_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_or_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_or_scalar :: + forall args . Fullfilled "_logical_or_scalar(ndarray)" args => + ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_or_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_or_scalar_upd :: + forall args . Fullfilled "_logical_or_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_or_scalar(ndarray)" args -> IO () +_logical_or_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_xor_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_xor_scalar :: + forall args . Fullfilled "_logical_xor_scalar(ndarray)" args => + ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_xor_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_xor_scalar_upd :: + forall args . Fullfilled "_logical_xor_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO () +_logical_xor_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "relu(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +relu :: + forall args . Fullfilled "relu(ndarray)" args => + ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle] +relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +relu_upd :: + forall args . Fullfilled "relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO () +relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_relu(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle] +_backward_relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_relu_upd :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO () +_backward_relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sigmoid(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(ndarray)" args => + ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle] +sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sigmoid_upd :: + forall args . Fullfilled "sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO () +sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sigmoid(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle] +_backward_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sigmoid_upd :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO () +_backward_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "hard_sigmoid(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +hard_sigmoid :: + forall args . Fullfilled "hard_sigmoid(ndarray)" args => + ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle] +hard_sigmoid args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +hard_sigmoid_upd :: + forall args . Fullfilled "hard_sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO () +hard_sigmoid_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[] + +_backward_hard_sigmoid :: + forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args => + ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> + IO [NDArrayHandle] +_backward_hard_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hard_sigmoid_upd :: + forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO () +_backward_hard_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softsign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +softsign :: + forall args . Fullfilled "softsign(ndarray)" args => + ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle] +softsign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softsign_upd :: + forall args . Fullfilled "softsign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO () +softsign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softsign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softsign :: + forall args . Fullfilled "_backward_softsign(ndarray)" args => + ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle] +_backward_softsign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softsign_upd :: + forall args . Fullfilled "_backward_softsign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softsign(ndarray)" args -> IO () +_backward_softsign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copy :: + forall args . Fullfilled "_copy(ndarray)" args => + ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle] +_copy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copy_upd :: + forall args . Fullfilled "_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO () +_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_copy(ndarray)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle] +_backward_copy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_copy_upd :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO () +_backward_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BlockGrad(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle] +_BlockGrad args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BlockGrad_upd :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO () +_BlockGrad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "make_loss(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(ndarray)" args => + ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle] +make_loss args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +make_loss_upd :: + forall args . Fullfilled "make_loss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO () +make_loss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_identity_with_attr_like_rhs(ndarray)" + = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> + IO [NDArrayHandle] +_identity_with_attr_like_rhs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_identity_with_attr_like_rhs_upd :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO () +_identity_with_attr_like_rhs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reshape_like(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(ndarray)" args => + ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle] +reshape_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reshape_like_upd :: + forall args . Fullfilled "reshape_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO () +reshape_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "shape_array(ndarray)" = + '[ '("lhs_begin", AttrOpt (Maybe Int)), + '("lhs_end", AttrOpt (Maybe Int)), + '("rhs_begin", AttrOpt (Maybe Int)), + '("rhs_end", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +shape_array :: + forall args . Fullfilled "shape_array(ndarray)" args => + ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle] +shape_array args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +shape_array_upd :: + forall args . Fullfilled "shape_array(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO () +shape_array_upd outputs args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "size_array(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +size_array :: + forall args . Fullfilled "size_array(ndarray)" args => + ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle] +size_array args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +size_array_upd :: + forall args . Fullfilled "size_array(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO () +size_array_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Cast(ndarray)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(ndarray)" args => + ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle] +_Cast args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Cast_upd :: + forall args . Fullfilled "_Cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO () +_Cast_upd outputs args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cast(ndarray)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle] +_backward_cast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cast_upd :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO () +_backward_cast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "negative(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +negative :: + forall args . Fullfilled "negative(ndarray)" args => + ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle] +negative args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +negative_upd :: + forall args . Fullfilled "negative(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO () +negative_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reciprocal(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(ndarray)" args => + ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle] +reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reciprocal_upd :: + forall args . Fullfilled "reciprocal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO () +reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reciprocal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle] +_backward_reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reciprocal_upd :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO () +_backward_reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "abs(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +abs :: + forall args . Fullfilled "abs(ndarray)" args => + ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle] +abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +abs_upd :: + forall args . Fullfilled "abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO () +abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_abs(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle] +_backward_abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_abs_upd :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO () +_backward_abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sign :: + forall args . Fullfilled "sign(ndarray)" args => + ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle] +sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sign_upd :: + forall args . Fullfilled "sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO () +sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle] +_backward_sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sign_upd :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO () +_backward_sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "round(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +round :: + forall args . Fullfilled "round(ndarray)" args => + ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle] +round args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +round_upd :: + forall args . Fullfilled "round(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO () +round_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rint(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rint :: + forall args . Fullfilled "rint(ndarray)" args => + ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle] +rint args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rint_upd :: + forall args . Fullfilled "rint(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO () +rint_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ceil(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ceil :: + forall args . Fullfilled "ceil(ndarray)" args => + ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle] +ceil args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ceil_upd :: + forall args . Fullfilled "ceil(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO () +ceil_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "floor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +floor :: + forall args . Fullfilled "floor(ndarray)" args => + ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle] +floor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +floor_upd :: + forall args . Fullfilled "floor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO () +floor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "trunc(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +trunc :: + forall args . Fullfilled "trunc(ndarray)" args => + ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle] +trunc args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +trunc_upd :: + forall args . Fullfilled "trunc(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO () +trunc_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fix(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +fix :: + forall args . Fullfilled "fix(ndarray)" args => + ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle] +fix args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fix_upd :: + forall args . Fullfilled "fix(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO () +fix_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "square(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +square :: + forall args . Fullfilled "square(ndarray)" args => + ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle] +square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +square_upd :: + forall args . Fullfilled "square(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO () +square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(ndarray)" args => + ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle] +_backward_square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_upd :: + forall args . Fullfilled "_backward_square(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square(ndarray)" args -> IO () +_backward_square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(ndarray)" args => + ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle] +sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sqrt_upd :: + forall args . Fullfilled "sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO () +sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sqrt_upd :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO () +_backward_sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rsqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(ndarray)" args => + ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle] +rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rsqrt_upd :: + forall args . Fullfilled "rsqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO () +rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rsqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rsqrt_upd :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO () +_backward_rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(ndarray)" args => + ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle] +cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cbrt_upd :: + forall args . Fullfilled "cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO () +cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cbrt_upd :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO () +_backward_cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "erf(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +erf :: + forall args . Fullfilled "erf(ndarray)" args => + ArgsHMap "erf(ndarray)" args -> IO [NDArrayHandle] +erf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +erf_upd :: + forall args . Fullfilled "erf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "erf(ndarray)" args -> IO () +erf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_erf(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_erf :: + forall args . Fullfilled "_backward_erf(ndarray)" args => + ArgsHMap "_backward_erf(ndarray)" args -> IO [NDArrayHandle] +_backward_erf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_erf_upd :: + forall args . Fullfilled "_backward_erf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_erf(ndarray)" args -> IO () +_backward_erf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rcbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(ndarray)" args => + ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle] +rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rcbrt_upd :: + forall args . Fullfilled "rcbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO () +rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rcbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rcbrt_upd :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO () +_backward_rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "exp(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +exp :: + forall args . Fullfilled "exp(ndarray)" args => + ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle] +exp args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +exp_upd :: + forall args . Fullfilled "exp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO () +exp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log :: + forall args . Fullfilled "log(ndarray)" args => + ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle] +log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_upd :: + forall args . Fullfilled "log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO () +log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log10(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log10 :: + forall args . Fullfilled "log10(ndarray)" args => + ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle] +log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log10_upd :: + forall args . Fullfilled "log10(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO () +log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log2(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log2 :: + forall args . Fullfilled "log2(ndarray)" args => + ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle] +log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log2_upd :: + forall args . Fullfilled "log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO () +log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(ndarray)" args => + ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle] +_backward_log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_upd :: + forall args . Fullfilled "_backward_log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO () +_backward_log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log10(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle] +_backward_log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log10_upd :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log10(ndarray)" args -> IO () +_backward_log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log2(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle] +_backward_log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log2_upd :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO () +_backward_log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log1p(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log1p :: + forall args . Fullfilled "log1p(ndarray)" args => + ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle] +log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log1p_upd :: + forall args . Fullfilled "log1p(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO () +log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log1p(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle] +_backward_log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log1p_upd :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log1p(ndarray)" args -> IO () +_backward_log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expm1(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +expm1 :: + forall args . Fullfilled "expm1(ndarray)" args => + ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle] +expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expm1_upd :: + forall args . Fullfilled "expm1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO () +expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_expm1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle] +_backward_expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_expm1_upd :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_expm1(ndarray)" args -> IO () +_backward_expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gamma(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gamma :: + forall args . Fullfilled "gamma(ndarray)" args => + ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle] +gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gamma_upd :: + forall args . Fullfilled "gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO () +gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gamma(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle] +_backward_gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gamma_upd :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gamma(ndarray)" args -> IO () +_backward_gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gammaln(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(ndarray)" args => + ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle] +gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gammaln_upd :: + forall args . Fullfilled "gammaln(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO () +gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gammaln(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle] +_backward_gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gammaln_upd :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gammaln(ndarray)" args -> IO () +_backward_gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "logical_not(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +logical_not :: + forall args . Fullfilled "logical_not(ndarray)" args => + ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle] +logical_not args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +logical_not_upd :: + forall args . Fullfilled "logical_not(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO () +logical_not_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +sum :: + forall args . Fullfilled "sum(ndarray)" args => + ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle] +sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sum_upd :: + forall args . Fullfilled "sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO () +sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sum(ndarray)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sum_upd :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO () +_backward_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mean(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +mean :: + forall args . Fullfilled "mean(ndarray)" args => + ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle] +mean args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mean_upd :: + forall args . Fullfilled "mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO () +mean_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mean(ndarray)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle] +_backward_mean args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mean_upd :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO () +_backward_mean_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "prod(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +prod :: + forall args . Fullfilled "prod(ndarray)" args => + ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle] +prod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +prod_upd :: + forall args . Fullfilled "prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO () +prod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_prod(ndarray)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle] +_backward_prod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_prod_upd :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO () +_backward_prod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nansum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nansum :: + forall args . Fullfilled "nansum(ndarray)" args => + ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle] +nansum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nansum_upd :: + forall args . Fullfilled "nansum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO () +nansum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nansum(ndarray)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle] +_backward_nansum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nansum_upd :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nansum(ndarray)" args -> IO () +_backward_nansum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nanprod(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(ndarray)" args => + ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle] +nanprod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nanprod_upd :: + forall args . Fullfilled "nanprod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO () +nanprod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nanprod(ndarray)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle] +_backward_nanprod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nanprod_upd :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nanprod(ndarray)" args -> IO () +_backward_nanprod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "max(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +max :: + forall args . Fullfilled "max(ndarray)" args => + ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle] +max args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +max_upd :: + forall args . Fullfilled "max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO () +max_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_max(ndarray)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(ndarray)" args => + ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle] +_backward_max args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_max_upd :: + forall args . Fullfilled "_backward_max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO () +_backward_max_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "min(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +min :: + forall args . Fullfilled "min(ndarray)" args => + ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle] +min args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +min_upd :: + forall args . Fullfilled "min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO () +min_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_min(ndarray)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(ndarray)" args => + ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle] +_backward_min args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_min_upd :: + forall args . Fullfilled "_backward_min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO () +_backward_min_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_axis(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle] +broadcast_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_axis_upd :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO () +broadcast_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_to(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle] +broadcast_to args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_to_upd :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO () +broadcast_to_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_broadcast_backward(ndarray)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle] +_broadcast_backward args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_broadcast_backward_upd :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_broadcast_backward(ndarray)" args -> IO () +_broadcast_backward_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_like(ndarray)" = + '[ '("lhs_axes", AttrOpt (Maybe [Int])), + '("rhs_axes", AttrOpt (Maybe [Int])), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +broadcast_like :: + forall args . Fullfilled "broadcast_like(ndarray)" args => + ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle] +broadcast_like args + = let scalarArgs + = catMaybes + [("lhs_axes",) . showValue <$> + (args !? #lhs_axes :: Maybe (Maybe [Int])), + ("rhs_axes",) . showValue <$> + (args !? #rhs_axes :: Maybe (Maybe [Int]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_like_upd :: + forall args . Fullfilled "broadcast_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO () +broadcast_like_upd outputs args + = let scalarArgs + = catMaybes + [("lhs_axes",) . showValue <$> + (args !? #lhs_axes :: Maybe (Maybe [Int])), + ("rhs_axes",) . showValue <$> + (args !? #rhs_axes :: Maybe (Maybe [Int]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "norm(ndarray)" = + '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])), + '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +norm :: + forall args . Fullfilled "norm(ndarray)" args => + ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle] +norm args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +norm_upd :: + forall args . Fullfilled "norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO () +norm_upd outputs args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_norm(ndarray)" = '[] + +_backward_norm :: + forall args . Fullfilled "_backward_norm(ndarray)" args => + ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle] +_backward_norm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_norm_upd :: + forall args . Fullfilled "_backward_norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO () +_backward_norm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle] +elemwise_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_add_upd :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO () +elemwise_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_grad_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(ndarray)" args => + ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle] +_grad_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_grad_add_upd :: + forall args . Fullfilled "_grad_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO () +_grad_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_add(ndarray)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(ndarray)" args => + ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle] +_backward_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_add_upd :: + forall args . Fullfilled "_backward_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO () +_backward_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle] +elemwise_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_sub_upd :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO () +elemwise_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sub(ndarray)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle] +_backward_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sub_upd :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO () +_backward_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle] +elemwise_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_mul_upd :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO () +elemwise_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul(ndarray)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle] +_backward_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_upd :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO () +_backward_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle] +elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_div_upd :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO () +elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div(ndarray)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(ndarray)" args => + ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle] +_backward_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_upd :: + forall args . Fullfilled "_backward_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO () +_backward_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_mod :: + forall args . Fullfilled "_mod(ndarray)" args => + ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle] +_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_upd :: + forall args . Fullfilled "_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO () +_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod(ndarray)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle] +_backward_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_upd :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO () +_backward_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> + IO [NDArrayHandle] +_scatter_elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_elemwise_div_upd :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO () +_scatter_elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_scatter_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_plus_scalar_upd :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO () +_scatter_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> + IO [NDArrayHandle] +_scatter_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_minus_scalar_upd :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO () +_scatter_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Embedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(ndarray)" args => + ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle] +_Embedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Embedding_upd :: + forall args . Fullfilled "_Embedding(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO () +_Embedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SparseEmbedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_contrib_SparseEmbedding :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SparseEmbedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SparseEmbedding_upd :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO () +_contrib_SparseEmbedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Embedding(ndarray)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle] +_backward_Embedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Embedding_upd :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Embedding(ndarray)" args -> IO () +_backward_Embedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SparseEmbedding(ndarray)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_backward_SparseEmbedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SparseEmbedding_upd :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO () +_backward_SparseEmbedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "take(ndarray)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)] + +take :: + forall args . Fullfilled "take(ndarray)" args => + ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle] +take args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +take_upd :: + forall args . Fullfilled "take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO () +take_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_take(ndarray)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(ndarray)" args => + ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle] +_backward_take args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_take_upd :: + forall args . Fullfilled "_backward_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO () +_backward_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_take(ndarray)" = + '[ '("a", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(ndarray)" args => + ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle] +batch_take args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_take_upd :: + forall args . Fullfilled "batch_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO () +batch_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "one_hot(ndarray)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("indices", AttrOpt NDArrayHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(ndarray)" args => + ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle] +one_hot args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +one_hot_upd :: + forall args . Fullfilled "one_hot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO () +one_hot_upd outputs args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gather_nd(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle] +gather_nd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gather_nd_upd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO () +gather_nd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "scatter_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle] +scatter_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +scatter_nd_upd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO () +scatter_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gather_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_backward_gather_nd :: + forall args . Fullfilled "_backward_gather_nd(ndarray)" args => + ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle] +_backward_gather_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gather_nd_upd :: + forall args . Fullfilled "_backward_gather_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gather_nd(ndarray)" args -> IO () +_backward_gather_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_set_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle] +_scatter_set_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_set_nd_upd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO () +_scatter_set_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_equal_upd :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_equal(ndarray)" args -> IO () +broadcast_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_not_equal_upd :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO () +broadcast_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle] +broadcast_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_upd :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater(ndarray)" args -> IO () +broadcast_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + ArgsHMap "broadcast_greater_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_equal_upd :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO () +broadcast_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle] +broadcast_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_upd :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser(ndarray)" args -> IO () +broadcast_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_equal_upd :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO () +broadcast_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_and(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_and :: + forall args . Fullfilled "broadcast_logical_and(ndarray)" args => + ArgsHMap "broadcast_logical_and(ndarray)" args -> + IO [NDArrayHandle] +broadcast_logical_and args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_and_upd :: + forall args . Fullfilled "broadcast_logical_and(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_and(ndarray)" args -> IO () +broadcast_logical_and_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_or(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_or :: + forall args . Fullfilled "broadcast_logical_or(ndarray)" args => + ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle] +broadcast_logical_or args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_or_upd :: + forall args . Fullfilled "broadcast_logical_or(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_or(ndarray)" args -> IO () +broadcast_logical_or_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_xor(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_xor :: + forall args . Fullfilled "broadcast_logical_xor(ndarray)" args => + ArgsHMap "broadcast_logical_xor(ndarray)" args -> + IO [NDArrayHandle] +broadcast_logical_xor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_xor_upd :: + forall args . Fullfilled "broadcast_logical_xor(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO () +broadcast_logical_xor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_plus_scalar_upd :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO () +_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle] +_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minus_scalar_upd :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO () +_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rminus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle] +_rminus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rminus_scalar_upd :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO () +_rminus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mul_scalar_upd :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO () +_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_scalar_upd :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO () +_backward_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_div_scalar_upd :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO () +_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_scalar_upd :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO () +_backward_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle] +_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rdiv_scalar_upd :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO () +_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rdiv_scalar_upd :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO () +_backward_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_scalar_upd :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO () +_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_scalar_upd :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO () +_backward_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle] +_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rmod_scalar_upd :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO () +_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rmod_scalar_upd :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO () +_backward_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ravel_multi_index(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_ravel_multi_index :: + forall args . Fullfilled "_ravel_multi_index(ndarray)" args => + ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle] +_ravel_multi_index args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ravel_multi_index_upd :: + forall args . Fullfilled "_ravel_multi_index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_ravel_multi_index(ndarray)" args -> IO () +_ravel_multi_index_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_unravel_index(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_unravel_index :: + forall args . Fullfilled "_unravel_index(ndarray)" args => + ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle] +_unravel_index args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_unravel_index_upd :: + forall args . Fullfilled "_unravel_index(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO () +_unravel_index_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmax :: + forall args . Fullfilled "argmax(ndarray)" args => + ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle] +argmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_upd :: + forall args . Fullfilled "argmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO () +argmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmin(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmin :: + forall args . Fullfilled "argmin(ndarray)" args => + ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle] +argmin args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmin_upd :: + forall args . Fullfilled "argmin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO () +argmin_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax_channel(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle] +argmax_channel args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_channel_upd :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO () +argmax_channel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "pick(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("mode", AttrOpt (EnumType '["clip", "wrap"])), + '("data", AttrOpt NDArrayHandle), + '("index", AttrOpt NDArrayHandle)] + +pick :: + forall args . Fullfilled "pick(ndarray)" args => + ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle] +pick args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +pick_upd :: + forall args . Fullfilled "pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO () +pick_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_pick(ndarray)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle] +_backward_pick args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_pick_upd :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO () +_backward_pick_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_retain(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle] +_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_retain_upd :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO () +_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sparse_retain(ndarray)" = + '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + ArgsHMap "_backward_sparse_retain(ndarray)" args -> + IO [NDArrayHandle] +_backward_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sparse_retain_upd :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO () +_backward_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_where(ndarray)" = + '[ '("condition", AttrOpt NDArrayHandle), + '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)] + +_where :: + forall args . Fullfilled "_where(ndarray)" args => + ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle] +_where args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_where_upd :: + forall args . Fullfilled "_where(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO () +_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_where(ndarray)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(ndarray)" args => + ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle] +_backward_where args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_where_upd :: + forall args . Fullfilled "_backward_where(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_where(ndarray)" args -> IO () +_backward_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "diag(ndarray)" = + '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int), + '("axis2", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +diag :: + forall args . Fullfilled "diag(ndarray)" args => + ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle] +diag args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int), + ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +diag_upd :: + forall args . Fullfilled "diag(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO () +diag_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int), + ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_diag(ndarray)" = '[] + +_backward_diag :: + forall args . Fullfilled "_backward_diag(ndarray)" args => + ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle] +_backward_diag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_diag_upd :: + forall args . Fullfilled "_backward_diag(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO () +_backward_diag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle] +_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_scalar_upd :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_maximum_scalar(ndarray)" args -> IO () +_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_maximum_scalar :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_scalar_upd :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO () +_backward_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle] +_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_scalar_upd :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_minimum_scalar(ndarray)" args -> IO () +_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_minimum_scalar :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_scalar_upd :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO () +_backward_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle] +_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_scalar_upd :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO () +_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + ArgsHMap "_backward_power_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_scalar_upd :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power_scalar(ndarray)" args -> IO () +_backward_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle] +_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rpower_scalar_upd :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO () +_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rpower_scalar_upd :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO () +_backward_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle] +_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_scalar_upd :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO () +_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_scalar_upd :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO () +_backward_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "smooth_l1(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle] +smooth_l1 args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +smooth_l1_upd :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO () +smooth_l1_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_smooth_l1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle] +_backward_smooth_l1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_smooth_l1_upd :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO () +_backward_smooth_l1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "topk(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +topk :: + forall args . Fullfilled "topk(ndarray)" args => + ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle] +topk args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +topk_upd :: + forall args . Fullfilled "topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO () +topk_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_topk(ndarray)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle] +_backward_topk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_topk_upd :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO () +_backward_topk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +sort :: + forall args . Fullfilled "sort(ndarray)" args => + ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle] +sort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sort_upd :: + forall args . Fullfilled "sort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO () +sort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argsort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +argsort :: + forall args . Fullfilled "argsort(ndarray)" args => + ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle] +argsort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argsort_upd :: + forall args . Fullfilled "argsort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO () +argsort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Reshape(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(ndarray)" args => + ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle] +_Reshape args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Reshape_upd :: + forall args . Fullfilled "_Reshape(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO () +_Reshape_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(ndarray)" args => + ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle] +_Flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Flatten_upd :: + forall args . Fullfilled "_Flatten(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO () +_Flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "transpose(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +transpose :: + forall args . Fullfilled "transpose(ndarray)" args => + ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle] +transpose args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +transpose_upd :: + forall args . Fullfilled "transpose(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO () +transpose_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expand_dims(ndarray)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(ndarray)" args => + ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle] +expand_dims args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expand_dims_upd :: + forall args . Fullfilled "expand_dims(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO () +expand_dims_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +slice :: + forall args . Fullfilled "slice(ndarray)" args => + ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle] +slice args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_upd :: + forall args . Fullfilled "slice(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO () +slice_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice(ndarray)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle] +_backward_slice args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_upd :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice(ndarray)" args -> IO () +_backward_slice_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle] +_slice_assign args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_upd :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO () +_slice_assign_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign_scalar(ndarray)" = + '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle] +_slice_assign_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_scalar_upd :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO () +_slice_assign_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_axis(ndarray)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(ndarray)" args => + ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle] +slice_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_axis_upd :: + forall args . Fullfilled "slice_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO () +slice_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_axis(ndarray)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_axis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_axis_upd :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO () +_backward_slice_axis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_like(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle), + '("shape_like", AttrOpt NDArrayHandle)] + +slice_like :: + forall args . Fullfilled "slice_like(ndarray)" args => + ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle] +slice_like args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_like_upd :: + forall args . Fullfilled "slice_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO () +slice_like_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_like(ndarray)" = '[] + +_backward_slice_like :: + forall args . Fullfilled "_backward_slice_like(ndarray)" args => + ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_like args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_like_upd :: + forall args . Fullfilled "_backward_slice_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_like(ndarray)" args -> IO () +_backward_slice_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "clip(ndarray)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +clip :: + forall args . Fullfilled "clip(ndarray)" args => + ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle] +clip args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +clip_upd :: + forall args . Fullfilled "clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO () +clip_upd outputs args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_clip(ndarray)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle] +_backward_clip args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_clip_upd :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO () +_backward_clip_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "repeat(ndarray)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +repeat :: + forall args . Fullfilled "repeat(ndarray)" args => + ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle] +repeat args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +repeat_upd :: + forall args . Fullfilled "repeat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO () +repeat_upd outputs args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_repeat(ndarray)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle] +_backward_repeat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_repeat_upd :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_repeat(ndarray)" args -> IO () +_backward_repeat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tile(ndarray)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +tile :: + forall args . Fullfilled "tile(ndarray)" args => + ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle] +tile args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tile_upd :: + forall args . Fullfilled "tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO () +tile_upd outputs args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tile(ndarray)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle] +_backward_tile args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tile_upd :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO () +_backward_tile_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reverse(ndarray)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +reverse :: + forall args . Fullfilled "reverse(ndarray)" args => + ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle] +reverse args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reverse_upd :: + forall args . Fullfilled "reverse(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO () +reverse_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reverse(ndarray)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle] +_backward_reverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reverse_upd :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reverse(ndarray)" args -> IO () +_backward_reverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "stack(ndarray)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [NDArrayHandle])] + +stack :: + forall args . Fullfilled "stack(ndarray)" args => + ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle] +stack args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +stack_upd :: + forall args . Fullfilled "stack(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO () +stack_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_stack(ndarray)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle] +_backward_stack args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_stack_upd :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_stack(ndarray)" args -> IO () +_backward_stack_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "squeeze(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), + '("data", AttrOpt [NDArrayHandle])] + +squeeze :: + forall args . Fullfilled "squeeze(ndarray)" args => + ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle] +squeeze args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +squeeze_upd :: + forall args . Fullfilled "squeeze(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO () +squeeze_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_squeeze(ndarray)" = '[] + +_backward_squeeze :: + forall args . Fullfilled "_backward_squeeze(ndarray)" args => + ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle] +_backward_squeeze args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_squeeze_upd :: + forall args . Fullfilled "_backward_squeeze(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_squeeze(ndarray)" args -> IO () +_backward_squeeze_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "depth_to_space(ndarray)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +depth_to_space :: + forall args . Fullfilled "depth_to_space(ndarray)" args => + ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle] +depth_to_space args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +depth_to_space_upd :: + forall args . Fullfilled "depth_to_space(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO () +depth_to_space_upd outputs args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "space_to_depth(ndarray)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +space_to_depth :: + forall args . Fullfilled "space_to_depth(ndarray)" args => + ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle] +space_to_depth args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +space_to_depth_upd :: + forall args . Fullfilled "space_to_depth(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO () +space_to_depth_upd outputs args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +dot :: + forall args . Fullfilled "dot(ndarray)" args => + ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle] +dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +dot_upd :: + forall args . Fullfilled "dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO () +dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_dot_upd :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO () +_backward_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(ndarray)" args => + ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle] +batch_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_dot_upd :: + forall args . Fullfilled "batch_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO () +batch_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_batch_dot(ndarray)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_batch_dot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_batch_dot_upd :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO () +_backward_batch_dot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sin :: + forall args . Fullfilled "sin(ndarray)" args => + ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle] +sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sin_upd :: + forall args . Fullfilled "sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO () +sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle] +_backward_sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sin_upd :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO () +_backward_sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cos :: + forall args . Fullfilled "cos(ndarray)" args => + ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle] +cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cos_upd :: + forall args . Fullfilled "cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO () +cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle] +_backward_cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cos_upd :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO () +_backward_cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tan :: + forall args . Fullfilled "tan(ndarray)" args => + ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle] +tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tan_upd :: + forall args . Fullfilled "tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO () +tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle] +_backward_tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tan_upd :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO () +_backward_tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(ndarray)" args => + ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle] +arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsin_upd :: + forall args . Fullfilled "arcsin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO () +arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsin_upd :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsin(ndarray)" args -> IO () +_backward_arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccos :: + forall args . Fullfilled "arccos(ndarray)" args => + ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle] +arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccos_upd :: + forall args . Fullfilled "arccos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO () +arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle] +_backward_arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccos_upd :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccos(ndarray)" args -> IO () +_backward_arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctan :: + forall args . Fullfilled "arctan(ndarray)" args => + ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle] +arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctan_upd :: + forall args . Fullfilled "arctan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO () +arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle] +_backward_arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctan_upd :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctan(ndarray)" args -> IO () +_backward_arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "degrees(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +degrees :: + forall args . Fullfilled "degrees(ndarray)" args => + ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle] +degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +degrees_upd :: + forall args . Fullfilled "degrees(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO () +degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_degrees(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle] +_backward_degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_degrees_upd :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_degrees(ndarray)" args -> IO () +_backward_degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "radians(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +radians :: + forall args . Fullfilled "radians(ndarray)" args => + ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle] +radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +radians_upd :: + forall args . Fullfilled "radians(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO () +radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_radians(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle] +_backward_radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_radians_upd :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_radians(ndarray)" args -> IO () +_backward_radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sinh :: + forall args . Fullfilled "sinh(ndarray)" args => + ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle] +sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sinh_upd :: + forall args . Fullfilled "sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO () +sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle] +_backward_sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sinh_upd :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO () +_backward_sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cosh :: + forall args . Fullfilled "cosh(ndarray)" args => + ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle] +cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cosh_upd :: + forall args . Fullfilled "cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO () +cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle] +_backward_cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cosh_upd :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO () +_backward_cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tanh :: + forall args . Fullfilled "tanh(ndarray)" args => + ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle] +tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tanh_upd :: + forall args . Fullfilled "tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO () +tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle] +_backward_tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tanh_upd :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO () +_backward_tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(ndarray)" args => + ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle] +arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsinh_upd :: + forall args . Fullfilled "arcsinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO () +arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsinh_upd :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO () +_backward_arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(ndarray)" args => + ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle] +arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccosh_upd :: + forall args . Fullfilled "arccosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO () +arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle] +_backward_arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccosh_upd :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccosh(ndarray)" args -> IO () +_backward_arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(ndarray)" args => + ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle] +arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctanh_upd :: + forall args . Fullfilled "arctanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO () +arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle] +_backward_arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctanh_upd :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctanh(ndarray)" args -> IO () +_backward_arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_group_adagrad_update(ndarray)" = + '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("history", AttrOpt NDArrayHandle)] + +_contrib_group_adagrad_update :: + forall args . + Fullfilled "_contrib_group_adagrad_update(ndarray)" args => + ArgsHMap "_contrib_group_adagrad_update(ndarray)" args -> + IO [NDArrayHandle] +_contrib_group_adagrad_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_group_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_group_adagrad_update_upd :: + forall args . + Fullfilled "_contrib_group_adagrad_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_group_adagrad_update(ndarray)" args -> + IO () +_contrib_group_adagrad_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_group_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_getnnz(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +_contrib_getnnz :: + forall args . Fullfilled "_contrib_getnnz(ndarray)" args => + ArgsHMap "_contrib_getnnz(ndarray)" args -> IO [NDArrayHandle] +_contrib_getnnz args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_getnnz" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_getnnz_upd :: + forall args . Fullfilled "_contrib_getnnz(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_getnnz(ndarray)" args -> IO () +_contrib_getnnz_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_getnnz" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_edge_id(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), '("u", AttrOpt NDArrayHandle), + '("v", AttrOpt NDArrayHandle)] + +_contrib_edge_id :: + forall args . Fullfilled "_contrib_edge_id(ndarray)" args => + ArgsHMap "_contrib_edge_id(ndarray)" args -> IO [NDArrayHandle] +_contrib_edge_id args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("u",) <$> (args !? #u :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_edge_id" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_edge_id_upd :: + forall args . Fullfilled "_contrib_edge_id(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_edge_id(ndarray)" args -> IO () +_contrib_edge_id_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("u",) <$> (args !? #u :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_edge_id" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_dgl_adjacency(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_contrib_dgl_adjacency :: + forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args => + ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> + IO [NDArrayHandle] +_contrib_dgl_adjacency args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dgl_adjacency" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_dgl_adjacency_upd :: + forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> IO () +_contrib_dgl_adjacency_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dgl_adjacency" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quadratic(ndarray)" = + '[ '("a", AttrOpt Float), '("b", AttrOpt Float), + '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_contrib_quadratic :: + forall args . Fullfilled "_contrib_quadratic(ndarray)" args => + ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle] +_contrib_quadratic args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quadratic_upd :: + forall args . Fullfilled "_contrib_quadratic(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quadratic(ndarray)" args -> IO () +_contrib_quadratic_upd outputs args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_backward_quadratic(ndarray)" + = '[] + +_contrib_backward_quadratic :: + forall args . + Fullfilled "_contrib_backward_quadratic(ndarray)" args => + ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> + IO [NDArrayHandle] +_contrib_backward_quadratic args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_quadratic_upd :: + forall args . + Fullfilled "_contrib_backward_quadratic(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO () +_contrib_backward_quadratic_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_contrib_div_sqrt_dim :: + forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args => + ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> + IO [NDArrayHandle] +_contrib_div_sqrt_dim args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_div_sqrt_dim_upd :: + forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO () +_contrib_div_sqrt_dim_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "khatri_rao(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +khatri_rao :: + forall args . Fullfilled "khatri_rao(ndarray)" args => + ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle] +khatri_rao args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +khatri_rao_upd :: + forall args . Fullfilled "khatri_rao(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO () +khatri_rao_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_contrib_index_copy(ndarray)" = + '[ '("old_tensor", AttrOpt NDArrayHandle), + '("index_vector", AttrOpt NDArrayHandle), + '("new_tensor", AttrOpt NDArrayHandle)] + +_contrib_index_copy :: + forall args . Fullfilled "_contrib_index_copy(ndarray)" args => + ArgsHMap "_contrib_index_copy(ndarray)" args -> IO [NDArrayHandle] +_contrib_index_copy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle), + ("index_vector",) <$> + (args !? #index_vector :: Maybe NDArrayHandle), + ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_index_copy_upd :: + forall args . Fullfilled "_contrib_index_copy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_index_copy(ndarray)" args -> IO () +_contrib_index_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle), + ("index_vector",) <$> + (args !? #index_vector :: Maybe NDArrayHandle), + ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_backward_index_copy(ndarray)" + = '[] + +_contrib_backward_index_copy :: + forall args . + Fullfilled "_contrib_backward_index_copy(ndarray)" args => + ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> + IO [NDArrayHandle] +_contrib_backward_index_copy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_index_copy_upd :: + forall args . + Fullfilled "_contrib_backward_index_copy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> IO () +_contrib_backward_index_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_ROIAlign(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_contrib_ROIAlign :: + forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args => + ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle] +_contrib_ROIAlign args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ROIAlign_upd :: + forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO () +_contrib_ROIAlign_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIAlign(ndarray)" = '[] + +_backward_ROIAlign :: + forall args . Fullfilled "_backward_ROIAlign(ndarray)" args => + ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIAlign args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIAlign_upd :: + forall args . Fullfilled "_backward_ROIAlign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO () +_backward_ROIAlign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_box_nms(ndarray)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"])), + '("data", AttrOpt NDArrayHandle)] + +_contrib_box_nms :: + forall args . Fullfilled "_contrib_box_nms(ndarray)" args => + ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle] +_contrib_box_nms args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_box_nms_upd :: + forall args . Fullfilled "_contrib_box_nms(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_box_nms(ndarray)" args -> IO () +_contrib_box_nms_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_contrib_box_nms(ndarray)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_nms :: + forall args . + Fullfilled "_backward_contrib_box_nms(ndarray)" args => + ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_box_nms args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_box_nms_upd :: + forall args . + Fullfilled "_backward_contrib_box_nms(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO () +_backward_contrib_box_nms_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_box_iou(ndarray)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"])), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +_contrib_box_iou :: + forall args . Fullfilled "_contrib_box_iou(ndarray)" args => + ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle] +_contrib_box_iou args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_box_iou_upd :: + forall args . Fullfilled "_contrib_box_iou(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_box_iou(ndarray)" args -> IO () +_contrib_box_iou_upd outputs args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_contrib_box_iou(ndarray)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_iou :: + forall args . + Fullfilled "_backward_contrib_box_iou(ndarray)" args => + ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_box_iou args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_box_iou_upd :: + forall args . + Fullfilled "_backward_contrib_box_iou(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO () +_backward_contrib_box_iou_upd outputs args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_bipartite_matching(ndarray)" + = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +_contrib_bipartite_matching :: + forall args . + Fullfilled "_contrib_bipartite_matching(ndarray)" args => + ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> + IO [NDArrayHandle] +_contrib_bipartite_matching args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_bipartite_matching_upd :: + forall args . + Fullfilled "_contrib_bipartite_matching(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO () +_contrib_bipartite_matching_upd outputs args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_bipartite_matching(ndarray)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int)] + +_backward_contrib_bipartite_matching :: + forall args . + Fullfilled "_backward_contrib_bipartite_matching(ndarray)" + args => + ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args + -> IO [NDArrayHandle] +_backward_contrib_bipartite_matching args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_bipartite_matching_upd :: + forall args . + Fullfilled + "_backward_contrib_bipartite_matching(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward_contrib_bipartite_matching(ndarray)" + args + -> IO () +_backward_contrib_bipartite_matching_upd outputs args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_BilinearResize2D(ndarray)" = + '[ '("height", AttrReq Int), '("width", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_BilinearResize2D :: + forall args . + Fullfilled "_contrib_BilinearResize2D(ndarray)" args => + ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> + IO [NDArrayHandle] +_contrib_BilinearResize2D args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_BilinearResize2D_upd :: + forall args . + Fullfilled "_contrib_BilinearResize2D(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO () +_contrib_BilinearResize2D_upd outputs args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[] + +_backward_contrib_BilinearResize2D :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(ndarray)" + args => + ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_BilinearResize2D args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_BilinearResize2D_upd :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" + args + -> IO () +_backward_contrib_BilinearResize2D_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_boolean_mask(ndarray)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle), + '("index", AttrOpt NDArrayHandle)] + +_contrib_boolean_mask :: + forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args => + ArgsHMap "_contrib_boolean_mask(ndarray)" args -> + IO [NDArrayHandle] +_contrib_boolean_mask args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_boolean_mask_upd :: + forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_boolean_mask(ndarray)" args -> IO () +_contrib_boolean_mask_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_boolean_mask(ndarray)" = + '[ '("axis", AttrOpt Int)] + +_backward_contrib_boolean_mask :: + forall args . + Fullfilled "_backward_contrib_boolean_mask(ndarray)" args => + ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_boolean_mask args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_boolean_mask_upd :: + forall args . + Fullfilled "_backward_contrib_boolean_mask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args -> + IO () +_backward_contrib_boolean_mask_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int), + '("key", AttrOpt String), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_contrib_SyncBatchNorm :: + forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args => + ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SyncBatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SyncBatchNorm_upd :: + forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO () +_contrib_SyncBatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" = + '[ '("output_size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args => + ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args -> + IO [NDArrayHandle] +_contrib_AdaptiveAvgPooling2D args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_AdaptiveAvgPooling2D_upd :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args -> + IO () +_contrib_AdaptiveAvgPooling2D_upd outputs args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" = + '[] + +_backward_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args => + ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args + -> IO [NDArrayHandle] +_backward_contrib_AdaptiveAvgPooling2D args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_AdaptiveAvgPooling2D_upd :: + forall args . + Fullfilled + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args + -> IO () +_backward_contrib_AdaptiveAvgPooling2D_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_to_tensor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_to_tensor :: + forall args . Fullfilled "_image_to_tensor(ndarray)" args => + ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle] +_image_to_tensor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_to_tensor_upd :: + forall args . Fullfilled "_image_to_tensor(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_to_tensor(ndarray)" args -> IO () +_image_to_tensor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_normalize(ndarray)" = + '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]), + '("data", AttrOpt NDArrayHandle)] + +_image_normalize :: + forall args . Fullfilled "_image_normalize(ndarray)" args => + ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle] +_image_normalize args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_normalize_upd :: + forall args . Fullfilled "_image_normalize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_normalize(ndarray)" args -> IO () +_image_normalize_upd outputs args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_flip_left_right(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_flip_left_right :: + forall args . Fullfilled "_image_flip_left_right(ndarray)" args => + ArgsHMap "_image_flip_left_right(ndarray)" args -> + IO [NDArrayHandle] +_image_flip_left_right args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_flip_left_right_upd :: + forall args . Fullfilled "_image_flip_left_right(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_flip_left_right(ndarray)" args -> IO () +_image_flip_left_right_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_image_random_flip_left_right(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_random_flip_left_right :: + forall args . + Fullfilled "_image_random_flip_left_right(ndarray)" args => + ArgsHMap "_image_random_flip_left_right(ndarray)" args -> + IO [NDArrayHandle] +_image_random_flip_left_right args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_flip_left_right_upd :: + forall args . + Fullfilled "_image_random_flip_left_right(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_flip_left_right(ndarray)" args -> + IO () +_image_random_flip_left_right_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_flip_top_bottom(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_flip_top_bottom :: + forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args => + ArgsHMap "_image_flip_top_bottom(ndarray)" args -> + IO [NDArrayHandle] +_image_flip_top_bottom args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_flip_top_bottom_upd :: + forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO () +_image_flip_top_bottom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_image_random_flip_top_bottom(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_random_flip_top_bottom :: + forall args . + Fullfilled "_image_random_flip_top_bottom(ndarray)" args => + ArgsHMap "_image_random_flip_top_bottom(ndarray)" args -> + IO [NDArrayHandle] +_image_random_flip_top_bottom args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_flip_top_bottom_upd :: + forall args . + Fullfilled "_image_random_flip_top_bottom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_flip_top_bottom(ndarray)" args -> + IO () +_image_random_flip_top_bottom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_brightness(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_brightness :: + forall args . + Fullfilled "_image_random_brightness(ndarray)" args => + ArgsHMap "_image_random_brightness(ndarray)" args -> + IO [NDArrayHandle] +_image_random_brightness args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_brightness_upd :: + forall args . + Fullfilled "_image_random_brightness(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_brightness(ndarray)" args -> IO () +_image_random_brightness_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_contrast(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_contrast :: + forall args . Fullfilled "_image_random_contrast(ndarray)" args => + ArgsHMap "_image_random_contrast(ndarray)" args -> + IO [NDArrayHandle] +_image_random_contrast args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_contrast_upd :: + forall args . Fullfilled "_image_random_contrast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_contrast(ndarray)" args -> IO () +_image_random_contrast_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_saturation(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_saturation :: + forall args . + Fullfilled "_image_random_saturation(ndarray)" args => + ArgsHMap "_image_random_saturation(ndarray)" args -> + IO [NDArrayHandle] +_image_random_saturation args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_saturation_upd :: + forall args . + Fullfilled "_image_random_saturation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_saturation(ndarray)" args -> IO () +_image_random_saturation_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_hue(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_hue :: + forall args . Fullfilled "_image_random_hue(ndarray)" args => + ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle] +_image_random_hue args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_hue_upd :: + forall args . Fullfilled "_image_random_hue(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_hue(ndarray)" args -> IO () +_image_random_hue_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_color_jitter(ndarray)" = + '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float), + '("saturation", AttrReq Float), '("hue", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_color_jitter :: + forall args . + Fullfilled "_image_random_color_jitter(ndarray)" args => + ArgsHMap "_image_random_color_jitter(ndarray)" args -> + IO [NDArrayHandle] +_image_random_color_jitter args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_color_jitter_upd :: + forall args . + Fullfilled "_image_random_color_jitter(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO () +_image_random_color_jitter_upd outputs args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_adjust_lighting(ndarray)" = + '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)] + +_image_adjust_lighting :: + forall args . Fullfilled "_image_adjust_lighting(ndarray)" args => + ArgsHMap "_image_adjust_lighting(ndarray)" args -> + IO [NDArrayHandle] +_image_adjust_lighting args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_adjust_lighting_upd :: + forall args . Fullfilled "_image_adjust_lighting(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO () +_image_adjust_lighting_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_lighting(ndarray)" = + '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_image_random_lighting :: + forall args . Fullfilled "_image_random_lighting(ndarray)" args => + ArgsHMap "_image_random_lighting(ndarray)" args -> + IO [NDArrayHandle] +_image_random_lighting args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_lighting_upd :: + forall args . Fullfilled "_image_random_lighting(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_lighting(ndarray)" args -> IO () +_image_random_lighting_upd outputs args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt NDArrayHandle)] + +softmax :: + forall args . Fullfilled "softmax(ndarray)" args => + ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle] +softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_upd :: + forall args . Fullfilled "softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO () +softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softmax(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_softmax args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_upd :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax(ndarray)" args -> IO () +_backward_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmin(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt NDArrayHandle)] + +softmin :: + forall args . Fullfilled "softmin(ndarray)" args => + ArgsHMap "softmin(ndarray)" args -> IO [NDArrayHandle] +softmin args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmin_upd :: + forall args . Fullfilled "softmin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softmin(ndarray)" args -> IO () +softmin_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softmin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softmin :: + forall args . Fullfilled "_backward_softmin(ndarray)" args => + ArgsHMap "_backward_softmin(ndarray)" args -> IO [NDArrayHandle] +_backward_softmin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmin_upd :: + forall args . Fullfilled "_backward_softmin(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmin(ndarray)" args -> IO () +_backward_softmin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log_softmax(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt NDArrayHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(ndarray)" args => + ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle] +log_softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_softmax_upd :: + forall args . Fullfilled "log_softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO () +log_softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log_softmax(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + ArgsHMap "_backward_log_softmax(ndarray)" args -> + IO [NDArrayHandle] +_backward_log_softmax args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_softmax_upd :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log_softmax(ndarray)" args -> IO () +_backward_log_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(ndarray)" args => + ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle] +_Pooling args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_upd :: + forall args . Fullfilled "_Pooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO () +_Pooling_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling(ndarray)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_upd :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling(ndarray)" args -> IO () +_backward_Pooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Deconvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle] +_Deconvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Deconvolution_upd :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO () +_Deconvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Deconvolution(ndarray)" = + '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + ArgsHMap "_backward_Deconvolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Deconvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Deconvolution_upd :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO () +_backward_Deconvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Activation(ndarray)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt NDArrayHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(ndarray)" args => + ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle] +_Activation args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Activation_upd :: + forall args . Fullfilled "_Activation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO () +_Activation_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Activation(ndarray)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle] +_backward_Activation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Activation_upd :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Activation(ndarray)" args -> IO () +_backward_Activation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_UpSampling(ndarray)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_UpSampling args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_UpSampling_upd :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO () +_UpSampling_upd outputs args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_UpSampling(ndarray)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_backward_UpSampling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_UpSampling_upd :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO () +_backward_UpSampling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_upd :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO () +_BatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm(ndarray)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_BatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_upd :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO () +_backward_BatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CTCLoss(ndarray)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("data_lengths", AttrOpt NDArrayHandle), + '("label_lengths", AttrOpt NDArrayHandle)] + +_CTCLoss :: + forall args . Fullfilled "_CTCLoss(ndarray)" args => + ArgsHMap "_CTCLoss(ndarray)" args -> IO [NDArrayHandle] +_CTCLoss args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CTCLoss_upd :: + forall args . Fullfilled "_CTCLoss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_CTCLoss(ndarray)" args -> IO () +_CTCLoss_upd outputs args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ctc_loss(ndarray)" = '[] + +_backward_ctc_loss :: + forall args . Fullfilled "_backward_ctc_loss(ndarray)" args => + ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO [NDArrayHandle] +_backward_ctc_loss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ctc_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ctc_loss_upd :: + forall args . Fullfilled "_backward_ctc_loss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO () +_backward_ctc_loss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ctc_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_FullyConnected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle] +_FullyConnected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_FullyConnected_upd :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_FullyConnected(ndarray)" args -> IO () +_FullyConnected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_FullyConnected(ndarray)" = + '[] + +_backward_FullyConnected :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + ArgsHMap "_backward_FullyConnected(ndarray)" args -> + IO [NDArrayHandle] +_backward_FullyConnected args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_FullyConnected_upd :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO () +_backward_FullyConnected_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(ndarray)" args => + ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle] +_Convolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_upd :: + forall args . Fullfilled "_Convolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO () +_Convolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution(ndarray)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + ArgsHMap "_backward_Convolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_upd :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution(ndarray)" args -> IO () +_backward_Convolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LayerNorm(ndarray)" = + '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_LayerNorm :: + forall args . Fullfilled "_LayerNorm(ndarray)" args => + ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle] +_LayerNorm args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LayerNorm_upd :: + forall args . Fullfilled "_LayerNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO () +_LayerNorm_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LayerNorm(ndarray)" = '[] + +_backward_LayerNorm :: + forall args . Fullfilled "_backward_LayerNorm(ndarray)" args => + ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_LayerNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LayerNorm_upd :: + forall args . Fullfilled "_backward_LayerNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO () +_backward_LayerNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(ndarray)" args => + ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle] +_Concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Concat_upd :: + forall args . Fullfilled "_Concat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO () +_Concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Concat(ndarray)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle] +_backward_Concat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Concat_upd :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Concat(ndarray)" args -> IO () +_backward_Concat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rnn_param_concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_rnn_param_concat :: + forall args . Fullfilled "_rnn_param_concat(ndarray)" args => + ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle] +_rnn_param_concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_rnn_param_concat_upd :: + forall args . Fullfilled "_rnn_param_concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_rnn_param_concat(ndarray)" args -> IO () +_rnn_param_concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_SoftmaxActivation(ndarray)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt NDArrayHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxActivation args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxActivation_upd :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO () +_SoftmaxActivation_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxActivation(ndarray)" + = '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxActivation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxActivation_upd :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO () +_backward_SoftmaxActivation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LRN(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(ndarray)" args => + ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle] +_LRN args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LRN_upd :: + forall args . Fullfilled "_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO () +_LRN_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LRN(ndarray)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle] +_backward_LRN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LRN_upd :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO () +_backward_LRN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Dropout(ndarray)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(ndarray)" args => + ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle] +_Dropout args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Dropout_upd :: + forall args . Fullfilled "_Dropout(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO () +_Dropout_upd outputs args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Dropout(ndarray)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle] +_backward_Dropout args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Dropout_upd :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Dropout(ndarray)" args -> IO () +_backward_Dropout_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_dequantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["float32"])), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_dequantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_dequantize_upd :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO () +_contrib_dequantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_flatten :: + forall args . + Fullfilled "_contrib_quantized_flatten(ndarray)" args => + ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_flatten_upd :: + forall args . + Fullfilled "_contrib_quantized_flatten(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO () +_contrib_quantized_flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_conv(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle), + '("min_weight", AttrOpt NDArrayHandle), + '("max_weight", AttrOpt NDArrayHandle), + '("min_bias", AttrOpt NDArrayHandle), + '("max_bias", AttrOpt NDArrayHandle)] + +_contrib_quantized_conv :: + forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args => + ArgsHMap "_contrib_quantized_conv(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_conv args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_conv_upd :: + forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO () +_contrib_quantized_conv_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_quantized_fully_connected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle), + '("min_weight", AttrOpt NDArrayHandle), + '("max_weight", AttrOpt NDArrayHandle), + '("min_bias", AttrOpt NDArrayHandle), + '("max_bias", AttrOpt NDArrayHandle)] + +_contrib_quantized_fully_connected :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(ndarray)" + args => + ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_fully_connected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_fully_connected_upd :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_fully_connected(ndarray)" + args + -> IO () +_contrib_quantized_fully_connected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_pooling(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_pooling :: + forall args . + Fullfilled "_contrib_quantized_pooling(ndarray)" args => + ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_pooling args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_pooling_upd :: + forall args . + Fullfilled "_contrib_quantized_pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO () +_contrib_quantized_pooling_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_contrib_quantized_concat :: + forall args . + Fullfilled "_contrib_quantized_concat(ndarray)" args => + ArgsHMap "_contrib_quantized_concat(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_contrib_quantized_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_contrib_quantized_concat_upd :: + forall args . + Fullfilled "_contrib_quantized_concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_concat(ndarray)" args -> IO () +_contrib_quantized_concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_contrib_quantized_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_contrib_requantize(ndarray)" = + '[ '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_requantize :: + forall args . Fullfilled "_contrib_requantize(ndarray)" args => + ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_requantize args + = let scalarArgs + = catMaybes + [("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_requantize_upd :: + forall args . Fullfilled "_contrib_requantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_requantize(ndarray)" args -> IO () +_contrib_requantize_upd outputs args + = let scalarArgs + = catMaybes + [("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_quantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantize_upd :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantize(ndarray)" args -> IO () +_contrib_quantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimdecode(ndarray)" = + '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool), + '("buf", AttrOpt NDArrayHandle)] + +_cvimdecode :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle] +_cvimdecode args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimdecode_upd :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO () +_cvimdecode_upd outputs args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimread(ndarray)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(ndarray)" args => + ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle] +_cvimread args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimread_upd :: + forall args . Fullfilled "_cvimread(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO () +_cvimread_upd outputs args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimresize(ndarray)" = + '[ '("w", AttrReq Int), '("h", AttrReq Int), + '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)] + +_cvimresize :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle] +_cvimresize args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimresize_upd :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO () +_cvimresize_upd outputs args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvcopyMakeBorder(ndarray)" = + '[ '("top", AttrReq Int), '("bot", AttrReq Int), + '("left", AttrReq Int), '("right", AttrReq Int), + '("type", AttrOpt Int), '("value", AttrOpt Double), + '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)] + +_cvcopyMakeBorder :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle] +_cvcopyMakeBorder args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvcopyMakeBorder_upd :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO () +_cvcopyMakeBorder_upd outputs args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_NoGradient(ndarray)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle] +_NoGradient args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_NoGradient_upd :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO () +_NoGradient_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CachedOp(ndarray)" = + '[ '("data", AttrOpt [NDArrayHandle])] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CachedOp_upd :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO () +_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CachedOp(ndarray)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_backward_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CachedOp_upd :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO () +_backward_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copyto(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copyto :: + forall args . Fullfilled "_copyto(ndarray)" args => + ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle] +_copyto args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copyto_upd :: + forall args . Fullfilled "_copyto(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO () +_copyto_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax_cross_entropy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + ArgsHMap "softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_cross_entropy_upd :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO () +softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +_backward_softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_cross_entropy_upd :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO () +_backward_softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pad(ndarray)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt NDArrayHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(ndarray)" args => + ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle] +_Pad args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pad_upd :: + forall args . Fullfilled "_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO () +_Pad_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_foreach(ndarray)" = '[] + +_backward_foreach :: + forall args . Fullfilled "_backward_foreach(ndarray)" args => + ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle] +_backward_foreach args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_foreach_upd :: + forall args . Fullfilled "_backward_foreach(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_foreach(ndarray)" args -> IO () +_backward_foreach_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_while_loop(ndarray)" = '[] + +_backward_while_loop :: + forall args . Fullfilled "_backward_while_loop(ndarray)" args => + ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle] +_backward_while_loop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_while_loop_upd :: + forall args . Fullfilled "_backward_while_loop(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_while_loop(ndarray)" args -> IO () +_backward_while_loop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cond(ndarray)" = '[] + +_backward_cond :: + forall args . Fullfilled "_backward_cond(ndarray)" args => + ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle] +_backward_cond args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cond_upd :: + forall args . Fullfilled "_backward_cond(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO () +_backward_cond_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LeakyReLU(ndarray)" = + '[ '("act_type", + AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_LeakyReLU args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LeakyReLU_upd :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO () +_LeakyReLU_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SwapAxis(ndarray)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_SwapAxis args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SwapAxis_upd :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO () +_SwapAxis_upd outputs args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> + IO [NDArrayHandle] +_IdentityAttachKLSparseReg args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO () +_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SliceChannel(ndarray)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle] +_SliceChannel args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SliceChannel_upd :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO () +_SliceChannel_upd outputs args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm_v1(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm_v1 args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_v1_upd :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO () +_BatchNorm_v1_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "signsgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +signsgd_update :: + forall args . Fullfilled "signsgd_update(ndarray)" args => + ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle] +signsgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +signsgd_update_upd :: + forall args . Fullfilled "signsgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO () +signsgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "signum_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +signum_update :: + forall args . Fullfilled "signum_update(ndarray)" args => + ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle] +signum_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +signum_update_upd :: + forall args . Fullfilled "signum_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO () +signum_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(ndarray)" args => + ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle] +sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_update_upd :: + forall args . Fullfilled "sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO () +sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_mom_update_upd :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO () +sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_update_upd :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO () +mp_sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_mom_update_upd :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO () +mp_sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftml_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double), + '("t", AttrReq Int), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle), + '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)] + +ftml_update :: + forall args . Fullfilled "ftml_update(ndarray)" args => + ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle] +ftml_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("d",) <$> (args !? #d :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftml_update_upd :: + forall args . Fullfilled "ftml_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO () +ftml_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("d",) <$> (args !? #d :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "adam_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle), + '("var", AttrOpt NDArrayHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(ndarray)" args => + ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle] +adam_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +adam_update_upd :: + forall args . Fullfilled "adam_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO () +adam_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmsprop_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle] +rmsprop_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmsprop_update_upd :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO () +rmsprop_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmspropalex_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle), + '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle] +rmspropalex_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmspropalex_update_upd :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "rmspropalex_update(ndarray)" args -> IO () +rmspropalex_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftrl_update(ndarray)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle), + '("n", AttrOpt NDArrayHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle] +ftrl_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftrl_update_upd :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO () +ftrl_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_adagrad_update(ndarray)" = + '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("history", AttrOpt NDArrayHandle)] + +_sparse_adagrad_update :: + forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args => + ArgsHMap "_sparse_adagrad_update(ndarray)" args -> + IO [NDArrayHandle] +_sparse_adagrad_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_adagrad_update_upd :: + forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO () +_sparse_adagrad_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LinearRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LinearRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LinearRegressionOutput_upd :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO () +_LinearRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linear_reg_out(ndarray)" = + '[] + +_backward_linear_reg_out :: + forall args . + Fullfilled "_backward_linear_reg_out(ndarray)" args => + ArgsHMap "_backward_linear_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_linear_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linear_reg_out_upd :: + forall args . + Fullfilled "_backward_linear_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO () +_backward_linear_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MAERegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle] +_MAERegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MAERegressionOutput_upd :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO () +_MAERegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[] + +_backward_mae_reg_out :: + forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args => + ArgsHMap "_backward_mae_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_mae_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mae_reg_out_upd :: + forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO () +_backward_mae_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LogisticRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LogisticRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LogisticRegressionOutput_upd :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO () +_LogisticRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_logistic_reg_out(ndarray)" = + '[] + +_backward_logistic_reg_out :: + forall args . + Fullfilled "_backward_logistic_reg_out(ndarray)" args => + ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_logistic_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_logistic_reg_out_upd :: + forall args . + Fullfilled "_backward_logistic_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO () +_backward_logistic_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CustomFunction(ndarray)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle] +_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CustomFunction_upd :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CustomFunction(ndarray)" args -> IO () +_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CustomFunction(ndarray)" = + '[] + +_backward_CustomFunction :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + ArgsHMap "_backward_CustomFunction(ndarray)" args -> + IO [NDArrayHandle] +_backward_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CustomFunction_upd :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO () +_backward_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__Native(ndarray)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle] +_backward__Native args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__Native_upd :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__Native(ndarray)" args -> IO () +_backward__Native_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__NDArray(ndarray)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle] +_backward__NDArray args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__NDArray_upd :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__NDArray(ndarray)" args -> IO () +_backward__NDArray_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), + '("anchor", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("cls_pred", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxTarget args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxTarget_upd :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO () +_contrib_MultiBoxTarget_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxTarget args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxTarget_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args + -> IO () +_backward__contrib_MultiBoxTarget_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_Proposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle] +_contrib_Proposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_Proposal_upd :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO () +_contrib_Proposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_Proposal(ndarray)" + = '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_Proposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_Proposal_upd :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO () +_backward__contrib_Proposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_count_sketch(ndarray)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle), + '("s", AttrOpt NDArrayHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + ArgsHMap "_contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_contrib_count_sketch args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_count_sketch_upd :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO () +_contrib_count_sketch_upd outputs args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_count_sketch(ndarray)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_count_sketch args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_count_sketch_upd :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO () +_backward__contrib_count_sketch_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle), + '("loc_pred", AttrOpt NDArrayHandle), + '("anchor", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxDetection args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO () +_contrib_MultiBoxDetection_upd outputs args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)" + args => + ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args + -> IO [NDArrayHandle] +_backward__contrib_MultiBoxDetection args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled + "_backward__contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_MultiBoxDetection(ndarray)" + args + -> IO () +_backward__contrib_MultiBoxDetection_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)" + = '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformablePSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformablePSROIPooling_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO () +_backward__contrib_DeformablePSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_fft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle] +_contrib_fft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_fft_upd :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO () +_contrib_fft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_fft(ndarray)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + ArgsHMap "_backward__contrib_fft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_fft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_fft_upd :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO () +_backward__contrib_fft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxPrior args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxPrior_upd :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO () +_contrib_MultiBoxPrior_upd outputs args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxPrior args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxPrior_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args + -> IO () +_backward__contrib_MultiBoxPrior_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiProposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiProposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiProposal_upd :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO () +_contrib_MultiProposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" args => + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiProposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiProposal_upd :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args + -> IO () +_backward__contrib_MultiProposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_PSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_PSROIPooling_upd :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO () +_backward__contrib_PSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_DeformableConvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt NDArrayHandle), + '("offset", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO [NDArrayHandle] +_contrib_DeformableConvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_DeformableConvolution_upd :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO () +_contrib_DeformableConvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformableConvolution(ndarray)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformableConvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformableConvolution_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO () +_backward__contrib_DeformableConvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_ifft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle] +_contrib_ifft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ifft_upd :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO () +_contrib_ifft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_ifft(ndarray)" = + '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_ifft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_ifft_upd :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO () +_backward__contrib_ifft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[] + +_backward__contrib_SyncBatchNorm :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args => + ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_SyncBatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_SyncBatchNorm_upd :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args + -> IO () +_backward__contrib_SyncBatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_InstanceNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle] +_InstanceNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_InstanceNorm_upd :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO () +_InstanceNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_InstanceNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_InstanceNorm_upd :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO () +_backward_InstanceNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SVMOutput(ndarray)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_SVMOutput args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SVMOutput_upd :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO () +_SVMOutput_upd outputs args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SVMOutput(ndarray)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_backward_SVMOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SVMOutput_upd :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO () +_backward_SVMOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_GridGenerator(ndarray)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle] +_GridGenerator args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_GridGenerator_upd :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO () +_GridGenerator_upd outputs args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_GridGenerator(ndarray)" = + '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + ArgsHMap "_backward_GridGenerator(ndarray)" args -> + IO [NDArrayHandle] +_backward_GridGenerator args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_GridGenerator_upd :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO () +_backward_GridGenerator_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pad(ndarray)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle] +_backward_Pad args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pad_upd :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO () +_backward_Pad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution_v1(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle] +_Convolution_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_v1_upd :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_Convolution_v1(ndarray)" args -> IO () +_Convolution_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution_v1(ndarray)" = + '[] + +_backward_Convolution_v1 :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_v1_upd :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO () +_backward_Convolution_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceReverse(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle] +_SequenceReverse args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceReverse_upd :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SequenceReverse(ndarray)" args -> IO () +_SequenceReverse_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceReverse(ndarray)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceReverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceReverse_upd :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO () +_backward_SequenceReverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SoftmaxOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxOutput_upd :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO () +_SoftmaxOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxOutput(ndarray)" = + '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxOutput_upd :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO () +_backward_SoftmaxOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Softmax(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_Softmax :: + forall args . Fullfilled "_Softmax(ndarray)" args => + ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle] +_Softmax args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Softmax_upd :: + forall args . Fullfilled "_Softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO () +_Softmax_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Softmax(ndarray)" = '[] + +_backward_Softmax :: + forall args . Fullfilled "_backward_Softmax(ndarray)" args => + ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_Softmax args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Softmax_upd :: + forall args . Fullfilled "_backward_Softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Softmax(ndarray)" args -> IO () +_backward_Softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BilinearSampler(ndarray)" = + '[ '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle), '("grid", AttrOpt NDArrayHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle] +_BilinearSampler args + = let scalarArgs + = catMaybes + [("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BilinearSampler_upd :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_BilinearSampler(ndarray)" args -> IO () +_BilinearSampler_upd outputs args + = let scalarArgs + = catMaybes + [("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BilinearSampler(ndarray)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> + IO [NDArrayHandle] +_backward_BilinearSampler args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BilinearSampler_upd :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO () +_backward_BilinearSampler_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_backward_LeakyReLU args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LeakyReLU_upd :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO () +_backward_LeakyReLU_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Crop(ndarray)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [NDArrayHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(ndarray)" args => + ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle] +_Crop args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Crop_upd :: + forall args . Fullfilled "_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO () +_Crop_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Crop(ndarray)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle] +_backward_Crop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Crop_upd :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO () +_backward_Crop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ROIPooling(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_ROIPooling args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ROIPooling_upd :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO () +_ROIPooling_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIPooling(ndarray)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIPooling_upd :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO () +_backward_ROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceLast(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle] +_SequenceLast args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceLast_upd :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO () +_SequenceLast_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceLast(ndarray)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + ArgsHMap "_backward_SequenceLast(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceLast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceLast_upd :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO () +_backward_SequenceLast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle] +_CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CrossDeviceCopy_upd :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO () +_CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> + IO [NDArrayHandle] +_backward__CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__CrossDeviceCopy_upd :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO () +_backward__CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SpatialTransformer(ndarray)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle] +_SpatialTransformer args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"])), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SpatialTransformer_upd :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO () +_SpatialTransformer_upd outputs args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"])), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SpatialTransformer(ndarray)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> + IO [NDArrayHandle] +_backward_SpatialTransformer args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SpatialTransformer_upd :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO () +_backward_SpatialTransformer_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SwapAxis(ndarray)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_backward_SwapAxis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SwapAxis_upd :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO () +_backward_SwapAxis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_L2Normalization(ndarray)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt NDArrayHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle] +_L2Normalization args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_L2Normalization_upd :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_L2Normalization(ndarray)" args -> IO () +_L2Normalization_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_L2Normalization(ndarray)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + ArgsHMap "_backward_L2Normalization(ndarray)" args -> + IO [NDArrayHandle] +_backward_L2Normalization args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_L2Normalization_upd :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO () +_backward_L2Normalization_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Correlation(ndarray)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle), + '("data2", AttrOpt NDArrayHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(ndarray)" args => + ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle] +_Correlation args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Correlation_upd :: + forall args . Fullfilled "_Correlation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO () +_Correlation_upd outputs args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Correlation(ndarray)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + ArgsHMap "_backward_Correlation(ndarray)" args -> + IO [NDArrayHandle] +_backward_Correlation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Correlation_upd :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Correlation(ndarray)" args -> IO () +_backward_Correlation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args + -> IO [NDArrayHandle] +_backward_IdentityAttachKLSparseReg args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" + args + -> IO () +_backward_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MakeLoss(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt NDArrayHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_MakeLoss args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MakeLoss_upd :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO () +_MakeLoss_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_MakeLoss(ndarray)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_backward_MakeLoss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_MakeLoss_upd :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO () +_backward_MakeLoss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SliceChannel(ndarray)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + ArgsHMap "_backward_SliceChannel(ndarray)" args -> + IO [NDArrayHandle] +_backward_SliceChannel args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SliceChannel_upd :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO () +_backward_SliceChannel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_RNN(ndarray)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("projection_size", AttrOpt (Maybe Int)), + '("lstm_state_clip_min", AttrOpt (Maybe Double)), + '("lstm_state_clip_max", AttrOpt (Maybe Double)), + '("lstm_state_clip_nan", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("parameters", AttrOpt NDArrayHandle), + '("state", AttrOpt NDArrayHandle), + '("state_cell", AttrOpt NDArrayHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(ndarray)" args => + ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle] +_RNN args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool), + ("projection_size",) . showValue <$> + (args !? #projection_size :: Maybe (Maybe Int)), + ("lstm_state_clip_min",) . showValue <$> + (args !? #lstm_state_clip_min :: Maybe (Maybe Double)), + ("lstm_state_clip_max",) . showValue <$> + (args !? #lstm_state_clip_max :: Maybe (Maybe Double)), + ("lstm_state_clip_nan",) . showValue <$> + (args !? #lstm_state_clip_nan :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_RNN_upd :: + forall args . Fullfilled "_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO () +_RNN_upd outputs args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool), + ("projection_size",) . showValue <$> + (args !? #projection_size :: Maybe (Maybe Int)), + ("lstm_state_clip_min",) . showValue <$> + (args !? #lstm_state_clip_min :: Maybe (Maybe Double)), + ("lstm_state_clip_max",) . showValue <$> + (args !? #lstm_state_clip_max :: Maybe (Maybe Double)), + ("lstm_state_clip_nan",) . showValue <$> + (args !? #lstm_state_clip_nan :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_RNN(ndarray)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle] +_backward_RNN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_RNN_upd :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO () +_backward_RNN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling_v1(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])), + '("global_pool", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_Pooling_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_v1_upd :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO () +_Pooling_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_v1_upd :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO () +_backward_Pooling_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_BatchNorm_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_v1_upd :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO () +_backward_BatchNorm_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceMask(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle] +_SequenceMask args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceMask_upd :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO () +_SequenceMask_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceMask(ndarray)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + ArgsHMap "_backward_SequenceMask(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceMask args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceMask_upd :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO () +_backward_SequenceMask_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_set_value(ndarray)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(ndarray)" args => + ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle] +_set_value args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_set_value_upd :: + forall args . Fullfilled "_set_value(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO () +_set_value_upd outputs args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_onehot_encode(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_onehot_encode :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle] +_onehot_encode args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_onehot_encode_upd :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO () +_onehot_encode_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "choose_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +choose_element_0index :: + forall args . Fullfilled "choose_element_0index(ndarray)" args => + ArgsHMap "choose_element_0index(ndarray)" args -> + IO [NDArrayHandle] +choose_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "choose_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +choose_element_0index_upd :: + forall args . Fullfilled "choose_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "choose_element_0index(ndarray)" args -> IO () +choose_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "choose_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fill_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +fill_element_0index :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle] +fill_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fill_element_0index_upd :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "fill_element_0index(ndarray)" args -> IO () +fill_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_imdecode(ndarray)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt NDArrayHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(ndarray)" args => + ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle] +_imdecode args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_imdecode_upd :: + forall args . Fullfilled "_imdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO () +_imdecode_upd outputs args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () diff --git a/ops/1.4/MXNet/Base/Operators/Symbol.hs b/ops/1.4/MXNet/Base/Operators/Symbol.hs new file mode 100644 --- /dev/null +++ b/ops/1.4/MXNet/Base/Operators/Symbol.hs @@ -0,0 +1,12038 @@ +module MXNet.Base.Operators.Symbol where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "_CuDNNBatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_CuDNNBatchNorm :: + forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args => + String -> + ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle +_CuDNNBatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" = + '[] + +_backward_CuDNNBatchNorm :: + forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle +_backward_CuDNNBatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_multinomial(symbol)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle +_sample_multinomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sample_multinomial(symbol)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_backward_sample_multinomial(symbol)" args -> + IO SymbolHandle +_backward_sample_multinomial name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_uniform(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(symbol)" args => + String -> + ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle +_sample_uniform name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe SymbolHandle), + ("high",) <$> (args !? #high :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_normal(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(symbol)" args => + String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle +_sample_normal name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_gamma(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(symbol)" args => + String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle +_sample_gamma name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_exponential(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(symbol)" args => + String -> + ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle +_sample_exponential name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_poisson(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(symbol)" args => + String -> + ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle +_sample_poisson name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(symbol)" args => + String -> + ArgsHMap "_sample_negative_binomial(symbol)" args -> + IO SymbolHandle +_sample_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe SymbolHandle), + ("p",) <$> (args !? #p :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_sample_generalized_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_sample_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_sample_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_unique_zipfian(symbol)" = + '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])] + +_sample_unique_zipfian :: + forall args . Fullfilled "_sample_unique_zipfian(symbol)" args => + String -> + ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle +_sample_unique_zipfian name args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_uniform(symbol)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(symbol)" args => + String -> + ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle +_random_uniform name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_normal(symbol)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(symbol)" args => + String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle +_random_normal name args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_gamma(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(symbol)" args => + String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle +_random_gamma name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_exponential(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(symbol)" args => + String -> + ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle +_random_exponential name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_poisson(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(symbol)" args => + String -> + ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle +_random_poisson name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_negative_binomial(symbol)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(symbol)" args => + String -> + ArgsHMap "_random_negative_binomial(symbol)" args -> + IO SymbolHandle +_random_negative_binomial name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_generalized_negative_binomial(symbol)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_random_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_random_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_randint(symbol)" = + '[ '("low", AttrReq Int), '("high", AttrReq Int), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))] + +_random_randint :: + forall args . Fullfilled "_random_randint(symbol)" args => + String -> + ArgsHMap "_random_randint(symbol)" args -> IO SymbolHandle +_random_randint name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Int), + ("high",) . showValue <$> (args !? #high :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_randint" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_uniform_like(symbol)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_uniform_like :: + forall args . Fullfilled "_random_uniform_like(symbol)" args => + String -> + ArgsHMap "_random_uniform_like(symbol)" args -> IO SymbolHandle +_random_uniform_like name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_normal_like(symbol)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_normal_like :: + forall args . Fullfilled "_random_normal_like(symbol)" args => + String -> + ArgsHMap "_random_normal_like(symbol)" args -> IO SymbolHandle +_random_normal_like name args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_gamma_like(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_gamma_like :: + forall args . Fullfilled "_random_gamma_like(symbol)" args => + String -> + ArgsHMap "_random_gamma_like(symbol)" args -> IO SymbolHandle +_random_gamma_like name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_exponential_like(symbol)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_random_exponential_like :: + forall args . Fullfilled "_random_exponential_like(symbol)" args => + String -> + ArgsHMap "_random_exponential_like(symbol)" args -> IO SymbolHandle +_random_exponential_like name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_poisson_like(symbol)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_random_poisson_like :: + forall args . Fullfilled "_random_poisson_like(symbol)" args => + String -> + ArgsHMap "_random_poisson_like(symbol)" args -> IO SymbolHandle +_random_poisson_like name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_negative_binomial_like(symbol)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_negative_binomial_like :: + forall args . + Fullfilled "_random_negative_binomial_like(symbol)" args => + String -> + ArgsHMap "_random_negative_binomial_like(symbol)" args -> + IO SymbolHandle +_random_negative_binomial_like name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_generalized_negative_binomial_like(symbol)" + = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_generalized_negative_binomial_like :: + forall args . + Fullfilled + "_random_generalized_negative_binomial_like(symbol)" + args => + String -> + ArgsHMap + "_random_generalized_negative_binomial_like(symbol)" + args + -> IO SymbolHandle +_random_generalized_negative_binomial_like name args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_shuffle(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_shuffle :: + forall args . Fullfilled "_shuffle(symbol)" args => + String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle +_shuffle name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Custom(symbol)" = + '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])] + +_Custom :: + forall args . + (Fullfilled "_Custom(symbol)" args, + PopKey (ArgOf "_Custom(symbol)") args "data", + Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) => + String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle +_Custom name args + = let scalarArgs = dump (pop args #data) + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Custom(symbol)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(symbol)" args => + String -> + ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle +_backward_Custom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(symbol)" args => + String -> + ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle +broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_power(symbol)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_power(symbol)" args -> + IO SymbolHandle +_backward_broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(symbol)" args => + String -> + ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle +broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_maximum(symbol)" = + '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_maximum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(symbol)" args => + String -> + ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle +broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_minimum(symbol)" = + '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_minimum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(symbol)" args => + String -> + ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle +broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_hypot(symbol)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_hypot(symbol)" args -> + IO SymbolHandle +_backward_broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_equal :: + forall args . Fullfilled "_equal(symbol)" args => + String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle +_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(symbol)" args => + String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle +_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater :: + forall args . Fullfilled "_greater(symbol)" args => + String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle +_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(symbol)" args => + String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle +_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(symbol)" args => + String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle +_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(symbol)" args => + String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle +_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_and(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_and :: + forall args . Fullfilled "_logical_and(symbol)" args => + String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle +_logical_and name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_or(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_or :: + forall args . Fullfilled "_logical_or(symbol)" args => + String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle +_logical_or name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_xor(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_xor :: + forall args . Fullfilled "_logical_xor(symbol)" args => + String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle +_logical_xor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_power :: + forall args . Fullfilled "_power(symbol)" args => + String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle +_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power(symbol)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(symbol)" args => + String -> + ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle +_backward_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(symbol)" args => + String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle +_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum(symbol)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(symbol)" args => + String -> + ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle +_backward_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(symbol)" args => + String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle +_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum(symbol)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(symbol)" args => + String -> + ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle +_backward_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(symbol)" args => + String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle +_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot(symbol)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(symbol)" args => + String -> + ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle +_backward_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_square_sum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(symbol)" args => + String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle +_square_sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square_sum(symbol)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(symbol)" args => + String -> + ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle +_backward_square_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "add_n(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +add_n :: + forall args . Fullfilled "add_n(symbol)" args => + String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle +add_n name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "add_n" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_zeros_without_dtype(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt Int)] + +_zeros_without_dtype :: + forall args . Fullfilled "_zeros_without_dtype(symbol)" args => + String -> + ArgsHMap "_zeros_without_dtype(symbol)" args -> IO SymbolHandle +_zeros_without_dtype name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros_without_dtype" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_zeros(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(symbol)" args => + String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle +_zeros name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_eye(symbol)" = + '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_eye :: + forall args . Fullfilled "_eye(symbol)" args => + String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle +_eye name args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ones(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(symbol)" args => + String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle +_ones name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_full(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(symbol)" args => + String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle +_full name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_arange(symbol)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(symbol)" args => + String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle +_arange name args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "zeros_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(symbol)" args => + String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle +zeros_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ones_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(symbol)" args => + String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle +ones_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(symbol)" args => + String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle +broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_add(symbol)" = '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle +_backward_broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(symbol)" args => + String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle +broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_sub(symbol)" = '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle +_backward_broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(symbol)" args => + String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle +broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mul(symbol)" = '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle +_backward_broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(symbol)" args => + String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle +broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_div(symbol)" = '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle +_backward_broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(symbol)" args => + String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle +broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mod(symbol)" = '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle +_backward_broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(symbol)" args => + String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle +_linalg_gemm name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle), + ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm(symbol)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm2(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("axis", AttrOpt Int), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(symbol)" args => + String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle +_linalg_gemm2 name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potrf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(symbol)" args => + String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle +_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potrf(symbol)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle +_backward_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potri(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(symbol)" args => + String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle +_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potri(symbol)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle +_backward_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trmm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(symbol)" args => + String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle +_linalg_trmm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trmm(symbol)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle +_backward_linalg_trmm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trsm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(symbol)" args => + String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle +_linalg_trsm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trsm(symbol)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle +_backward_linalg_trsm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_sumlogdiag(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle +_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" = + '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args -> + IO SymbolHandle +_backward_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syrk(symbol)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(symbol)" args => + String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle +_linalg_syrk name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syrk(symbol)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle +_backward_linalg_syrk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gelqf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(symbol)" args => + String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle +_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle +_backward_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syevd(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(symbol)" args => + String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle +_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syevd(symbol)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle +_backward_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_histogram(symbol)" = + '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)] + +_histogram :: + forall args . Fullfilled "_histogram(symbol)" args => + String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle +_histogram name args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cast_storage(symbol)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt SymbolHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(symbol)" args => + String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle +cast_storage name args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(symbol)" args => + String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle +_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(symbol)" args => + String -> + ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle +_not_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(symbol)" args => + String -> + ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle +_greater_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(symbol)" args => + String -> + ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle +_greater_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(symbol)" args => + String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle +_lesser_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(symbol)" args => + String -> + ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle +_lesser_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_and_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_and_scalar :: + forall args . Fullfilled "_logical_and_scalar(symbol)" args => + String -> + ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle +_logical_and_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_or_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_or_scalar :: + forall args . Fullfilled "_logical_or_scalar(symbol)" args => + String -> + ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle +_logical_or_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_xor_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_xor_scalar :: + forall args . Fullfilled "_logical_xor_scalar(symbol)" args => + String -> + ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle +_logical_xor_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "relu(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +relu :: + forall args . Fullfilled "relu(symbol)" args => + String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle +relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_relu(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(symbol)" args => + String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle +_backward_relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sigmoid(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(symbol)" args => + String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle +sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sigmoid(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle +_backward_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "hard_sigmoid(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +hard_sigmoid :: + forall args . Fullfilled "hard_sigmoid(symbol)" args => + String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle +hard_sigmoid name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[] + +_backward_hard_sigmoid :: + forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle +_backward_hard_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softsign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +softsign :: + forall args . Fullfilled "softsign(symbol)" args => + String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle +softsign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softsign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softsign :: + forall args . Fullfilled "_backward_softsign(symbol)" args => + String -> + ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle +_backward_softsign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_copy(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_copy :: + forall args . Fullfilled "_copy(symbol)" args => + String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle +_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_copy(symbol)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(symbol)" args => + String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle +_backward_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BlockGrad(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(symbol)" args => + String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle +_BlockGrad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "make_loss(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(symbol)" args => + String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle +make_loss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_identity_with_attr_like_rhs(symbol)" + = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(symbol)" args => + String -> + ArgsHMap "_identity_with_attr_like_rhs(symbol)" args -> + IO SymbolHandle +_identity_with_attr_like_rhs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reshape_like(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(symbol)" args => + String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle +reshape_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "shape_array(symbol)" = + '[ '("lhs_begin", AttrOpt (Maybe Int)), + '("lhs_end", AttrOpt (Maybe Int)), + '("rhs_begin", AttrOpt (Maybe Int)), + '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +shape_array :: + forall args . Fullfilled "shape_array(symbol)" args => + String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle +shape_array name args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "size_array(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +size_array :: + forall args . Fullfilled "size_array(symbol)" args => + String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle +size_array name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Cast(symbol)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(symbol)" args => + String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle +_Cast name args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cast(symbol)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(symbol)" args => + String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle +_backward_cast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "negative(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +negative :: + forall args . Fullfilled "negative(symbol)" args => + String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle +negative name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reciprocal(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(symbol)" args => + String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle +reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reciprocal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(symbol)" args => + String -> + ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle +_backward_reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "abs(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +abs :: + forall args . Fullfilled "abs(symbol)" args => + String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle +abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_abs(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(symbol)" args => + String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle +_backward_abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sign :: + forall args . Fullfilled "sign(symbol)" args => + String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle +sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(symbol)" args => + String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle +_backward_sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "round(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +round :: + forall args . Fullfilled "round(symbol)" args => + String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle +round name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rint(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rint :: + forall args . Fullfilled "rint(symbol)" args => + String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle +rint name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ceil(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ceil :: + forall args . Fullfilled "ceil(symbol)" args => + String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle +ceil name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "floor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +floor :: + forall args . Fullfilled "floor(symbol)" args => + String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle +floor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "trunc(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +trunc :: + forall args . Fullfilled "trunc(symbol)" args => + String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle +trunc name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "fix(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +fix :: + forall args . Fullfilled "fix(symbol)" args => + String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle +fix name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "square(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +square :: + forall args . Fullfilled "square(symbol)" args => + String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle +square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(symbol)" args => + String -> + ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle +_backward_square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(symbol)" args => + String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle +sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(symbol)" args => + String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle +_backward_sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rsqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(symbol)" args => + String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle +rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rsqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(symbol)" args => + String -> + ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle +_backward_rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(symbol)" args => + String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle +cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(symbol)" args => + String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle +_backward_cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "erf(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +erf :: + forall args . Fullfilled "erf(symbol)" args => + String -> ArgsHMap "erf(symbol)" args -> IO SymbolHandle +erf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_erf(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_erf :: + forall args . Fullfilled "_backward_erf(symbol)" args => + String -> ArgsHMap "_backward_erf(symbol)" args -> IO SymbolHandle +_backward_erf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rcbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(symbol)" args => + String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle +rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rcbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(symbol)" args => + String -> + ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle +_backward_rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "exp(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +exp :: + forall args . Fullfilled "exp(symbol)" args => + String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle +exp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log :: + forall args . Fullfilled "log(symbol)" args => + String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle +log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log10(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log10 :: + forall args . Fullfilled "log10(symbol)" args => + String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle +log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log2(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log2 :: + forall args . Fullfilled "log2(symbol)" args => + String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle +log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(symbol)" args => + String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle +_backward_log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log10(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(symbol)" args => + String -> + ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle +_backward_log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log2(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(symbol)" args => + String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle +_backward_log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log1p(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log1p :: + forall args . Fullfilled "log1p(symbol)" args => + String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle +log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log1p(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(symbol)" args => + String -> + ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle +_backward_log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expm1(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +expm1 :: + forall args . Fullfilled "expm1(symbol)" args => + String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle +expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_expm1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(symbol)" args => + String -> + ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle +_backward_expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gamma(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gamma :: + forall args . Fullfilled "gamma(symbol)" args => + String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle +gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gamma(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(symbol)" args => + String -> + ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle +_backward_gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gammaln(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(symbol)" args => + String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle +gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gammaln(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(symbol)" args => + String -> + ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle +_backward_gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "logical_not(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +logical_not :: + forall args . Fullfilled "logical_not(symbol)" args => + String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle +logical_not name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +sum :: + forall args . Fullfilled "sum(symbol)" args => + String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle +sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sum(symbol)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(symbol)" args => + String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle +_backward_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mean(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +mean :: + forall args . Fullfilled "mean(symbol)" args => + String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle +mean name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mean(symbol)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(symbol)" args => + String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle +_backward_mean name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "prod(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +prod :: + forall args . Fullfilled "prod(symbol)" args => + String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle +prod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_prod(symbol)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(symbol)" args => + String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle +_backward_prod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nansum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nansum :: + forall args . Fullfilled "nansum(symbol)" args => + String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle +nansum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nansum(symbol)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(symbol)" args => + String -> + ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle +_backward_nansum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nanprod(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(symbol)" args => + String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle +nanprod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nanprod(symbol)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(symbol)" args => + String -> + ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle +_backward_nanprod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "max(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +max :: + forall args . Fullfilled "max(symbol)" args => + String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle +max name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_max(symbol)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(symbol)" args => + String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle +_backward_max name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "min(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +min :: + forall args . Fullfilled "min(symbol)" args => + String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle +min name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_min(symbol)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(symbol)" args => + String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle +_backward_min name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_axis(symbol)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(symbol)" args => + String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle +broadcast_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_to(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(symbol)" args => + String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle +broadcast_to name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_broadcast_backward(symbol)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(symbol)" args => + String -> + ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle +_broadcast_backward name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_like(symbol)" = + '[ '("lhs_axes", AttrOpt (Maybe [Int])), + '("rhs_axes", AttrOpt (Maybe [Int])), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_like :: + forall args . Fullfilled "broadcast_like(symbol)" args => + String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle +broadcast_like name args + = let scalarArgs + = catMaybes + [("lhs_axes",) . showValue <$> + (args !? #lhs_axes :: Maybe (Maybe [Int])), + ("rhs_axes",) . showValue <$> + (args !? #rhs_axes :: Maybe (Maybe [Int]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "norm(symbol)" = + '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])), + '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +norm :: + forall args . Fullfilled "norm(symbol)" args => + String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle +norm name args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_norm(symbol)" = '[] + +_backward_norm :: + forall args . Fullfilled "_backward_norm(symbol)" args => + String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle +_backward_norm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(symbol)" args => + String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle +elemwise_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_grad_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(symbol)" args => + String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle +_grad_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_add(symbol)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(symbol)" args => + String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle +_backward_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(symbol)" args => + String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle +elemwise_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sub(symbol)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(symbol)" args => + String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle +_backward_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(symbol)" args => + String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle +elemwise_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul(symbol)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(symbol)" args => + String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle +_backward_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(symbol)" args => + String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle +elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div(symbol)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(symbol)" args => + String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle +_backward_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_mod :: + forall args . Fullfilled "_mod(symbol)" args => + String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle +_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod(symbol)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(symbol)" args => + String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle +_backward_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(symbol)" args => + String -> + ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle +_scatter_elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle +_scatter_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle +_scatter_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Embedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(symbol)" args => + String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle +_Embedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SparseEmbedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle)] + +_contrib_SparseEmbedding :: + forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle +_contrib_SparseEmbedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Embedding(symbol)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(symbol)" args => + String -> + ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle +_backward_Embedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SparseEmbedding(symbol)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_backward_SparseEmbedding(symbol)" args -> + IO SymbolHandle +_backward_SparseEmbedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "take(symbol)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +take :: + forall args . Fullfilled "take(symbol)" args => + String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle +take name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_take(symbol)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(symbol)" args => + String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle +_backward_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_take(symbol)" = + '[ '("a", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(symbol)" args => + String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle +batch_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "one_hot(symbol)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("indices", AttrOpt SymbolHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(symbol)" args => + String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle +one_hot name args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gather_nd(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(symbol)" args => + String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle +gather_nd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "scatter_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(symbol)" args => + String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle +scatter_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gather_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_backward_gather_nd :: + forall args . Fullfilled "_backward_gather_nd(symbol)" args => + String -> + ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle +_backward_gather_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_set_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(symbol)" args => + String -> + ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle +_scatter_set_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(symbol)" args => + String -> + ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle +broadcast_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(symbol)" args => + String -> + ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle +broadcast_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(symbol)" args => + String -> + ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle +broadcast_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(symbol)" args => + String -> + ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle +broadcast_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(symbol)" args => + String -> + ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle +broadcast_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(symbol)" args => + String -> + ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle +broadcast_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_and(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_and :: + forall args . Fullfilled "broadcast_logical_and(symbol)" args => + String -> + ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle +broadcast_logical_and name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_or(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_or :: + forall args . Fullfilled "broadcast_logical_or(symbol)" args => + String -> + ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle +broadcast_logical_or name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_xor(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_xor :: + forall args . Fullfilled "broadcast_logical_xor(symbol)" args => + String -> + ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle +broadcast_logical_xor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(symbol)" args => + String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle +_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(symbol)" args => + String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle +_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rminus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(symbol)" args => + String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle +_rminus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(symbol)" args => + String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle +_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle +_backward_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(symbol)" args => + String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle +_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(symbol)" args => + String -> + ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle +_backward_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(symbol)" args => + String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle +_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle +_backward_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(symbol)" args => + String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle +_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle +_backward_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(symbol)" args => + String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle +_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle +_backward_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ravel_multi_index(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_ravel_multi_index :: + forall args . Fullfilled "_ravel_multi_index(symbol)" args => + String -> + ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle +_ravel_multi_index name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_unravel_index(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_unravel_index :: + forall args . Fullfilled "_unravel_index(symbol)" args => + String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle +_unravel_index name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmax :: + forall args . Fullfilled "argmax(symbol)" args => + String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle +argmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmin(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmin :: + forall args . Fullfilled "argmin(symbol)" args => + String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle +argmin name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax_channel(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(symbol)" args => + String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle +argmax_channel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "pick(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("mode", AttrOpt (EnumType '["clip", "wrap"])), + '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)] + +pick :: + forall args . Fullfilled "pick(symbol)" args => + String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle +pick name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("index",) <$> (args !? #index :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_pick(symbol)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(symbol)" args => + String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle +_backward_pick name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_retain(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(symbol)" args => + String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle +_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sparse_retain(symbol)" = '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(symbol)" args => + String -> + ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle +_backward_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_where(symbol)" = + '[ '("condition", AttrOpt SymbolHandle), + '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)] + +_where :: + forall args . Fullfilled "_where(symbol)" args => + String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle +_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe SymbolHandle), + ("x",) <$> (args !? #x :: Maybe SymbolHandle), + ("y",) <$> (args !? #y :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_where(symbol)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(symbol)" args => + String -> + ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle +_backward_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "diag(symbol)" = + '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int), + '("axis2", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +diag :: + forall args . Fullfilled "diag(symbol)" args => + String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle +diag name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int), + ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_diag(symbol)" = '[] + +_backward_diag :: + forall args . Fullfilled "_backward_diag(symbol)" args => + String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle +_backward_diag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle +_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_maximum_scalar :: + forall args . Fullfilled "_backward_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle +_backward_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle +_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_minimum_scalar :: + forall args . Fullfilled "_backward_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle +_backward_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(symbol)" args => + String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle +_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(symbol)" args => + String -> + ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle +_backward_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(symbol)" args => + String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle +_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle +_backward_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(symbol)" args => + String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle +_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(symbol)" args => + String -> + ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle +_backward_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "smooth_l1(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(symbol)" args => + String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle +smooth_l1 name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_smooth_l1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(symbol)" args => + String -> + ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle +_backward_smooth_l1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "topk(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +topk :: + forall args . Fullfilled "topk(symbol)" args => + String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle +topk name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_topk(symbol)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(symbol)" args => + String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle +_backward_topk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +sort :: + forall args . Fullfilled "sort(symbol)" args => + String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle +sort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argsort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +argsort :: + forall args . Fullfilled "argsort(symbol)" args => + String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle +argsort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Reshape(symbol)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(symbol)" args => + String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle +_Reshape name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(symbol)" args => + String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle +_Flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "transpose(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +transpose :: + forall args . Fullfilled "transpose(symbol)" args => + String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle +transpose name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expand_dims(symbol)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(symbol)" args => + String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle +expand_dims name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +slice :: + forall args . Fullfilled "slice(symbol)" args => + String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle +slice name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice(symbol)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(symbol)" args => + String -> + ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle +_backward_slice name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(symbol)" args => + String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle +_slice_assign name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign_scalar(symbol)" = + '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(symbol)" args => + String -> + ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle +_slice_assign_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_axis(symbol)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(symbol)" args => + String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle +slice_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_axis(symbol)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(symbol)" args => + String -> + ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle +_backward_slice_axis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_like(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle), + '("shape_like", AttrOpt SymbolHandle)] + +slice_like :: + forall args . Fullfilled "slice_like(symbol)" args => + String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle +slice_like name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_like(symbol)" = '[] + +_backward_slice_like :: + forall args . Fullfilled "_backward_slice_like(symbol)" args => + String -> + ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle +_backward_slice_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "clip(symbol)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +clip :: + forall args . Fullfilled "clip(symbol)" args => + String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle +clip name args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_clip(symbol)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(symbol)" args => + String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle +_backward_clip name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "repeat(symbol)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt SymbolHandle)] + +repeat :: + forall args . Fullfilled "repeat(symbol)" args => + String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle +repeat name args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_repeat(symbol)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(symbol)" args => + String -> + ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle +_backward_repeat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tile(symbol)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +tile :: + forall args . Fullfilled "tile(symbol)" args => + String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle +tile name args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tile(symbol)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(symbol)" args => + String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle +_backward_tile name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reverse(symbol)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +reverse :: + forall args . Fullfilled "reverse(symbol)" args => + String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle +reverse name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reverse(symbol)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(symbol)" args => + String -> + ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle +_backward_reverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "stack(symbol)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [SymbolHandle])] + +stack :: + forall args . Fullfilled "stack(symbol)" args => + String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle +stack name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "stack" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_stack(symbol)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(symbol)" args => + String -> + ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle +_backward_stack name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "squeeze(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), + '("data", AttrOpt [SymbolHandle])] + +squeeze :: + forall args . Fullfilled "squeeze(symbol)" args => + String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle +squeeze name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "squeeze" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_squeeze(symbol)" = '[] + +_backward_squeeze :: + forall args . Fullfilled "_backward_squeeze(symbol)" args => + String -> + ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle +_backward_squeeze name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "depth_to_space(symbol)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +depth_to_space :: + forall args . Fullfilled "depth_to_space(symbol)" args => + String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle +depth_to_space name args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "space_to_depth(symbol)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +space_to_depth :: + forall args . Fullfilled "space_to_depth(symbol)" args => + String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle +space_to_depth name args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +dot :: + forall args . Fullfilled "dot(symbol)" args => + String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle +dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(symbol)" args => + String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle +_backward_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(symbol)" args => + String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle +batch_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_batch_dot(symbol)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(symbol)" args => + String -> + ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle +_backward_batch_dot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sin :: + forall args . Fullfilled "sin(symbol)" args => + String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle +sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(symbol)" args => + String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle +_backward_sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cos :: + forall args . Fullfilled "cos(symbol)" args => + String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle +cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(symbol)" args => + String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle +_backward_cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tan :: + forall args . Fullfilled "tan(symbol)" args => + String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle +tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(symbol)" args => + String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle +_backward_tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(symbol)" args => + String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle +arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(symbol)" args => + String -> + ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle +_backward_arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccos :: + forall args . Fullfilled "arccos(symbol)" args => + String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle +arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(symbol)" args => + String -> + ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle +_backward_arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctan :: + forall args . Fullfilled "arctan(symbol)" args => + String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle +arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(symbol)" args => + String -> + ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle +_backward_arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "degrees(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +degrees :: + forall args . Fullfilled "degrees(symbol)" args => + String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle +degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_degrees(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(symbol)" args => + String -> + ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle +_backward_degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "radians(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +radians :: + forall args . Fullfilled "radians(symbol)" args => + String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle +radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_radians(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(symbol)" args => + String -> + ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle +_backward_radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sinh :: + forall args . Fullfilled "sinh(symbol)" args => + String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle +sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(symbol)" args => + String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle +_backward_sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cosh :: + forall args . Fullfilled "cosh(symbol)" args => + String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle +cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(symbol)" args => + String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle +_backward_cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tanh :: + forall args . Fullfilled "tanh(symbol)" args => + String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle +tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(symbol)" args => + String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle +_backward_tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(symbol)" args => + String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle +arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(symbol)" args => + String -> + ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle +_backward_arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(symbol)" args => + String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle +arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(symbol)" args => + String -> + ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle +_backward_arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(symbol)" args => + String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle +arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(symbol)" args => + String -> + ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle +_backward_arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_group_adagrad_update(symbol)" + = + '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("history", AttrOpt SymbolHandle)] + +_contrib_group_adagrad_update :: + forall args . + Fullfilled "_contrib_group_adagrad_update(symbol)" args => + String -> + ArgsHMap "_contrib_group_adagrad_update(symbol)" args -> + IO SymbolHandle +_contrib_group_adagrad_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("history",) <$> (args !? #history :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_group_adagrad_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_getnnz(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +_contrib_getnnz :: + forall args . Fullfilled "_contrib_getnnz(symbol)" args => + String -> + ArgsHMap "_contrib_getnnz(symbol)" args -> IO SymbolHandle +_contrib_getnnz name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_getnnz" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_edge_id(symbol)" = + '[ '("data", AttrOpt SymbolHandle), '("u", AttrOpt SymbolHandle), + '("v", AttrOpt SymbolHandle)] + +_contrib_edge_id :: + forall args . Fullfilled "_contrib_edge_id(symbol)" args => + String -> + ArgsHMap "_contrib_edge_id(symbol)" args -> IO SymbolHandle +_contrib_edge_id name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("u",) <$> (args !? #u :: Maybe SymbolHandle), + ("v",) <$> (args !? #v :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_edge_id" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_dgl_adjacency(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_contrib_dgl_adjacency :: + forall args . Fullfilled "_contrib_dgl_adjacency(symbol)" args => + String -> + ArgsHMap "_contrib_dgl_adjacency(symbol)" args -> IO SymbolHandle +_contrib_dgl_adjacency name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dgl_adjacency" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quadratic(symbol)" = + '[ '("a", AttrOpt Float), '("b", AttrOpt Float), + '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_contrib_quadratic :: + forall args . Fullfilled "_contrib_quadratic(symbol)" args => + String -> + ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle +_contrib_quadratic name args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_backward_quadratic(symbol)" = + '[] + +_contrib_backward_quadratic :: + forall args . + Fullfilled "_contrib_backward_quadratic(symbol)" args => + String -> + ArgsHMap "_contrib_backward_quadratic(symbol)" args -> + IO SymbolHandle +_contrib_backward_quadratic name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_div_sqrt_dim(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_contrib_div_sqrt_dim :: + forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args => + String -> + ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle +_contrib_div_sqrt_dim name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "khatri_rao(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +khatri_rao :: + forall args . Fullfilled "khatri_rao(symbol)" args => + String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle +khatri_rao name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_contrib_index_copy(symbol)" = + '[ '("old_tensor", AttrOpt SymbolHandle), + '("index_vector", AttrOpt SymbolHandle), + '("new_tensor", AttrOpt SymbolHandle)] + +_contrib_index_copy :: + forall args . Fullfilled "_contrib_index_copy(symbol)" args => + String -> + ArgsHMap "_contrib_index_copy(symbol)" args -> IO SymbolHandle +_contrib_index_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("old_tensor",) <$> (args !? #old_tensor :: Maybe SymbolHandle), + ("index_vector",) <$> + (args !? #index_vector :: Maybe SymbolHandle), + ("new_tensor",) <$> (args !? #new_tensor :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_backward_index_copy(symbol)" + = '[] + +_contrib_backward_index_copy :: + forall args . + Fullfilled "_contrib_backward_index_copy(symbol)" args => + String -> + ArgsHMap "_contrib_backward_index_copy(symbol)" args -> + IO SymbolHandle +_contrib_backward_index_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_index_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_ROIAlign(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_ROIAlign :: + forall args . Fullfilled "_contrib_ROIAlign(symbol)" args => + String -> + ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle +_contrib_ROIAlign name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIAlign(symbol)" = '[] + +_backward_ROIAlign :: + forall args . Fullfilled "_backward_ROIAlign(symbol)" args => + String -> + ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle +_backward_ROIAlign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_box_nms(symbol)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"])), + '("data", AttrOpt SymbolHandle)] + +_contrib_box_nms :: + forall args . Fullfilled "_contrib_box_nms(symbol)" args => + String -> + ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle +_contrib_box_nms name args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_contrib_box_nms(symbol)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_nms :: + forall args . + Fullfilled "_backward_contrib_box_nms(symbol)" args => + String -> + ArgsHMap "_backward_contrib_box_nms(symbol)" args -> + IO SymbolHandle +_backward_contrib_box_nms name args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_box_iou(symbol)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"])), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_contrib_box_iou :: + forall args . Fullfilled "_contrib_box_iou(symbol)" args => + String -> + ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle +_contrib_box_iou name args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_contrib_box_iou(symbol)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_iou :: + forall args . + Fullfilled "_backward_contrib_box_iou(symbol)" args => + String -> + ArgsHMap "_backward_contrib_box_iou(symbol)" args -> + IO SymbolHandle +_backward_contrib_box_iou name args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_bipartite_matching(symbol)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_bipartite_matching :: + forall args . + Fullfilled "_contrib_bipartite_matching(symbol)" args => + String -> + ArgsHMap "_contrib_bipartite_matching(symbol)" args -> + IO SymbolHandle +_contrib_bipartite_matching name args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_bipartite_matching(symbol)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int)] + +_backward_contrib_bipartite_matching :: + forall args . + Fullfilled "_backward_contrib_bipartite_matching(symbol)" + args => + String -> + ArgsHMap "_backward_contrib_bipartite_matching(symbol)" + args + -> IO SymbolHandle +_backward_contrib_bipartite_matching name args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_BilinearResize2D(symbol)" = + '[ '("height", AttrReq Int), '("width", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_contrib_BilinearResize2D :: + forall args . + Fullfilled "_contrib_BilinearResize2D(symbol)" args => + String -> + ArgsHMap "_contrib_BilinearResize2D(symbol)" args -> + IO SymbolHandle +_contrib_BilinearResize2D name args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[] + +_backward_contrib_BilinearResize2D :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args => + String -> + ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args -> + IO SymbolHandle +_backward_contrib_BilinearResize2D name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_boolean_mask(symbol)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle), + '("index", AttrOpt SymbolHandle)] + +_contrib_boolean_mask :: + forall args . Fullfilled "_contrib_boolean_mask(symbol)" args => + String -> + ArgsHMap "_contrib_boolean_mask(symbol)" args -> IO SymbolHandle +_contrib_boolean_mask name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("index",) <$> (args !? #index :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_boolean_mask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_boolean_mask(symbol)" = + '[ '("axis", AttrOpt Int)] + +_backward_contrib_boolean_mask :: + forall args . + Fullfilled "_backward_contrib_boolean_mask(symbol)" args => + String -> + ArgsHMap "_backward_contrib_boolean_mask(symbol)" args -> + IO SymbolHandle +_backward_contrib_boolean_mask name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_boolean_mask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SyncBatchNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int), + '("key", AttrOpt String), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_contrib_SyncBatchNorm :: + forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args => + String -> + ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle +_contrib_SyncBatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)" + = + '[ '("output_size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args => + String -> + ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args -> + IO SymbolHandle +_contrib_AdaptiveAvgPooling2D name args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" = + '[] + +_backward_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)" + args => + String -> + ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)" + args + -> IO SymbolHandle +_backward_contrib_AdaptiveAvgPooling2D name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_to_tensor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_to_tensor :: + forall args . Fullfilled "_image_to_tensor(symbol)" args => + String -> + ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle +_image_to_tensor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_normalize(symbol)" = + '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]), + '("data", AttrOpt SymbolHandle)] + +_image_normalize :: + forall args . Fullfilled "_image_normalize(symbol)" args => + String -> + ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle +_image_normalize name args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_flip_left_right(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_flip_left_right :: + forall args . Fullfilled "_image_flip_left_right(symbol)" args => + String -> + ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle +_image_flip_left_right name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_flip_left_right(symbol)" + = '[ '("data", AttrOpt SymbolHandle)] + +_image_random_flip_left_right :: + forall args . + Fullfilled "_image_random_flip_left_right(symbol)" args => + String -> + ArgsHMap "_image_random_flip_left_right(symbol)" args -> + IO SymbolHandle +_image_random_flip_left_right name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_flip_top_bottom(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_flip_top_bottom :: + forall args . Fullfilled "_image_flip_top_bottom(symbol)" args => + String -> + ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle +_image_flip_top_bottom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_flip_top_bottom(symbol)" + = '[ '("data", AttrOpt SymbolHandle)] + +_image_random_flip_top_bottom :: + forall args . + Fullfilled "_image_random_flip_top_bottom(symbol)" args => + String -> + ArgsHMap "_image_random_flip_top_bottom(symbol)" args -> + IO SymbolHandle +_image_random_flip_top_bottom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_brightness(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_brightness :: + forall args . Fullfilled "_image_random_brightness(symbol)" args => + String -> + ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle +_image_random_brightness name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_contrast(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_contrast :: + forall args . Fullfilled "_image_random_contrast(symbol)" args => + String -> + ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle +_image_random_contrast name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_saturation(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_saturation :: + forall args . Fullfilled "_image_random_saturation(symbol)" args => + String -> + ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle +_image_random_saturation name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_hue(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_hue :: + forall args . Fullfilled "_image_random_hue(symbol)" args => + String -> + ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle +_image_random_hue name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_color_jitter(symbol)" = + '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float), + '("saturation", AttrReq Float), '("hue", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_color_jitter :: + forall args . + Fullfilled "_image_random_color_jitter(symbol)" args => + String -> + ArgsHMap "_image_random_color_jitter(symbol)" args -> + IO SymbolHandle +_image_random_color_jitter name args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_adjust_lighting(symbol)" = + '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)] + +_image_adjust_lighting :: + forall args . Fullfilled "_image_adjust_lighting(symbol)" args => + String -> + ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle +_image_adjust_lighting name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_lighting(symbol)" = + '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_image_random_lighting :: + forall args . Fullfilled "_image_random_lighting(symbol)" args => + String -> + ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle +_image_random_lighting name args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt SymbolHandle)] + +softmax :: + forall args . Fullfilled "softmax(symbol)" args => + String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle +softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softmax(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(symbol)" args => + String -> + ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle +_backward_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmin(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt SymbolHandle)] + +softmin :: + forall args . Fullfilled "softmin(symbol)" args => + String -> ArgsHMap "softmin(symbol)" args -> IO SymbolHandle +softmin name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softmin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softmin :: + forall args . Fullfilled "_backward_softmin(symbol)" args => + String -> + ArgsHMap "_backward_softmin(symbol)" args -> IO SymbolHandle +_backward_softmin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log_softmax(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("data", AttrOpt SymbolHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(symbol)" args => + String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle +log_softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log_softmax(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(symbol)" args => + String -> + ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle +_backward_log_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(symbol)" args => + String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle +_Pooling name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling(symbol)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(symbol)" args => + String -> + ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle +_backward_Pooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Deconvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(symbol)" args => + String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle +_Deconvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Deconvolution(symbol)" = '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(symbol)" args => + String -> + ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle +_backward_Deconvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Activation(symbol)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt SymbolHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(symbol)" args => + String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle +_Activation name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Activation(symbol)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(symbol)" args => + String -> + ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle +_backward_Activation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_UpSampling(symbol)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(symbol)" args => + String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle +_UpSampling name args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "UpSampling" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_UpSampling(symbol)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(symbol)" args => + String -> + ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle +_backward_UpSampling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(symbol)" args => + String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle +_BatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm(symbol)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle +_backward_BatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CTCLoss(symbol)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle), + '("data_lengths", AttrOpt SymbolHandle), + '("label_lengths", AttrOpt SymbolHandle)] + +_CTCLoss :: + forall args . Fullfilled "_CTCLoss(symbol)" args => + String -> ArgsHMap "_CTCLoss(symbol)" args -> IO SymbolHandle +_CTCLoss name args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe SymbolHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CTCLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ctc_loss(symbol)" = '[] + +_backward_ctc_loss :: + forall args . Fullfilled "_backward_ctc_loss(symbol)" args => + String -> + ArgsHMap "_backward_ctc_loss(symbol)" args -> IO SymbolHandle +_backward_ctc_loss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ctc_loss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_FullyConnected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(symbol)" args => + String -> + ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle +_FullyConnected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_FullyConnected(symbol)" = + '[] + +_backward_FullyConnected :: + forall args . Fullfilled "_backward_FullyConnected(symbol)" args => + String -> + ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle +_backward_FullyConnected name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(symbol)" args => + String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle +_Convolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution(symbol)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(symbol)" args => + String -> + ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle +_backward_Convolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LayerNorm(symbol)" = + '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_LayerNorm :: + forall args . Fullfilled "_LayerNorm(symbol)" args => + String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle +_LayerNorm name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LayerNorm(symbol)" = '[] + +_backward_LayerNorm :: + forall args . Fullfilled "_backward_LayerNorm(symbol)" args => + String -> + ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle +_backward_LayerNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(symbol)" args => + String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle +_Concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Concat(symbol)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(symbol)" args => + String -> + ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle +_backward_Concat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rnn_param_concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_rnn_param_concat :: + forall args . Fullfilled "_rnn_param_concat(symbol)" args => + String -> + ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle +_rnn_param_concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_SoftmaxActivation(symbol)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt SymbolHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle +_SoftmaxActivation name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxActivation(symbol)" = + '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxActivation(symbol)" args -> + IO SymbolHandle +_backward_SoftmaxActivation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LRN(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(symbol)" args => + String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle +_LRN name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LRN(symbol)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(symbol)" args => + String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle +_backward_LRN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Dropout(symbol)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(symbol)" args => + String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle +_Dropout name args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Dropout(symbol)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(symbol)" args => + String -> + ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle +_backward_Dropout name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_dequantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["float32"])), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(symbol)" args => + String -> + ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle +_contrib_dequantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_flatten :: + forall args . + Fullfilled "_contrib_quantized_flatten(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_flatten(symbol)" args -> + IO SymbolHandle +_contrib_quantized_flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_conv(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle), + '("min_weight", AttrOpt SymbolHandle), + '("max_weight", AttrOpt SymbolHandle), + '("min_bias", AttrOpt SymbolHandle), + '("max_bias", AttrOpt SymbolHandle)] + +_contrib_quantized_conv :: + forall args . Fullfilled "_contrib_quantized_conv(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle +_contrib_quantized_conv name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_quantized_fully_connected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle), + '("min_weight", AttrOpt SymbolHandle), + '("max_weight", AttrOpt SymbolHandle), + '("min_bias", AttrOpt SymbolHandle), + '("max_bias", AttrOpt SymbolHandle)] + +_contrib_quantized_fully_connected :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_fully_connected(symbol)" args -> + IO SymbolHandle +_contrib_quantized_fully_connected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_pooling(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_pooling :: + forall args . + Fullfilled "_contrib_quantized_pooling(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_pooling(symbol)" args -> + IO SymbolHandle +_contrib_quantized_pooling name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_contrib_quantized_concat :: + forall args . + Fullfilled "_contrib_quantized_concat(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_concat(symbol)" args -> + IO SymbolHandle +_contrib_quantized_concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_contrib_quantized_concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_contrib_requantize(symbol)" = + '[ '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_requantize :: + forall args . Fullfilled "_contrib_requantize(symbol)" args => + String -> + ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle +_contrib_requantize name args + = let scalarArgs + = catMaybes + [("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(symbol)" args => + String -> + ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle +_contrib_quantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_cvimread(symbol)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(symbol)" args => + String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle +_cvimread name args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_NoGradient(symbol)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(symbol)" args => + String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle +_NoGradient name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CachedOp(symbol)" = + '[ '("data", AttrOpt [SymbolHandle])] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(symbol)" args => + String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle +_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_CachedOp(symbol)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(symbol)" args => + String -> + ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle +_backward_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax_cross_entropy(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle +softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_softmax_cross_entropy(symbol)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "_backward_softmax_cross_entropy(symbol)" args -> + IO SymbolHandle +_backward_softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pad(symbol)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt SymbolHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(symbol)" args => + String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle +_Pad name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_foreach(symbol)" = '[] + +_backward_foreach :: + forall args . Fullfilled "_backward_foreach(symbol)" args => + String -> + ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle +_backward_foreach name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_while_loop(symbol)" = '[] + +_backward_while_loop :: + forall args . Fullfilled "_backward_while_loop(symbol)" args => + String -> + ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle +_backward_while_loop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cond(symbol)" = '[] + +_backward_cond :: + forall args . Fullfilled "_backward_cond(symbol)" args => + String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle +_backward_cond name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LeakyReLU(symbol)" = + '[ '("act_type", + AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(symbol)" args => + String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle +_LeakyReLU name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SwapAxis(symbol)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt SymbolHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(symbol)" args => + String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle +_SwapAxis name args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(symbol)" args => + String -> + ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args -> + IO SymbolHandle +_IdentityAttachKLSparseReg name args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SliceChannel(symbol)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(symbol)" args => + String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle +_SliceChannel name args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm_v1(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(symbol)" args => + String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_BatchNorm_v1 name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "signsgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +signsgd_update :: + forall args . Fullfilled "signsgd_update(symbol)" args => + String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle +signsgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "signum_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +signum_update :: + forall args . Fullfilled "signum_update(symbol)" args => + String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle +signum_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(symbol)" args => + String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle +sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(symbol)" args => + String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle +sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(symbol)" args => + String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle +mp_sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(symbol)" args => + String -> + ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle +mp_sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftml_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double), + '("t", AttrReq Int), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle)] + +ftml_update :: + forall args . Fullfilled "ftml_update(symbol)" args => + String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle +ftml_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("d",) <$> (args !? #d :: Maybe SymbolHandle), + ("v",) <$> (args !? #v :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "adam_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(symbol)" args => + String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle +adam_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mean",) <$> (args !? #mean :: Maybe SymbolHandle), + ("var",) <$> (args !? #var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmsprop_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(symbol)" args => + String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle +rmsprop_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmspropalex_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle), + '("delta", AttrOpt SymbolHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(symbol)" args => + String -> + ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle +rmspropalex_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle), + ("g",) <$> (args !? #g :: Maybe SymbolHandle), + ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftrl_update(symbol)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(symbol)" args => + String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle +ftrl_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_adagrad_update(symbol)" = + '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("history", AttrOpt SymbolHandle)] + +_sparse_adagrad_update :: + forall args . Fullfilled "_sparse_adagrad_update(symbol)" args => + String -> + ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle +_sparse_adagrad_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("history",) <$> (args !? #history :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LinearRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle +_LinearRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linear_reg_out(symbol)" = + '[] + +_backward_linear_reg_out :: + forall args . Fullfilled "_backward_linear_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle +_backward_linear_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MAERegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(symbol)" args => + String -> + ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle +_MAERegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mae_reg_out(symbol)" = '[] + +_backward_mae_reg_out :: + forall args . Fullfilled "_backward_mae_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle +_backward_mae_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LogisticRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LogisticRegressionOutput(symbol)" args -> + IO SymbolHandle +_LogisticRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_logistic_reg_out(symbol)" = + '[] + +_backward_logistic_reg_out :: + forall args . + Fullfilled "_backward_logistic_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_logistic_reg_out(symbol)" args -> + IO SymbolHandle +_backward_logistic_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CustomFunction(symbol)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(symbol)" args => + String -> + ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle +_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CustomFunction(symbol)" = + '[] + +_backward_CustomFunction :: + forall args . Fullfilled "_backward_CustomFunction(symbol)" args => + String -> + ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle +_backward_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__Native(symbol)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(symbol)" args => + String -> + ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle +_backward__Native name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__NDArray(symbol)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(symbol)" args => + String -> + ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle +_backward__NDArray name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxTarget(symbol)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle), + '("cls_pred", AttrOpt SymbolHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxTarget name args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxTarget name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_Proposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle +_contrib_Proposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_Proposal(symbol)" = + '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_Proposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_Proposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_count_sketch(symbol)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle), + '("s", AttrOpt SymbolHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle +_contrib_count_sketch name args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("h",) <$> (args !? #h :: Maybe SymbolHandle), + ("s",) <$> (args !? #s :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_count_sketch(symbol)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_backward__contrib_count_sketch(symbol)" args -> + IO SymbolHandle +_backward__contrib_count_sketch name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxDetection(symbol)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle), + '("loc_pred", AttrOpt SymbolHandle), + '("anchor", AttrOpt SymbolHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxDetection(symbol)" args -> + IO SymbolHandle +_contrib_MultiBoxDetection name args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle), + ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(symbol)" + args => + String -> + ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)" + args + -> IO SymbolHandle +_backward__contrib_MultiBoxDetection name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformablePSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("group_size", AttrReq Int), '("pooled_size", AttrReq Int), + '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int), + '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle), + '("trans", AttrOpt SymbolHandle)] + +_contrib_DeformablePSROIPooling :: + forall args . + Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args -> + IO SymbolHandle +_contrib_DeformablePSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int), + ("sample_per_part",) . showValue <$> + (args !? #sample_per_part :: Maybe Int), + ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float), + ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle), + ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" = + '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformablePSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_fft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(symbol)" args => + String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle +_contrib_fft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_fft(symbol)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle +_backward__contrib_fft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxPrior(symbol)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxPrior name args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxPrior name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiProposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle +_contrib_MultiProposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiProposal(symbol)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiProposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiProposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_PSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_PSROIPooling :: + forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle +_contrib_PSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args -> + IO SymbolHandle +_backward__contrib_PSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformableConvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(symbol)" args => + String -> + ArgsHMap "_contrib_DeformableConvolution(symbol)" args -> + IO SymbolHandle +_contrib_DeformableConvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("offset",) <$> (args !? #offset :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformableConvolution(symbol)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformableConvolution(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformableConvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_ifft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(symbol)" args => + String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle +_contrib_ifft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_ifft(symbol)" = '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle +_backward__contrib_ifft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[] + +_backward__contrib_SyncBatchNorm :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args => + String -> + ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args -> + IO SymbolHandle +_backward__contrib_SyncBatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_InstanceNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(symbol)" args => + String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle +_InstanceNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_InstanceNorm(symbol)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(symbol)" args => + String -> + ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle +_backward_InstanceNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SVMOutput(symbol)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(symbol)" args => + String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle +_SVMOutput name args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SVMOutput(symbol)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(symbol)" args => + String -> + ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle +_backward_SVMOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_GridGenerator(symbol)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(symbol)" args => + String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle +_GridGenerator name args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_GridGenerator(symbol)" = '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(symbol)" args => + String -> + ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle +_backward_GridGenerator name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pad(symbol)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(symbol)" args => + String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle +_backward_Pad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution_v1(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle +_Convolution_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution_v1(symbol)" = + '[] + +_backward_Convolution_v1 :: + forall args . Fullfilled "_backward_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle +_backward_Convolution_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceReverse(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle +_SequenceReverse name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceReverse(symbol)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_backward_SequenceReverse(symbol)" args -> + IO SymbolHandle +_backward_SequenceReverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SoftmaxOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(symbol)" args => + String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_SoftmaxOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_backward_SoftmaxOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Softmax(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_Softmax :: + forall args . Fullfilled "_Softmax(symbol)" args => + String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle +_Softmax name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Softmax(symbol)" = '[] + +_backward_Softmax :: + forall args . Fullfilled "_backward_Softmax(symbol)" args => + String -> + ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle +_backward_Softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BilinearSampler(symbol)" = + '[ '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle), '("grid", AttrOpt SymbolHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle +_BilinearSampler name args + = let scalarArgs + = catMaybes + [("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BilinearSampler(symbol)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_backward_BilinearSampler(symbol)" args -> + IO SymbolHandle +_backward_BilinearSampler name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LeakyReLU(symbol)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(symbol)" args => + String -> + ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle +_backward_LeakyReLU name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Crop(symbol)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [SymbolHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(symbol)" args => + String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle +_Crop name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Crop" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Crop(symbol)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(symbol)" args => + String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle +_backward_Crop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ROIPooling(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle), + '("rois", AttrOpt SymbolHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(symbol)" args => + String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle +_ROIPooling name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIPooling(symbol)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(symbol)" args => + String -> + ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle +_backward_ROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceLast(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(symbol)" args => + String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle +_SequenceLast name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceLast(symbol)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(symbol)" args => + String -> + ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle +_backward_SequenceLast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CrossDeviceCopy(symbol)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle +_CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__CrossDeviceCopy(symbol)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_backward__CrossDeviceCopy(symbol)" args -> + IO SymbolHandle +_backward__CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SpatialTransformer(symbol)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle +_SpatialTransformer name args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"])), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SpatialTransformer(symbol)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_backward_SpatialTransformer(symbol)" args -> + IO SymbolHandle +_backward_SpatialTransformer name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SwapAxis(symbol)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(symbol)" args => + String -> + ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle +_backward_SwapAxis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_L2Normalization(symbol)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt SymbolHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(symbol)" args => + String -> + ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle +_L2Normalization name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_L2Normalization(symbol)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(symbol)" args => + String -> + ArgsHMap "_backward_L2Normalization(symbol)" args -> + IO SymbolHandle +_backward_L2Normalization name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Correlation(symbol)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle), + '("data2", AttrOpt SymbolHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(symbol)" args => + String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle +_Correlation name args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle), + ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Correlation(symbol)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(symbol)" args => + String -> + ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle +_backward_Correlation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)" + args => + String -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args + -> IO SymbolHandle +_backward_IdentityAttachKLSparseReg name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MakeLoss(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt SymbolHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(symbol)" args => + String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle +_MakeLoss name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_MakeLoss(symbol)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(symbol)" args => + String -> + ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle +_backward_MakeLoss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SliceChannel(symbol)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(symbol)" args => + String -> + ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle +_backward_SliceChannel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_RNN(symbol)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("projection_size", AttrOpt (Maybe Int)), + '("lstm_state_clip_min", AttrOpt (Maybe Double)), + '("lstm_state_clip_max", AttrOpt (Maybe Double)), + '("lstm_state_clip_nan", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), + '("parameters", AttrOpt SymbolHandle), + '("state", AttrOpt SymbolHandle), + '("state_cell", AttrOpt SymbolHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(symbol)" args => + String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle +_RNN name args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool), + ("projection_size",) . showValue <$> + (args !? #projection_size :: Maybe (Maybe Int)), + ("lstm_state_clip_min",) . showValue <$> + (args !? #lstm_state_clip_min :: Maybe (Maybe Double)), + ("lstm_state_clip_max",) . showValue <$> + (args !? #lstm_state_clip_max :: Maybe (Maybe Double)), + ("lstm_state_clip_nan",) . showValue <$> + (args !? #lstm_state_clip_nan :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle), + ("state",) <$> (args !? #state :: Maybe SymbolHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_RNN(symbol)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(symbol)" args => + String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle +_backward_RNN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling_v1(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])), + '("global_pool", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(symbol)" args => + String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle +_Pooling_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling_v1(symbol)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(symbol)" args => + String -> + ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle +_backward_Pooling_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_backward_BatchNorm_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceMask(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(symbol)" args => + String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle +_SequenceMask name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceMask(symbol)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(symbol)" args => + String -> + ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle +_backward_SequenceMask name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_set_value(symbol)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(symbol)" args => + String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle +_set_value name args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_imdecode(symbol)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt SymbolHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(symbol)" args => + String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle +_imdecode name args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym diff --git a/ops/1.5/MXNet/Base/Operators/NDArray.hs b/ops/1.5/MXNet/Base/Operators/NDArray.hs new file mode 100644 --- /dev/null +++ b/ops/1.5/MXNet/Base/Operators/NDArray.hs @@ -0,0 +1,23053 @@ +module MXNet.Base.Operators.NDArray where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "_CuDNNBatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_CuDNNBatchNorm :: + forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args => + ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle] +_CuDNNBatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CuDNNBatchNorm_upd :: + forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO () +_CuDNNBatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" = + '[] + +_backward_CuDNNBatchNorm :: + forall args . + Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args => + ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_CuDNNBatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CuDNNBatchNorm_upd :: + forall args . + Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO () +_backward_CuDNNBatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_multinomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle] +_sample_multinomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_multinomial_upd :: + forall args . Fullfilled "_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_multinomial(ndarray)" args -> IO () +_sample_multinomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sample_multinomial(ndarray)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> + IO [NDArrayHandle] +_backward_sample_multinomial args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sample_multinomial_upd :: + forall args . + Fullfilled "_backward_sample_multinomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO () +_backward_sample_multinomial_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_uniform(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle] +_sample_uniform args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_uniform_upd :: + forall args . Fullfilled "_sample_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_uniform(ndarray)" args -> IO () +_sample_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe NDArrayHandle), + ("high",) <$> (args !? #high :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_normal(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle] +_sample_normal args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_normal_upd :: + forall args . Fullfilled "_sample_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO () +_sample_normal_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_gamma(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle] +_sample_gamma args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_gamma_upd :: + forall args . Fullfilled "_sample_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO () +_sample_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_exponential(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle] +_sample_exponential args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_exponential_upd :: + forall args . Fullfilled "_sample_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_exponential(ndarray)" args -> IO () +_sample_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_poisson(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt NDArrayHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle] +_sample_poisson args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_poisson_upd :: + forall args . Fullfilled "_sample_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_poisson(ndarray)" args -> IO () +_sample_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + ArgsHMap "_sample_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_sample_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_negative_binomial_upd :: + forall args . + Fullfilled "_sample_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO () +_sample_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe NDArrayHandle), + ("p",) <$> (args !? #p :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_sample_generalized_negative_binomial(ndarray)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_sample_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_sample_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_sample_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_sample_generalized_negative_binomial(ndarray)" + args + -> IO () +_sample_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sample_unique_zipfian(ndarray)" = + '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])] + +_sample_unique_zipfian :: + forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args => + ArgsHMap "_sample_unique_zipfian(ndarray)" args -> + IO [NDArrayHandle] +_sample_unique_zipfian args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sample_unique_zipfian_upd :: + forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO () +_sample_unique_zipfian_upd outputs args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_uniform(ndarray)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle] +_random_uniform args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_uniform_upd :: + forall args . Fullfilled "_random_uniform(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_uniform(ndarray)" args -> IO () +_random_uniform_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_normal(ndarray)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(ndarray)" args => + ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle] +_random_normal args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_normal_upd :: + forall args . Fullfilled "_random_normal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO () +_random_normal_upd outputs args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_gamma(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle] +_random_gamma args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_gamma_upd :: + forall args . Fullfilled "_random_gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO () +_random_gamma_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_exponential(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle] +_random_exponential args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_exponential_upd :: + forall args . Fullfilled "_random_exponential(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_exponential(ndarray)" args -> IO () +_random_exponential_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_poisson(ndarray)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle] +_random_poisson args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_poisson_upd :: + forall args . Fullfilled "_random_poisson(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_poisson(ndarray)" args -> IO () +_random_poisson_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_negative_binomial(ndarray)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + ArgsHMap "_random_negative_binomial(ndarray)" args -> + IO [NDArrayHandle] +_random_negative_binomial args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_negative_binomial_upd :: + forall args . + Fullfilled "_random_negative_binomial(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_negative_binomial(ndarray)" args -> IO () +_random_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_generalized_negative_binomial(ndarray)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(ndarray)" + args => + ArgsHMap "_random_generalized_negative_binomial(ndarray)" + args + -> IO [NDArrayHandle] +_random_generalized_negative_binomial args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_generalized_negative_binomial_upd :: + forall args . + Fullfilled + "_random_generalized_negative_binomial(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_random_generalized_negative_binomial(ndarray)" + args + -> IO () +_random_generalized_negative_binomial_upd outputs args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_randint(ndarray)" = + '[ '("low", AttrReq Int), '("high", AttrReq Int), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))] + +_random_randint :: + forall args . Fullfilled "_random_randint(ndarray)" args => + ArgsHMap "_random_randint(ndarray)" args -> IO [NDArrayHandle] +_random_randint args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Int), + ("high",) . showValue <$> (args !? #high :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_randint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_randint_upd :: + forall args . Fullfilled "_random_randint(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_randint(ndarray)" args -> IO () +_random_randint_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Int), + ("high",) . showValue <$> (args !? #high :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_randint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_uniform_like(ndarray)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_uniform_like :: + forall args . Fullfilled "_random_uniform_like(ndarray)" args => + ArgsHMap "_random_uniform_like(ndarray)" args -> IO [NDArrayHandle] +_random_uniform_like args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_uniform_like_upd :: + forall args . Fullfilled "_random_uniform_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_uniform_like(ndarray)" args -> IO () +_random_uniform_like_upd outputs args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_normal_like(ndarray)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_normal_like :: + forall args . Fullfilled "_random_normal_like(ndarray)" args => + ArgsHMap "_random_normal_like(ndarray)" args -> IO [NDArrayHandle] +_random_normal_like args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_normal_like_upd :: + forall args . Fullfilled "_random_normal_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_normal_like(ndarray)" args -> IO () +_random_normal_like_upd outputs args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_gamma_like(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_gamma_like :: + forall args . Fullfilled "_random_gamma_like(ndarray)" args => + ArgsHMap "_random_gamma_like(ndarray)" args -> IO [NDArrayHandle] +_random_gamma_like args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_gamma_like_upd :: + forall args . Fullfilled "_random_gamma_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_gamma_like(ndarray)" args -> IO () +_random_gamma_like_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_exponential_like(ndarray)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_random_exponential_like :: + forall args . + Fullfilled "_random_exponential_like(ndarray)" args => + ArgsHMap "_random_exponential_like(ndarray)" args -> + IO [NDArrayHandle] +_random_exponential_like args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_exponential_like_upd :: + forall args . + Fullfilled "_random_exponential_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_exponential_like(ndarray)" args -> IO () +_random_exponential_like_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_random_poisson_like(ndarray)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_random_poisson_like :: + forall args . Fullfilled "_random_poisson_like(ndarray)" args => + ArgsHMap "_random_poisson_like(ndarray)" args -> IO [NDArrayHandle] +_random_poisson_like args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_poisson_like_upd :: + forall args . Fullfilled "_random_poisson_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_poisson_like(ndarray)" args -> IO () +_random_poisson_like_upd outputs args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_negative_binomial_like(ndarray)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_negative_binomial_like :: + forall args . + Fullfilled "_random_negative_binomial_like(ndarray)" args => + ArgsHMap "_random_negative_binomial_like(ndarray)" args -> + IO [NDArrayHandle] +_random_negative_binomial_like args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_negative_binomial_like_upd :: + forall args . + Fullfilled "_random_negative_binomial_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_random_negative_binomial_like(ndarray)" args -> + IO () +_random_negative_binomial_like_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_random_generalized_negative_binomial_like(ndarray)" + = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_random_generalized_negative_binomial_like :: + forall args . + Fullfilled + "_random_generalized_negative_binomial_like(ndarray)" + args => + ArgsHMap + "_random_generalized_negative_binomial_like(ndarray)" + args + -> IO [NDArrayHandle] +_random_generalized_negative_binomial_like args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_random_generalized_negative_binomial_like_upd :: + forall args . + Fullfilled + "_random_generalized_negative_binomial_like(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_random_generalized_negative_binomial_like(ndarray)" + args + -> IO () +_random_generalized_negative_binomial_like_upd outputs args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_shuffle(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_shuffle :: + forall args . Fullfilled "_shuffle(ndarray)" args => + ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle] +_shuffle args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_shuffle_upd :: + forall args . Fullfilled "_shuffle(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO () +_shuffle_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Custom(ndarray)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle] +_backward_Custom args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Custom_upd :: + forall args . Fullfilled "_backward_Custom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Custom(ndarray)" args -> IO () +_backward_Custom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle] +broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_power_upd :: + forall args . Fullfilled "broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_power(ndarray)" args -> IO () +broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_power(ndarray)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + ArgsHMap "_backward_broadcast_power(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_power_upd :: + forall args . + Fullfilled "_backward_broadcast_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO () +_backward_broadcast_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle] +broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_maximum_upd :: + forall args . Fullfilled "broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_maximum(ndarray)" args -> IO () +broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_maximum(ndarray)" + = '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_maximum_upd :: + forall args . + Fullfilled "_backward_broadcast_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO () +_backward_broadcast_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle] +broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_minimum_upd :: + forall args . Fullfilled "broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_minimum(ndarray)" args -> IO () +broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_minimum(ndarray)" + = '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_minimum_upd :: + forall args . + Fullfilled "_backward_broadcast_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO () +_backward_broadcast_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle] +broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_hypot_upd :: + forall args . Fullfilled "broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_hypot(ndarray)" args -> IO () +broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_hypot(ndarray)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_hypot_upd :: + forall args . + Fullfilled "_backward_broadcast_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO () +_backward_broadcast_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_equal :: + forall args . Fullfilled "_equal(ndarray)" args => + ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle] +_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_upd :: + forall args . Fullfilled "_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO () +_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(ndarray)" args => + ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle] +_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_upd :: + forall args . Fullfilled "_not_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO () +_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater :: + forall args . Fullfilled "_greater(ndarray)" args => + ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle] +_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_upd :: + forall args . Fullfilled "_greater(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO () +_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle] +_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_upd :: + forall args . Fullfilled "_greater_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO () +_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(ndarray)" args => + ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle] +_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_upd :: + forall args . Fullfilled "_lesser(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO () +_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_upd :: + forall args . Fullfilled "_lesser_equal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO () +_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_and(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_and :: + forall args . Fullfilled "_logical_and(ndarray)" args => + ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle] +_logical_and args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_and_upd :: + forall args . Fullfilled "_logical_and(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO () +_logical_and_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_or(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_or :: + forall args . Fullfilled "_logical_or(ndarray)" args => + ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle] +_logical_or args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_or_upd :: + forall args . Fullfilled "_logical_or(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO () +_logical_or_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_xor(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_logical_xor :: + forall args . Fullfilled "_logical_xor(ndarray)" args => + ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle] +_logical_xor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_xor_upd :: + forall args . Fullfilled "_logical_xor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO () +_logical_xor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_power :: + forall args . Fullfilled "_power(ndarray)" args => + ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle] +_power args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_upd :: + forall args . Fullfilled "_power(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO () +_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power(ndarray)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(ndarray)" args => + ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle] +_backward_power args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_upd :: + forall args . Fullfilled "_backward_power(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power(ndarray)" args -> IO () +_backward_power_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(ndarray)" args => + ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle] +_maximum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_upd :: + forall args . Fullfilled "_maximum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO () +_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum(ndarray)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle] +_backward_maximum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_upd :: + forall args . Fullfilled "_backward_maximum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum(ndarray)" args -> IO () +_backward_maximum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(ndarray)" args => + ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle] +_minimum args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_upd :: + forall args . Fullfilled "_minimum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO () +_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum(ndarray)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle] +_backward_minimum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_upd :: + forall args . Fullfilled "_backward_minimum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum(ndarray)" args -> IO () +_backward_minimum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(ndarray)" args => + ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle] +_hypot args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_upd :: + forall args . Fullfilled "_hypot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO () +_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot(ndarray)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle] +_backward_hypot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_upd :: + forall args . Fullfilled "_backward_hypot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot(ndarray)" args -> IO () +_backward_hypot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_square_sum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(ndarray)" args => + ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle] +_square_sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_square_sum_upd :: + forall args . Fullfilled "_square_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO () +_square_sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square_sum(ndarray)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_square_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_sum_upd :: + forall args . Fullfilled "_backward_square_sum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square_sum(ndarray)" args -> IO () +_backward_square_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "add_n(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +add_n :: + forall args . Fullfilled "add_n(ndarray)" args => + ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle] +add_n args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +add_n_upd :: + forall args . Fullfilled "add_n(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO () +add_n_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "add_n" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_zeros_without_dtype(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt Int)] + +_zeros_without_dtype :: + forall args . Fullfilled "_zeros_without_dtype(ndarray)" args => + ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO [NDArrayHandle] +_zeros_without_dtype args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros_without_dtype" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_zeros_without_dtype_upd :: + forall args . Fullfilled "_zeros_without_dtype(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO () +_zeros_without_dtype_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros_without_dtype" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_zeros(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(ndarray)" args => + ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle] +_zeros args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_zeros_upd :: + forall args . Fullfilled "_zeros(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO () +_zeros_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_eye(ndarray)" = + '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_eye :: + forall args . Fullfilled "_eye(ndarray)" args => + ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle] +_eye args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_eye_upd :: + forall args . Fullfilled "_eye(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO () +_eye_upd outputs args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ones(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(ndarray)" args => + ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle] +_ones args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ones_upd :: + forall args . Fullfilled "_ones(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO () +_ones_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_full(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(ndarray)" args => + ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle] +_full args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_full_upd :: + forall args . Fullfilled "_full(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO () +_full_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_arange(ndarray)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(ndarray)" args => + ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle] +_arange args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_arange_upd :: + forall args . Fullfilled "_arange(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO () +_arange_upd outputs args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linspace(ndarray)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_linspace :: + forall args . Fullfilled "_linspace(ndarray)" args => + ArgsHMap "_linspace(ndarray)" args -> IO [NDArrayHandle] +_linspace args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linspace" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linspace_upd :: + forall args . Fullfilled "_linspace(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linspace(ndarray)" args -> IO () +_linspace_upd outputs args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linspace" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "zeros_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(ndarray)" args => + ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle] +zeros_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +zeros_like_upd :: + forall args . Fullfilled "zeros_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO () +zeros_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ones_like(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(ndarray)" args => + ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle] +ones_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ones_like_upd :: + forall args . Fullfilled "ones_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO () +ones_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle] +broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_add_upd :: + forall args . Fullfilled "broadcast_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO () +broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_add(ndarray)" = + '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + ArgsHMap "_backward_broadcast_add(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_add_upd :: + forall args . Fullfilled "_backward_broadcast_add(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO () +_backward_broadcast_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle] +broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_sub_upd :: + forall args . Fullfilled "broadcast_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO () +broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_sub(ndarray)" = + '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_sub_upd :: + forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO () +_backward_broadcast_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle] +broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mul_upd :: + forall args . Fullfilled "broadcast_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO () +broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mul(ndarray)" = + '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mul_upd :: + forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO () +_backward_broadcast_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle] +broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_div_upd :: + forall args . Fullfilled "broadcast_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO () +broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_div(ndarray)" = + '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + ArgsHMap "_backward_broadcast_div(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_div_upd :: + forall args . Fullfilled "_backward_broadcast_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO () +_backward_broadcast_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle] +broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_mod_upd :: + forall args . Fullfilled "broadcast_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO () +broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_broadcast_mod(ndarray)" = + '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> + IO [NDArrayHandle] +_backward_broadcast_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_broadcast_mod_upd :: + forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO () +_backward_broadcast_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle), + '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm_upd :: + forall args . Fullfilled "_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO () +_linalg_gemm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle), + ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm_upd :: + forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO () +_backward_linalg_gemm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gemm2(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("axis", AttrOpt Int), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle] +_linalg_gemm2 args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gemm2_upd :: + forall args . Fullfilled "_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO () +_linalg_gemm2_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gemm2 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gemm2_upd :: + forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO () +_backward_linalg_gemm2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potrf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle] +_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potrf_upd :: + forall args . Fullfilled "_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO () +_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potrf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potrf_upd :: + forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO () +_backward_linalg_potrf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_potri(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle] +_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_potri_upd :: + forall args . Fullfilled "_linalg_potri(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO () +_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_potri(ndarray)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + ArgsHMap "_backward_linalg_potri(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_potri args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_potri_upd :: + forall args . Fullfilled "_backward_linalg_potri(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO () +_backward_linalg_potri_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trmm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trmm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trmm_upd :: + forall args . Fullfilled "_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO () +_linalg_trmm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trmm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trmm_upd :: + forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO () +_backward_linalg_trmm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_trsm(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle] +_linalg_trsm args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_trsm_upd :: + forall args . Fullfilled "_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO () +_linalg_trsm_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle), + ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_trsm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_trsm_upd :: + forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO () +_backward_linalg_trsm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_sumlogdiag(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle] +_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_sumlogdiag_upd :: + forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO () +_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)" + = '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_sumlogdiag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_sumlogdiag_upd :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO () +_backward_linalg_sumlogdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_extractdiag(ndarray)" = + '[ '("offset", AttrOpt Int), '("_A", AttrOpt NDArrayHandle)] + +_linalg_extractdiag :: + forall args . Fullfilled "_linalg_extractdiag(ndarray)" args => + ArgsHMap "_linalg_extractdiag(ndarray)" args -> IO [NDArrayHandle] +_linalg_extractdiag args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_extractdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_extractdiag_upd :: + forall args . Fullfilled "_linalg_extractdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_extractdiag(ndarray)" args -> IO () +_linalg_extractdiag_upd outputs args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_extractdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_extractdiag(ndarray)" + = '[] + +_backward_linalg_extractdiag :: + forall args . + Fullfilled "_backward_linalg_extractdiag(ndarray)" args => + ArgsHMap "_backward_linalg_extractdiag(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_extractdiag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_extractdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_extractdiag_upd :: + forall args . + Fullfilled "_backward_linalg_extractdiag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_extractdiag(ndarray)" args -> IO () +_backward_linalg_extractdiag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_extractdiag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_makediag(ndarray)" = + '[ '("offset", AttrOpt Int), '("_A", AttrOpt NDArrayHandle)] + +_linalg_makediag :: + forall args . Fullfilled "_linalg_makediag(ndarray)" args => + ArgsHMap "_linalg_makediag(ndarray)" args -> IO [NDArrayHandle] +_linalg_makediag args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_makediag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_makediag_upd :: + forall args . Fullfilled "_linalg_makediag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_makediag(ndarray)" args -> IO () +_linalg_makediag_upd outputs args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_makediag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_makediag(ndarray)" = + '[] + +_backward_linalg_makediag :: + forall args . + Fullfilled "_backward_linalg_makediag(ndarray)" args => + ArgsHMap "_backward_linalg_makediag(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_makediag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_makediag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_makediag_upd :: + forall args . + Fullfilled "_backward_linalg_makediag(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_makediag(ndarray)" args -> IO () +_backward_linalg_makediag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_makediag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_extracttrian(ndarray)" = + '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool), + '("_A", AttrOpt NDArrayHandle)] + +_linalg_extracttrian :: + forall args . Fullfilled "_linalg_extracttrian(ndarray)" args => + ArgsHMap "_linalg_extracttrian(ndarray)" args -> IO [NDArrayHandle] +_linalg_extracttrian args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_extracttrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_extracttrian_upd :: + forall args . Fullfilled "_linalg_extracttrian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_extracttrian(ndarray)" args -> IO () +_linalg_extracttrian_upd outputs args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_extracttrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_linalg_extracttrian(ndarray)" = '[] + +_backward_linalg_extracttrian :: + forall args . + Fullfilled "_backward_linalg_extracttrian(ndarray)" args => + ArgsHMap "_backward_linalg_extracttrian(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_extracttrian args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_extracttrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_extracttrian_upd :: + forall args . + Fullfilled "_backward_linalg_extracttrian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_extracttrian(ndarray)" args -> + IO () +_backward_linalg_extracttrian_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_extracttrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_maketrian(ndarray)" = + '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool), + '("_A", AttrOpt NDArrayHandle)] + +_linalg_maketrian :: + forall args . Fullfilled "_linalg_maketrian(ndarray)" args => + ArgsHMap "_linalg_maketrian(ndarray)" args -> IO [NDArrayHandle] +_linalg_maketrian args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_maketrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_maketrian_upd :: + forall args . Fullfilled "_linalg_maketrian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_maketrian(ndarray)" args -> IO () +_linalg_maketrian_upd outputs args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_maketrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_maketrian(ndarray)" = + '[] + +_backward_linalg_maketrian :: + forall args . + Fullfilled "_backward_linalg_maketrian(ndarray)" args => + ArgsHMap "_backward_linalg_maketrian(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_maketrian args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_maketrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_maketrian_upd :: + forall args . + Fullfilled "_backward_linalg_maketrian(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_maketrian(ndarray)" args -> IO () +_backward_linalg_maketrian_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_maketrian" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syrk(ndarray)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt NDArrayHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle] +_linalg_syrk args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syrk_upd :: + forall args . Fullfilled "_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO () +_linalg_syrk_upd outputs args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syrk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syrk_upd :: + forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO () +_backward_linalg_syrk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_gelqf(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle] +_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_gelqf_upd :: + forall args . Fullfilled "_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO () +_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_gelqf args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_gelqf_upd :: + forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO () +_backward_linalg_gelqf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_syevd(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle] +_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_syevd_upd :: + forall args . Fullfilled "_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO () +_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_syevd args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_syevd_upd :: + forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO () +_backward_linalg_syevd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_linalg_inverse(ndarray)" = + '[ '("_A", AttrOpt NDArrayHandle)] + +_linalg_inverse :: + forall args . Fullfilled "_linalg_inverse(ndarray)" args => + ArgsHMap "_linalg_inverse(ndarray)" args -> IO [NDArrayHandle] +_linalg_inverse args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_inverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_linalg_inverse_upd :: + forall args . Fullfilled "_linalg_inverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_linalg_inverse(ndarray)" args -> IO () +_linalg_inverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_inverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linalg_inverse(ndarray)" = + '[] + +_backward_linalg_inverse :: + forall args . + Fullfilled "_backward_linalg_inverse(ndarray)" args => + ArgsHMap "_backward_linalg_inverse(ndarray)" args -> + IO [NDArrayHandle] +_backward_linalg_inverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_inverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linalg_inverse_upd :: + forall args . + Fullfilled "_backward_linalg_inverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linalg_inverse(ndarray)" args -> IO () +_backward_linalg_inverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_inverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_histogram(ndarray)" = + '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)] + +_histogram :: + forall args . Fullfilled "_histogram(ndarray)" args => + ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle] +_histogram args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_histogram_upd :: + forall args . Fullfilled "_histogram(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO () +_histogram_upd outputs args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cast_storage(ndarray)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt NDArrayHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(ndarray)" args => + ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle] +cast_storage args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cast_storage_upd :: + forall args . Fullfilled "cast_storage(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO () +cast_storage_upd outputs args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_equal_scalar_upd :: + forall args . Fullfilled "_equal_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO () +_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_not_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_not_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_not_equal_scalar_upd :: + forall args . Fullfilled "_not_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_not_equal_scalar(ndarray)" args -> IO () +_not_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle] +_greater_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_scalar_upd :: + forall args . Fullfilled "_greater_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_scalar(ndarray)" args -> IO () +_greater_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_greater_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + ArgsHMap "_greater_equal_scalar(ndarray)" args -> + IO [NDArrayHandle] +_greater_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_greater_equal_scalar_upd :: + forall args . Fullfilled "_greater_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO () +_greater_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_scalar_upd :: + forall args . Fullfilled "_lesser_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO () +_lesser_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_lesser_equal_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle] +_lesser_equal_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_lesser_equal_scalar_upd :: + forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO () +_lesser_equal_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_and_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_and_scalar :: + forall args . Fullfilled "_logical_and_scalar(ndarray)" args => + ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_and_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_and_scalar_upd :: + forall args . Fullfilled "_logical_and_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_and_scalar(ndarray)" args -> IO () +_logical_and_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_or_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_or_scalar :: + forall args . Fullfilled "_logical_or_scalar(ndarray)" args => + ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_or_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_or_scalar_upd :: + forall args . Fullfilled "_logical_or_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_or_scalar(ndarray)" args -> IO () +_logical_or_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_logical_xor_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_logical_xor_scalar :: + forall args . Fullfilled "_logical_xor_scalar(ndarray)" args => + ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle] +_logical_xor_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_logical_xor_scalar_upd :: + forall args . Fullfilled "_logical_xor_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO () +_logical_xor_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "relu(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +relu :: + forall args . Fullfilled "relu(ndarray)" args => + ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle] +relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +relu_upd :: + forall args . Fullfilled "relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO () +relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_relu(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle] +_backward_relu args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_relu_upd :: + forall args . Fullfilled "_backward_relu(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO () +_backward_relu_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sigmoid(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(ndarray)" args => + ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle] +sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sigmoid_upd :: + forall args . Fullfilled "sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO () +sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sigmoid(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle] +_backward_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sigmoid_upd :: + forall args . Fullfilled "_backward_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sigmoid(ndarray)" args -> IO () +_backward_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "hard_sigmoid(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +hard_sigmoid :: + forall args . Fullfilled "hard_sigmoid(ndarray)" args => + ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle] +hard_sigmoid args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +hard_sigmoid_upd :: + forall args . Fullfilled "hard_sigmoid(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO () +hard_sigmoid_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[] + +_backward_hard_sigmoid :: + forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args => + ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> + IO [NDArrayHandle] +_backward_hard_sigmoid args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hard_sigmoid_upd :: + forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO () +_backward_hard_sigmoid_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softsign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +softsign :: + forall args . Fullfilled "softsign(ndarray)" args => + ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle] +softsign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softsign_upd :: + forall args . Fullfilled "softsign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO () +softsign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softsign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_softsign :: + forall args . Fullfilled "_backward_softsign(ndarray)" args => + ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle] +_backward_softsign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softsign_upd :: + forall args . Fullfilled "_backward_softsign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softsign(ndarray)" args -> IO () +_backward_softsign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copy :: + forall args . Fullfilled "_copy(ndarray)" args => + ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle] +_copy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copy_upd :: + forall args . Fullfilled "_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO () +_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_copy(ndarray)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle] +_backward_copy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_copy_upd :: + forall args . Fullfilled "_backward_copy(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO () +_backward_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reshape(ndarray)" = '[] + +_backward_reshape :: + forall args . Fullfilled "_backward_reshape(ndarray)" args => + ArgsHMap "_backward_reshape(ndarray)" args -> IO [NDArrayHandle] +_backward_reshape args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reshape_upd :: + forall args . Fullfilled "_backward_reshape(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reshape(ndarray)" args -> IO () +_backward_reshape_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BlockGrad(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle] +_BlockGrad args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BlockGrad_upd :: + forall args . Fullfilled "_BlockGrad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO () +_BlockGrad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "make_loss(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(ndarray)" args => + ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle] +make_loss args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +make_loss_upd :: + forall args . Fullfilled "make_loss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO () +make_loss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_identity_with_attr_like_rhs(ndarray)" + = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> + IO [NDArrayHandle] +_identity_with_attr_like_rhs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_identity_with_attr_like_rhs_upd :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO () +_identity_with_attr_like_rhs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reshape_like(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(ndarray)" args => + ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle] +reshape_like args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reshape_like_upd :: + forall args . Fullfilled "reshape_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO () +reshape_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "shape_array(ndarray)" = + '[ '("lhs_begin", AttrOpt (Maybe Int)), + '("lhs_end", AttrOpt (Maybe Int)), + '("rhs_begin", AttrOpt (Maybe Int)), + '("rhs_end", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +shape_array :: + forall args . Fullfilled "shape_array(ndarray)" args => + ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle] +shape_array args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +shape_array_upd :: + forall args . Fullfilled "shape_array(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO () +shape_array_upd outputs args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "size_array(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +size_array :: + forall args . Fullfilled "size_array(ndarray)" args => + ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle] +size_array args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +size_array_upd :: + forall args . Fullfilled "size_array(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO () +size_array_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Cast(ndarray)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(ndarray)" args => + ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle] +_Cast args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Cast_upd :: + forall args . Fullfilled "_Cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO () +_Cast_upd outputs args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cast(ndarray)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle] +_backward_cast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cast_upd :: + forall args . Fullfilled "_backward_cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO () +_backward_cast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "negative(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +negative :: + forall args . Fullfilled "negative(ndarray)" args => + ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle] +negative args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +negative_upd :: + forall args . Fullfilled "negative(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO () +negative_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reciprocal(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(ndarray)" args => + ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle] +reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reciprocal_upd :: + forall args . Fullfilled "reciprocal(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO () +reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reciprocal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle] +_backward_reciprocal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reciprocal_upd :: + forall args . Fullfilled "_backward_reciprocal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reciprocal(ndarray)" args -> IO () +_backward_reciprocal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "abs(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +abs :: + forall args . Fullfilled "abs(ndarray)" args => + ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle] +abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +abs_upd :: + forall args . Fullfilled "abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO () +abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_abs(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle] +_backward_abs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_abs_upd :: + forall args . Fullfilled "_backward_abs(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO () +_backward_abs_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sign(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sign :: + forall args . Fullfilled "sign(ndarray)" args => + ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle] +sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sign_upd :: + forall args . Fullfilled "sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO () +sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sign(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle] +_backward_sign args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sign_upd :: + forall args . Fullfilled "_backward_sign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO () +_backward_sign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "round(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +round :: + forall args . Fullfilled "round(ndarray)" args => + ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle] +round args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +round_upd :: + forall args . Fullfilled "round(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO () +round_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rint(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rint :: + forall args . Fullfilled "rint(ndarray)" args => + ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle] +rint args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rint_upd :: + forall args . Fullfilled "rint(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO () +rint_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ceil(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +ceil :: + forall args . Fullfilled "ceil(ndarray)" args => + ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle] +ceil args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ceil_upd :: + forall args . Fullfilled "ceil(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO () +ceil_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "floor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +floor :: + forall args . Fullfilled "floor(ndarray)" args => + ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle] +floor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +floor_upd :: + forall args . Fullfilled "floor(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO () +floor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "trunc(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +trunc :: + forall args . Fullfilled "trunc(ndarray)" args => + ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle] +trunc args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +trunc_upd :: + forall args . Fullfilled "trunc(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO () +trunc_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fix(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +fix :: + forall args . Fullfilled "fix(ndarray)" args => + ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle] +fix args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fix_upd :: + forall args . Fullfilled "fix(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO () +fix_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "square(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +square :: + forall args . Fullfilled "square(ndarray)" args => + ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle] +square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +square_upd :: + forall args . Fullfilled "square(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO () +square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_square(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(ndarray)" args => + ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle] +_backward_square args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_square_upd :: + forall args . Fullfilled "_backward_square(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_square(ndarray)" args -> IO () +_backward_square_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(ndarray)" args => + ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle] +sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sqrt_upd :: + forall args . Fullfilled "sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO () +sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_sqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sqrt_upd :: + forall args . Fullfilled "_backward_sqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO () +_backward_sqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rsqrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(ndarray)" args => + ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle] +rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rsqrt_upd :: + forall args . Fullfilled "rsqrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO () +rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rsqrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rsqrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rsqrt_upd :: + forall args . Fullfilled "_backward_rsqrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rsqrt(ndarray)" args -> IO () +_backward_rsqrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(ndarray)" args => + ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle] +cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cbrt_upd :: + forall args . Fullfilled "cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO () +cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_cbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cbrt_upd :: + forall args . Fullfilled "_backward_cbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO () +_backward_cbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "erf(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +erf :: + forall args . Fullfilled "erf(ndarray)" args => + ArgsHMap "erf(ndarray)" args -> IO [NDArrayHandle] +erf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +erf_upd :: + forall args . Fullfilled "erf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "erf(ndarray)" args -> IO () +erf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_erf(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_erf :: + forall args . Fullfilled "_backward_erf(ndarray)" args => + ArgsHMap "_backward_erf(ndarray)" args -> IO [NDArrayHandle] +_backward_erf args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_erf_upd :: + forall args . Fullfilled "_backward_erf(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_erf(ndarray)" args -> IO () +_backward_erf_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erf" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "erfinv(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +erfinv :: + forall args . Fullfilled "erfinv(ndarray)" args => + ArgsHMap "erfinv(ndarray)" args -> IO [NDArrayHandle] +erfinv args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erfinv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +erfinv_upd :: + forall args . Fullfilled "erfinv(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "erfinv(ndarray)" args -> IO () +erfinv_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erfinv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_erfinv(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_erfinv :: + forall args . Fullfilled "_backward_erfinv(ndarray)" args => + ArgsHMap "_backward_erfinv(ndarray)" args -> IO [NDArrayHandle] +_backward_erfinv args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erfinv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_erfinv_upd :: + forall args . Fullfilled "_backward_erfinv(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_erfinv(ndarray)" args -> IO () +_backward_erfinv_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erfinv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rcbrt(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(ndarray)" args => + ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle] +rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rcbrt_upd :: + forall args . Fullfilled "rcbrt(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO () +rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rcbrt(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle] +_backward_rcbrt args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rcbrt_upd :: + forall args . Fullfilled "_backward_rcbrt(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rcbrt(ndarray)" args -> IO () +_backward_rcbrt_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "exp(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +exp :: + forall args . Fullfilled "exp(ndarray)" args => + ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle] +exp args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +exp_upd :: + forall args . Fullfilled "exp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO () +exp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log :: + forall args . Fullfilled "log(ndarray)" args => + ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle] +log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_upd :: + forall args . Fullfilled "log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO () +log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log10(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log10 :: + forall args . Fullfilled "log10(ndarray)" args => + ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle] +log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log10_upd :: + forall args . Fullfilled "log10(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO () +log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log2(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log2 :: + forall args . Fullfilled "log2(ndarray)" args => + ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle] +log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log2_upd :: + forall args . Fullfilled "log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO () +log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(ndarray)" args => + ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle] +_backward_log args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_upd :: + forall args . Fullfilled "_backward_log(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO () +_backward_log_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log10(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle] +_backward_log10 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log10_upd :: + forall args . Fullfilled "_backward_log10(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log10(ndarray)" args -> IO () +_backward_log10_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log2(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle] +_backward_log2 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log2_upd :: + forall args . Fullfilled "_backward_log2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO () +_backward_log2_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log1p(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +log1p :: + forall args . Fullfilled "log1p(ndarray)" args => + ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle] +log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log1p_upd :: + forall args . Fullfilled "log1p(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO () +log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log1p(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle] +_backward_log1p args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log1p_upd :: + forall args . Fullfilled "_backward_log1p(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log1p(ndarray)" args -> IO () +_backward_log1p_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expm1(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +expm1 :: + forall args . Fullfilled "expm1(ndarray)" args => + ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle] +expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expm1_upd :: + forall args . Fullfilled "expm1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO () +expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_expm1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle] +_backward_expm1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_expm1_upd :: + forall args . Fullfilled "_backward_expm1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_expm1(ndarray)" args -> IO () +_backward_expm1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gamma(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gamma :: + forall args . Fullfilled "gamma(ndarray)" args => + ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle] +gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gamma_upd :: + forall args . Fullfilled "gamma(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO () +gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gamma(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle] +_backward_gamma args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gamma_upd :: + forall args . Fullfilled "_backward_gamma(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gamma(ndarray)" args -> IO () +_backward_gamma_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gammaln(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(ndarray)" args => + ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle] +gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gammaln_upd :: + forall args . Fullfilled "gammaln(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO () +gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gammaln(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle] +_backward_gammaln args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gammaln_upd :: + forall args . Fullfilled "_backward_gammaln(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gammaln(ndarray)" args -> IO () +_backward_gammaln_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "logical_not(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +logical_not :: + forall args . Fullfilled "logical_not(ndarray)" args => + ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle] +logical_not args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +logical_not_upd :: + forall args . Fullfilled "logical_not(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO () +logical_not_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "amp_cast(ndarray)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +amp_cast :: + forall args . Fullfilled "amp_cast(ndarray)" args => + ArgsHMap "amp_cast(ndarray)" args -> IO [NDArrayHandle] +amp_cast args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "amp_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +amp_cast_upd :: + forall args . Fullfilled "amp_cast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "amp_cast(ndarray)" args -> IO () +amp_cast_upd outputs args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "amp_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_amp_cast(ndarray)" = '[] + +_backward_amp_cast :: + forall args . Fullfilled "_backward_amp_cast(ndarray)" args => + ArgsHMap "_backward_amp_cast(ndarray)" args -> IO [NDArrayHandle] +_backward_amp_cast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_amp_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_amp_cast_upd :: + forall args . Fullfilled "_backward_amp_cast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_amp_cast(ndarray)" args -> IO () +_backward_amp_cast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_amp_cast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "amp_multicast(ndarray)" = + '[ '("num_outputs", AttrReq Int), + '("data", AttrOpt [NDArrayHandle])] + +amp_multicast :: + forall args . Fullfilled "amp_multicast(ndarray)" args => + ArgsHMap "amp_multicast(ndarray)" args -> IO [NDArrayHandle] +amp_multicast args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "amp_multicast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +amp_multicast_upd :: + forall args . Fullfilled "amp_multicast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "amp_multicast(ndarray)" args -> IO () +amp_multicast_upd outputs args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "amp_multicast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_amp_multicast(ndarray)" = + '[ '("num_outputs", AttrReq Int), + '("grad", AttrOpt [NDArrayHandle])] + +_backward_amp_multicast :: + forall args . Fullfilled "_backward_amp_multicast(ndarray)" args => + ArgsHMap "_backward_amp_multicast(ndarray)" args -> + IO [NDArrayHandle] +_backward_amp_multicast args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #grad :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_amp_multicast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_amp_multicast_upd :: + forall args . Fullfilled "_backward_amp_multicast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_amp_multicast(ndarray)" args -> IO () +_backward_amp_multicast_upd outputs args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #grad :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_amp_multicast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle] +elemwise_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_add_upd :: + forall args . Fullfilled "elemwise_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO () +elemwise_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_grad_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(ndarray)" args => + ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle] +_grad_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_grad_add_upd :: + forall args . Fullfilled "_grad_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO () +_grad_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_add(ndarray)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(ndarray)" args => + ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle] +_backward_add args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_add_upd :: + forall args . Fullfilled "_backward_add(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO () +_backward_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_sub(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle] +elemwise_sub args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_sub_upd :: + forall args . Fullfilled "elemwise_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO () +elemwise_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sub(ndarray)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle] +_backward_sub args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sub_upd :: + forall args . Fullfilled "_backward_sub(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO () +_backward_sub_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_mul(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle] +elemwise_mul args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_mul_upd :: + forall args . Fullfilled "elemwise_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO () +elemwise_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul(ndarray)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle] +_backward_mul args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_upd :: + forall args . Fullfilled "_backward_mul(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO () +_backward_mul_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle] +elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +elemwise_div_upd :: + forall args . Fullfilled "elemwise_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO () +elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div(ndarray)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(ndarray)" args => + ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle] +_backward_div args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_upd :: + forall args . Fullfilled "_backward_div(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO () +_backward_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_mod :: + forall args . Fullfilled "_mod(ndarray)" args => + ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle] +_mod args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_upd :: + forall args . Fullfilled "_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO () +_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod(ndarray)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle] +_backward_mod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_upd :: + forall args . Fullfilled "_backward_mod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO () +_backward_mod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_elemwise_div(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> + IO [NDArrayHandle] +_scatter_elemwise_div args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_elemwise_div_upd :: + forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO () +_scatter_elemwise_div_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_scatter_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_plus_scalar_upd :: + forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO () +_scatter_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> + IO [NDArrayHandle] +_scatter_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_minus_scalar_upd :: + forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO () +_scatter_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Embedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(ndarray)" args => + ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle] +_Embedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Embedding_upd :: + forall args . Fullfilled "_Embedding(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO () +_Embedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SparseEmbedding(ndarray)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle)] + +_contrib_SparseEmbedding :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SparseEmbedding args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SparseEmbedding_upd :: + forall args . + Fullfilled "_contrib_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO () +_contrib_SparseEmbedding_upd outputs args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Embedding(ndarray)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle] +_backward_Embedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Embedding_upd :: + forall args . Fullfilled "_backward_Embedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Embedding(ndarray)" args -> IO () +_backward_Embedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SparseEmbedding(ndarray)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> + IO [NDArrayHandle] +_backward_SparseEmbedding args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SparseEmbedding_upd :: + forall args . + Fullfilled "_backward_SparseEmbedding(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO () +_backward_SparseEmbedding_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "take(ndarray)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)] + +take :: + forall args . Fullfilled "take(ndarray)" args => + ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle] +take args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +take_upd :: + forall args . Fullfilled "take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO () +take_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_take(ndarray)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(ndarray)" args => + ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle] +_backward_take args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_take_upd :: + forall args . Fullfilled "_backward_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO () +_backward_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_take(ndarray)" = + '[ '("a", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(ndarray)" args => + ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle] +batch_take args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_take_upd :: + forall args . Fullfilled "batch_take(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO () +batch_take_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "one_hot(ndarray)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("indices", AttrOpt NDArrayHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(ndarray)" args => + ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle] +one_hot args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +one_hot_upd :: + forall args . Fullfilled "one_hot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO () +one_hot_upd outputs args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "gather_nd(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle] +gather_nd args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +gather_nd_upd :: + forall args . Fullfilled "gather_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO () +gather_nd_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "scatter_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle] +scatter_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +scatter_nd_upd :: + forall args . Fullfilled "scatter_nd(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO () +scatter_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_gather_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_backward_gather_nd :: + forall args . Fullfilled "_backward_gather_nd(ndarray)" args => + ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle] +_backward_gather_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_gather_nd_upd :: + forall args . Fullfilled "_backward_gather_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_gather_nd(ndarray)" args -> IO () +_backward_gather_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_scatter_set_nd(ndarray)" = + '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle] +_scatter_set_nd args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_scatter_set_nd_upd :: + forall args . Fullfilled "_scatter_set_nd(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_scatter_set_nd(ndarray)" args -> IO () +_scatter_set_nd_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_equal_upd :: + forall args . Fullfilled "broadcast_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_equal(ndarray)" args -> IO () +broadcast_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_not_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle] +broadcast_not_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_not_equal_upd :: + forall args . Fullfilled "broadcast_not_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_not_equal(ndarray)" args -> IO () +broadcast_not_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle] +broadcast_greater args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_upd :: + forall args . Fullfilled "broadcast_greater(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater(ndarray)" args -> IO () +broadcast_greater_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_greater_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + ArgsHMap "broadcast_greater_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_greater_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_greater_equal_upd :: + forall args . Fullfilled "broadcast_greater_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO () +broadcast_greater_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle] +broadcast_lesser args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_upd :: + forall args . Fullfilled "broadcast_lesser(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser(ndarray)" args -> IO () +broadcast_lesser_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_lesser_equal(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> + IO [NDArrayHandle] +broadcast_lesser_equal args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_lesser_equal_upd :: + forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO () +broadcast_lesser_equal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_and(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_and :: + forall args . Fullfilled "broadcast_logical_and(ndarray)" args => + ArgsHMap "broadcast_logical_and(ndarray)" args -> + IO [NDArrayHandle] +broadcast_logical_and args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_and_upd :: + forall args . Fullfilled "broadcast_logical_and(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_and(ndarray)" args -> IO () +broadcast_logical_and_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_or(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_or :: + forall args . Fullfilled "broadcast_logical_or(ndarray)" args => + ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle] +broadcast_logical_or args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_or_upd :: + forall args . Fullfilled "broadcast_logical_or(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_or(ndarray)" args -> IO () +broadcast_logical_or_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_logical_xor(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +broadcast_logical_xor :: + forall args . Fullfilled "broadcast_logical_xor(ndarray)" args => + ArgsHMap "broadcast_logical_xor(ndarray)" args -> + IO [NDArrayHandle] +broadcast_logical_xor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_logical_xor_upd :: + forall args . Fullfilled "broadcast_logical_xor(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO () +broadcast_logical_xor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_plus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle] +_plus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_plus_scalar_upd :: + forall args . Fullfilled "_plus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO () +_plus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle] +_minus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minus_scalar_upd :: + forall args . Fullfilled "_minus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO () +_minus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rminus_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle] +_rminus_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rminus_scalar_upd :: + forall args . Fullfilled "_rminus_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO () +_rminus_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mul_scalar_upd :: + forall args . Fullfilled "_mul_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO () +_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mul_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mul_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mul_scalar_upd :: + forall args . Fullfilled "_backward_mul_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO () +_backward_mul_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_div_scalar_upd :: + forall args . Fullfilled "_div_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO () +_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_div_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_div_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_div_scalar_upd :: + forall args . Fullfilled "_backward_div_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_div_scalar(ndarray)" args -> IO () +_backward_div_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle] +_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rdiv_scalar_upd :: + forall args . Fullfilled "_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO () +_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rdiv_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rdiv_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rdiv_scalar_upd :: + forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO () +_backward_rdiv_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mod_scalar_upd :: + forall args . Fullfilled "_mod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO () +_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle] +_backward_mod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mod_scalar_upd :: + forall args . Fullfilled "_backward_mod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO () +_backward_mod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle] +_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rmod_scalar_upd :: + forall args . Fullfilled "_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO () +_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rmod_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rmod_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rmod_scalar_upd :: + forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO () +_backward_rmod_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ravel_multi_index(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_ravel_multi_index :: + forall args . Fullfilled "_ravel_multi_index(ndarray)" args => + ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle] +_ravel_multi_index args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ravel_multi_index_upd :: + forall args . Fullfilled "_ravel_multi_index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_ravel_multi_index(ndarray)" args -> IO () +_ravel_multi_index_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_unravel_index(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_unravel_index :: + forall args . Fullfilled "_unravel_index(ndarray)" args => + ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle] +_unravel_index args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_unravel_index_upd :: + forall args . Fullfilled "_unravel_index(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO () +_unravel_index_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +sum :: + forall args . Fullfilled "sum(ndarray)" args => + ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle] +sum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sum_upd :: + forall args . Fullfilled "sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO () +sum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sum(ndarray)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle] +_backward_sum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sum_upd :: + forall args . Fullfilled "_backward_sum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO () +_backward_sum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mean(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +mean :: + forall args . Fullfilled "mean(ndarray)" args => + ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle] +mean args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mean_upd :: + forall args . Fullfilled "mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO () +mean_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mean(ndarray)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle] +_backward_mean args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mean_upd :: + forall args . Fullfilled "_backward_mean(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO () +_backward_mean_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "prod(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +prod :: + forall args . Fullfilled "prod(ndarray)" args => + ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle] +prod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +prod_upd :: + forall args . Fullfilled "prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO () +prod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_prod(ndarray)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle] +_backward_prod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_prod_upd :: + forall args . Fullfilled "_backward_prod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO () +_backward_prod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nansum(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nansum :: + forall args . Fullfilled "nansum(ndarray)" args => + ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle] +nansum args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nansum_upd :: + forall args . Fullfilled "nansum(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO () +nansum_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nansum(ndarray)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle] +_backward_nansum args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nansum_upd :: + forall args . Fullfilled "_backward_nansum(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nansum(ndarray)" args -> IO () +_backward_nansum_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nanprod(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(ndarray)" args => + ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle] +nanprod args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nanprod_upd :: + forall args . Fullfilled "nanprod(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO () +nanprod_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_nanprod(ndarray)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle] +_backward_nanprod args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_nanprod_upd :: + forall args . Fullfilled "_backward_nanprod(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_nanprod(ndarray)" args -> IO () +_backward_nanprod_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "max(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +max :: + forall args . Fullfilled "max(ndarray)" args => + ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle] +max args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +max_upd :: + forall args . Fullfilled "max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO () +max_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_max(ndarray)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(ndarray)" args => + ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle] +_backward_max args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_max_upd :: + forall args . Fullfilled "_backward_max(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO () +_backward_max_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "min(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +min :: + forall args . Fullfilled "min(ndarray)" args => + ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle] +min args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +min_upd :: + forall args . Fullfilled "min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO () +min_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_min(ndarray)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(ndarray)" args => + ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle] +_backward_min args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_min_upd :: + forall args . Fullfilled "_backward_min(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO () +_backward_min_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_axis(ndarray)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle] +broadcast_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_axis_upd :: + forall args . Fullfilled "broadcast_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO () +broadcast_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_to(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle] +broadcast_to args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_to_upd :: + forall args . Fullfilled "broadcast_to(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO () +broadcast_to_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_broadcast_backward(ndarray)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle] +_broadcast_backward args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_broadcast_backward_upd :: + forall args . Fullfilled "_broadcast_backward(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_broadcast_backward(ndarray)" args -> IO () +_broadcast_backward_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "broadcast_like(ndarray)" = + '[ '("lhs_axes", AttrOpt (Maybe [Int])), + '("rhs_axes", AttrOpt (Maybe [Int])), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +broadcast_like :: + forall args . Fullfilled "broadcast_like(ndarray)" args => + ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle] +broadcast_like args + = let scalarArgs + = catMaybes + [("lhs_axes",) . showValue <$> + (args !? #lhs_axes :: Maybe (Maybe [Int])), + ("rhs_axes",) . showValue <$> + (args !? #rhs_axes :: Maybe (Maybe [Int]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +broadcast_like_upd :: + forall args . Fullfilled "broadcast_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO () +broadcast_like_upd outputs args + = let scalarArgs + = catMaybes + [("lhs_axes",) . showValue <$> + (args !? #lhs_axes :: Maybe (Maybe [Int])), + ("rhs_axes",) . showValue <$> + (args !? #rhs_axes :: Maybe (Maybe [Int]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "norm(ndarray)" = + '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])), + '("out_dtype", + AttrOpt + (Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8"]))), + '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +norm :: + forall args . Fullfilled "norm(ndarray)" args => + ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle] +norm args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("out_dtype",) . showValue <$> + (args !? #out_dtype :: + Maybe + (Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8"]))), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +norm_upd :: + forall args . Fullfilled "norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO () +norm_upd outputs args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("out_dtype",) . showValue <$> + (args !? #out_dtype :: + Maybe + (Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8"]))), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_norm(ndarray)" = '[] + +_backward_norm :: + forall args . Fullfilled "_backward_norm(ndarray)" args => + ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle] +_backward_norm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_norm_upd :: + forall args . Fullfilled "_backward_norm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO () +_backward_norm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmax :: + forall args . Fullfilled "argmax(ndarray)" args => + ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle] +argmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_upd :: + forall args . Fullfilled "argmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO () +argmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmin(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +argmin :: + forall args . Fullfilled "argmin(ndarray)" args => + ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle] +argmin args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmin_upd :: + forall args . Fullfilled "argmin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO () +argmin_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argmax_channel(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle] +argmax_channel args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argmax_channel_upd :: + forall args . Fullfilled "argmax_channel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO () +argmax_channel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "pick(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("mode", AttrOpt (EnumType '["clip", "wrap"])), + '("data", AttrOpt NDArrayHandle), + '("index", AttrOpt NDArrayHandle)] + +pick :: + forall args . Fullfilled "pick(ndarray)" args => + ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle] +pick args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +pick_upd :: + forall args . Fullfilled "pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO () +pick_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_pick(ndarray)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle] +_backward_pick args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_pick_upd :: + forall args . Fullfilled "_backward_pick(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO () +_backward_pick_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_retain(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("indices", AttrOpt NDArrayHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle] +_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_retain_upd :: + forall args . Fullfilled "_sparse_retain(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO () +_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sparse_retain(ndarray)" = + '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + ArgsHMap "_backward_sparse_retain(ndarray)" args -> + IO [NDArrayHandle] +_backward_sparse_retain args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sparse_retain_upd :: + forall args . Fullfilled "_backward_sparse_retain(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO () +_backward_sparse_retain_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_where(ndarray)" = + '[ '("condition", AttrOpt NDArrayHandle), + '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)] + +_where :: + forall args . Fullfilled "_where(ndarray)" args => + ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle] +_where args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_where_upd :: + forall args . Fullfilled "_where(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO () +_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle), + ("x",) <$> (args !? #x :: Maybe NDArrayHandle), + ("y",) <$> (args !? #y :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_where(ndarray)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(ndarray)" args => + ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle] +_backward_where args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_where_upd :: + forall args . Fullfilled "_backward_where(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_where(ndarray)" args -> IO () +_backward_where_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "diag(ndarray)" = + '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int), + '("axis2", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +diag :: + forall args . Fullfilled "diag(ndarray)" args => + ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle] +diag args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int), + ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +diag_upd :: + forall args . Fullfilled "diag(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO () +diag_upd outputs args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int), + ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_diag(ndarray)" = '[] + +_backward_diag :: + forall args . Fullfilled "_backward_diag(ndarray)" args => + ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle] +_backward_diag args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_diag_upd :: + forall args . Fullfilled "_backward_diag(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO () +_backward_diag_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle] +_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_maximum_scalar_upd :: + forall args . Fullfilled "_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_maximum_scalar(ndarray)" args -> IO () +_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_maximum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_maximum_scalar :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_maximum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_maximum_scalar_upd :: + forall args . + Fullfilled "_backward_maximum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO () +_backward_maximum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle] +_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_minimum_scalar_upd :: + forall args . Fullfilled "_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_minimum_scalar(ndarray)" args -> IO () +_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_minimum_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_minimum_scalar :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_minimum_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_minimum_scalar_upd :: + forall args . + Fullfilled "_backward_minimum_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO () +_backward_minimum_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle] +_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_power_scalar_upd :: + forall args . Fullfilled "_power_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO () +_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_power_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + ArgsHMap "_backward_power_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_power_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_power_scalar_upd :: + forall args . Fullfilled "_backward_power_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_power_scalar(ndarray)" args -> IO () +_backward_power_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle] +_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_rpower_scalar_upd :: + forall args . Fullfilled "_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO () +_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_rpower_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_rpower_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_rpower_scalar_upd :: + forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO () +_backward_rpower_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle] +_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_hypot_scalar_upd :: + forall args . Fullfilled "_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO () +_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_hypot_scalar(ndarray)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> + IO [NDArrayHandle] +_backward_hypot_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_hypot_scalar_upd :: + forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO () +_backward_hypot_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "smooth_l1(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle] +smooth_l1 args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +smooth_l1_upd :: + forall args . Fullfilled "smooth_l1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO () +smooth_l1_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_smooth_l1(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle] +_backward_smooth_l1 args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_smooth_l1_upd :: + forall args . Fullfilled "_backward_smooth_l1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO () +_backward_smooth_l1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "topk(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +topk :: + forall args . Fullfilled "topk(ndarray)" args => + ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle] +topk args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +topk_upd :: + forall args . Fullfilled "topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO () +topk_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_topk(ndarray)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle] +_backward_topk args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_topk_upd :: + forall args . Fullfilled "_backward_topk(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO () +_backward_topk_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +sort :: + forall args . Fullfilled "sort(ndarray)" args => + ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle] +sort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sort_upd :: + forall args . Fullfilled "sort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO () +sort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "argsort(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt NDArrayHandle)] + +argsort :: + forall args . Fullfilled "argsort(ndarray)" args => + ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle] +argsort args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +argsort_upd :: + forall args . Fullfilled "argsort(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO () +argsort_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Reshape(ndarray)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(ndarray)" args => + ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle] +_Reshape args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Reshape_upd :: + forall args . Fullfilled "_Reshape(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO () +_Reshape_upd outputs args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(ndarray)" args => + ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle] +_Flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Flatten_upd :: + forall args . Fullfilled "_Flatten(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO () +_Flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "transpose(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +transpose :: + forall args . Fullfilled "transpose(ndarray)" args => + ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle] +transpose args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +transpose_upd :: + forall args . Fullfilled "transpose(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO () +transpose_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "expand_dims(ndarray)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(ndarray)" args => + ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle] +expand_dims args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +expand_dims_upd :: + forall args . Fullfilled "expand_dims(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO () +expand_dims_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +slice :: + forall args . Fullfilled "slice(ndarray)" args => + ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle] +slice args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_upd :: + forall args . Fullfilled "slice(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO () +slice_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice(ndarray)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle] +_backward_slice args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_upd :: + forall args . Fullfilled "_backward_slice(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice(ndarray)" args -> IO () +_backward_slice_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign(ndarray)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle] +_slice_assign args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_upd :: + forall args . Fullfilled "_slice_assign(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO () +_slice_assign_upd outputs args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_slice_assign_scalar(ndarray)" = + '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle] +_slice_assign_scalar args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_slice_assign_scalar_upd :: + forall args . Fullfilled "_slice_assign_scalar(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO () +_slice_assign_scalar_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_axis(ndarray)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(ndarray)" args => + ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle] +slice_axis args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_axis_upd :: + forall args . Fullfilled "slice_axis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO () +slice_axis_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_axis(ndarray)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_axis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_axis_upd :: + forall args . Fullfilled "_backward_slice_axis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_axis(ndarray)" args -> IO () +_backward_slice_axis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "slice_like(ndarray)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle), + '("shape_like", AttrOpt NDArrayHandle)] + +slice_like :: + forall args . Fullfilled "slice_like(ndarray)" args => + ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle] +slice_like args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +slice_like_upd :: + forall args . Fullfilled "slice_like(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO () +slice_like_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_slice_like(ndarray)" = '[] + +_backward_slice_like :: + forall args . Fullfilled "_backward_slice_like(ndarray)" args => + ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle] +_backward_slice_like args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_slice_like_upd :: + forall args . Fullfilled "_backward_slice_like(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_slice_like(ndarray)" args -> IO () +_backward_slice_like_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "clip(ndarray)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +clip :: + forall args . Fullfilled "clip(ndarray)" args => + ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle] +clip args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +clip_upd :: + forall args . Fullfilled "clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO () +clip_upd outputs args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_clip(ndarray)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle] +_backward_clip args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_clip_upd :: + forall args . Fullfilled "_backward_clip(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO () +_backward_clip_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "repeat(ndarray)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +repeat :: + forall args . Fullfilled "repeat(ndarray)" args => + ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle] +repeat args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +repeat_upd :: + forall args . Fullfilled "repeat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO () +repeat_upd outputs args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_repeat(ndarray)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle] +_backward_repeat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_repeat_upd :: + forall args . Fullfilled "_backward_repeat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_repeat(ndarray)" args -> IO () +_backward_repeat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tile(ndarray)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +tile :: + forall args . Fullfilled "tile(ndarray)" args => + ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle] +tile args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tile_upd :: + forall args . Fullfilled "tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO () +tile_upd outputs args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tile(ndarray)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle] +_backward_tile args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tile_upd :: + forall args . Fullfilled "_backward_tile(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO () +_backward_tile_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "reverse(ndarray)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)] + +reverse :: + forall args . Fullfilled "reverse(ndarray)" args => + ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle] +reverse args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +reverse_upd :: + forall args . Fullfilled "reverse(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO () +reverse_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_reverse(ndarray)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle] +_backward_reverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_reverse_upd :: + forall args . Fullfilled "_backward_reverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_reverse(ndarray)" args -> IO () +_backward_reverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "stack(ndarray)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [NDArrayHandle])] + +stack :: + forall args . Fullfilled "stack(ndarray)" args => + ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle] +stack args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +stack_upd :: + forall args . Fullfilled "stack(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO () +stack_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "stack" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_stack(ndarray)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle] +_backward_stack args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_stack_upd :: + forall args . Fullfilled "_backward_stack(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_stack(ndarray)" args -> IO () +_backward_stack_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "squeeze(ndarray)" = + '[ '("axis", AttrOpt (Maybe [Int])), + '("data", AttrOpt [NDArrayHandle])] + +squeeze :: + forall args . Fullfilled "squeeze(ndarray)" args => + ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle] +squeeze args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +squeeze_upd :: + forall args . Fullfilled "squeeze(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO () +squeeze_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_squeeze(ndarray)" = '[] + +_backward_squeeze :: + forall args . Fullfilled "_backward_squeeze(ndarray)" args => + ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle] +_backward_squeeze args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_squeeze_upd :: + forall args . Fullfilled "_backward_squeeze(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_squeeze(ndarray)" args -> IO () +_backward_squeeze_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "depth_to_space(ndarray)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +depth_to_space :: + forall args . Fullfilled "depth_to_space(ndarray)" args => + ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle] +depth_to_space args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +depth_to_space_upd :: + forall args . Fullfilled "depth_to_space(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO () +depth_to_space_upd outputs args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "space_to_depth(ndarray)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)] + +space_to_depth :: + forall args . Fullfilled "space_to_depth(ndarray)" args => + ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle] +space_to_depth args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +space_to_depth_upd :: + forall args . Fullfilled "space_to_depth(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO () +space_to_depth_upd outputs args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_split_v2(ndarray)" = + '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_split_v2 :: + forall args . Fullfilled "_split_v2(ndarray)" args => + ArgsHMap "_split_v2(ndarray)" args -> IO [NDArrayHandle] +_split_v2 args + = let scalarArgs + = catMaybes + [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool), + ("sections",) . showValue <$> (args !? #sections :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_split_v2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_split_v2_upd :: + forall args . Fullfilled "_split_v2(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_split_v2(ndarray)" args -> IO () +_split_v2_upd outputs args + = let scalarArgs + = catMaybes + [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool), + ("sections",) . showValue <$> (args !? #sections :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_split_v2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_split_v2_backward(ndarray)" = '[] + +_split_v2_backward :: + forall args . Fullfilled "_split_v2_backward(ndarray)" args => + ArgsHMap "_split_v2_backward(ndarray)" args -> IO [NDArrayHandle] +_split_v2_backward args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_split_v2_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_split_v2_backward_upd :: + forall args . Fullfilled "_split_v2_backward(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_split_v2_backward(ndarray)" args -> IO () +_split_v2_backward_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_split_v2_backward" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +dot :: + forall args . Fullfilled "dot(ndarray)" args => + ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle] +dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +dot_upd :: + forall args . Fullfilled "dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO () +dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_dot_upd :: + forall args . Fullfilled "_backward_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO () +_backward_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "batch_dot(ndarray)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(ndarray)" args => + ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle] +batch_dot args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +batch_dot_upd :: + forall args . Fullfilled "batch_dot(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO () +batch_dot_upd outputs args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_batch_dot(ndarray)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle] +_backward_batch_dot args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_batch_dot_upd :: + forall args . Fullfilled "_backward_batch_dot(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_batch_dot(ndarray)" args -> IO () +_backward_batch_dot_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sin :: + forall args . Fullfilled "sin(ndarray)" args => + ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle] +sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sin_upd :: + forall args . Fullfilled "sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO () +sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle] +_backward_sin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sin_upd :: + forall args . Fullfilled "_backward_sin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO () +_backward_sin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cos :: + forall args . Fullfilled "cos(ndarray)" args => + ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle] +cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cos_upd :: + forall args . Fullfilled "cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO () +cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle] +_backward_cos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cos_upd :: + forall args . Fullfilled "_backward_cos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO () +_backward_cos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tan :: + forall args . Fullfilled "tan(ndarray)" args => + ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle] +tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tan_upd :: + forall args . Fullfilled "tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO () +tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle] +_backward_tan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tan_upd :: + forall args . Fullfilled "_backward_tan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO () +_backward_tan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsin(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(ndarray)" args => + ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle] +arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsin_upd :: + forall args . Fullfilled "arcsin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO () +arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsin(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsin args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsin_upd :: + forall args . Fullfilled "_backward_arcsin(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsin(ndarray)" args -> IO () +_backward_arcsin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccos(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccos :: + forall args . Fullfilled "arccos(ndarray)" args => + ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle] +arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccos_upd :: + forall args . Fullfilled "arccos(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO () +arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccos(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle] +_backward_arccos args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccos_upd :: + forall args . Fullfilled "_backward_arccos(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccos(ndarray)" args -> IO () +_backward_arccos_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctan(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctan :: + forall args . Fullfilled "arctan(ndarray)" args => + ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle] +arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctan_upd :: + forall args . Fullfilled "arctan(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO () +arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctan(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle] +_backward_arctan args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctan_upd :: + forall args . Fullfilled "_backward_arctan(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctan(ndarray)" args -> IO () +_backward_arctan_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "degrees(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +degrees :: + forall args . Fullfilled "degrees(ndarray)" args => + ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle] +degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +degrees_upd :: + forall args . Fullfilled "degrees(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO () +degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_degrees(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle] +_backward_degrees args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_degrees_upd :: + forall args . Fullfilled "_backward_degrees(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_degrees(ndarray)" args -> IO () +_backward_degrees_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "radians(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +radians :: + forall args . Fullfilled "radians(ndarray)" args => + ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle] +radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +radians_upd :: + forall args . Fullfilled "radians(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO () +radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_radians(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle] +_backward_radians args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_radians_upd :: + forall args . Fullfilled "_backward_radians(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_radians(ndarray)" args -> IO () +_backward_radians_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +sinh :: + forall args . Fullfilled "sinh(ndarray)" args => + ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle] +sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sinh_upd :: + forall args . Fullfilled "sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO () +sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_sinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle] +_backward_sinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_sinh_upd :: + forall args . Fullfilled "_backward_sinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO () +_backward_sinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "cosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +cosh :: + forall args . Fullfilled "cosh(ndarray)" args => + ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle] +cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +cosh_upd :: + forall args . Fullfilled "cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO () +cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle] +_backward_cosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cosh_upd :: + forall args . Fullfilled "_backward_cosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO () +_backward_cosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "tanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +tanh :: + forall args . Fullfilled "tanh(ndarray)" args => + ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle] +tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +tanh_upd :: + forall args . Fullfilled "tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO () +tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_tanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle] +_backward_tanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_tanh_upd :: + forall args . Fullfilled "_backward_tanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO () +_backward_tanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arcsinh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(ndarray)" args => + ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle] +arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arcsinh_upd :: + forall args . Fullfilled "arcsinh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO () +arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arcsinh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle] +_backward_arcsinh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arcsinh_upd :: + forall args . Fullfilled "_backward_arcsinh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arcsinh(ndarray)" args -> IO () +_backward_arcsinh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arccosh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(ndarray)" args => + ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle] +arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arccosh_upd :: + forall args . Fullfilled "arccosh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO () +arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arccosh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle] +_backward_arccosh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arccosh_upd :: + forall args . Fullfilled "_backward_arccosh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arccosh(ndarray)" args -> IO () +_backward_arccosh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "arctanh(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(ndarray)" args => + ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle] +arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +arctanh_upd :: + forall args . Fullfilled "arctanh(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO () +arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_arctanh(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle] +_backward_arctanh args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_arctanh_upd :: + forall args . Fullfilled "_backward_arctanh(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_arctanh(ndarray)" args -> IO () +_backward_arctanh_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "khatri_rao(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +khatri_rao :: + forall args . Fullfilled "khatri_rao(ndarray)" args => + ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle] +khatri_rao args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +khatri_rao_upd :: + forall args . Fullfilled "khatri_rao(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO () +khatri_rao_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance + ParameterList "_contrib_group_adagrad_update(ndarray)" = + '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("history", AttrOpt NDArrayHandle)] + +_contrib_group_adagrad_update :: + forall args . + Fullfilled "_contrib_group_adagrad_update(ndarray)" args => + ArgsHMap "_contrib_group_adagrad_update(ndarray)" args -> + IO [NDArrayHandle] +_contrib_group_adagrad_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_group_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_group_adagrad_update_upd :: + forall args . + Fullfilled "_contrib_group_adagrad_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_group_adagrad_update(ndarray)" args -> + IO () +_contrib_group_adagrad_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_group_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_getnnz(ndarray)" = + '[ '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt NDArrayHandle)] + +_contrib_getnnz :: + forall args . Fullfilled "_contrib_getnnz(ndarray)" args => + ArgsHMap "_contrib_getnnz(ndarray)" args -> IO [NDArrayHandle] +_contrib_getnnz args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_getnnz" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_getnnz_upd :: + forall args . Fullfilled "_contrib_getnnz(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_getnnz(ndarray)" args -> IO () +_contrib_getnnz_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_getnnz" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_gradientmultiplier(ndarray)" + = '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_contrib_gradientmultiplier :: + forall args . + Fullfilled "_contrib_gradientmultiplier(ndarray)" args => + ArgsHMap "_contrib_gradientmultiplier(ndarray)" args -> + IO [NDArrayHandle] +_contrib_gradientmultiplier args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_gradientmultiplier" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_gradientmultiplier_upd :: + forall args . + Fullfilled "_contrib_gradientmultiplier(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_gradientmultiplier(ndarray)" args -> IO () +_contrib_gradientmultiplier_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_gradientmultiplier" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_backward_gradientmultiplier(ndarray)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_contrib_backward_gradientmultiplier :: + forall args . + Fullfilled "_contrib_backward_gradientmultiplier(ndarray)" + args => + ArgsHMap "_contrib_backward_gradientmultiplier(ndarray)" args + -> IO [NDArrayHandle] +_contrib_backward_gradientmultiplier args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_gradientmultiplier_upd :: + forall args . + Fullfilled + "_contrib_backward_gradientmultiplier(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_contrib_backward_gradientmultiplier(ndarray)" + args + -> IO () +_contrib_backward_gradientmultiplier_upd outputs args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_edge_id(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), '("u", AttrOpt NDArrayHandle), + '("v", AttrOpt NDArrayHandle)] + +_contrib_edge_id :: + forall args . Fullfilled "_contrib_edge_id(ndarray)" args => + ArgsHMap "_contrib_edge_id(ndarray)" args -> IO [NDArrayHandle] +_contrib_edge_id args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("u",) <$> (args !? #u :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_edge_id" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_edge_id_upd :: + forall args . Fullfilled "_contrib_edge_id(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_edge_id(ndarray)" args -> IO () +_contrib_edge_id_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("u",) <$> (args !? #u :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_edge_id" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_dgl_adjacency(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_contrib_dgl_adjacency :: + forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args => + ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> + IO [NDArrayHandle] +_contrib_dgl_adjacency args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dgl_adjacency" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_dgl_adjacency_upd :: + forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> IO () +_contrib_dgl_adjacency_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dgl_adjacency" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_hawkesll(ndarray)" = + '[ '("lda", AttrOpt NDArrayHandle), + '("alpha", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("state", AttrOpt NDArrayHandle), + '("lags", AttrOpt NDArrayHandle), + '("marks", AttrOpt NDArrayHandle), + '("valid_length", AttrOpt NDArrayHandle), + '("max_time", AttrOpt NDArrayHandle)] + +_contrib_hawkesll :: + forall args . Fullfilled "_contrib_hawkesll(ndarray)" args => + ArgsHMap "_contrib_hawkesll(ndarray)" args -> IO [NDArrayHandle] +_contrib_hawkesll args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lda",) <$> (args !? #lda :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("lags",) <$> (args !? #lags :: Maybe NDArrayHandle), + ("marks",) <$> (args !? #marks :: Maybe NDArrayHandle), + ("valid_length",) <$> + (args !? #valid_length :: Maybe NDArrayHandle), + ("max_time",) <$> (args !? #max_time :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_hawkesll" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_hawkesll_upd :: + forall args . Fullfilled "_contrib_hawkesll(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_hawkesll(ndarray)" args -> IO () +_contrib_hawkesll_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lda",) <$> (args !? #lda :: Maybe NDArrayHandle), + ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("lags",) <$> (args !? #lags :: Maybe NDArrayHandle), + ("marks",) <$> (args !? #marks :: Maybe NDArrayHandle), + ("valid_length",) <$> + (args !? #valid_length :: Maybe NDArrayHandle), + ("max_time",) <$> (args !? #max_time :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_hawkesll" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_backward_hawkesll(ndarray)" = + '[] + +_contrib_backward_hawkesll :: + forall args . + Fullfilled "_contrib_backward_hawkesll(ndarray)" args => + ArgsHMap "_contrib_backward_hawkesll(ndarray)" args -> + IO [NDArrayHandle] +_contrib_backward_hawkesll args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_hawkesll" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_hawkesll_upd :: + forall args . + Fullfilled "_contrib_backward_hawkesll(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_backward_hawkesll(ndarray)" args -> IO () +_contrib_backward_hawkesll_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_hawkesll" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_mp_adamw_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("eta", AttrReq Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle), + '("var", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle), + '("rescale_grad", AttrOpt NDArrayHandle)] + +_mp_adamw_update :: + forall args . Fullfilled "_mp_adamw_update(ndarray)" args => + ArgsHMap "_mp_adamw_update(ndarray)" args -> IO [NDArrayHandle] +_mp_adamw_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("eta",) . showValue <$> (args !? #eta :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle), + ("rescale_grad",) <$> + (args !? #rescale_grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mp_adamw_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_mp_adamw_update_upd :: + forall args . Fullfilled "_mp_adamw_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_mp_adamw_update(ndarray)" args -> IO () +_mp_adamw_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("eta",) . showValue <$> (args !? #eta :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle), + ("rescale_grad",) <$> + (args !? #rescale_grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mp_adamw_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_adamw_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("eta", AttrReq Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle), + '("var", AttrOpt NDArrayHandle), + '("rescale_grad", AttrOpt NDArrayHandle)] + +_adamw_update :: + forall args . Fullfilled "_adamw_update(ndarray)" args => + ArgsHMap "_adamw_update(ndarray)" args -> IO [NDArrayHandle] +_adamw_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("eta",) . showValue <$> (args !? #eta :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle), + ("rescale_grad",) <$> + (args !? #rescale_grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_adamw_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_adamw_update_upd :: + forall args . Fullfilled "_adamw_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_adamw_update(ndarray)" args -> IO () +_adamw_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("eta",) . showValue <$> (args !? #eta :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle), + ("rescale_grad",) <$> + (args !? #rescale_grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_adamw_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quadratic(ndarray)" = + '[ '("a", AttrOpt Float), '("b", AttrOpt Float), + '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_contrib_quadratic :: + forall args . Fullfilled "_contrib_quadratic(ndarray)" args => + ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle] +_contrib_quadratic args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quadratic_upd :: + forall args . Fullfilled "_contrib_quadratic(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quadratic(ndarray)" args -> IO () +_contrib_quadratic_upd outputs args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_backward_quadratic(ndarray)" + = '[] + +_contrib_backward_quadratic :: + forall args . + Fullfilled "_contrib_backward_quadratic(ndarray)" args => + ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> + IO [NDArrayHandle] +_contrib_backward_quadratic args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_quadratic_upd :: + forall args . + Fullfilled "_contrib_backward_quadratic(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO () +_contrib_backward_quadratic_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_contrib_div_sqrt_dim :: + forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args => + ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> + IO [NDArrayHandle] +_contrib_div_sqrt_dim args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_div_sqrt_dim_upd :: + forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO () +_contrib_div_sqrt_dim_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "all_finite(ndarray)" = + '[ '("init_output", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +all_finite :: + forall args . Fullfilled "all_finite(ndarray)" args => + ArgsHMap "all_finite(ndarray)" args -> IO [NDArrayHandle] +all_finite args + = let scalarArgs + = catMaybes + [("init_output",) . showValue <$> + (args !? #init_output :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "all_finite" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +all_finite_upd :: + forall args . Fullfilled "all_finite(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "all_finite(ndarray)" args -> IO () +all_finite_upd outputs args + = let scalarArgs + = catMaybes + [("init_output",) . showValue <$> + (args !? #init_output :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "all_finite" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "multi_all_finite(ndarray)" = + '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool), + '("data", AttrOpt [NDArrayHandle])] + +multi_all_finite :: + forall args . Fullfilled "multi_all_finite(ndarray)" args => + ArgsHMap "multi_all_finite(ndarray)" args -> IO [NDArrayHandle] +multi_all_finite args + = let scalarArgs + = catMaybes + [("num_arrays",) . showValue <$> + (args !? #num_arrays :: Maybe Int), + ("init_output",) . showValue <$> + (args !? #init_output :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_all_finite" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +multi_all_finite_upd :: + forall args . Fullfilled "multi_all_finite(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "multi_all_finite(ndarray)" args -> IO () +multi_all_finite_upd outputs args + = let scalarArgs + = catMaybes + [("num_arrays",) . showValue <$> + (args !? #num_arrays :: Maybe Int), + ("init_output",) . showValue <$> + (args !? #init_output :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_all_finite" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_index_array(ndarray)" = + '[ '("axes", AttrOpt (Maybe [Int])), + '("data", AttrOpt NDArrayHandle)] + +_contrib_index_array :: + forall args . Fullfilled "_contrib_index_array(ndarray)" args => + ArgsHMap "_contrib_index_array(ndarray)" args -> IO [NDArrayHandle] +_contrib_index_array args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_index_array_upd :: + forall args . Fullfilled "_contrib_index_array(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_index_array(ndarray)" args -> IO () +_contrib_index_array_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_array" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_index_copy(ndarray)" = + '[ '("old_tensor", AttrOpt NDArrayHandle), + '("index_vector", AttrOpt NDArrayHandle), + '("new_tensor", AttrOpt NDArrayHandle)] + +_contrib_index_copy :: + forall args . Fullfilled "_contrib_index_copy(ndarray)" args => + ArgsHMap "_contrib_index_copy(ndarray)" args -> IO [NDArrayHandle] +_contrib_index_copy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle), + ("index_vector",) <$> + (args !? #index_vector :: Maybe NDArrayHandle), + ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_index_copy_upd :: + forall args . Fullfilled "_contrib_index_copy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_index_copy(ndarray)" args -> IO () +_contrib_index_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle), + ("index_vector",) <$> + (args !? #index_vector :: Maybe NDArrayHandle), + ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_backward_index_copy(ndarray)" + = '[] + +_contrib_backward_index_copy :: + forall args . + Fullfilled "_contrib_backward_index_copy(ndarray)" args => + ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> + IO [NDArrayHandle] +_contrib_backward_index_copy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_backward_index_copy_upd :: + forall args . + Fullfilled "_contrib_backward_index_copy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> IO () +_contrib_backward_index_copy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_index_copy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_ROIAlign(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int), + '("position_sensitive", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_contrib_ROIAlign :: + forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args => + ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle] +_contrib_ROIAlign args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int), + ("position_sensitive",) . showValue <$> + (args !? #position_sensitive :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ROIAlign_upd :: + forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO () +_contrib_ROIAlign_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int), + ("position_sensitive",) . showValue <$> + (args !? #position_sensitive :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIAlign(ndarray)" = '[] + +_backward_ROIAlign :: + forall args . Fullfilled "_backward_ROIAlign(ndarray)" args => + ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIAlign args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIAlign_upd :: + forall args . Fullfilled "_backward_ROIAlign(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO () +_backward_ROIAlign_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_box_nms(ndarray)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("background_id", AttrOpt Int), + '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"])), + '("data", AttrOpt NDArrayHandle)] + +_contrib_box_nms :: + forall args . Fullfilled "_contrib_box_nms(ndarray)" args => + ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle] +_contrib_box_nms args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_box_nms_upd :: + forall args . Fullfilled "_contrib_box_nms(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_box_nms(ndarray)" args -> IO () +_contrib_box_nms_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_contrib_box_nms(ndarray)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("background_id", AttrOpt Int), + '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_nms :: + forall args . + Fullfilled "_backward_contrib_box_nms(ndarray)" args => + ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_box_nms args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_box_nms_upd :: + forall args . + Fullfilled "_backward_contrib_box_nms(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO () +_backward_contrib_box_nms_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_box_iou(ndarray)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"])), + '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +_contrib_box_iou :: + forall args . Fullfilled "_contrib_box_iou(ndarray)" args => + ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle] +_contrib_box_iou args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_box_iou_upd :: + forall args . Fullfilled "_contrib_box_iou(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_box_iou(ndarray)" args -> IO () +_contrib_box_iou_upd outputs args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_contrib_box_iou(ndarray)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_iou :: + forall args . + Fullfilled "_backward_contrib_box_iou(ndarray)" args => + ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_box_iou args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_box_iou_upd :: + forall args . + Fullfilled "_backward_contrib_box_iou(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO () +_backward_contrib_box_iou_upd outputs args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_bipartite_matching(ndarray)" + = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +_contrib_bipartite_matching :: + forall args . + Fullfilled "_contrib_bipartite_matching(ndarray)" args => + ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> + IO [NDArrayHandle] +_contrib_bipartite_matching args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_bipartite_matching_upd :: + forall args . + Fullfilled "_contrib_bipartite_matching(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO () +_contrib_bipartite_matching_upd outputs args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_bipartite_matching(ndarray)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int)] + +_backward_contrib_bipartite_matching :: + forall args . + Fullfilled "_backward_contrib_bipartite_matching(ndarray)" + args => + ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args + -> IO [NDArrayHandle] +_backward_contrib_bipartite_matching args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_bipartite_matching_upd :: + forall args . + Fullfilled + "_backward_contrib_bipartite_matching(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward_contrib_bipartite_matching(ndarray)" + args + -> IO () +_backward_contrib_bipartite_matching_upd outputs args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_BilinearResize2D(ndarray)" = + '[ '("height", AttrOpt Int), '("width", AttrOpt Int), + '("scale_height", AttrOpt (Maybe Float)), + '("scale_width", AttrOpt (Maybe Float)), + '("mode", + AttrOpt + (EnumType + '["like", "odd_scale", "size", "to_even_down", "to_even_up", + "to_odd_down", "to_odd_up"])), + '("data", AttrOpt NDArrayHandle), '("like", AttrOpt NDArrayHandle)] + +_contrib_BilinearResize2D :: + forall args . + Fullfilled "_contrib_BilinearResize2D(ndarray)" args => + ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> + IO [NDArrayHandle] +_contrib_BilinearResize2D args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int), + ("scale_height",) . showValue <$> + (args !? #scale_height :: Maybe (Maybe Float)), + ("scale_width",) . showValue <$> + (args !? #scale_width :: Maybe (Maybe Float)), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe + (EnumType + '["like", "odd_scale", "size", "to_even_down", "to_even_up", + "to_odd_down", "to_odd_up"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("like",) <$> (args !? #like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_BilinearResize2D_upd :: + forall args . + Fullfilled "_contrib_BilinearResize2D(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO () +_contrib_BilinearResize2D_upd outputs args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int), + ("scale_height",) . showValue <$> + (args !? #scale_height :: Maybe (Maybe Float)), + ("scale_width",) . showValue <$> + (args !? #scale_width :: Maybe (Maybe Float)), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe + (EnumType + '["like", "odd_scale", "size", "to_even_down", "to_even_up", + "to_odd_down", "to_odd_up"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("like",) <$> (args !? #like :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[] + +_backward_contrib_BilinearResize2D :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(ndarray)" + args => + ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_BilinearResize2D args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_BilinearResize2D_upd :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" + args + -> IO () +_backward_contrib_BilinearResize2D_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_boolean_mask(ndarray)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle), + '("index", AttrOpt NDArrayHandle)] + +_contrib_boolean_mask :: + forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args => + ArgsHMap "_contrib_boolean_mask(ndarray)" args -> + IO [NDArrayHandle] +_contrib_boolean_mask args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_boolean_mask_upd :: + forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_boolean_mask(ndarray)" args -> IO () +_contrib_boolean_mask_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("index",) <$> (args !? #index :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_boolean_mask(ndarray)" = + '[ '("axis", AttrOpt Int)] + +_backward_contrib_boolean_mask :: + forall args . + Fullfilled "_backward_contrib_boolean_mask(ndarray)" args => + ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args -> + IO [NDArrayHandle] +_backward_contrib_boolean_mask args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_boolean_mask_upd :: + forall args . + Fullfilled "_backward_contrib_boolean_mask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args -> + IO () +_backward_contrib_boolean_mask_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_boolean_mask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int), + '("key", AttrReq String), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_contrib_SyncBatchNorm :: + forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args => + ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_contrib_SyncBatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_SyncBatchNorm_upd :: + forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO () +_contrib_SyncBatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" = + '[ '("output_size", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args => + ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args -> + IO [NDArrayHandle] +_contrib_AdaptiveAvgPooling2D args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_AdaptiveAvgPooling2D_upd :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args -> + IO () +_contrib_AdaptiveAvgPooling2D_upd outputs args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" = + '[] + +_backward_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args => + ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args + -> IO [NDArrayHandle] +_backward_contrib_AdaptiveAvgPooling2D args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_contrib_AdaptiveAvgPooling2D_upd :: + forall args . + Fullfilled + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" + args + -> IO () +_backward_contrib_AdaptiveAvgPooling2D_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_crop(ndarray)" = + '[ '("x", AttrReq Int), '("y", AttrReq Int), + '("width", AttrReq Int), '("height", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_image_crop :: + forall args . Fullfilled "_image_crop(ndarray)" args => + ArgsHMap "_image_crop(ndarray)" args -> IO [NDArrayHandle] +_image_crop args + = let scalarArgs + = catMaybes + [("x",) . showValue <$> (args !? #x :: Maybe Int), + ("y",) . showValue <$> (args !? #y :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int), + ("height",) . showValue <$> (args !? #height :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_crop_upd :: + forall args . Fullfilled "_image_crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_image_crop(ndarray)" args -> IO () +_image_crop_upd outputs args + = let scalarArgs + = catMaybes + [("x",) . showValue <$> (args !? #x :: Maybe Int), + ("y",) . showValue <$> (args !? #y :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int), + ("height",) . showValue <$> (args !? #height :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_image_crop(ndarray)" = '[] + +_backward_image_crop :: + forall args . Fullfilled "_backward_image_crop(ndarray)" args => + ArgsHMap "_backward_image_crop(ndarray)" args -> IO [NDArrayHandle] +_backward_image_crop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_image_crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_image_crop_upd :: + forall args . Fullfilled "_backward_image_crop(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_image_crop(ndarray)" args -> IO () +_backward_image_crop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_image_crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_to_tensor(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_to_tensor :: + forall args . Fullfilled "_image_to_tensor(ndarray)" args => + ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle] +_image_to_tensor args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_to_tensor_upd :: + forall args . Fullfilled "_image_to_tensor(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_to_tensor(ndarray)" args -> IO () +_image_to_tensor_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_normalize(ndarray)" = + '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]), + '("data", AttrOpt NDArrayHandle)] + +_image_normalize :: + forall args . Fullfilled "_image_normalize(ndarray)" args => + ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle] +_image_normalize args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_normalize_upd :: + forall args . Fullfilled "_image_normalize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_normalize(ndarray)" args -> IO () +_image_normalize_upd outputs args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_image_normalize(ndarray)" = + '[] + +_backward_image_normalize :: + forall args . + Fullfilled "_backward_image_normalize(ndarray)" args => + ArgsHMap "_backward_image_normalize(ndarray)" args -> + IO [NDArrayHandle] +_backward_image_normalize args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_image_normalize_upd :: + forall args . + Fullfilled "_backward_image_normalize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_image_normalize(ndarray)" args -> IO () +_backward_image_normalize_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_image_normalize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_flip_left_right(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_flip_left_right :: + forall args . Fullfilled "_image_flip_left_right(ndarray)" args => + ArgsHMap "_image_flip_left_right(ndarray)" args -> + IO [NDArrayHandle] +_image_flip_left_right args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_flip_left_right_upd :: + forall args . Fullfilled "_image_flip_left_right(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_flip_left_right(ndarray)" args -> IO () +_image_flip_left_right_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_image_random_flip_left_right(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_random_flip_left_right :: + forall args . + Fullfilled "_image_random_flip_left_right(ndarray)" args => + ArgsHMap "_image_random_flip_left_right(ndarray)" args -> + IO [NDArrayHandle] +_image_random_flip_left_right args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_flip_left_right_upd :: + forall args . + Fullfilled "_image_random_flip_left_right(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_flip_left_right(ndarray)" args -> + IO () +_image_random_flip_left_right_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_flip_top_bottom(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_flip_top_bottom :: + forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args => + ArgsHMap "_image_flip_top_bottom(ndarray)" args -> + IO [NDArrayHandle] +_image_flip_top_bottom args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_flip_top_bottom_upd :: + forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO () +_image_flip_top_bottom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_image_random_flip_top_bottom(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_image_random_flip_top_bottom :: + forall args . + Fullfilled "_image_random_flip_top_bottom(ndarray)" args => + ArgsHMap "_image_random_flip_top_bottom(ndarray)" args -> + IO [NDArrayHandle] +_image_random_flip_top_bottom args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_flip_top_bottom_upd :: + forall args . + Fullfilled "_image_random_flip_top_bottom(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_flip_top_bottom(ndarray)" args -> + IO () +_image_random_flip_top_bottom_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_brightness(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_brightness :: + forall args . + Fullfilled "_image_random_brightness(ndarray)" args => + ArgsHMap "_image_random_brightness(ndarray)" args -> + IO [NDArrayHandle] +_image_random_brightness args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_brightness_upd :: + forall args . + Fullfilled "_image_random_brightness(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_brightness(ndarray)" args -> IO () +_image_random_brightness_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_contrast(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_contrast :: + forall args . Fullfilled "_image_random_contrast(ndarray)" args => + ArgsHMap "_image_random_contrast(ndarray)" args -> + IO [NDArrayHandle] +_image_random_contrast args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_contrast_upd :: + forall args . Fullfilled "_image_random_contrast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_contrast(ndarray)" args -> IO () +_image_random_contrast_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_saturation(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_saturation :: + forall args . + Fullfilled "_image_random_saturation(ndarray)" args => + ArgsHMap "_image_random_saturation(ndarray)" args -> + IO [NDArrayHandle] +_image_random_saturation args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_saturation_upd :: + forall args . + Fullfilled "_image_random_saturation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_saturation(ndarray)" args -> IO () +_image_random_saturation_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_hue(ndarray)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_hue :: + forall args . Fullfilled "_image_random_hue(ndarray)" args => + ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle] +_image_random_hue args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_hue_upd :: + forall args . Fullfilled "_image_random_hue(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_hue(ndarray)" args -> IO () +_image_random_hue_upd outputs args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_color_jitter(ndarray)" = + '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float), + '("saturation", AttrReq Float), '("hue", AttrReq Float), + '("data", AttrOpt NDArrayHandle)] + +_image_random_color_jitter :: + forall args . + Fullfilled "_image_random_color_jitter(ndarray)" args => + ArgsHMap "_image_random_color_jitter(ndarray)" args -> + IO [NDArrayHandle] +_image_random_color_jitter args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_color_jitter_upd :: + forall args . + Fullfilled "_image_random_color_jitter(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO () +_image_random_color_jitter_upd outputs args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_adjust_lighting(ndarray)" = + '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)] + +_image_adjust_lighting :: + forall args . Fullfilled "_image_adjust_lighting(ndarray)" args => + ArgsHMap "_image_adjust_lighting(ndarray)" args -> + IO [NDArrayHandle] +_image_adjust_lighting args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_adjust_lighting_upd :: + forall args . Fullfilled "_image_adjust_lighting(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO () +_image_adjust_lighting_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_random_lighting(ndarray)" = + '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)] + +_image_random_lighting :: + forall args . Fullfilled "_image_random_lighting(ndarray)" args => + ArgsHMap "_image_random_lighting(ndarray)" args -> + IO [NDArrayHandle] +_image_random_lighting args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_random_lighting_upd :: + forall args . Fullfilled "_image_random_lighting(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_image_random_lighting(ndarray)" args -> IO () +_image_random_lighting_upd outputs args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_image_resize(ndarray)" = + '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool), + '("interp", AttrOpt Int), '("data", AttrOpt NDArrayHandle)] + +_image_resize :: + forall args . Fullfilled "_image_resize(ndarray)" args => + ArgsHMap "_image_resize(ndarray)" args -> IO [NDArrayHandle] +_image_resize args + = let scalarArgs + = catMaybes + [("size",) . showValue <$> (args !? #size :: Maybe [Int]), + ("keep_ratio",) . showValue <$> + (args !? #keep_ratio :: Maybe Bool), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_resize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_image_resize_upd :: + forall args . Fullfilled "_image_resize(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_image_resize(ndarray)" args -> IO () +_image_resize_upd outputs args + = let scalarArgs + = catMaybes + [("size",) . showValue <$> (args !? #size :: Maybe [Int]), + ("keep_ratio",) . showValue <$> + (args !? #keep_ratio :: Maybe Bool), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_resize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "moments(ndarray)" = + '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle)] + +moments :: + forall args . Fullfilled "moments(ndarray)" args => + ArgsHMap "moments(ndarray)" args -> IO [NDArrayHandle] +moments args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "moments" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +moments_upd :: + forall args . Fullfilled "moments(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "moments(ndarray)" args -> IO () +moments_upd outputs args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "moments" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_moments(ndarray)" = '[] + +_backward_moments :: + forall args . Fullfilled "_backward_moments(ndarray)" args => + ArgsHMap "_backward_moments(ndarray)" args -> IO [NDArrayHandle] +_backward_moments args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_moments" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_moments_upd :: + forall args . Fullfilled "_backward_moments(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_moments(ndarray)" args -> IO () +_backward_moments_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_moments" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("dtype", + AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))), + '("data", AttrOpt NDArrayHandle)] + +softmax :: + forall args . Fullfilled "softmax(ndarray)" args => + ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle] +softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_upd :: + forall args . Fullfilled "softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO () +softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softmax(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle] +_backward_softmax args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_upd :: + forall args . Fullfilled "_backward_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax(ndarray)" args -> IO () +_backward_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmin(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("dtype", + AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))), + '("data", AttrOpt NDArrayHandle)] + +softmin :: + forall args . Fullfilled "softmin(ndarray)" args => + ArgsHMap "softmin(ndarray)" args -> IO [NDArrayHandle] +softmin args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmin_upd :: + forall args . Fullfilled "softmin(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "softmin(ndarray)" args -> IO () +softmin_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_softmin(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +_backward_softmin :: + forall args . Fullfilled "_backward_softmin(ndarray)" args => + ArgsHMap "_backward_softmin(ndarray)" args -> IO [NDArrayHandle] +_backward_softmin args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmin_upd :: + forall args . Fullfilled "_backward_softmin(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmin(ndarray)" args -> IO () +_backward_softmin_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_softmin" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "log_softmax(ndarray)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("dtype", + AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))), + '("data", AttrOpt NDArrayHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(ndarray)" args => + ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle] +log_softmax args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +log_softmax_upd :: + forall args . Fullfilled "log_softmax(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO () +log_softmax_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_log_softmax(ndarray)" = + '[ '("args", AttrOpt [NDArrayHandle])] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + ArgsHMap "_backward_log_softmax(ndarray)" args -> + IO [NDArrayHandle] +_backward_log_softmax args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_log_softmax_upd :: + forall args . Fullfilled "_backward_log_softmax(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_log_softmax(ndarray)" args -> IO () +_backward_log_softmax_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_backward_log_softmax" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("layout", + AttrOpt + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))), + '("data", AttrOpt NDArrayHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(ndarray)" args => + ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle] +_Pooling args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool)), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_upd :: + forall args . Fullfilled "_Pooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO () +_Pooling_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool)), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling(ndarray)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_upd :: + forall args . Fullfilled "_backward_Pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling(ndarray)" args -> IO () +_backward_Pooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Deconvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle] +_Deconvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Deconvolution_upd :: + forall args . Fullfilled "_Deconvolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO () +_Deconvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Deconvolution(ndarray)" = + '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + ArgsHMap "_backward_Deconvolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Deconvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Deconvolution_upd :: + forall args . Fullfilled "_backward_Deconvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO () +_backward_Deconvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Activation(ndarray)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt NDArrayHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(ndarray)" args => + ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle] +_Activation args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Activation_upd :: + forall args . Fullfilled "_Activation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO () +_Activation_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Activation(ndarray)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle] +_backward_Activation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Activation_upd :: + forall args . Fullfilled "_backward_Activation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Activation(ndarray)" args -> IO () +_backward_Activation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_UpSampling(ndarray)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_UpSampling args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_UpSampling_upd :: + forall args . Fullfilled "_UpSampling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO () +_UpSampling_upd outputs args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "UpSampling" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_UpSampling(ndarray)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle] +_backward_UpSampling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_UpSampling_upd :: + forall args . Fullfilled "_backward_UpSampling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_UpSampling(ndarray)" args -> IO () +_backward_UpSampling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm(ndarray)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle), + '("moving_mean", AttrOpt NDArrayHandle), + '("moving_var", AttrOpt NDArrayHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_upd :: + forall args . Fullfilled "_BatchNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO () +_BatchNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm(ndarray)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_BatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_upd :: + forall args . Fullfilled "_backward_BatchNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO () +_backward_BatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CTCLoss(ndarray)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("data_lengths", AttrOpt NDArrayHandle), + '("label_lengths", AttrOpt NDArrayHandle)] + +_CTCLoss :: + forall args . Fullfilled "_CTCLoss(ndarray)" args => + ArgsHMap "_CTCLoss(ndarray)" args -> IO [NDArrayHandle] +_CTCLoss args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CTCLoss_upd :: + forall args . Fullfilled "_CTCLoss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_CTCLoss(ndarray)" args -> IO () +_CTCLoss_upd outputs args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe NDArrayHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CTCLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ctc_loss(ndarray)" = '[] + +_backward_ctc_loss :: + forall args . Fullfilled "_backward_ctc_loss(ndarray)" args => + ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO [NDArrayHandle] +_backward_ctc_loss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ctc_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ctc_loss_upd :: + forall args . Fullfilled "_backward_ctc_loss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO () +_backward_ctc_loss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ctc_loss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_FullyConnected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle] +_FullyConnected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_FullyConnected_upd :: + forall args . Fullfilled "_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_FullyConnected(ndarray)" args -> IO () +_FullyConnected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_FullyConnected(ndarray)" = + '[] + +_backward_FullyConnected :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + ArgsHMap "_backward_FullyConnected(ndarray)" args -> + IO [NDArrayHandle] +_backward_FullyConnected args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_FullyConnected_upd :: + forall args . + Fullfilled "_backward_FullyConnected(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO () +_backward_FullyConnected_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(ndarray)" args => + ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle] +_Convolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_upd :: + forall args . Fullfilled "_Convolution(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO () +_Convolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution(ndarray)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + ArgsHMap "_backward_Convolution(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_upd :: + forall args . Fullfilled "_backward_Convolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution(ndarray)" args -> IO () +_backward_Convolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LayerNorm(ndarray)" = + '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_LayerNorm :: + forall args . Fullfilled "_LayerNorm(ndarray)" args => + ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle] +_LayerNorm args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LayerNorm_upd :: + forall args . Fullfilled "_LayerNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO () +_LayerNorm_upd outputs args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LayerNorm(ndarray)" = '[] + +_backward_LayerNorm :: + forall args . Fullfilled "_backward_LayerNorm(ndarray)" args => + ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle] +_backward_LayerNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LayerNorm_upd :: + forall args . Fullfilled "_backward_LayerNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO () +_backward_LayerNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(ndarray)" args => + ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle] +_Concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Concat_upd :: + forall args . Fullfilled "_Concat(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO () +_Concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Concat(ndarray)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle] +_backward_Concat args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Concat_upd :: + forall args . Fullfilled "_backward_Concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Concat(ndarray)" args -> IO () +_backward_Concat_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_rnn_param_concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_rnn_param_concat :: + forall args . Fullfilled "_rnn_param_concat(ndarray)" args => + ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle] +_rnn_param_concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_rnn_param_concat_upd :: + forall args . Fullfilled "_rnn_param_concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_rnn_param_concat(ndarray)" args -> IO () +_rnn_param_concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_SoftmaxActivation(ndarray)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt NDArrayHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxActivation args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxActivation_upd :: + forall args . Fullfilled "_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO () +_SoftmaxActivation_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxActivation(ndarray)" + = '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxActivation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxActivation_upd :: + forall args . + Fullfilled "_backward_SoftmaxActivation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO () +_backward_SoftmaxActivation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LRN(ndarray)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt NDArrayHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(ndarray)" args => + ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle] +_LRN args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LRN_upd :: + forall args . Fullfilled "_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO () +_LRN_upd outputs args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LRN(ndarray)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle] +_backward_LRN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LRN_upd :: + forall args . Fullfilled "_backward_LRN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO () +_backward_LRN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Dropout(ndarray)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(ndarray)" args => + ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle] +_Dropout args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Dropout_upd :: + forall args . Fullfilled "_Dropout(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO () +_Dropout_upd outputs args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Dropout(ndarray)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle] +_backward_Dropout args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Dropout_upd :: + forall args . Fullfilled "_backward_Dropout(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Dropout(ndarray)" args -> IO () +_backward_Dropout_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_quantized_elemwise_add(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle), + '("lhs_min", AttrOpt NDArrayHandle), + '("lhs_max", AttrOpt NDArrayHandle), + '("rhs_min", AttrOpt NDArrayHandle), + '("rhs_max", AttrOpt NDArrayHandle)] + +_contrib_quantized_elemwise_add :: + forall args . + Fullfilled "_contrib_quantized_elemwise_add(ndarray)" args => + ArgsHMap "_contrib_quantized_elemwise_add(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_elemwise_add args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("lhs_min",) <$> (args !? #lhs_min :: Maybe NDArrayHandle), + ("lhs_max",) <$> (args !? #lhs_max :: Maybe NDArrayHandle), + ("rhs_min",) <$> (args !? #rhs_min :: Maybe NDArrayHandle), + ("rhs_max",) <$> (args !? #rhs_max :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_elemwise_add_upd :: + forall args . + Fullfilled "_contrib_quantized_elemwise_add(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_elemwise_add(ndarray)" args -> + IO () +_contrib_quantized_elemwise_add_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle), + ("lhs_min",) <$> (args !? #lhs_min :: Maybe NDArrayHandle), + ("lhs_max",) <$> (args !? #lhs_max :: Maybe NDArrayHandle), + ("rhs_min",) <$> (args !? #rhs_min :: Maybe NDArrayHandle), + ("rhs_max",) <$> (args !? #rhs_max :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_elemwise_add" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_dequantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["float32"])), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_dequantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_dequantize_upd :: + forall args . Fullfilled "_contrib_dequantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_dequantize(ndarray)" args -> IO () +_contrib_dequantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_flatten(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_flatten :: + forall args . + Fullfilled "_contrib_quantized_flatten(ndarray)" args => + ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_flatten args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_flatten_upd :: + forall args . + Fullfilled "_contrib_quantized_flatten(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO () +_contrib_quantized_flatten_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_conv(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle), + '("min_weight", AttrOpt NDArrayHandle), + '("max_weight", AttrOpt NDArrayHandle), + '("min_bias", AttrOpt NDArrayHandle), + '("max_bias", AttrOpt NDArrayHandle)] + +_contrib_quantized_conv :: + forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args => + ArgsHMap "_contrib_quantized_conv(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_conv args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_conv_upd :: + forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO () +_contrib_quantized_conv_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_quantized_fully_connected(ndarray)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle), + '("min_weight", AttrOpt NDArrayHandle), + '("max_weight", AttrOpt NDArrayHandle), + '("min_bias", AttrOpt NDArrayHandle), + '("max_bias", AttrOpt NDArrayHandle)] + +_contrib_quantized_fully_connected :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(ndarray)" + args => + ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_fully_connected args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_fully_connected_upd :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_fully_connected(ndarray)" + args + -> IO () +_contrib_quantized_fully_connected_upd outputs args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_pooling(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("layout", + AttrOpt + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))), + '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_pooling :: + forall args . + Fullfilled "_contrib_quantized_pooling(ndarray)" args => + ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_pooling args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool)), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_pooling_upd :: + forall args . + Fullfilled "_contrib_quantized_pooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO () +_contrib_quantized_pooling_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool)), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantize_v2(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])), + '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt NDArrayHandle)] + +_contrib_quantize_v2 :: + forall args . Fullfilled "_contrib_quantize_v2(ndarray)" args => + ArgsHMap "_contrib_quantize_v2(ndarray)" args -> IO [NDArrayHandle] +_contrib_quantize_v2 args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])), + ("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize_v2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantize_v2_upd :: + forall args . Fullfilled "_contrib_quantize_v2(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantize_v2(ndarray)" args -> IO () +_contrib_quantize_v2_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])), + ("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize_v2" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_concat(ndarray)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +_contrib_quantized_concat :: + forall args . + Fullfilled "_contrib_quantized_concat(ndarray)" args => + ArgsHMap "_contrib_quantized_concat(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_concat args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_contrib_quantized_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_contrib_quantized_concat_upd :: + forall args . + Fullfilled "_contrib_quantized_concat(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_concat(ndarray)" args -> IO () +_contrib_quantized_concat_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_contrib_quantized_concat" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_contrib_requantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])), + '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_requantize :: + forall args . Fullfilled "_contrib_requantize(ndarray)" args => + ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_requantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])), + ("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_requantize_upd :: + forall args . Fullfilled "_contrib_requantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_requantize(ndarray)" args -> IO () +_contrib_requantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])), + ("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantized_act(ndarray)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt NDArrayHandle), + '("min_data", AttrOpt NDArrayHandle), + '("max_data", AttrOpt NDArrayHandle)] + +_contrib_quantized_act :: + forall args . Fullfilled "_contrib_quantized_act(ndarray)" args => + ArgsHMap "_contrib_quantized_act(ndarray)" args -> + IO [NDArrayHandle] +_contrib_quantized_act args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_act" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantized_act_upd :: + forall args . Fullfilled "_contrib_quantized_act(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantized_act(ndarray)" args -> IO () +_contrib_quantized_act_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle), + ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_act" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_quantize(ndarray)" = + '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])), + '("data", AttrOpt NDArrayHandle), + '("min_range", AttrOpt NDArrayHandle), + '("max_range", AttrOpt NDArrayHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle] +_contrib_quantize args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_quantize_upd :: + forall args . Fullfilled "_contrib_quantize(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_quantize(ndarray)" args -> IO () +_contrib_quantize_upd outputs args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle), + ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimdecode(ndarray)" = + '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool), + '("buf", AttrOpt NDArrayHandle)] + +_cvimdecode :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle] +_cvimdecode args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimdecode_upd :: + forall args . Fullfilled "_cvimdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO () +_cvimdecode_upd outputs args + = let scalarArgs + = catMaybes + [("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs + = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimread(ndarray)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(ndarray)" args => + ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle] +_cvimread args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimread_upd :: + forall args . Fullfilled "_cvimread(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO () +_cvimread_upd outputs args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvimresize(ndarray)" = + '[ '("w", AttrReq Int), '("h", AttrReq Int), + '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)] + +_cvimresize :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle] +_cvimresize args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvimresize_upd :: + forall args . Fullfilled "_cvimresize(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO () +_cvimresize_upd outputs args + = let scalarArgs + = catMaybes + [("w",) . showValue <$> (args !? #w :: Maybe Int), + ("h",) . showValue <$> (args !? #h :: Maybe Int), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimresize" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_cvcopyMakeBorder(ndarray)" = + '[ '("top", AttrReq Int), '("bot", AttrReq Int), + '("left", AttrReq Int), '("right", AttrReq Int), + '("type", AttrOpt Int), '("value", AttrOpt Double), + '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)] + +_cvcopyMakeBorder :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle] +_cvcopyMakeBorder args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_cvcopyMakeBorder_upd :: + forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO () +_cvcopyMakeBorder_upd outputs args + = let scalarArgs + = catMaybes + [("top",) . showValue <$> (args !? #top :: Maybe Int), + ("bot",) . showValue <$> (args !? #bot :: Maybe Int), + ("left",) . showValue <$> (args !? #left :: Maybe Int), + ("right",) . showValue <$> (args !? #right :: Maybe Int), + ("type",) . showValue <$> (args !? #type :: Maybe Int), + ("value",) . showValue <$> (args !? #value :: Maybe Double), + ("values",) . showValue <$> (args !? #values :: Maybe [Double])] + tensorArgs + = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvcopyMakeBorder" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_NoGradient(ndarray)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle] +_NoGradient args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_NoGradient_upd :: + forall args . Fullfilled "_NoGradient(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO () +_NoGradient_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CachedOp(ndarray)" = + '[ '("data", AttrOpt [NDArrayHandle])] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CachedOp_upd :: + forall args . Fullfilled "_CachedOp(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO () +_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CachedOp(ndarray)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle] +_backward_CachedOp args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CachedOp_upd :: + forall args . Fullfilled "_backward_CachedOp(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CachedOp(ndarray)" args -> IO () +_backward_CachedOp_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_copyto(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle)] + +_copyto :: + forall args . Fullfilled "_copyto(ndarray)" args => + ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle] +_copyto args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_copyto_upd :: + forall args . Fullfilled "_copyto(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO () +_copyto_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copyto" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "softmax_cross_entropy(ndarray)" = + '[ '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + ArgsHMap "softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +softmax_cross_entropy_upd :: + forall args . Fullfilled "softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO () +softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO [NDArrayHandle] +_backward_softmax_cross_entropy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_softmax_cross_entropy_upd :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args -> + IO () +_backward_softmax_cross_entropy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_foreach(ndarray)" = '[] + +_backward_foreach :: + forall args . Fullfilled "_backward_foreach(ndarray)" args => + ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle] +_backward_foreach args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_foreach_upd :: + forall args . Fullfilled "_backward_foreach(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_foreach(ndarray)" args -> IO () +_backward_foreach_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_while_loop(ndarray)" = '[] + +_backward_while_loop :: + forall args . Fullfilled "_backward_while_loop(ndarray)" args => + ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle] +_backward_while_loop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_while_loop_upd :: + forall args . Fullfilled "_backward_while_loop(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_while_loop(ndarray)" args -> IO () +_backward_while_loop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_cond(ndarray)" = '[] + +_backward_cond :: + forall args . Fullfilled "_backward_cond(ndarray)" args => + ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle] +_backward_cond args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_cond_upd :: + forall args . Fullfilled "_backward_cond(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO () +_backward_cond_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SoftmaxOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle] +_SoftmaxOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SoftmaxOutput_upd :: + forall args . Fullfilled "_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO () +_SoftmaxOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SoftmaxOutput(ndarray)" = + '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> + IO [NDArrayHandle] +_backward_SoftmaxOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SoftmaxOutput_upd :: + forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO () +_backward_SoftmaxOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LeakyReLU(ndarray)" = + '[ '("act_type", + AttrOpt + (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_LeakyReLU args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LeakyReLU_upd :: + forall args . Fullfilled "_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO () +_LeakyReLU_upd outputs args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SwapAxis(ndarray)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_SwapAxis args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SwapAxis_upd :: + forall args . Fullfilled "_SwapAxis(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO () +_SwapAxis_upd outputs args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt NDArrayHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> + IO [NDArrayHandle] +_IdentityAttachKLSparseReg args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO () +_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SliceChannel(ndarray)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle] +_SliceChannel args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SliceChannel_upd :: + forall args . Fullfilled "_SliceChannel(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO () +_SliceChannel_upd outputs args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_RNN(ndarray)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("projection_size", AttrOpt (Maybe Int)), + '("lstm_state_clip_min", AttrOpt (Maybe Double)), + '("lstm_state_clip_max", AttrOpt (Maybe Double)), + '("lstm_state_clip_nan", AttrOpt Bool), + '("use_sequence_length", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("parameters", AttrOpt NDArrayHandle), + '("state", AttrOpt NDArrayHandle), + '("state_cell", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(ndarray)" args => + ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle] +_RNN args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool), + ("projection_size",) . showValue <$> + (args !? #projection_size :: Maybe (Maybe Int)), + ("lstm_state_clip_min",) . showValue <$> + (args !? #lstm_state_clip_min :: Maybe (Maybe Double)), + ("lstm_state_clip_max",) . showValue <$> + (args !? #lstm_state_clip_max :: Maybe (Maybe Double)), + ("lstm_state_clip_nan",) . showValue <$> + (args !? #lstm_state_clip_nan :: Maybe Bool), + ("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_RNN_upd :: + forall args . Fullfilled "_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO () +_RNN_upd outputs args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool), + ("projection_size",) . showValue <$> + (args !? #projection_size :: Maybe (Maybe Int)), + ("lstm_state_clip_min",) . showValue <$> + (args !? #lstm_state_clip_min :: Maybe (Maybe Double)), + ("lstm_state_clip_max",) . showValue <$> + (args !? #lstm_state_clip_max :: Maybe (Maybe Double)), + ("lstm_state_clip_nan",) . showValue <$> + (args !? #lstm_state_clip_nan :: Maybe Bool), + ("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle), + ("state",) <$> (args !? #state :: Maybe NDArrayHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_RNN(ndarray)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle] +_backward_RNN args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_RNN_upd :: + forall args . Fullfilled "_backward_RNN(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO () +_backward_RNN_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pad(ndarray)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt NDArrayHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(ndarray)" args => + ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle] +_Pad args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pad_upd :: + forall args . Fullfilled "_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO () +_Pad_upd outputs args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BatchNorm_v1(ndarray)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle] +_BatchNorm_v1 args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BatchNorm_v1_upd :: + forall args . Fullfilled "_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO () +_BatchNorm_v1_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "signsgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +signsgd_update :: + forall args . Fullfilled "signsgd_update(ndarray)" args => + ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle] +signsgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +signsgd_update_upd :: + forall args . Fullfilled "signsgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO () +signsgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "signum_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +signum_update :: + forall args . Fullfilled "signum_update(ndarray)" args => + ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle] +signum_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +signum_update_upd :: + forall args . Fullfilled "signum_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO () +signum_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "multi_sgd_update(ndarray)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +multi_sgd_update :: + forall args . Fullfilled "multi_sgd_update(ndarray)" args => + ArgsHMap "multi_sgd_update(ndarray)" args -> IO [NDArrayHandle] +multi_sgd_update args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +multi_sgd_update_upd :: + forall args . Fullfilled "multi_sgd_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "multi_sgd_update(ndarray)" args -> IO () +multi_sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "multi_sgd_mom_update(ndarray)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +multi_sgd_mom_update :: + forall args . Fullfilled "multi_sgd_mom_update(ndarray)" args => + ArgsHMap "multi_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +multi_sgd_mom_update args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +multi_sgd_mom_update_upd :: + forall args . Fullfilled "multi_sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "multi_sgd_mom_update(ndarray)" args -> IO () +multi_sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "multi_mp_sgd_update(ndarray)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +multi_mp_sgd_update :: + forall args . Fullfilled "multi_mp_sgd_update(ndarray)" args => + ArgsHMap "multi_mp_sgd_update(ndarray)" args -> IO [NDArrayHandle] +multi_mp_sgd_update args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +multi_mp_sgd_update_upd :: + forall args . Fullfilled "multi_mp_sgd_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "multi_mp_sgd_update(ndarray)" args -> IO () +multi_mp_sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "multi_mp_sgd_mom_update(ndarray)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [NDArrayHandle])] + +multi_mp_sgd_mom_update :: + forall args . Fullfilled "multi_mp_sgd_mom_update(ndarray)" args => + ArgsHMap "multi_mp_sgd_mom_update(ndarray)" args -> + IO [NDArrayHandle] +multi_mp_sgd_mom_update args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +multi_mp_sgd_mom_update_upd :: + forall args . Fullfilled "multi_mp_sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "multi_mp_sgd_mom_update(ndarray)" args -> IO () +multi_mp_sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "multi_mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(ndarray)" args => + ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle] +sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_update_upd :: + forall args . Fullfilled "sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO () +sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +sgd_mom_update_upd :: + forall args . Fullfilled "sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO () +sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_update(ndarray)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_update_upd :: + forall args . Fullfilled "mp_sgd_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO () +mp_sgd_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_sgd_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle] +mp_sgd_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_sgd_mom_update_upd :: + forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO () +mp_sgd_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftml_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double), + '("t", AttrReq Int), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle), + '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)] + +ftml_update :: + forall args . Fullfilled "ftml_update(ndarray)" args => + ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle] +ftml_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("d",) <$> (args !? #d :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftml_update_upd :: + forall args . Fullfilled "ftml_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO () +ftml_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("d",) <$> (args !? #d :: Maybe NDArrayHandle), + ("v",) <$> (args !? #v :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "adam_update(ndarray)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle), + '("var", AttrOpt NDArrayHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(ndarray)" args => + ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle] +adam_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +adam_update_upd :: + forall args . Fullfilled "adam_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO () +adam_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle), + ("var",) <$> (args !? #var :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "nag_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)] + +nag_mom_update :: + forall args . Fullfilled "nag_mom_update(ndarray)" args => + ArgsHMap "nag_mom_update(ndarray)" args -> IO [NDArrayHandle] +nag_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nag_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +nag_mom_update_upd :: + forall args . Fullfilled "nag_mom_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "nag_mom_update(ndarray)" args -> IO () +nag_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nag_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "mp_nag_mom_update(ndarray)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle), + '("weight32", AttrOpt NDArrayHandle)] + +mp_nag_mom_update :: + forall args . Fullfilled "mp_nag_mom_update(ndarray)" args => + ArgsHMap "mp_nag_mom_update(ndarray)" args -> IO [NDArrayHandle] +mp_nag_mom_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_nag_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +mp_nag_mom_update_upd :: + forall args . Fullfilled "mp_nag_mom_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "mp_nag_mom_update(ndarray)" args -> IO () +mp_nag_mom_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_nag_mom_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmsprop_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle] +rmsprop_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmsprop_update_upd :: + forall args . Fullfilled "rmsprop_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO () +rmsprop_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "rmspropalex_update(ndarray)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle), + '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle] +rmspropalex_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +rmspropalex_update_upd :: + forall args . Fullfilled "rmspropalex_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "rmspropalex_update(ndarray)" args -> IO () +rmspropalex_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle), + ("g",) <$> (args !? #g :: Maybe NDArrayHandle), + ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "ftrl_update(ndarray)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle), + '("n", AttrOpt NDArrayHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle] +ftrl_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +ftrl_update_upd :: + forall args . Fullfilled "ftrl_update(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO () +ftrl_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("z",) <$> (args !? #z :: Maybe NDArrayHandle), + ("n",) <$> (args !? #n :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_sparse_adagrad_update(ndarray)" = + '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt NDArrayHandle), + '("grad", AttrOpt NDArrayHandle), + '("history", AttrOpt NDArrayHandle)] + +_sparse_adagrad_update :: + forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args => + ArgsHMap "_sparse_adagrad_update(ndarray)" args -> + IO [NDArrayHandle] +_sparse_adagrad_update args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_sparse_adagrad_update_upd :: + forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO () +_sparse_adagrad_update_upd outputs args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle), + ("history",) <$> (args !? #history :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LinearRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LinearRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LinearRegressionOutput_upd :: + forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO () +_LinearRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_linear_reg_out(ndarray)" = + '[] + +_backward_linear_reg_out :: + forall args . + Fullfilled "_backward_linear_reg_out(ndarray)" args => + ArgsHMap "_backward_linear_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_linear_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_linear_reg_out_upd :: + forall args . + Fullfilled "_backward_linear_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO () +_backward_linear_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MAERegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle] +_MAERegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MAERegressionOutput_upd :: + forall args . Fullfilled "_MAERegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO () +_MAERegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[] + +_backward_mae_reg_out :: + forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args => + ArgsHMap "_backward_mae_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_mae_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_mae_reg_out_upd :: + forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO () +_backward_mae_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_LogisticRegressionOutput(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> + IO [NDArrayHandle] +_LogisticRegressionOutput args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_LogisticRegressionOutput_upd :: + forall args . + Fullfilled "_LogisticRegressionOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO () +_LogisticRegressionOutput_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_logistic_reg_out(ndarray)" = + '[] + +_backward_logistic_reg_out :: + forall args . + Fullfilled "_backward_logistic_reg_out(ndarray)" args => + ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> + IO [NDArrayHandle] +_backward_logistic_reg_out args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_logistic_reg_out_upd :: + forall args . + Fullfilled "_backward_logistic_reg_out(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO () +_backward_logistic_reg_out_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CustomFunction(ndarray)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle] +_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CustomFunction_upd :: + forall args . Fullfilled "_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CustomFunction(ndarray)" args -> IO () +_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_CustomFunction(ndarray)" = + '[] + +_backward_CustomFunction :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + ArgsHMap "_backward_CustomFunction(ndarray)" args -> + IO [NDArrayHandle] +_backward_CustomFunction args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_CustomFunction_upd :: + forall args . + Fullfilled "_backward_CustomFunction(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO () +_backward_CustomFunction_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__Native(ndarray)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle] +_backward__Native args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__Native_upd :: + forall args . Fullfilled "_backward__Native(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__Native(ndarray)" args -> IO () +_backward__Native_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__NDArray(ndarray)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle] +_backward__NDArray args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__NDArray_upd :: + forall args . Fullfilled "_backward__NDArray(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__NDArray(ndarray)" args -> IO () +_backward__NDArray_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), + '("anchor", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle), + '("cls_pred", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxTarget args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxTarget_upd :: + forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO () +_contrib_MultiBoxTarget_upd outputs args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxTarget args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxTarget_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args + -> IO () +_backward__contrib_MultiBoxTarget_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_Proposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle] +_contrib_Proposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_Proposal_upd :: + forall args . Fullfilled "_contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_Proposal(ndarray)" args -> IO () +_contrib_Proposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_Proposal(ndarray)" + = '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_Proposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_Proposal_upd :: + forall args . + Fullfilled "_backward__contrib_Proposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO () +_backward__contrib_Proposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_count_sketch(ndarray)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle), + '("s", AttrOpt NDArrayHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + ArgsHMap "_contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_contrib_count_sketch args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_count_sketch_upd :: + forall args . Fullfilled "_contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO () +_contrib_count_sketch_upd outputs args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("h",) <$> (args !? #h :: Maybe NDArrayHandle), + ("s",) <$> (args !? #s :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_count_sketch(ndarray)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_count_sketch args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_count_sketch_upd :: + forall args . + Fullfilled "_backward__contrib_count_sketch(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_count_sketch(ndarray)" args -> + IO () +_backward__contrib_count_sketch_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle), + '("loc_pred", AttrOpt NDArrayHandle), + '("anchor", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxDetection args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO () +_contrib_MultiBoxDetection_upd outputs args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle), + ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)" + args => + ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args + -> IO [NDArrayHandle] +_backward__contrib_MultiBoxDetection args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxDetection_upd :: + forall args . + Fullfilled + "_backward__contrib_MultiBoxDetection(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_MultiBoxDetection(ndarray)" + args + -> IO () +_backward__contrib_MultiBoxDetection_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)" + = '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformablePSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformablePSROIPooling_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(ndarray)" + args + -> IO () +_backward__contrib_DeformablePSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_fft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle] +_contrib_fft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_fft_upd :: + forall args . Fullfilled "_contrib_fft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO () +_contrib_fft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_fft(ndarray)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + ArgsHMap "_backward__contrib_fft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_fft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_fft_upd :: + forall args . Fullfilled "_backward__contrib_fft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO () +_backward__contrib_fft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiBoxPrior args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiBoxPrior_upd :: + forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO () +_contrib_MultiBoxPrior_upd outputs args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args => + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiBoxPrior args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiBoxPrior_upd :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args + -> IO () +_backward__contrib_MultiBoxPrior_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_MultiProposal(ndarray)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle), + '("bbox_pred", AttrOpt NDArrayHandle), + '("im_info", AttrOpt NDArrayHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_contrib_MultiProposal args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_MultiProposal_upd :: + forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO () +_contrib_MultiProposal_upd outputs args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle), + ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" args => + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_MultiProposal args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_MultiProposal_upd :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args + -> IO () +_backward__contrib_MultiProposal_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_PSROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_PSROIPooling_upd :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args -> + IO () +_backward__contrib_PSROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_contrib_DeformableConvolution(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt NDArrayHandle), + '("offset", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO [NDArrayHandle] +_contrib_DeformableConvolution args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_DeformableConvolution_upd :: + forall args . + Fullfilled "_contrib_DeformableConvolution(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_contrib_DeformableConvolution(ndarray)" args -> + IO () +_contrib_DeformableConvolution_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_DeformableConvolution(ndarray)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO [NDArrayHandle] +_backward__contrib_DeformableConvolution args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_DeformableConvolution_upd :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap + "_backward__contrib_DeformableConvolution(ndarray)" + args + -> IO () +_backward__contrib_DeformableConvolution_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_contrib_ifft(ndarray)" = + '[ '("compute_size", AttrOpt Int), + '("data", AttrOpt NDArrayHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle] +_contrib_ifft args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_contrib_ifft_upd :: + forall args . Fullfilled "_contrib_ifft(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO () +_contrib_ifft_upd outputs args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__contrib_ifft(ndarray)" = + '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_ifft args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_ifft_upd :: + forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO () +_backward__contrib_ifft_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[] + +_backward__contrib_SyncBatchNorm :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args => + ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward__contrib_SyncBatchNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__contrib_SyncBatchNorm_upd :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args + -> IO () +_backward__contrib_SyncBatchNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_InstanceNorm(ndarray)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle), + '("gamma", AttrOpt NDArrayHandle), + '("beta", AttrOpt NDArrayHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle] +_InstanceNorm args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_InstanceNorm_upd :: + forall args . Fullfilled "_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO () +_InstanceNorm_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle), + ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> + IO [NDArrayHandle] +_backward_InstanceNorm args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_InstanceNorm_upd :: + forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO () +_backward_InstanceNorm_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SVMOutput(ndarray)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle), + '("label", AttrOpt NDArrayHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_SVMOutput args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SVMOutput_upd :: + forall args . Fullfilled "_SVMOutput(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO () +_SVMOutput_upd outputs args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("label",) <$> (args !? #label :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SVMOutput(ndarray)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle] +_backward_SVMOutput args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SVMOutput_upd :: + forall args . Fullfilled "_backward_SVMOutput(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO () +_backward_SVMOutput_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_GridGenerator(ndarray)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle] +_GridGenerator args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_GridGenerator_upd :: + forall args . Fullfilled "_GridGenerator(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO () +_GridGenerator_upd outputs args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_GridGenerator(ndarray)" = + '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + ArgsHMap "_backward_GridGenerator(ndarray)" args -> + IO [NDArrayHandle] +_backward_GridGenerator args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_GridGenerator_upd :: + forall args . Fullfilled "_backward_GridGenerator(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO () +_backward_GridGenerator_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Convolution_v1(ndarray)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt NDArrayHandle), + '("weight", AttrOpt NDArrayHandle), + '("bias", AttrOpt NDArrayHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle] +_Convolution_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Convolution_v1_upd :: + forall args . Fullfilled "_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_Convolution_v1(ndarray)" args -> IO () +_Convolution_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle), + ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Convolution_v1(ndarray)" = + '[] + +_backward_Convolution_v1 :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_Convolution_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Convolution_v1_upd :: + forall args . + Fullfilled "_backward_Convolution_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO () +_backward_Convolution_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceReverse(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle] +_SequenceReverse args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceReverse_upd :: + forall args . Fullfilled "_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SequenceReverse(ndarray)" args -> IO () +_SequenceReverse_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceReverse(ndarray)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceReverse args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceReverse_upd :: + forall args . + Fullfilled "_backward_SequenceReverse(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO () +_backward_SequenceReverse_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_BilinearSampler(ndarray)" = + '[ '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle), '("grid", AttrOpt NDArrayHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle] +_BilinearSampler args + = let scalarArgs + = catMaybes + [("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_BilinearSampler_upd :: + forall args . Fullfilled "_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_BilinearSampler(ndarray)" args -> IO () +_BilinearSampler_upd outputs args + = let scalarArgs + = catMaybes + [("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BilinearSampler(ndarray)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> + IO [NDArrayHandle] +_backward_BilinearSampler args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BilinearSampler_upd :: + forall args . + Fullfilled "_backward_BilinearSampler(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO () +_backward_BilinearSampler_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle] +_backward_LeakyReLU args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_LeakyReLU_upd :: + forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO () +_backward_LeakyReLU_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Crop(ndarray)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [NDArrayHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(ndarray)" args => + ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle] +_Crop args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + Nothing + return listndarr + +_Crop_upd :: + forall args . Fullfilled "_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO () +_Crop_upd outputs args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle]) + in + do op <- nnGetOpHandle "Crop" + let scalarArgs' + = if hasKey args #num_args then scalarArgs else + (,) "num_args" (showValue (length array)) : scalarArgs + listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs' + (Just outputs) + return () + +type instance ParameterList "_backward_Crop(ndarray)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle] +_backward_Crop args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Crop_upd :: + forall args . Fullfilled "_backward_Crop(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO () +_backward_Crop_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_ROIPooling(ndarray)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), + '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_ROIPooling args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_ROIPooling_upd :: + forall args . Fullfilled "_ROIPooling(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO () +_ROIPooling_upd outputs args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_ROIPooling(ndarray)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle] +_backward_ROIPooling args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_ROIPooling_upd :: + forall args . Fullfilled "_backward_ROIPooling(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO () +_backward_ROIPooling_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceLast(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle] +_SequenceLast args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceLast_upd :: + forall args . Fullfilled "_SequenceLast(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO () +_SequenceLast_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceLast(ndarray)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + ArgsHMap "_backward_SequenceLast(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceLast args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceLast_upd :: + forall args . Fullfilled "_backward_SequenceLast(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO () +_backward_SequenceLast_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle] +_CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_CrossDeviceCopy_upd :: + forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO () +_CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> + IO [NDArrayHandle] +_backward__CrossDeviceCopy args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward__CrossDeviceCopy_upd :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO () +_backward__CrossDeviceCopy_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SpatialTransformer(ndarray)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle] +_SpatialTransformer args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"])), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SpatialTransformer_upd :: + forall args . Fullfilled "_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_SpatialTransformer(ndarray)" args -> IO () +_SpatialTransformer_upd outputs args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"])), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SpatialTransformer(ndarray)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> + IO [NDArrayHandle] +_backward_SpatialTransformer args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SpatialTransformer_upd :: + forall args . + Fullfilled "_backward_SpatialTransformer(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO () +_backward_SpatialTransformer_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SwapAxis(ndarray)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle] +_backward_SwapAxis args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SwapAxis_upd :: + forall args . Fullfilled "_backward_SwapAxis(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO () +_backward_SwapAxis_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_L2Normalization(ndarray)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt NDArrayHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle] +_L2Normalization args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_L2Normalization_upd :: + forall args . Fullfilled "_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_L2Normalization(ndarray)" args -> IO () +_L2Normalization_upd outputs args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_L2Normalization(ndarray)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + ArgsHMap "_backward_L2Normalization(ndarray)" args -> + IO [NDArrayHandle] +_backward_L2Normalization args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_L2Normalization_upd :: + forall args . + Fullfilled "_backward_L2Normalization(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO () +_backward_L2Normalization_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Correlation(ndarray)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle), + '("data2", AttrOpt NDArrayHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(ndarray)" args => + ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle] +_Correlation args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Correlation_upd :: + forall args . Fullfilled "_Correlation(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO () +_Correlation_upd outputs args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle), + ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Correlation(ndarray)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + ArgsHMap "_backward_Correlation(ndarray)" args -> + IO [NDArrayHandle] +_backward_Correlation args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Correlation_upd :: + forall args . Fullfilled "_backward_Correlation(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Correlation(ndarray)" args -> IO () +_backward_Correlation_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args + -> IO [NDArrayHandle] +_backward_IdentityAttachKLSparseReg args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_IdentityAttachKLSparseReg_upd :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)" + args => + [NDArrayHandle] -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" + args + -> IO () +_backward_IdentityAttachKLSparseReg_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_MakeLoss(ndarray)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt NDArrayHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_MakeLoss args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_MakeLoss_upd :: + forall args . Fullfilled "_MakeLoss(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO () +_MakeLoss_upd outputs args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_MakeLoss(ndarray)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle] +_backward_MakeLoss args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_MakeLoss_upd :: + forall args . Fullfilled "_backward_MakeLoss(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO () +_backward_MakeLoss_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SliceChannel(ndarray)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + ArgsHMap "_backward_SliceChannel(ndarray)" args -> + IO [NDArrayHandle] +_backward_SliceChannel args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SliceChannel_upd :: + forall args . Fullfilled "_backward_SliceChannel(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO () +_backward_SliceChannel_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_Pooling_v1(ndarray)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])), + '("global_pool", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt NDArrayHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_Pooling_v1 args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_Pooling_v1_upd :: + forall args . Fullfilled "_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO () +_Pooling_v1_upd outputs args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle] +_backward_Pooling_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pooling_v1_upd :: + forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO () +_backward_Pooling_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_Pad(ndarray)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle] +_backward_Pad args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_Pad_upd :: + forall args . Fullfilled "_backward_Pad(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO () +_backward_Pad_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> + IO [NDArrayHandle] +_backward_BatchNorm_v1 args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_BatchNorm_v1_upd :: + forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO () +_backward_BatchNorm_v1_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_SequenceMask(ndarray)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("axis", AttrOpt Int), + '("data", AttrOpt NDArrayHandle), + '("sequence_length", AttrOpt NDArrayHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle] +_SequenceMask args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_SequenceMask_upd :: + forall args . Fullfilled "_SequenceMask(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO () +_SequenceMask_upd outputs args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe NDArrayHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_backward_SequenceMask(ndarray)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + ArgsHMap "_backward_SequenceMask(ndarray)" args -> + IO [NDArrayHandle] +_backward_SequenceMask args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_backward_SequenceMask_upd :: + forall args . Fullfilled "_backward_SequenceMask(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO () +_backward_SequenceMask_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_set_value(ndarray)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(ndarray)" args => + ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle] +_set_value args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_set_value_upd :: + forall args . Fullfilled "_set_value(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO () +_set_value_upd outputs args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_onehot_encode(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("rhs", AttrOpt NDArrayHandle)] + +_onehot_encode :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle] +_onehot_encode args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_onehot_encode_upd :: + forall args . Fullfilled "_onehot_encode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO () +_onehot_encode_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_onehot_encode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "fill_element_0index(ndarray)" = + '[ '("lhs", AttrOpt NDArrayHandle), + '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)] + +fill_element_0index :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle] +fill_element_0index args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +fill_element_0index_upd :: + forall args . Fullfilled "fill_element_0index(ndarray)" args => + [NDArrayHandle] -> + ArgsHMap "fill_element_0index(ndarray)" args -> IO () +fill_element_0index_upd outputs args + = let scalarArgs = catMaybes [] + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle), + ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle), + ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fill_element_0index" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () + +type instance ParameterList "_imdecode(ndarray)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt NDArrayHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(ndarray)" args => + ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle] +_imdecode args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + Nothing + return listndarr + +_imdecode_upd :: + forall args . Fullfilled "_imdecode(ndarray)" args => + [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO () +_imdecode_upd outputs args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals + scalarArgs + (Just outputs) + return () diff --git a/ops/1.5/MXNet/Base/Operators/Symbol.hs b/ops/1.5/MXNet/Base/Operators/Symbol.hs new file mode 100644 --- /dev/null +++ b/ops/1.5/MXNet/Base/Operators/Symbol.hs @@ -0,0 +1,13179 @@ +module MXNet.Base.Operators.Symbol where +import MXNet.Base.Raw +import MXNet.Base.Spec.Operator +import MXNet.Base.Spec.HMap +import Data.Maybe (catMaybes, fromMaybe) + +type instance ParameterList "_CuDNNBatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_CuDNNBatchNorm :: + forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args => + String -> + ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle +_CuDNNBatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CuDNNBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" = + '[] + +_backward_CuDNNBatchNorm :: + forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle +_backward_CuDNNBatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CuDNNBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_multinomial(symbol)" = + '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_sample_multinomial :: + forall args . Fullfilled "_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle +_sample_multinomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sample_multinomial(symbol)" + = '[] + +_backward_sample_multinomial :: + forall args . + Fullfilled "_backward_sample_multinomial(symbol)" args => + String -> + ArgsHMap "_backward_sample_multinomial(symbol)" args -> + IO SymbolHandle +_backward_sample_multinomial name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sample_multinomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_uniform(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)] + +_sample_uniform :: + forall args . Fullfilled "_sample_uniform(symbol)" args => + String -> + ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle +_sample_uniform name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("low",) <$> (args !? #low :: Maybe SymbolHandle), + ("high",) <$> (args !? #high :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_normal(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)] + +_sample_normal :: + forall args . Fullfilled "_sample_normal(symbol)" args => + String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle +_sample_normal name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_gamma(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_sample_gamma :: + forall args . Fullfilled "_sample_gamma(symbol)" args => + String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle +_sample_gamma name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_exponential(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_exponential :: + forall args . Fullfilled "_sample_exponential(symbol)" args => + String -> + ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle +_sample_exponential name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_poisson(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("lam", AttrOpt SymbolHandle)] + +_sample_poisson :: + forall args . Fullfilled "_sample_poisson(symbol)" args => + String -> + ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle +_sample_poisson name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)] + +_sample_negative_binomial :: + forall args . + Fullfilled "_sample_negative_binomial(symbol)" args => + String -> + ArgsHMap "_sample_negative_binomial(symbol)" args -> + IO SymbolHandle +_sample_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("k",) <$> (args !? #k :: Maybe SymbolHandle), + ("p",) <$> (args !? #p :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_sample_generalized_negative_binomial(symbol)" = + '[ '("shape", AttrOpt [Int]), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"])), + '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)] + +_sample_generalized_negative_binomial :: + forall args . + Fullfilled "_sample_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_sample_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_sample_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("mu",) <$> (args !? #mu :: Maybe SymbolHandle), + ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sample_unique_zipfian(symbol)" = + '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])] + +_sample_unique_zipfian :: + forall args . Fullfilled "_sample_unique_zipfian(symbol)" args => + String -> + ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle +_sample_unique_zipfian name args + = let scalarArgs + = catMaybes + [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sample_unique_zipfian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_uniform(symbol)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_uniform :: + forall args . Fullfilled "_random_uniform(symbol)" args => + String -> + ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle +_random_uniform name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_normal(symbol)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_normal :: + forall args . Fullfilled "_random_normal(symbol)" args => + String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle +_random_normal name args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_gamma(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_gamma :: + forall args . Fullfilled "_random_gamma(symbol)" args => + String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle +_random_gamma name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_exponential(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_exponential :: + forall args . Fullfilled "_random_exponential(symbol)" args => + String -> + ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle +_random_exponential name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_poisson(symbol)" = + '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_poisson :: + forall args . Fullfilled "_random_poisson(symbol)" args => + String -> + ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle +_random_poisson name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_negative_binomial(symbol)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_negative_binomial :: + forall args . + Fullfilled "_random_negative_binomial(symbol)" args => + String -> + ArgsHMap "_random_negative_binomial(symbol)" args -> + IO SymbolHandle +_random_negative_binomial name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_generalized_negative_binomial(symbol)" = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt (EnumType '["None", "float16", "float32", "float64"]))] + +_random_generalized_negative_binomial :: + forall args . + Fullfilled "_random_generalized_negative_binomial(symbol)" + args => + String -> + ArgsHMap "_random_generalized_negative_binomial(symbol)" + args + -> IO SymbolHandle +_random_generalized_negative_binomial name args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (EnumType '["None", "float16", "float32", "float64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_randint(symbol)" = + '[ '("low", AttrReq Int), '("high", AttrReq Int), + '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))] + +_random_randint :: + forall args . Fullfilled "_random_randint(symbol)" args => + String -> + ArgsHMap "_random_randint(symbol)" args -> IO SymbolHandle +_random_randint name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Int), + ("high",) . showValue <$> (args !? #high :: Maybe Int), + ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_randint" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_uniform_like(symbol)" = + '[ '("low", AttrOpt Float), '("high", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_uniform_like :: + forall args . Fullfilled "_random_uniform_like(symbol)" args => + String -> + ArgsHMap "_random_uniform_like(symbol)" args -> IO SymbolHandle +_random_uniform_like name args + = let scalarArgs + = catMaybes + [("low",) . showValue <$> (args !? #low :: Maybe Float), + ("high",) . showValue <$> (args !? #high :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_uniform_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_normal_like(symbol)" = + '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_normal_like :: + forall args . Fullfilled "_random_normal_like(symbol)" args => + String -> + ArgsHMap "_random_normal_like(symbol)" args -> IO SymbolHandle +_random_normal_like name args + = let scalarArgs + = catMaybes + [("loc",) . showValue <$> (args !? #loc :: Maybe Float), + ("scale",) . showValue <$> (args !? #scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_normal_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_gamma_like(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_gamma_like :: + forall args . Fullfilled "_random_gamma_like(symbol)" args => + String -> + ArgsHMap "_random_gamma_like(symbol)" args -> IO SymbolHandle +_random_gamma_like name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_gamma_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_exponential_like(symbol)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_random_exponential_like :: + forall args . Fullfilled "_random_exponential_like(symbol)" args => + String -> + ArgsHMap "_random_exponential_like(symbol)" args -> IO SymbolHandle +_random_exponential_like name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_exponential_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_random_poisson_like(symbol)" = + '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_random_poisson_like :: + forall args . Fullfilled "_random_poisson_like(symbol)" args => + String -> + ArgsHMap "_random_poisson_like(symbol)" args -> IO SymbolHandle +_random_poisson_like name args + = let scalarArgs + = catMaybes + [("lam",) . showValue <$> (args !? #lam :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_poisson_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_negative_binomial_like(symbol)" = + '[ '("k", AttrOpt Int), '("p", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_negative_binomial_like :: + forall args . + Fullfilled "_random_negative_binomial_like(symbol)" args => + String -> + ArgsHMap "_random_negative_binomial_like(symbol)" args -> + IO SymbolHandle +_random_negative_binomial_like name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("p",) . showValue <$> (args !? #p :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_negative_binomial_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_random_generalized_negative_binomial_like(symbol)" + = + '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_random_generalized_negative_binomial_like :: + forall args . + Fullfilled + "_random_generalized_negative_binomial_like(symbol)" + args => + String -> + ArgsHMap + "_random_generalized_negative_binomial_like(symbol)" + args + -> IO SymbolHandle +_random_generalized_negative_binomial_like name args + = let scalarArgs + = catMaybes + [("mu",) . showValue <$> (args !? #mu :: Maybe Float), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_random_generalized_negative_binomial_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_shuffle(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_shuffle :: + forall args . Fullfilled "_shuffle(symbol)" args => + String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle +_shuffle name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_shuffle" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Custom(symbol)" = + '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])] + +_Custom :: + forall args . + (Fullfilled "_Custom(symbol)" args, + PopKey (ArgOf "_Custom(symbol)") args "data", + Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) => + String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle +_Custom name args + = let scalarArgs = dump (pop args #data) + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Custom(symbol)" = '[] + +_backward_Custom :: + forall args . Fullfilled "_backward_Custom(symbol)" args => + String -> + ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle +_backward_Custom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Custom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_power :: + forall args . Fullfilled "broadcast_power(symbol)" args => + String -> + ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle +broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_power(symbol)" = + '[] + +_backward_broadcast_power :: + forall args . + Fullfilled "_backward_broadcast_power(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_power(symbol)" args -> + IO SymbolHandle +_backward_broadcast_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_maximum :: + forall args . Fullfilled "broadcast_maximum(symbol)" args => + String -> + ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle +broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_maximum(symbol)" = + '[] + +_backward_broadcast_maximum :: + forall args . + Fullfilled "_backward_broadcast_maximum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_maximum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_minimum :: + forall args . Fullfilled "broadcast_minimum(symbol)" args => + String -> + ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle +broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_minimum(symbol)" = + '[] + +_backward_broadcast_minimum :: + forall args . + Fullfilled "_backward_broadcast_minimum(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_minimum(symbol)" args -> + IO SymbolHandle +_backward_broadcast_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_hypot :: + forall args . Fullfilled "broadcast_hypot(symbol)" args => + String -> + ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle +broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_hypot(symbol)" = + '[] + +_backward_broadcast_hypot :: + forall args . + Fullfilled "_backward_broadcast_hypot(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_hypot(symbol)" args -> + IO SymbolHandle +_backward_broadcast_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_equal :: + forall args . Fullfilled "_equal(symbol)" args => + String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle +_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_not_equal :: + forall args . Fullfilled "_not_equal(symbol)" args => + String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle +_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater :: + forall args . Fullfilled "_greater(symbol)" args => + String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle +_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_greater_equal :: + forall args . Fullfilled "_greater_equal(symbol)" args => + String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle +_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser :: + forall args . Fullfilled "_lesser(symbol)" args => + String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle +_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_lesser_equal :: + forall args . Fullfilled "_lesser_equal(symbol)" args => + String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle +_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_and(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_and :: + forall args . Fullfilled "_logical_and(symbol)" args => + String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle +_logical_and name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_or(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_or :: + forall args . Fullfilled "_logical_or(symbol)" args => + String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle +_logical_or name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_xor(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_logical_xor :: + forall args . Fullfilled "_logical_xor(symbol)" args => + String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle +_logical_xor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_power :: + forall args . Fullfilled "_power(symbol)" args => + String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle +_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power(symbol)" = '[] + +_backward_power :: + forall args . Fullfilled "_backward_power(symbol)" args => + String -> + ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle +_backward_power name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_maximum :: + forall args . Fullfilled "_maximum(symbol)" args => + String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle +_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum(symbol)" = '[] + +_backward_maximum :: + forall args . Fullfilled "_backward_maximum(symbol)" args => + String -> + ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle +_backward_maximum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_minimum :: + forall args . Fullfilled "_minimum(symbol)" args => + String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle +_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum(symbol)" = '[] + +_backward_minimum :: + forall args . Fullfilled "_backward_minimum(symbol)" args => + String -> + ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle +_backward_minimum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_hypot :: + forall args . Fullfilled "_hypot(symbol)" args => + String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle +_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot(symbol)" = '[] + +_backward_hypot :: + forall args . Fullfilled "_backward_hypot(symbol)" args => + String -> + ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle +_backward_hypot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_square_sum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_square_sum :: + forall args . Fullfilled "_square_sum(symbol)" args => + String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle +_square_sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square_sum(symbol)" = '[] + +_backward_square_sum :: + forall args . Fullfilled "_backward_square_sum(symbol)" args => + String -> + ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle +_backward_square_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "add_n(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +add_n :: + forall args . Fullfilled "add_n(symbol)" args => + String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle +add_n name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "add_n" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_zeros_without_dtype(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", AttrOpt Int)] + +_zeros_without_dtype :: + forall args . Fullfilled "_zeros_without_dtype(symbol)" args => + String -> + ArgsHMap "_zeros_without_dtype(symbol)" args -> IO SymbolHandle +_zeros_without_dtype name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros_without_dtype" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_zeros(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_zeros :: + forall args . Fullfilled "_zeros(symbol)" args => + String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle +_zeros name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_zeros" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_eye(symbol)" = + '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int), + '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_eye :: + forall args . Fullfilled "_eye(symbol)" args => + String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle +_eye name args + = let scalarArgs + = catMaybes + [("_N",) . showValue <$> (args !? #_N :: Maybe Int), + ("_M",) . showValue <$> (args !? #_M :: Maybe Int), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_eye" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ones(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_ones :: + forall args . Fullfilled "_ones(symbol)" args => + String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle +_ones name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ones" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_full(symbol)" = + '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("value", AttrReq Double)] + +_full :: + forall args . Fullfilled "_full(symbol)" args => + String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle +_full name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("value",) . showValue <$> (args !? #value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_full" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_arange(symbol)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_arange :: + forall args . Fullfilled "_arange(symbol)" args => + String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle +_arange name args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_arange" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linspace(symbol)" = + '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)), + '("step", AttrOpt Double), '("repeat", AttrOpt Int), + '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + +_linspace :: + forall args . Fullfilled "_linspace(symbol)" args => + String -> ArgsHMap "_linspace(symbol)" args -> IO SymbolHandle +_linspace name args + = let scalarArgs + = catMaybes + [("start",) . showValue <$> (args !? #start :: Maybe Double), + ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)), + ("step",) . showValue <$> (args !? #step :: Maybe Double), + ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int), + ("infer_range",) . showValue <$> + (args !? #infer_range :: Maybe Bool), + ("ctx",) . showValue <$> (args !? #ctx :: Maybe String), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linspace" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "zeros_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +zeros_like :: + forall args . Fullfilled "zeros_like(symbol)" args => + String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle +zeros_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "zeros_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ones_like(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ones_like :: + forall args . Fullfilled "ones_like(symbol)" args => + String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle +ones_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ones_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_add :: + forall args . Fullfilled "broadcast_add(symbol)" args => + String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle +broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_add(symbol)" = '[] + +_backward_broadcast_add :: + forall args . Fullfilled "_backward_broadcast_add(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle +_backward_broadcast_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_sub :: + forall args . Fullfilled "broadcast_sub(symbol)" args => + String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle +broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_sub(symbol)" = '[] + +_backward_broadcast_sub :: + forall args . Fullfilled "_backward_broadcast_sub(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle +_backward_broadcast_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mul :: + forall args . Fullfilled "broadcast_mul(symbol)" args => + String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle +broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mul(symbol)" = '[] + +_backward_broadcast_mul :: + forall args . Fullfilled "_backward_broadcast_mul(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle +_backward_broadcast_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_div :: + forall args . Fullfilled "broadcast_div(symbol)" args => + String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle +broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_div(symbol)" = '[] + +_backward_broadcast_div :: + forall args . Fullfilled "_backward_broadcast_div(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle +_backward_broadcast_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_mod :: + forall args . Fullfilled "broadcast_mod(symbol)" args => + String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle +broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_broadcast_mod(symbol)" = '[] + +_backward_broadcast_mod :: + forall args . Fullfilled "_backward_broadcast_mod(symbol)" args => + String -> + ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle +_backward_broadcast_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_broadcast_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("beta", AttrOpt Double), + '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle), + '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)] + +_linalg_gemm :: + forall args . Fullfilled "_linalg_gemm(symbol)" args => + String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle +_linalg_gemm name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("beta",) . showValue <$> (args !? #beta :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle), + ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm(symbol)" = '[] + +_backward_linalg_gemm :: + forall args . Fullfilled "_backward_linalg_gemm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gemm2(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("alpha", AttrOpt Double), '("axis", AttrOpt Int), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_gemm2 :: + forall args . Fullfilled "_linalg_gemm2(symbol)" args => + String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle +_linalg_gemm2 name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[] + +_backward_linalg_gemm2 :: + forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle +_backward_linalg_gemm2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gemm2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potrf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potrf :: + forall args . Fullfilled "_linalg_potrf(symbol)" args => + String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle +_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potrf(symbol)" = '[] + +_backward_linalg_potrf :: + forall args . Fullfilled "_backward_linalg_potrf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle +_backward_linalg_potrf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potrf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_potri(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_potri :: + forall args . Fullfilled "_linalg_potri(symbol)" args => + String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle +_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_potri(symbol)" = '[] + +_backward_linalg_potri :: + forall args . Fullfilled "_backward_linalg_potri(symbol)" args => + String -> + ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle +_backward_linalg_potri name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_potri" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trmm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_trmm :: + forall args . Fullfilled "_linalg_trmm(symbol)" args => + String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle +_linalg_trmm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trmm(symbol)" = '[] + +_backward_linalg_trmm :: + forall args . Fullfilled "_backward_linalg_trmm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle +_backward_linalg_trmm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trmm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_trsm(symbol)" = + '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool), + '("lower", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)] + +_linalg_trsm :: + forall args . Fullfilled "_linalg_trsm(symbol)" args => + String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle +_linalg_trsm name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("_A",) <$> (args !? #_A :: Maybe SymbolHandle), + ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_trsm(symbol)" = '[] + +_backward_linalg_trsm :: + forall args . Fullfilled "_backward_linalg_trsm(symbol)" args => + String -> + ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle +_backward_linalg_trsm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_trsm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_sumlogdiag(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_sumlogdiag :: + forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle +_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" = + '[] + +_backward_linalg_sumlogdiag :: + forall args . + Fullfilled "_backward_linalg_sumlogdiag(symbol)" args => + String -> + ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args -> + IO SymbolHandle +_backward_linalg_sumlogdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_sumlogdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_extractdiag(symbol)" = + '[ '("offset", AttrOpt Int), '("_A", AttrOpt SymbolHandle)] + +_linalg_extractdiag :: + forall args . Fullfilled "_linalg_extractdiag(symbol)" args => + String -> + ArgsHMap "_linalg_extractdiag(symbol)" args -> IO SymbolHandle +_linalg_extractdiag name args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_extractdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_extractdiag(symbol)" + = '[] + +_backward_linalg_extractdiag :: + forall args . + Fullfilled "_backward_linalg_extractdiag(symbol)" args => + String -> + ArgsHMap "_backward_linalg_extractdiag(symbol)" args -> + IO SymbolHandle +_backward_linalg_extractdiag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_extractdiag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_makediag(symbol)" = + '[ '("offset", AttrOpt Int), '("_A", AttrOpt SymbolHandle)] + +_linalg_makediag :: + forall args . Fullfilled "_linalg_makediag(symbol)" args => + String -> + ArgsHMap "_linalg_makediag(symbol)" args -> IO SymbolHandle +_linalg_makediag name args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_makediag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_makediag(symbol)" = + '[] + +_backward_linalg_makediag :: + forall args . + Fullfilled "_backward_linalg_makediag(symbol)" args => + String -> + ArgsHMap "_backward_linalg_makediag(symbol)" args -> + IO SymbolHandle +_backward_linalg_makediag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_makediag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_extracttrian(symbol)" = + '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool), + '("_A", AttrOpt SymbolHandle)] + +_linalg_extracttrian :: + forall args . Fullfilled "_linalg_extracttrian(symbol)" args => + String -> + ArgsHMap "_linalg_extracttrian(symbol)" args -> IO SymbolHandle +_linalg_extracttrian name args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_extracttrian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_extracttrian(symbol)" + = '[] + +_backward_linalg_extracttrian :: + forall args . + Fullfilled "_backward_linalg_extracttrian(symbol)" args => + String -> + ArgsHMap "_backward_linalg_extracttrian(symbol)" args -> + IO SymbolHandle +_backward_linalg_extracttrian name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_extracttrian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_maketrian(symbol)" = + '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool), + '("_A", AttrOpt SymbolHandle)] + +_linalg_maketrian :: + forall args . Fullfilled "_linalg_maketrian(symbol)" args => + String -> + ArgsHMap "_linalg_maketrian(symbol)" args -> IO SymbolHandle +_linalg_maketrian name args + = let scalarArgs + = catMaybes + [("offset",) . showValue <$> (args !? #offset :: Maybe Int), + ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_maketrian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_maketrian(symbol)" = + '[] + +_backward_linalg_maketrian :: + forall args . + Fullfilled "_backward_linalg_maketrian(symbol)" args => + String -> + ArgsHMap "_backward_linalg_maketrian(symbol)" args -> + IO SymbolHandle +_backward_linalg_maketrian name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_maketrian" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syrk(symbol)" = + '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double), + '("_A", AttrOpt SymbolHandle)] + +_linalg_syrk :: + forall args . Fullfilled "_linalg_syrk(symbol)" args => + String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle +_linalg_syrk name args + = let scalarArgs + = catMaybes + [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool), + ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syrk(symbol)" = '[] + +_backward_linalg_syrk :: + forall args . Fullfilled "_backward_linalg_syrk(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle +_backward_linalg_syrk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syrk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_gelqf(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_gelqf :: + forall args . Fullfilled "_linalg_gelqf(symbol)" args => + String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle +_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[] + +_backward_linalg_gelqf :: + forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args => + String -> + ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle +_backward_linalg_gelqf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_gelqf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_syevd(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_syevd :: + forall args . Fullfilled "_linalg_syevd(symbol)" args => + String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle +_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_syevd(symbol)" = '[] + +_backward_linalg_syevd :: + forall args . Fullfilled "_backward_linalg_syevd(symbol)" args => + String -> + ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle +_backward_linalg_syevd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_syevd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_linalg_inverse(symbol)" = + '[ '("_A", AttrOpt SymbolHandle)] + +_linalg_inverse :: + forall args . Fullfilled "_linalg_inverse(symbol)" args => + String -> + ArgsHMap "_linalg_inverse(symbol)" args -> IO SymbolHandle +_linalg_inverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_linalg_inverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linalg_inverse(symbol)" = + '[] + +_backward_linalg_inverse :: + forall args . Fullfilled "_backward_linalg_inverse(symbol)" args => + String -> + ArgsHMap "_backward_linalg_inverse(symbol)" args -> IO SymbolHandle +_backward_linalg_inverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linalg_inverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_histogram(symbol)" = + '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)] + +_histogram :: + forall args . Fullfilled "_histogram(symbol)" args => + String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle +_histogram name args + = let scalarArgs + = catMaybes + [("bin_cnt",) . showValue <$> + (args !? #bin_cnt :: Maybe (Maybe Int)), + ("range",) . showValue <$> (args !? #range :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_histogram" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cast_storage(symbol)" = + '[ '("stype", + AttrReq (EnumType '["csr", "default", "row_sparse"])), + '("data", AttrOpt SymbolHandle)] + +cast_storage :: + forall args . Fullfilled "cast_storage(symbol)" args => + String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle +cast_storage name args + = let scalarArgs + = catMaybes + [("stype",) . showValue <$> + (args !? #stype :: + Maybe (EnumType '["csr", "default", "row_sparse"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cast_storage" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_equal_scalar :: + forall args . Fullfilled "_equal_scalar(symbol)" args => + String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle +_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_not_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_not_equal_scalar :: + forall args . Fullfilled "_not_equal_scalar(symbol)" args => + String -> + ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle +_not_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_not_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_scalar :: + forall args . Fullfilled "_greater_scalar(symbol)" args => + String -> + ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle +_greater_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_greater_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_greater_equal_scalar :: + forall args . Fullfilled "_greater_equal_scalar(symbol)" args => + String -> + ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle +_greater_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_greater_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_scalar :: + forall args . Fullfilled "_lesser_scalar(symbol)" args => + String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle +_lesser_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_lesser_equal_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_lesser_equal_scalar :: + forall args . Fullfilled "_lesser_equal_scalar(symbol)" args => + String -> + ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle +_lesser_equal_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_lesser_equal_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_and_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_and_scalar :: + forall args . Fullfilled "_logical_and_scalar(symbol)" args => + String -> + ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle +_logical_and_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_and_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_or_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_or_scalar :: + forall args . Fullfilled "_logical_or_scalar(symbol)" args => + String -> + ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle +_logical_or_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_or_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_logical_xor_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_logical_xor_scalar :: + forall args . Fullfilled "_logical_xor_scalar(symbol)" args => + String -> + ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle +_logical_xor_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_logical_xor_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "relu(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +relu :: + forall args . Fullfilled "relu(symbol)" args => + String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle +relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_relu(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_relu :: + forall args . Fullfilled "_backward_relu(symbol)" args => + String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle +_backward_relu name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_relu" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sigmoid(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sigmoid :: + forall args . Fullfilled "sigmoid(symbol)" args => + String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle +sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sigmoid(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sigmoid :: + forall args . Fullfilled "_backward_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle +_backward_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "hard_sigmoid(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +hard_sigmoid :: + forall args . Fullfilled "hard_sigmoid(symbol)" args => + String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle +hard_sigmoid name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "hard_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[] + +_backward_hard_sigmoid :: + forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args => + String -> + ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle +_backward_hard_sigmoid name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hard_sigmoid" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softsign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +softsign :: + forall args . Fullfilled "softsign(symbol)" args => + String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle +softsign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softsign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softsign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_softsign :: + forall args . Fullfilled "_backward_softsign(symbol)" args => + String -> + ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle +_backward_softsign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softsign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_copy(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_copy :: + forall args . Fullfilled "_copy(symbol)" args => + String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle +_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_copy(symbol)" = '[] + +_backward_copy :: + forall args . Fullfilled "_backward_copy(symbol)" args => + String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle +_backward_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reshape(symbol)" = '[] + +_backward_reshape :: + forall args . Fullfilled "_backward_reshape(symbol)" args => + String -> + ArgsHMap "_backward_reshape(symbol)" args -> IO SymbolHandle +_backward_reshape name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reshape" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BlockGrad(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_BlockGrad :: + forall args . Fullfilled "_BlockGrad(symbol)" args => + String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle +_BlockGrad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BlockGrad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "make_loss(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +make_loss :: + forall args . Fullfilled "make_loss(symbol)" args => + String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle +make_loss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "make_loss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_identity_with_attr_like_rhs(symbol)" + = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_identity_with_attr_like_rhs :: + forall args . + Fullfilled "_identity_with_attr_like_rhs(symbol)" args => + String -> + ArgsHMap "_identity_with_attr_like_rhs(symbol)" args -> + IO SymbolHandle +_identity_with_attr_like_rhs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_identity_with_attr_like_rhs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reshape_like(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +reshape_like :: + forall args . Fullfilled "reshape_like(symbol)" args => + String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle +reshape_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reshape_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "shape_array(symbol)" = + '[ '("lhs_begin", AttrOpt (Maybe Int)), + '("lhs_end", AttrOpt (Maybe Int)), + '("rhs_begin", AttrOpt (Maybe Int)), + '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +shape_array :: + forall args . Fullfilled "shape_array(symbol)" args => + String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle +shape_array name args + = let scalarArgs + = catMaybes + [("lhs_begin",) . showValue <$> + (args !? #lhs_begin :: Maybe (Maybe Int)), + ("lhs_end",) . showValue <$> + (args !? #lhs_end :: Maybe (Maybe Int)), + ("rhs_begin",) . showValue <$> + (args !? #rhs_begin :: Maybe (Maybe Int)), + ("rhs_end",) . showValue <$> + (args !? #rhs_end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "shape_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "size_array(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +size_array :: + forall args . Fullfilled "size_array(symbol)" args => + String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle +size_array name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "size_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Cast(symbol)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt SymbolHandle)] + +_Cast :: + forall args . Fullfilled "_Cast(symbol)" args => + String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle +_Cast name args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cast(symbol)" = '[] + +_backward_cast :: + forall args . Fullfilled "_backward_cast(symbol)" args => + String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle +_backward_cast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "negative(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +negative :: + forall args . Fullfilled "negative(symbol)" args => + String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle +negative name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "negative" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reciprocal(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +reciprocal :: + forall args . Fullfilled "reciprocal(symbol)" args => + String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle +reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reciprocal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_reciprocal :: + forall args . Fullfilled "_backward_reciprocal(symbol)" args => + String -> + ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle +_backward_reciprocal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reciprocal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "abs(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +abs :: + forall args . Fullfilled "abs(symbol)" args => + String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle +abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_abs(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_abs :: + forall args . Fullfilled "_backward_abs(symbol)" args => + String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle +_backward_abs name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_abs" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sign(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sign :: + forall args . Fullfilled "sign(symbol)" args => + String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle +sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sign(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sign :: + forall args . Fullfilled "_backward_sign(symbol)" args => + String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle +_backward_sign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "round(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +round :: + forall args . Fullfilled "round(symbol)" args => + String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle +round name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "round" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rint(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rint :: + forall args . Fullfilled "rint(symbol)" args => + String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle +rint name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rint" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ceil(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +ceil :: + forall args . Fullfilled "ceil(symbol)" args => + String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle +ceil name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ceil" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "floor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +floor :: + forall args . Fullfilled "floor(symbol)" args => + String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle +floor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "floor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "trunc(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +trunc :: + forall args . Fullfilled "trunc(symbol)" args => + String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle +trunc name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "trunc" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "fix(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +fix :: + forall args . Fullfilled "fix(symbol)" args => + String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle +fix name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "fix" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "square(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +square :: + forall args . Fullfilled "square(symbol)" args => + String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle +square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_square(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_square :: + forall args . Fullfilled "_backward_square(symbol)" args => + String -> + ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle +_backward_square name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_square" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sqrt :: + forall args . Fullfilled "sqrt(symbol)" args => + String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle +sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sqrt :: + forall args . Fullfilled "_backward_sqrt(symbol)" args => + String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle +_backward_sqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rsqrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rsqrt :: + forall args . Fullfilled "rsqrt(symbol)" args => + String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle +rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rsqrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rsqrt :: + forall args . Fullfilled "_backward_rsqrt(symbol)" args => + String -> + ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle +_backward_rsqrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rsqrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cbrt :: + forall args . Fullfilled "cbrt(symbol)" args => + String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle +cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cbrt :: + forall args . Fullfilled "_backward_cbrt(symbol)" args => + String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle +_backward_cbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "erf(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +erf :: + forall args . Fullfilled "erf(symbol)" args => + String -> ArgsHMap "erf(symbol)" args -> IO SymbolHandle +erf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_erf(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_erf :: + forall args . Fullfilled "_backward_erf(symbol)" args => + String -> ArgsHMap "_backward_erf(symbol)" args -> IO SymbolHandle +_backward_erf name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erf" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "erfinv(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +erfinv :: + forall args . Fullfilled "erfinv(symbol)" args => + String -> ArgsHMap "erfinv(symbol)" args -> IO SymbolHandle +erfinv name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "erfinv" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_erfinv(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_erfinv :: + forall args . Fullfilled "_backward_erfinv(symbol)" args => + String -> + ArgsHMap "_backward_erfinv(symbol)" args -> IO SymbolHandle +_backward_erfinv name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_erfinv" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rcbrt(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +rcbrt :: + forall args . Fullfilled "rcbrt(symbol)" args => + String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle +rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rcbrt(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_rcbrt :: + forall args . Fullfilled "_backward_rcbrt(symbol)" args => + String -> + ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle +_backward_rcbrt name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rcbrt" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "exp(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +exp :: + forall args . Fullfilled "exp(symbol)" args => + String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle +exp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "exp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log :: + forall args . Fullfilled "log(symbol)" args => + String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle +log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log10(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log10 :: + forall args . Fullfilled "log10(symbol)" args => + String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle +log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log2(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log2 :: + forall args . Fullfilled "log2(symbol)" args => + String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle +log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log :: + forall args . Fullfilled "_backward_log(symbol)" args => + String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle +_backward_log name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log10(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log10 :: + forall args . Fullfilled "_backward_log10(symbol)" args => + String -> + ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle +_backward_log10 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log10" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log2(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log2 :: + forall args . Fullfilled "_backward_log2(symbol)" args => + String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle +_backward_log2 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "log1p(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +log1p :: + forall args . Fullfilled "log1p(symbol)" args => + String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle +log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log1p(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_log1p :: + forall args . Fullfilled "_backward_log1p(symbol)" args => + String -> + ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle +_backward_log1p name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_log1p" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expm1(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +expm1 :: + forall args . Fullfilled "expm1(symbol)" args => + String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle +expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_expm1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_expm1 :: + forall args . Fullfilled "_backward_expm1(symbol)" args => + String -> + ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle +_backward_expm1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_expm1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gamma(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gamma :: + forall args . Fullfilled "gamma(symbol)" args => + String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle +gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gamma(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gamma :: + forall args . Fullfilled "_backward_gamma(symbol)" args => + String -> + ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle +_backward_gamma name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gamma" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gammaln(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +gammaln :: + forall args . Fullfilled "gammaln(symbol)" args => + String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle +gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gammaln(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_gammaln :: + forall args . Fullfilled "_backward_gammaln(symbol)" args => + String -> + ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle +_backward_gammaln name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gammaln" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "logical_not(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +logical_not :: + forall args . Fullfilled "logical_not(symbol)" args => + String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle +logical_not name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "logical_not" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "amp_cast(symbol)" = + '[ '("dtype", + AttrReq + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("data", AttrOpt SymbolHandle)] + +amp_cast :: + forall args . Fullfilled "amp_cast(symbol)" args => + String -> ArgsHMap "amp_cast(symbol)" args -> IO SymbolHandle +amp_cast name args + = let scalarArgs + = catMaybes + [("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "amp_cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_amp_cast(symbol)" = '[] + +_backward_amp_cast :: + forall args . Fullfilled "_backward_amp_cast(symbol)" args => + String -> + ArgsHMap "_backward_amp_cast(symbol)" args -> IO SymbolHandle +_backward_amp_cast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_amp_cast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "amp_multicast(symbol)" = + '[ '("num_outputs", AttrReq Int), + '("data", AttrOpt [SymbolHandle])] + +amp_multicast :: + forall args . Fullfilled "amp_multicast(symbol)" args => + String -> ArgsHMap "amp_multicast(symbol)" args -> IO SymbolHandle +amp_multicast name args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "amp_multicast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_amp_multicast(symbol)" = + '[ '("num_outputs", AttrReq Int), + '("grad", AttrOpt [SymbolHandle])] + +_backward_amp_multicast :: + forall args . Fullfilled "_backward_amp_multicast(symbol)" args => + String -> + ArgsHMap "_backward_amp_multicast(symbol)" args -> IO SymbolHandle +_backward_amp_multicast name args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #grad :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_backward_amp_multicast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "elemwise_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_add :: + forall args . Fullfilled "elemwise_add(symbol)" args => + String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle +elemwise_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_grad_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_grad_add :: + forall args . Fullfilled "_grad_add(symbol)" args => + String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle +_grad_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_grad_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_add(symbol)" = '[] + +_backward_add :: + forall args . Fullfilled "_backward_add(symbol)" args => + String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle +_backward_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_sub(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_sub :: + forall args . Fullfilled "elemwise_sub(symbol)" args => + String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle +elemwise_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sub(symbol)" = '[] + +_backward_sub :: + forall args . Fullfilled "_backward_sub(symbol)" args => + String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle +_backward_sub name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sub" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_mul(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_mul :: + forall args . Fullfilled "elemwise_mul(symbol)" args => + String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle +elemwise_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul(symbol)" = '[] + +_backward_mul :: + forall args . Fullfilled "_backward_mul(symbol)" args => + String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle +_backward_mul name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +elemwise_div :: + forall args . Fullfilled "elemwise_div(symbol)" args => + String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle +elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div(symbol)" = '[] + +_backward_div :: + forall args . Fullfilled "_backward_div(symbol)" args => + String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle +_backward_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_mod :: + forall args . Fullfilled "_mod(symbol)" args => + String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle +_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod(symbol)" = '[] + +_backward_mod :: + forall args . Fullfilled "_backward_mod(symbol)" args => + String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle +_backward_mod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_elemwise_div(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_scatter_elemwise_div :: + forall args . Fullfilled "_scatter_elemwise_div(symbol)" args => + String -> + ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle +_scatter_elemwise_div name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_elemwise_div" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_plus_scalar :: + forall args . Fullfilled "_scatter_plus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle +_scatter_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_scatter_minus_scalar :: + forall args . Fullfilled "_scatter_minus_scalar(symbol)" args => + String -> + ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle +_scatter_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Embedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle)] + +_Embedding :: + forall args . Fullfilled "_Embedding(symbol)" args => + String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle +_Embedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SparseEmbedding(symbol)" = + '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle)] + +_contrib_SparseEmbedding :: + forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle +_contrib_SparseEmbedding name args + = let scalarArgs + = catMaybes + [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + ("sparse_grad",) . showValue <$> + (args !? #sparse_grad :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Embedding(symbol)" = '[] + +_backward_Embedding :: + forall args . Fullfilled "_backward_Embedding(symbol)" args => + String -> + ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle +_backward_Embedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Embedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SparseEmbedding(symbol)" = + '[] + +_backward_SparseEmbedding :: + forall args . + Fullfilled "_backward_SparseEmbedding(symbol)" args => + String -> + ArgsHMap "_backward_SparseEmbedding(symbol)" args -> + IO SymbolHandle +_backward_SparseEmbedding name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SparseEmbedding" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "take(symbol)" = + '[ '("axis", AttrOpt Int), + '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])), + '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +take :: + forall args . Fullfilled "take(symbol)" args => + String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle +take name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_take(symbol)" = '[] + +_backward_take :: + forall args . Fullfilled "_backward_take(symbol)" args => + String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle +_backward_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_take(symbol)" = + '[ '("a", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +batch_take :: + forall args . Fullfilled "batch_take(symbol)" args => + String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle +batch_take name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("a",) <$> (args !? #a :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_take" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "one_hot(symbol)" = + '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double), + '("off_value", AttrOpt Double), + '("dtype", + AttrOpt + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"])), + '("indices", AttrOpt SymbolHandle)] + +one_hot :: + forall args . Fullfilled "one_hot(symbol)" args => + String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle +one_hot name args + = let scalarArgs + = catMaybes + [("depth",) . showValue <$> (args !? #depth :: Maybe Int), + ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double), + ("off_value",) . showValue <$> + (args !? #off_value :: Maybe Double), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8", + "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "one_hot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "gather_nd(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +gather_nd :: + forall args . Fullfilled "gather_nd(symbol)" args => + String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle +gather_nd name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "scatter_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +scatter_nd :: + forall args . Fullfilled "scatter_nd(symbol)" args => + String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle +scatter_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "scatter_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_gather_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_backward_gather_nd :: + forall args . Fullfilled "_backward_gather_nd(symbol)" args => + String -> + ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle +_backward_gather_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_gather_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_scatter_set_nd(symbol)" = + '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)] + +_scatter_set_nd :: + forall args . Fullfilled "_scatter_set_nd(symbol)" args => + String -> + ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle +_scatter_set_nd name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_scatter_set_nd" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_equal :: + forall args . Fullfilled "broadcast_equal(symbol)" args => + String -> + ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle +broadcast_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_not_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_not_equal :: + forall args . Fullfilled "broadcast_not_equal(symbol)" args => + String -> + ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle +broadcast_not_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_not_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater :: + forall args . Fullfilled "broadcast_greater(symbol)" args => + String -> + ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle +broadcast_greater name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_greater_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_greater_equal :: + forall args . Fullfilled "broadcast_greater_equal(symbol)" args => + String -> + ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle +broadcast_greater_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_greater_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser :: + forall args . Fullfilled "broadcast_lesser(symbol)" args => + String -> + ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle +broadcast_lesser name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_lesser_equal(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_lesser_equal :: + forall args . Fullfilled "broadcast_lesser_equal(symbol)" args => + String -> + ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle +broadcast_lesser_equal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_lesser_equal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_and(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_and :: + forall args . Fullfilled "broadcast_logical_and(symbol)" args => + String -> + ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle +broadcast_logical_and name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_and" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_or(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_or :: + forall args . Fullfilled "broadcast_logical_or(symbol)" args => + String -> + ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle +broadcast_logical_or name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_or" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_logical_xor(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_logical_xor :: + forall args . Fullfilled "broadcast_logical_xor(symbol)" args => + String -> + ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle +broadcast_logical_xor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_logical_xor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_plus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_plus_scalar :: + forall args . Fullfilled "_plus_scalar(symbol)" args => + String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle +_plus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_plus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minus_scalar :: + forall args . Fullfilled "_minus_scalar(symbol)" args => + String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle +_minus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rminus_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rminus_scalar :: + forall args . Fullfilled "_rminus_scalar(symbol)" args => + String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle +_rminus_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rminus_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mul_scalar :: + forall args . Fullfilled "_mul_scalar(symbol)" args => + String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle +_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mul_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_mul_scalar :: + forall args . Fullfilled "_backward_mul_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle +_backward_mul_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mul_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_div_scalar :: + forall args . Fullfilled "_div_scalar(symbol)" args => + String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle +_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_div_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_backward_div_scalar :: + forall args . Fullfilled "_backward_div_scalar(symbol)" args => + String -> + ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle +_backward_div_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_div_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rdiv_scalar :: + forall args . Fullfilled "_rdiv_scalar(symbol)" args => + String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle +_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rdiv_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rdiv_scalar :: + forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle +_backward_rdiv_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rdiv_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_mod_scalar :: + forall args . Fullfilled "_mod_scalar(symbol)" args => + String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle +_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_mod_scalar :: + forall args . Fullfilled "_backward_mod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle +_backward_mod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rmod_scalar :: + forall args . Fullfilled "_rmod_scalar(symbol)" args => + String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle +_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rmod_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rmod_scalar :: + forall args . Fullfilled "_backward_rmod_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle +_backward_rmod_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rmod_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ravel_multi_index(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_ravel_multi_index :: + forall args . Fullfilled "_ravel_multi_index(symbol)" args => + String -> + ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle +_ravel_multi_index name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_ravel_multi_index" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_unravel_index(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_unravel_index :: + forall args . Fullfilled "_unravel_index(symbol)" args => + String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle +_unravel_index name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_unravel_index" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +sum :: + forall args . Fullfilled "sum(symbol)" args => + String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle +sum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sum(symbol)" = '[] + +_backward_sum :: + forall args . Fullfilled "_backward_sum(symbol)" args => + String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle +_backward_sum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mean(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +mean :: + forall args . Fullfilled "mean(symbol)" args => + String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle +mean name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mean(symbol)" = '[] + +_backward_mean :: + forall args . Fullfilled "_backward_mean(symbol)" args => + String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle +_backward_mean name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mean" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "prod(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +prod :: + forall args . Fullfilled "prod(symbol)" args => + String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle +prod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_prod(symbol)" = '[] + +_backward_prod :: + forall args . Fullfilled "_backward_prod(symbol)" args => + String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle +_backward_prod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_prod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nansum(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nansum :: + forall args . Fullfilled "nansum(symbol)" args => + String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle +nansum name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nansum(symbol)" = '[] + +_backward_nansum :: + forall args . Fullfilled "_backward_nansum(symbol)" args => + String -> + ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle +_backward_nansum name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nansum" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nanprod(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +nanprod :: + forall args . Fullfilled "nanprod(symbol)" args => + String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle +nanprod name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_nanprod(symbol)" = '[] + +_backward_nanprod :: + forall args . Fullfilled "_backward_nanprod(symbol)" args => + String -> + ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle +_backward_nanprod name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_nanprod" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "max(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +max :: + forall args . Fullfilled "max(symbol)" args => + String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle +max name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_max(symbol)" = '[] + +_backward_max :: + forall args . Fullfilled "_backward_max(symbol)" args => + String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle +_backward_max name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_max" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "min(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +min :: + forall args . Fullfilled "min(symbol)" args => + String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle +min name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_min(symbol)" = '[] + +_backward_min :: + forall args . Fullfilled "_backward_min(symbol)" args => + String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle +_backward_min name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_min" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_axis(symbol)" = + '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +broadcast_axis :: + forall args . Fullfilled "broadcast_axis(symbol)" args => + String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle +broadcast_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]), + ("size",) . showValue <$> (args !? #size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_to(symbol)" = + '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +broadcast_to :: + forall args . Fullfilled "broadcast_to(symbol)" args => + String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle +broadcast_to name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_to" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_broadcast_backward(symbol)" = '[] + +_broadcast_backward :: + forall args . Fullfilled "_broadcast_backward(symbol)" args => + String -> + ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle +_broadcast_backward name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_broadcast_backward" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "broadcast_like(symbol)" = + '[ '("lhs_axes", AttrOpt (Maybe [Int])), + '("rhs_axes", AttrOpt (Maybe [Int])), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +broadcast_like :: + forall args . Fullfilled "broadcast_like(symbol)" args => + String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle +broadcast_like name args + = let scalarArgs + = catMaybes + [("lhs_axes",) . showValue <$> + (args !? #lhs_axes :: Maybe (Maybe [Int])), + ("rhs_axes",) . showValue <$> + (args !? #rhs_axes :: Maybe (Maybe [Int]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "broadcast_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "norm(symbol)" = + '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])), + '("out_dtype", + AttrOpt + (Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8"]))), + '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +norm :: + forall args . Fullfilled "norm(symbol)" args => + String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle +norm name args + = let scalarArgs + = catMaybes + [("ord",) . showValue <$> (args !? #ord :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])), + ("out_dtype",) . showValue <$> + (args !? #out_dtype :: + Maybe + (Maybe + (EnumType + '["float16", "float32", "float64", "int32", "int64", "int8"]))), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_norm(symbol)" = '[] + +_backward_norm :: + forall args . Fullfilled "_backward_norm(symbol)" args => + String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle +_backward_norm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_norm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmax :: + forall args . Fullfilled "argmax(symbol)" args => + String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle +argmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmin(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +argmin :: + forall args . Fullfilled "argmin(symbol)" args => + String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle +argmin name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argmax_channel(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +argmax_channel :: + forall args . Fullfilled "argmax_channel(symbol)" args => + String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle +argmax_channel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argmax_channel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "pick(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool), + '("mode", AttrOpt (EnumType '["clip", "wrap"])), + '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)] + +pick :: + forall args . Fullfilled "pick(symbol)" args => + String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle +pick name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("index",) <$> (args !? #index :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_pick(symbol)" = '[] + +_backward_pick :: + forall args . Fullfilled "_backward_pick(symbol)" args => + String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle +_backward_pick name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_pick" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_retain(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("indices", AttrOpt SymbolHandle)] + +_sparse_retain :: + forall args . Fullfilled "_sparse_retain(symbol)" args => + String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle +_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sparse_retain(symbol)" = '[] + +_backward_sparse_retain :: + forall args . Fullfilled "_backward_sparse_retain(symbol)" args => + String -> + ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle +_backward_sparse_retain name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sparse_retain" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_where(symbol)" = + '[ '("condition", AttrOpt SymbolHandle), + '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)] + +_where :: + forall args . Fullfilled "_where(symbol)" args => + String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle +_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("condition",) <$> (args !? #condition :: Maybe SymbolHandle), + ("x",) <$> (args !? #x :: Maybe SymbolHandle), + ("y",) <$> (args !? #y :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_where(symbol)" = '[] + +_backward_where :: + forall args . Fullfilled "_backward_where(symbol)" args => + String -> + ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle +_backward_where name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_where" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "diag(symbol)" = + '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int), + '("axis2", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +diag :: + forall args . Fullfilled "diag(symbol)" args => + String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle +diag name args + = let scalarArgs + = catMaybes + [("k",) . showValue <$> (args !? #k :: Maybe Int), + ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int), + ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "diag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_diag(symbol)" = '[] + +_backward_diag :: + forall args . Fullfilled "_backward_diag(symbol)" args => + String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle +_backward_diag name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_diag" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_maximum_scalar :: + forall args . Fullfilled "_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle +_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_maximum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_maximum_scalar :: + forall args . Fullfilled "_backward_maximum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle +_backward_maximum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_maximum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_minimum_scalar :: + forall args . Fullfilled "_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle +_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_minimum_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_minimum_scalar :: + forall args . Fullfilled "_backward_minimum_scalar(symbol)" args => + String -> + ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle +_backward_minimum_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_minimum_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_power_scalar :: + forall args . Fullfilled "_power_scalar(symbol)" args => + String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle +_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_power_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_power_scalar :: + forall args . Fullfilled "_backward_power_scalar(symbol)" args => + String -> + ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle +_backward_power_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_power_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_rpower_scalar :: + forall args . Fullfilled "_rpower_scalar(symbol)" args => + String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle +_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_rpower_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_rpower_scalar :: + forall args . Fullfilled "_backward_rpower_scalar(symbol)" args => + String -> + ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle +_backward_rpower_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_rpower_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_hypot_scalar :: + forall args . Fullfilled "_hypot_scalar(symbol)" args => + String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle +_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_hypot_scalar(symbol)" = + '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_backward_hypot_scalar :: + forall args . Fullfilled "_backward_hypot_scalar(symbol)" args => + String -> + ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle +_backward_hypot_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_hypot_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "smooth_l1(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +smooth_l1 :: + forall args . Fullfilled "smooth_l1(symbol)" args => + String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle +smooth_l1 name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_smooth_l1(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_smooth_l1 :: + forall args . Fullfilled "_backward_smooth_l1(symbol)" args => + String -> + ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle +_backward_smooth_l1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_smooth_l1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "topk(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int), + '("ret_typ", + AttrOpt (EnumType '["both", "indices", "mask", "value"])), + '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +topk :: + forall args . Fullfilled "topk(symbol)" args => + String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle +topk name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("k",) . showValue <$> (args !? #k :: Maybe Int), + ("ret_typ",) . showValue <$> + (args !? #ret_typ :: + Maybe (EnumType '["both", "indices", "mask", "value"])), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_topk(symbol)" = '[] + +_backward_topk :: + forall args . Fullfilled "_backward_topk(symbol)" args => + String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle +_backward_topk name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_topk" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +sort :: + forall args . Fullfilled "sort(symbol)" args => + String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle +sort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "argsort(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool), + '("dtype", + AttrOpt + (EnumType '["float16", "float32", "float64", "int32", "uint8"])), + '("data", AttrOpt SymbolHandle)] + +argsort :: + forall args . Fullfilled "argsort(symbol)" args => + String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle +argsort name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)), + ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe + (EnumType '["float16", "float32", "float64", "int32", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "argsort" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Reshape(symbol)" = + '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool), + '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +_Reshape :: + forall args . Fullfilled "_Reshape(symbol)" args => + String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle +_Reshape name args + = let scalarArgs + = catMaybes + [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]), + ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("keep_highest",) . showValue <$> + (args !? #keep_highest :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Reshape" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_Flatten :: + forall args . Fullfilled "_Flatten(symbol)" args => + String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle +_Flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "transpose(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +transpose :: + forall args . Fullfilled "transpose(symbol)" args => + String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle +transpose name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "transpose" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "expand_dims(symbol)" = + '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +expand_dims :: + forall args . Fullfilled "expand_dims(symbol)" args => + String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle +expand_dims name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "expand_dims" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +slice :: + forall args . Fullfilled "slice(symbol)" args => + String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle +slice name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice(symbol)" = '[] + +_backward_slice :: + forall args . Fullfilled "_backward_slice(symbol)" args => + String -> + ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle +_backward_slice name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign(symbol)" = + '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]), + '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle), + '("rhs", AttrOpt SymbolHandle)] + +_slice_assign :: + forall args . Fullfilled "_slice_assign(symbol)" args => + String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle +_slice_assign name args + = let scalarArgs + = catMaybes + [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_slice_assign_scalar(symbol)" = + '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]), + '("end", AttrReq [Int]), '("step", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_slice_assign_scalar :: + forall args . Fullfilled "_slice_assign_scalar(symbol)" args => + String -> + ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle +_slice_assign_scalar name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double), + ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]), + ("end",) . showValue <$> (args !? #end :: Maybe [Int]), + ("step",) . showValue <$> (args !? #step :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_slice_assign_scalar" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_axis(symbol)" = + '[ '("axis", AttrReq Int), '("begin", AttrReq Int), + '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +slice_axis :: + forall args . Fullfilled "slice_axis(symbol)" args => + String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle +slice_axis name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("begin",) . showValue <$> (args !? #begin :: Maybe Int), + ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_axis(symbol)" = '[] + +_backward_slice_axis :: + forall args . Fullfilled "_backward_slice_axis(symbol)" args => + String -> + ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle +_backward_slice_axis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_axis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "slice_like(symbol)" = + '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle), + '("shape_like", AttrOpt SymbolHandle)] + +slice_like :: + forall args . Fullfilled "slice_like(symbol)" args => + String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle +slice_like name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "slice_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_slice_like(symbol)" = '[] + +_backward_slice_like :: + forall args . Fullfilled "_backward_slice_like(symbol)" args => + String -> + ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle +_backward_slice_like name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_slice_like" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "clip(symbol)" = + '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +clip :: + forall args . Fullfilled "clip(symbol)" args => + String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle +clip name args + = let scalarArgs + = catMaybes + [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float), + ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_clip(symbol)" = '[] + +_backward_clip :: + forall args . Fullfilled "_backward_clip(symbol)" args => + String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle +_backward_clip name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_clip" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "repeat(symbol)" = + '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)), + '("data", AttrOpt SymbolHandle)] + +repeat :: + forall args . Fullfilled "repeat(symbol)" args => + String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle +repeat name args + = let scalarArgs + = catMaybes + [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_repeat(symbol)" = '[] + +_backward_repeat :: + forall args . Fullfilled "_backward_repeat(symbol)" args => + String -> + ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle +_backward_repeat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_repeat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tile(symbol)" = + '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +tile :: + forall args . Fullfilled "tile(symbol)" args => + String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle +tile name args + = let scalarArgs + = catMaybes + [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tile(symbol)" = '[] + +_backward_tile :: + forall args . Fullfilled "_backward_tile(symbol)" args => + String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle +_backward_tile name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tile" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "reverse(symbol)" = + '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)] + +reverse :: + forall args . Fullfilled "reverse(symbol)" args => + String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle +reverse name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_reverse(symbol)" = '[] + +_backward_reverse :: + forall args . Fullfilled "_backward_reverse(symbol)" args => + String -> + ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle +_backward_reverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_reverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "stack(symbol)" = + '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int), + '("data", AttrOpt [SymbolHandle])] + +stack :: + forall args . Fullfilled "stack(symbol)" args => + String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle +stack name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "stack" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_stack(symbol)" = '[] + +_backward_stack :: + forall args . Fullfilled "_backward_stack(symbol)" args => + String -> + ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle +_backward_stack name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_stack" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "squeeze(symbol)" = + '[ '("axis", AttrOpt (Maybe [Int])), + '("data", AttrOpt [SymbolHandle])] + +squeeze :: + forall args . Fullfilled "squeeze(symbol)" args => + String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle +squeeze name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "squeeze" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_squeeze(symbol)" = '[] + +_backward_squeeze :: + forall args . Fullfilled "_backward_squeeze(symbol)" args => + String -> + ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle +_backward_squeeze name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_squeeze" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "depth_to_space(symbol)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +depth_to_space :: + forall args . Fullfilled "depth_to_space(symbol)" args => + String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle +depth_to_space name args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "depth_to_space" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "space_to_depth(symbol)" = + '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)] + +space_to_depth :: + forall args . Fullfilled "space_to_depth(symbol)" args => + String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle +space_to_depth name args + = let scalarArgs + = catMaybes + [("block_size",) . showValue <$> + (args !? #block_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "space_to_depth" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_split_v2(symbol)" = + '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int), + '("data", AttrOpt SymbolHandle)] + +_split_v2 :: + forall args . Fullfilled "_split_v2(symbol)" args => + String -> ArgsHMap "_split_v2(symbol)" args -> IO SymbolHandle +_split_v2 name args + = let scalarArgs + = catMaybes + [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool), + ("sections",) . showValue <$> (args !? #sections :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_split_v2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_split_v2_backward(symbol)" = '[] + +_split_v2_backward :: + forall args . Fullfilled "_split_v2_backward(symbol)" args => + String -> + ArgsHMap "_split_v2_backward(symbol)" args -> IO SymbolHandle +_split_v2_backward name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_split_v2_backward" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +dot :: + forall args . Fullfilled "dot(symbol)" args => + String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle +dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))] + +_backward_dot :: + forall args . Fullfilled "_backward_dot(symbol)" args => + String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle +_backward_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "batch_dot(symbol)" = + '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool), + '("forward_stype", + AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +batch_dot :: + forall args . Fullfilled "batch_dot(symbol)" args => + String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle +batch_dot name args + = let scalarArgs + = catMaybes + [("transpose_a",) . showValue <$> + (args !? #transpose_a :: Maybe Bool), + ("transpose_b",) . showValue <$> + (args !? #transpose_b :: Maybe Bool), + ("forward_stype",) . showValue <$> + (args !? #forward_stype :: + Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_batch_dot(symbol)" = '[] + +_backward_batch_dot :: + forall args . Fullfilled "_backward_batch_dot(symbol)" args => + String -> + ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle +_backward_batch_dot name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_batch_dot" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sin :: + forall args . Fullfilled "sin(symbol)" args => + String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle +sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sin :: + forall args . Fullfilled "_backward_sin(symbol)" args => + String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle +_backward_sin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cos :: + forall args . Fullfilled "cos(symbol)" args => + String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle +cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cos :: + forall args . Fullfilled "_backward_cos(symbol)" args => + String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle +_backward_cos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tan :: + forall args . Fullfilled "tan(symbol)" args => + String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle +tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tan :: + forall args . Fullfilled "_backward_tan(symbol)" args => + String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle +_backward_tan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsin(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsin :: + forall args . Fullfilled "arcsin(symbol)" args => + String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle +arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsin(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsin :: + forall args . Fullfilled "_backward_arcsin(symbol)" args => + String -> + ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle +_backward_arcsin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccos(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccos :: + forall args . Fullfilled "arccos(symbol)" args => + String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle +arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccos(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccos :: + forall args . Fullfilled "_backward_arccos(symbol)" args => + String -> + ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle +_backward_arccos name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccos" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctan(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctan :: + forall args . Fullfilled "arctan(symbol)" args => + String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle +arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctan(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctan :: + forall args . Fullfilled "_backward_arctan(symbol)" args => + String -> + ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle +_backward_arctan name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctan" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "degrees(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +degrees :: + forall args . Fullfilled "degrees(symbol)" args => + String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle +degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_degrees(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_degrees :: + forall args . Fullfilled "_backward_degrees(symbol)" args => + String -> + ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle +_backward_degrees name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_degrees" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "radians(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +radians :: + forall args . Fullfilled "radians(symbol)" args => + String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle +radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_radians(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_radians :: + forall args . Fullfilled "_backward_radians(symbol)" args => + String -> + ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle +_backward_radians name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_radians" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +sinh :: + forall args . Fullfilled "sinh(symbol)" args => + String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle +sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_sinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_sinh :: + forall args . Fullfilled "_backward_sinh(symbol)" args => + String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle +_backward_sinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_sinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "cosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +cosh :: + forall args . Fullfilled "cosh(symbol)" args => + String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle +cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_cosh :: + forall args . Fullfilled "_backward_cosh(symbol)" args => + String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle +_backward_cosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "tanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +tanh :: + forall args . Fullfilled "tanh(symbol)" args => + String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle +tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_tanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_tanh :: + forall args . Fullfilled "_backward_tanh(symbol)" args => + String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle +_backward_tanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_tanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arcsinh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arcsinh :: + forall args . Fullfilled "arcsinh(symbol)" args => + String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle +arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arcsinh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arcsinh :: + forall args . Fullfilled "_backward_arcsinh(symbol)" args => + String -> + ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle +_backward_arcsinh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arcsinh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arccosh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arccosh :: + forall args . Fullfilled "arccosh(symbol)" args => + String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle +arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arccosh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arccosh :: + forall args . Fullfilled "_backward_arccosh(symbol)" args => + String -> + ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle +_backward_arccosh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arccosh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "arctanh(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +arctanh :: + forall args . Fullfilled "arctanh(symbol)" args => + String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle +arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_arctanh(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_backward_arctanh :: + forall args . Fullfilled "_backward_arctanh(symbol)" args => + String -> + ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle +_backward_arctanh name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_arctanh" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "khatri_rao(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +khatri_rao :: + forall args . Fullfilled "khatri_rao(symbol)" args => + String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle +khatri_rao name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "khatri_rao" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_contrib_group_adagrad_update(symbol)" + = + '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("history", AttrOpt SymbolHandle)] + +_contrib_group_adagrad_update :: + forall args . + Fullfilled "_contrib_group_adagrad_update(symbol)" args => + String -> + ArgsHMap "_contrib_group_adagrad_update(symbol)" args -> + IO SymbolHandle +_contrib_group_adagrad_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("history",) <$> (args !? #history :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_group_adagrad_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_getnnz(symbol)" = + '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)] + +_contrib_getnnz :: + forall args . Fullfilled "_contrib_getnnz(symbol)" args => + String -> + ArgsHMap "_contrib_getnnz(symbol)" args -> IO SymbolHandle +_contrib_getnnz name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_getnnz" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_gradientmultiplier(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_contrib_gradientmultiplier :: + forall args . + Fullfilled "_contrib_gradientmultiplier(symbol)" args => + String -> + ArgsHMap "_contrib_gradientmultiplier(symbol)" args -> + IO SymbolHandle +_contrib_gradientmultiplier name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_gradientmultiplier" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_backward_gradientmultiplier(symbol)" = + '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_contrib_backward_gradientmultiplier :: + forall args . + Fullfilled "_contrib_backward_gradientmultiplier(symbol)" + args => + String -> + ArgsHMap "_contrib_backward_gradientmultiplier(symbol)" + args + -> IO SymbolHandle +_contrib_backward_gradientmultiplier name args + = let scalarArgs + = catMaybes + [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_edge_id(symbol)" = + '[ '("data", AttrOpt SymbolHandle), '("u", AttrOpt SymbolHandle), + '("v", AttrOpt SymbolHandle)] + +_contrib_edge_id :: + forall args . Fullfilled "_contrib_edge_id(symbol)" args => + String -> + ArgsHMap "_contrib_edge_id(symbol)" args -> IO SymbolHandle +_contrib_edge_id name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("u",) <$> (args !? #u :: Maybe SymbolHandle), + ("v",) <$> (args !? #v :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_edge_id" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_dgl_adjacency(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_contrib_dgl_adjacency :: + forall args . Fullfilled "_contrib_dgl_adjacency(symbol)" args => + String -> + ArgsHMap "_contrib_dgl_adjacency(symbol)" args -> IO SymbolHandle +_contrib_dgl_adjacency name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dgl_adjacency" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_hawkesll(symbol)" = + '[ '("lda", AttrOpt SymbolHandle), + '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("state", AttrOpt SymbolHandle), '("lags", AttrOpt SymbolHandle), + '("marks", AttrOpt SymbolHandle), + '("valid_length", AttrOpt SymbolHandle), + '("max_time", AttrOpt SymbolHandle)] + +_contrib_hawkesll :: + forall args . Fullfilled "_contrib_hawkesll(symbol)" args => + String -> + ArgsHMap "_contrib_hawkesll(symbol)" args -> IO SymbolHandle +_contrib_hawkesll name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lda",) <$> (args !? #lda :: Maybe SymbolHandle), + ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("state",) <$> (args !? #state :: Maybe SymbolHandle), + ("lags",) <$> (args !? #lags :: Maybe SymbolHandle), + ("marks",) <$> (args !? #marks :: Maybe SymbolHandle), + ("valid_length",) <$> + (args !? #valid_length :: Maybe SymbolHandle), + ("max_time",) <$> (args !? #max_time :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_hawkesll" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_backward_hawkesll(symbol)" = + '[] + +_contrib_backward_hawkesll :: + forall args . + Fullfilled "_contrib_backward_hawkesll(symbol)" args => + String -> + ArgsHMap "_contrib_backward_hawkesll(symbol)" args -> + IO SymbolHandle +_contrib_backward_hawkesll name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_hawkesll" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_mp_adamw_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("eta", AttrReq Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle), + '("rescale_grad", AttrOpt SymbolHandle)] + +_mp_adamw_update :: + forall args . Fullfilled "_mp_adamw_update(symbol)" args => + String -> + ArgsHMap "_mp_adamw_update(symbol)" args -> IO SymbolHandle +_mp_adamw_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("eta",) . showValue <$> (args !? #eta :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mean",) <$> (args !? #mean :: Maybe SymbolHandle), + ("var",) <$> (args !? #var :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle), + ("rescale_grad",) <$> + (args !? #rescale_grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_mp_adamw_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_adamw_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("eta", AttrReq Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle), + '("rescale_grad", AttrOpt SymbolHandle)] + +_adamw_update :: + forall args . Fullfilled "_adamw_update(symbol)" args => + String -> ArgsHMap "_adamw_update(symbol)" args -> IO SymbolHandle +_adamw_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("eta",) . showValue <$> (args !? #eta :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mean",) <$> (args !? #mean :: Maybe SymbolHandle), + ("var",) <$> (args !? #var :: Maybe SymbolHandle), + ("rescale_grad",) <$> + (args !? #rescale_grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_adamw_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quadratic(symbol)" = + '[ '("a", AttrOpt Float), '("b", AttrOpt Float), + '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_contrib_quadratic :: + forall args . Fullfilled "_contrib_quadratic(symbol)" args => + String -> + ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle +_contrib_quadratic name args + = let scalarArgs + = catMaybes + [("a",) . showValue <$> (args !? #a :: Maybe Float), + ("b",) . showValue <$> (args !? #b :: Maybe Float), + ("c",) . showValue <$> (args !? #c :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quadratic" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_backward_quadratic(symbol)" = + '[] + +_contrib_backward_quadratic :: + forall args . + Fullfilled "_contrib_backward_quadratic(symbol)" args => + String -> + ArgsHMap "_contrib_backward_quadratic(symbol)" args -> + IO SymbolHandle +_contrib_backward_quadratic name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_quadratic" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_div_sqrt_dim(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_contrib_div_sqrt_dim :: + forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args => + String -> + ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle +_contrib_div_sqrt_dim name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_div_sqrt_dim" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "multi_all_finite(symbol)" = + '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool), + '("data", AttrOpt [SymbolHandle])] + +multi_all_finite :: + forall args . Fullfilled "multi_all_finite(symbol)" args => + String -> + ArgsHMap "multi_all_finite(symbol)" args -> IO SymbolHandle +multi_all_finite name args + = let scalarArgs + = catMaybes + [("num_arrays",) . showValue <$> + (args !? #num_arrays :: Maybe Int), + ("init_output",) . showValue <$> + (args !? #init_output :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "multi_all_finite" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_contrib_index_array(symbol)" = + '[ '("axes", AttrOpt (Maybe [Int])), + '("data", AttrOpt SymbolHandle)] + +_contrib_index_array :: + forall args . Fullfilled "_contrib_index_array(symbol)" args => + String -> + ArgsHMap "_contrib_index_array(symbol)" args -> IO SymbolHandle +_contrib_index_array name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_array" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_index_copy(symbol)" = + '[ '("old_tensor", AttrOpt SymbolHandle), + '("index_vector", AttrOpt SymbolHandle), + '("new_tensor", AttrOpt SymbolHandle)] + +_contrib_index_copy :: + forall args . Fullfilled "_contrib_index_copy(symbol)" args => + String -> + ArgsHMap "_contrib_index_copy(symbol)" args -> IO SymbolHandle +_contrib_index_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("old_tensor",) <$> (args !? #old_tensor :: Maybe SymbolHandle), + ("index_vector",) <$> + (args !? #index_vector :: Maybe SymbolHandle), + ("new_tensor",) <$> (args !? #new_tensor :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_index_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_backward_index_copy(symbol)" + = '[] + +_contrib_backward_index_copy :: + forall args . + Fullfilled "_contrib_backward_index_copy(symbol)" args => + String -> + ArgsHMap "_contrib_backward_index_copy(symbol)" args -> + IO SymbolHandle +_contrib_backward_index_copy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_backward_index_copy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_ROIAlign(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int), + '("position_sensitive", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_ROIAlign :: + forall args . Fullfilled "_contrib_ROIAlign(symbol)" args => + String -> + ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle +_contrib_ROIAlign name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("sample_ratio",) . showValue <$> + (args !? #sample_ratio :: Maybe Int), + ("position_sensitive",) . showValue <$> + (args !? #position_sensitive :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ROIAlign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIAlign(symbol)" = '[] + +_backward_ROIAlign :: + forall args . Fullfilled "_backward_ROIAlign(symbol)" args => + String -> + ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle +_backward_ROIAlign name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIAlign" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_box_nms(symbol)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("background_id", AttrOpt Int), + '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"])), + '("data", AttrOpt SymbolHandle)] + +_contrib_box_nms :: + forall args . Fullfilled "_contrib_box_nms(symbol)" args => + String -> + ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle +_contrib_box_nms name args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_nms" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_contrib_box_nms(symbol)" = + '[ '("overlap_thresh", AttrOpt Float), + '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int), + '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int), + '("id_index", AttrOpt Int), '("background_id", AttrOpt Int), + '("force_suppress", AttrOpt Bool), + '("in_format", AttrOpt (EnumType '["center", "corner"])), + '("out_format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_nms :: + forall args . + Fullfilled "_backward_contrib_box_nms(symbol)" args => + String -> + ArgsHMap "_backward_contrib_box_nms(symbol)" args -> + IO SymbolHandle +_backward_contrib_box_nms name args + = let scalarArgs + = catMaybes + [("overlap_thresh",) . showValue <$> + (args !? #overlap_thresh :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int), + ("coord_start",) . showValue <$> + (args !? #coord_start :: Maybe Int), + ("score_index",) . showValue <$> + (args !? #score_index :: Maybe Int), + ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("in_format",) . showValue <$> + (args !? #in_format :: Maybe (EnumType '["center", "corner"])), + ("out_format",) . showValue <$> + (args !? #out_format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_nms" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_box_iou(symbol)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"])), + '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)] + +_contrib_box_iou :: + forall args . Fullfilled "_contrib_box_iou(symbol)" args => + String -> + ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle +_contrib_box_iou name args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_box_iou" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_contrib_box_iou(symbol)" = + '[ '("format", AttrOpt (EnumType '["center", "corner"]))] + +_backward_contrib_box_iou :: + forall args . + Fullfilled "_backward_contrib_box_iou(symbol)" args => + String -> + ArgsHMap "_backward_contrib_box_iou(symbol)" args -> + IO SymbolHandle +_backward_contrib_box_iou name args + = let scalarArgs + = catMaybes + [("format",) . showValue <$> + (args !? #format :: Maybe (EnumType '["center", "corner"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_box_iou" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_bipartite_matching(symbol)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_bipartite_matching :: + forall args . + Fullfilled "_contrib_bipartite_matching(symbol)" args => + String -> + ArgsHMap "_contrib_bipartite_matching(symbol)" args -> + IO SymbolHandle +_contrib_bipartite_matching name args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_bipartite_matching" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_bipartite_matching(symbol)" = + '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float), + '("topk", AttrOpt Int)] + +_backward_contrib_bipartite_matching :: + forall args . + Fullfilled "_backward_contrib_bipartite_matching(symbol)" + args => + String -> + ArgsHMap "_backward_contrib_bipartite_matching(symbol)" + args + -> IO SymbolHandle +_backward_contrib_bipartite_matching name args + = let scalarArgs + = catMaybes + [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("topk",) . showValue <$> (args !? #topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_bipartite_matching" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_BilinearResize2D(symbol)" = + '[ '("height", AttrOpt Int), '("width", AttrOpt Int), + '("scale_height", AttrOpt (Maybe Float)), + '("scale_width", AttrOpt (Maybe Float)), + '("mode", + AttrOpt + (EnumType + '["like", "odd_scale", "size", "to_even_down", "to_even_up", + "to_odd_down", "to_odd_up"])), + '("data", AttrOpt SymbolHandle), '("like", AttrOpt SymbolHandle)] + +_contrib_BilinearResize2D :: + forall args . + Fullfilled "_contrib_BilinearResize2D(symbol)" args => + String -> + ArgsHMap "_contrib_BilinearResize2D(symbol)" args -> + IO SymbolHandle +_contrib_BilinearResize2D name args + = let scalarArgs + = catMaybes + [("height",) . showValue <$> (args !? #height :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int), + ("scale_height",) . showValue <$> + (args !? #scale_height :: Maybe (Maybe Float)), + ("scale_width",) . showValue <$> + (args !? #scale_width :: Maybe (Maybe Float)), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe + (EnumType + '["like", "odd_scale", "size", "to_even_down", "to_even_up", + "to_odd_down", "to_odd_up"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("like",) <$> (args !? #like :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_BilinearResize2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[] + +_backward_contrib_BilinearResize2D :: + forall args . + Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args => + String -> + ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args -> + IO SymbolHandle +_backward_contrib_BilinearResize2D name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_boolean_mask(symbol)" = + '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle), + '("index", AttrOpt SymbolHandle)] + +_contrib_boolean_mask :: + forall args . Fullfilled "_contrib_boolean_mask(symbol)" args => + String -> + ArgsHMap "_contrib_boolean_mask(symbol)" args -> IO SymbolHandle +_contrib_boolean_mask name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("index",) <$> (args !? #index :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_boolean_mask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_boolean_mask(symbol)" = + '[ '("axis", AttrOpt Int)] + +_backward_contrib_boolean_mask :: + forall args . + Fullfilled "_backward_contrib_boolean_mask(symbol)" args => + String -> + ArgsHMap "_backward_contrib_boolean_mask(symbol)" args -> + IO SymbolHandle +_backward_contrib_boolean_mask name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_boolean_mask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_SyncBatchNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int), + '("key", AttrReq String), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_contrib_SyncBatchNorm :: + forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args => + String -> + ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle +_contrib_SyncBatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int), + ("key",) . showValue <$> (args !? #key :: Maybe String)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_SyncBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)" + = + '[ '("output_size", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args => + String -> + ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args -> + IO SymbolHandle +_contrib_AdaptiveAvgPooling2D name args + = let scalarArgs + = catMaybes + [("output_size",) . showValue <$> + (args !? #output_size :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" = + '[] + +_backward_contrib_AdaptiveAvgPooling2D :: + forall args . + Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)" + args => + String -> + ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)" + args + -> IO SymbolHandle +_backward_contrib_AdaptiveAvgPooling2D name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_crop(symbol)" = + '[ '("x", AttrReq Int), '("y", AttrReq Int), + '("width", AttrReq Int), '("height", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_image_crop :: + forall args . Fullfilled "_image_crop(symbol)" args => + String -> ArgsHMap "_image_crop(symbol)" args -> IO SymbolHandle +_image_crop name args + = let scalarArgs + = catMaybes + [("x",) . showValue <$> (args !? #x :: Maybe Int), + ("y",) . showValue <$> (args !? #y :: Maybe Int), + ("width",) . showValue <$> (args !? #width :: Maybe Int), + ("height",) . showValue <$> (args !? #height :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_crop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_image_crop(symbol)" = '[] + +_backward_image_crop :: + forall args . Fullfilled "_backward_image_crop(symbol)" args => + String -> + ArgsHMap "_backward_image_crop(symbol)" args -> IO SymbolHandle +_backward_image_crop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_image_crop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_to_tensor(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_to_tensor :: + forall args . Fullfilled "_image_to_tensor(symbol)" args => + String -> + ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle +_image_to_tensor name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_to_tensor" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_normalize(symbol)" = + '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]), + '("data", AttrOpt SymbolHandle)] + +_image_normalize :: + forall args . Fullfilled "_image_normalize(symbol)" args => + String -> + ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle +_image_normalize name args + = let scalarArgs + = catMaybes + [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]), + ("std",) . showValue <$> (args !? #std :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_normalize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_image_normalize(symbol)" = + '[] + +_backward_image_normalize :: + forall args . + Fullfilled "_backward_image_normalize(symbol)" args => + String -> + ArgsHMap "_backward_image_normalize(symbol)" args -> + IO SymbolHandle +_backward_image_normalize name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_image_normalize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_flip_left_right(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_flip_left_right :: + forall args . Fullfilled "_image_flip_left_right(symbol)" args => + String -> + ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle +_image_flip_left_right name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_left_right" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_flip_left_right(symbol)" + = '[ '("data", AttrOpt SymbolHandle)] + +_image_random_flip_left_right :: + forall args . + Fullfilled "_image_random_flip_left_right(symbol)" args => + String -> + ArgsHMap "_image_random_flip_left_right(symbol)" args -> + IO SymbolHandle +_image_random_flip_left_right name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_left_right" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_flip_top_bottom(symbol)" = + '[ '("data", AttrOpt SymbolHandle)] + +_image_flip_top_bottom :: + forall args . Fullfilled "_image_flip_top_bottom(symbol)" args => + String -> + ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle +_image_flip_top_bottom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_flip_top_bottom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_flip_top_bottom(symbol)" + = '[ '("data", AttrOpt SymbolHandle)] + +_image_random_flip_top_bottom :: + forall args . + Fullfilled "_image_random_flip_top_bottom(symbol)" args => + String -> + ArgsHMap "_image_random_flip_top_bottom(symbol)" args -> + IO SymbolHandle +_image_random_flip_top_bottom name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_flip_top_bottom" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_brightness(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_brightness :: + forall args . Fullfilled "_image_random_brightness(symbol)" args => + String -> + ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle +_image_random_brightness name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_brightness" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_contrast(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_contrast :: + forall args . Fullfilled "_image_random_contrast(symbol)" args => + String -> + ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle +_image_random_contrast name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_contrast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_saturation(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_saturation :: + forall args . Fullfilled "_image_random_saturation(symbol)" args => + String -> + ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle +_image_random_saturation name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_saturation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_hue(symbol)" = + '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_hue :: + forall args . Fullfilled "_image_random_hue(symbol)" args => + String -> + ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle +_image_random_hue name args + = let scalarArgs + = catMaybes + [("min_factor",) . showValue <$> + (args !? #min_factor :: Maybe Float), + ("max_factor",) . showValue <$> + (args !? #max_factor :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_hue" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_color_jitter(symbol)" = + '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float), + '("saturation", AttrReq Float), '("hue", AttrReq Float), + '("data", AttrOpt SymbolHandle)] + +_image_random_color_jitter :: + forall args . + Fullfilled "_image_random_color_jitter(symbol)" args => + String -> + ArgsHMap "_image_random_color_jitter(symbol)" args -> + IO SymbolHandle +_image_random_color_jitter name args + = let scalarArgs + = catMaybes + [("brightness",) . showValue <$> + (args !? #brightness :: Maybe Float), + ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float), + ("saturation",) . showValue <$> + (args !? #saturation :: Maybe Float), + ("hue",) . showValue <$> (args !? #hue :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_color_jitter" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_adjust_lighting(symbol)" = + '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)] + +_image_adjust_lighting :: + forall args . Fullfilled "_image_adjust_lighting(symbol)" args => + String -> + ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle +_image_adjust_lighting name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_adjust_lighting" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_random_lighting(symbol)" = + '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)] + +_image_random_lighting :: + forall args . Fullfilled "_image_random_lighting(symbol)" args => + String -> + ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle +_image_random_lighting name args + = let scalarArgs + = catMaybes + [("alpha_std",) . showValue <$> + (args !? #alpha_std :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_random_lighting" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_image_resize(symbol)" = + '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool), + '("interp", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_image_resize :: + forall args . Fullfilled "_image_resize(symbol)" args => + String -> ArgsHMap "_image_resize(symbol)" args -> IO SymbolHandle +_image_resize name args + = let scalarArgs + = catMaybes + [("size",) . showValue <$> (args !? #size :: Maybe [Int]), + ("keep_ratio",) . showValue <$> + (args !? #keep_ratio :: Maybe Bool), + ("interp",) . showValue <$> (args !? #interp :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_image_resize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "moments(symbol)" = + '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool), + '("data", AttrOpt SymbolHandle)] + +moments :: + forall args . Fullfilled "moments(symbol)" args => + String -> ArgsHMap "moments(symbol)" args -> IO SymbolHandle +moments name args + = let scalarArgs + = catMaybes + [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])), + ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "moments" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_moments(symbol)" = '[] + +_backward_moments :: + forall args . Fullfilled "_backward_moments(symbol)" args => + String -> + ArgsHMap "_backward_moments(symbol)" args -> IO SymbolHandle +_backward_moments name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_moments" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("dtype", + AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))), + '("data", AttrOpt SymbolHandle)] + +softmax :: + forall args . Fullfilled "softmax(symbol)" args => + String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle +softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softmax(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +_backward_softmax :: + forall args . Fullfilled "_backward_softmax(symbol)" args => + String -> + ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle +_backward_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_backward_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "softmin(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("dtype", + AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))), + '("data", AttrOpt SymbolHandle)] + +softmin :: + forall args . Fullfilled "softmin(symbol)" args => + String -> ArgsHMap "softmin(symbol)" args -> IO SymbolHandle +softmin name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_softmin(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +_backward_softmin :: + forall args . Fullfilled "_backward_softmin(symbol)" args => + String -> + ArgsHMap "_backward_softmin(symbol)" args -> IO SymbolHandle +_backward_softmin name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_backward_softmin" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "log_softmax(symbol)" = + '[ '("axis", AttrOpt Int), + '("temperature", AttrOpt (Maybe Double)), + '("dtype", + AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))), + '("data", AttrOpt SymbolHandle)] + +log_softmax :: + forall args . Fullfilled "log_softmax(symbol)" args => + String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle +log_softmax name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("temperature",) . showValue <$> + (args !? #temperature :: Maybe (Maybe Double)), + ("dtype",) . showValue <$> + (args !? #dtype :: + Maybe (Maybe (EnumType '["float16", "float32", "float64"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_log_softmax(symbol)" = + '[ '("args", AttrOpt [SymbolHandle])] + +_backward_log_softmax :: + forall args . Fullfilled "_backward_log_softmax(symbol)" args => + String -> + ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle +_backward_log_softmax name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_backward_log_softmax" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_Pooling(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("layout", + AttrOpt + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))), + '("data", AttrOpt SymbolHandle)] + +_Pooling :: + forall args . Fullfilled "_Pooling(symbol)" args => + String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle +_Pooling name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool)), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling(symbol)" = '[] + +_backward_Pooling :: + forall args . Fullfilled "_backward_Pooling(symbol)" args => + String -> + ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle +_backward_Pooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Deconvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Deconvolution :: + forall args . Fullfilled "_Deconvolution(symbol)" args => + String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle +_Deconvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Deconvolution(symbol)" = '[] + +_backward_Deconvolution :: + forall args . Fullfilled "_backward_Deconvolution(symbol)" args => + String -> + ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle +_backward_Deconvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Deconvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Activation(symbol)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt SymbolHandle)] + +_Activation :: + forall args . Fullfilled "_Activation(symbol)" args => + String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle +_Activation name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Activation(symbol)" = '[] + +_backward_Activation :: + forall args . Fullfilled "_backward_Activation(symbol)" args => + String -> + ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle +_backward_Activation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Activation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_UpSampling(symbol)" = + '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int), + '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])), + '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])), + '("num_args", AttrReq Int), '("workspace", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_UpSampling :: + forall args . Fullfilled "_UpSampling(symbol)" args => + String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle +_UpSampling name args + = let scalarArgs + = catMaybes + [("scale",) . showValue <$> (args !? #scale :: Maybe Int), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("sample_type",) . showValue <$> + (args !? #sample_type :: + Maybe (EnumType '["bilinear", "nearest"])), + ("multi_input_mode",) . showValue <$> + (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])), + ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "UpSampling" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_UpSampling(symbol)" = '[] + +_backward_UpSampling :: + forall args . Fullfilled "_backward_UpSampling(symbol)" args => + String -> + ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle +_backward_UpSampling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_UpSampling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm(symbol)" = + '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int), + '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle), + '("moving_mean", AttrOpt SymbolHandle), + '("moving_var", AttrOpt SymbolHandle)] + +_BatchNorm :: + forall args . Fullfilled "_BatchNorm(symbol)" args => + String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle +_BatchNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Double), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle), + ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle), + ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm(symbol)" = '[] + +_backward_BatchNorm :: + forall args . Fullfilled "_backward_BatchNorm(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle +_backward_BatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CTCLoss(symbol)" = + '[ '("use_data_lengths", AttrOpt Bool), + '("use_label_lengths", AttrOpt Bool), + '("blank_label", AttrOpt (EnumType '["first", "last"])), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle), + '("data_lengths", AttrOpt SymbolHandle), + '("label_lengths", AttrOpt SymbolHandle)] + +_CTCLoss :: + forall args . Fullfilled "_CTCLoss(symbol)" args => + String -> ArgsHMap "_CTCLoss(symbol)" args -> IO SymbolHandle +_CTCLoss name args + = let scalarArgs + = catMaybes + [("use_data_lengths",) . showValue <$> + (args !? #use_data_lengths :: Maybe Bool), + ("use_label_lengths",) . showValue <$> + (args !? #use_label_lengths :: Maybe Bool), + ("blank_label",) . showValue <$> + (args !? #blank_label :: Maybe (EnumType '["first", "last"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("data_lengths",) <$> + (args !? #data_lengths :: Maybe SymbolHandle), + ("label_lengths",) <$> + (args !? #label_lengths :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "CTCLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ctc_loss(symbol)" = '[] + +_backward_ctc_loss :: + forall args . Fullfilled "_backward_ctc_loss(symbol)" args => + String -> + ArgsHMap "_backward_ctc_loss(symbol)" args -> IO SymbolHandle +_backward_ctc_loss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ctc_loss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_FullyConnected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_FullyConnected :: + forall args . Fullfilled "_FullyConnected(symbol)" args => + String -> + ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle +_FullyConnected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_FullyConnected(symbol)" = + '[] + +_backward_FullyConnected :: + forall args . Fullfilled "_backward_FullyConnected(symbol)" args => + String -> + ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle +_backward_FullyConnected name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_FullyConnected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution :: + forall args . Fullfilled "_Convolution(symbol)" args => + String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle +_Convolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution(symbol)" = '[] + +_backward_Convolution :: + forall args . Fullfilled "_backward_Convolution(symbol)" args => + String -> + ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle +_backward_Convolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LayerNorm(symbol)" = + '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_LayerNorm :: + forall args . Fullfilled "_LayerNorm(symbol)" args => + String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle +_LayerNorm name args + = let scalarArgs + = catMaybes + [("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LayerNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LayerNorm(symbol)" = '[] + +_backward_LayerNorm :: + forall args . Fullfilled "_backward_LayerNorm(symbol)" args => + String -> + ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle +_backward_LayerNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LayerNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_Concat :: + forall args . Fullfilled "_Concat(symbol)" args => + String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle +_Concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Concat(symbol)" = '[] + +_backward_Concat :: + forall args . Fullfilled "_backward_Concat(symbol)" args => + String -> + ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle +_backward_Concat name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Concat" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_rnn_param_concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_rnn_param_concat :: + forall args . Fullfilled "_rnn_param_concat(symbol)" args => + String -> + ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle +_rnn_param_concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_rnn_param_concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_SoftmaxActivation(symbol)" = + '[ '("mode", AttrOpt (EnumType '["channel", "instance"])), + '("data", AttrOpt SymbolHandle)] + +_SoftmaxActivation :: + forall args . Fullfilled "_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle +_SoftmaxActivation name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["channel", "instance"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxActivation(symbol)" = + '[] + +_backward_SoftmaxActivation :: + forall args . + Fullfilled "_backward_SoftmaxActivation(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxActivation(symbol)" args -> + IO SymbolHandle +_backward_SoftmaxActivation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxActivation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LRN(symbol)" = + '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float), + '("knorm", AttrOpt Float), '("nsize", AttrReq Int), + '("data", AttrOpt SymbolHandle)] + +_LRN :: + forall args . Fullfilled "_LRN(symbol)" args => + String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle +_LRN name args + = let scalarArgs + = catMaybes + [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float), + ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LRN(symbol)" = '[] + +_backward_LRN :: + forall args . Fullfilled "_backward_LRN(symbol)" args => + String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle +_backward_LRN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LRN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Dropout(symbol)" = + '[ '("p", AttrOpt Float), + '("mode", AttrOpt (EnumType '["always", "training"])), + '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle)] + +_Dropout :: + forall args . Fullfilled "_Dropout(symbol)" args => + String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle +_Dropout name args + = let scalarArgs + = catMaybes + [("p",) . showValue <$> (args !? #p :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: Maybe (EnumType '["always", "training"])), + ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Dropout(symbol)" = '[] + +_backward_Dropout :: + forall args . Fullfilled "_backward_Dropout(symbol)" args => + String -> + ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle +_backward_Dropout name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Dropout" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_quantized_elemwise_add(symbol)" = + '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle), + '("lhs_min", AttrOpt SymbolHandle), + '("lhs_max", AttrOpt SymbolHandle), + '("rhs_min", AttrOpt SymbolHandle), + '("rhs_max", AttrOpt SymbolHandle)] + +_contrib_quantized_elemwise_add :: + forall args . + Fullfilled "_contrib_quantized_elemwise_add(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_elemwise_add(symbol)" args -> + IO SymbolHandle +_contrib_quantized_elemwise_add name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle), + ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle), + ("lhs_min",) <$> (args !? #lhs_min :: Maybe SymbolHandle), + ("lhs_max",) <$> (args !? #lhs_max :: Maybe SymbolHandle), + ("rhs_min",) <$> (args !? #rhs_min :: Maybe SymbolHandle), + ("rhs_max",) <$> (args !? #rhs_max :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_elemwise_add" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_dequantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["float32"])), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_dequantize :: + forall args . Fullfilled "_contrib_dequantize(symbol)" args => + String -> + ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle +_contrib_dequantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["float32"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_dequantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_flatten(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_flatten :: + forall args . + Fullfilled "_contrib_quantized_flatten(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_flatten(symbol)" args -> + IO SymbolHandle +_contrib_quantized_flatten name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_flatten" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_conv(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle), + '("min_weight", AttrOpt SymbolHandle), + '("max_weight", AttrOpt SymbolHandle), + '("min_bias", AttrOpt SymbolHandle), + '("max_bias", AttrOpt SymbolHandle)] + +_contrib_quantized_conv :: + forall args . Fullfilled "_contrib_quantized_conv(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle +_contrib_quantized_conv name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_conv" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_quantized_fully_connected(symbol)" = + '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool), + '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle), + '("min_weight", AttrOpt SymbolHandle), + '("max_weight", AttrOpt SymbolHandle), + '("min_bias", AttrOpt SymbolHandle), + '("max_bias", AttrOpt SymbolHandle)] + +_contrib_quantized_fully_connected :: + forall args . + Fullfilled "_contrib_quantized_fully_connected(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_fully_connected(symbol)" args -> + IO SymbolHandle +_contrib_quantized_fully_connected name args + = let scalarArgs + = catMaybes + [("num_hidden",) . showValue <$> + (args !? #num_hidden :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle), + ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle), + ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle), + ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle), + ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_fully_connected" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_pooling(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])), + '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool), + '("pooling_convention", + AttrOpt (EnumType '["full", "same", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("p_value", AttrOpt (Maybe Int)), + '("count_include_pad", AttrOpt (Maybe Bool)), + '("layout", + AttrOpt + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))), + '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_pooling :: + forall args . + Fullfilled "_contrib_quantized_pooling(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_pooling(symbol)" args -> + IO SymbolHandle +_contrib_quantized_pooling name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: + Maybe (EnumType '["avg", "lp", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "same", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("p_value",) . showValue <$> + (args !? #p_value :: Maybe (Maybe Int)), + ("count_include_pad",) . showValue <$> + (args !? #count_include_pad :: Maybe (Maybe Bool)), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe + (Maybe + (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_pooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantize_v2(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])), + '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt SymbolHandle)] + +_contrib_quantize_v2 :: + forall args . Fullfilled "_contrib_quantize_v2(symbol)" args => + String -> + ArgsHMap "_contrib_quantize_v2(symbol)" args -> IO SymbolHandle +_contrib_quantize_v2 name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])), + ("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize_v2" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_concat(symbol)" = + '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +_contrib_quantized_concat :: + forall args . + Fullfilled "_contrib_quantized_concat(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_concat(symbol)" args -> + IO SymbolHandle +_contrib_quantized_concat name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("dim",) . showValue <$> (args !? #dim :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_contrib_quantized_concat" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_contrib_requantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])), + '("min_calib_range", AttrOpt (Maybe Float)), + '("max_calib_range", AttrOpt (Maybe Float)), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_requantize :: + forall args . Fullfilled "_contrib_requantize(symbol)" args => + String -> + ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle +_contrib_requantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])), + ("min_calib_range",) . showValue <$> + (args !? #min_calib_range :: Maybe (Maybe Float)), + ("max_calib_range",) . showValue <$> + (args !? #max_calib_range :: Maybe (Maybe Float))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_requantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantized_act(symbol)" = + '[ '("act_type", + AttrReq + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])), + '("data", AttrOpt SymbolHandle), + '("min_data", AttrOpt SymbolHandle), + '("max_data", AttrOpt SymbolHandle)] + +_contrib_quantized_act :: + forall args . Fullfilled "_contrib_quantized_act(symbol)" args => + String -> + ArgsHMap "_contrib_quantized_act(symbol)" args -> IO SymbolHandle +_contrib_quantized_act name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle), + ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantized_act" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_quantize(symbol)" = + '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])), + '("data", AttrOpt SymbolHandle), + '("min_range", AttrOpt SymbolHandle), + '("max_range", AttrOpt SymbolHandle)] + +_contrib_quantize :: + forall args . Fullfilled "_contrib_quantize(symbol)" args => + String -> + ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle +_contrib_quantize name args + = let scalarArgs + = catMaybes + [("out_type",) . showValue <$> + (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle), + ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_quantize" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_cvimread(symbol)" = + '[ '("filename", AttrReq String), '("flag", AttrOpt Int), + '("to_rgb", AttrOpt Bool)] + +_cvimread :: + forall args . Fullfilled "_cvimread(symbol)" args => + String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle +_cvimread name args + = let scalarArgs + = catMaybes + [("filename",) . showValue <$> (args !? #filename :: Maybe String), + ("flag",) . showValue <$> (args !? #flag :: Maybe Int), + ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_cvimread" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_NoGradient(symbol)" = '[] + +_NoGradient :: + forall args . Fullfilled "_NoGradient(symbol)" args => + String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle +_NoGradient name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_NoGradient" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CachedOp(symbol)" = + '[ '("data", AttrOpt [SymbolHandle])] + +_CachedOp :: + forall args . Fullfilled "_CachedOp(symbol)" args => + String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle +_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_CachedOp(symbol)" = '[] + +_backward_CachedOp :: + forall args . Fullfilled "_backward_CachedOp(symbol)" args => + String -> + ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle +_backward_CachedOp name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CachedOp" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "softmax_cross_entropy(symbol)" = + '[ '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +softmax_cross_entropy :: + forall args . Fullfilled "softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle +softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_softmax_cross_entropy(symbol)" = '[] + +_backward_softmax_cross_entropy :: + forall args . + Fullfilled "_backward_softmax_cross_entropy(symbol)" args => + String -> + ArgsHMap "_backward_softmax_cross_entropy(symbol)" args -> + IO SymbolHandle +_backward_softmax_cross_entropy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_softmax_cross_entropy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_foreach(symbol)" = '[] + +_backward_foreach :: + forall args . Fullfilled "_backward_foreach(symbol)" args => + String -> + ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle +_backward_foreach name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_foreach" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_while_loop(symbol)" = '[] + +_backward_while_loop :: + forall args . Fullfilled "_backward_while_loop(symbol)" args => + String -> + ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle +_backward_while_loop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_while_loop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_cond(symbol)" = '[] + +_backward_cond :: + forall args . Fullfilled "_backward_cond(symbol)" args => + String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle +_backward_cond name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_cond" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SoftmaxOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool), + '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float), + '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)] + +_SoftmaxOutput :: + forall args . Fullfilled "_SoftmaxOutput(symbol)" args => + String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_SoftmaxOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("multi_output",) . showValue <$> + (args !? #multi_output :: Maybe Bool), + ("use_ignore",) . showValue <$> + (args !? #use_ignore :: Maybe Bool), + ("preserve_shape",) . showValue <$> + (args !? #preserve_shape :: Maybe Bool), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"])), + ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool), + ("smooth_alpha",) . showValue <$> + (args !? #smooth_alpha :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[] + +_backward_SoftmaxOutput :: + forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args => + String -> + ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle +_backward_SoftmaxOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SoftmaxOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LeakyReLU(symbol)" = + '[ '("act_type", + AttrOpt + (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])), + '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float), + '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle)] + +_LeakyReLU :: + forall args . Fullfilled "_LeakyReLU(symbol)" args => + String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle +_LeakyReLU name args + = let scalarArgs + = catMaybes + [("act_type",) . showValue <$> + (args !? #act_type :: + Maybe + (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])), + ("slope",) . showValue <$> (args !? #slope :: Maybe Float), + ("lower_bound",) . showValue <$> + (args !? #lower_bound :: Maybe Float), + ("upper_bound",) . showValue <$> + (args !? #upper_bound :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SwapAxis(symbol)" = + '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int), + '("data", AttrOpt SymbolHandle)] + +_SwapAxis :: + forall args . Fullfilled "_SwapAxis(symbol)" args => + String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle +_SwapAxis name args + = let scalarArgs + = catMaybes + [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int), + ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" = + '[ '("sparseness_target", AttrOpt Float), + '("penalty", AttrOpt Float), '("momentum", AttrOpt Float), + '("data", AttrOpt SymbolHandle)] + +_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_IdentityAttachKLSparseReg(symbol)" args => + String -> + ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args -> + IO SymbolHandle +_IdentityAttachKLSparseReg name args + = let scalarArgs + = catMaybes + [("sparseness_target",) . showValue <$> + (args !? #sparseness_target :: Maybe Float), + ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SliceChannel(symbol)" = + '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int), + '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)] + +_SliceChannel :: + forall args . Fullfilled "_SliceChannel(symbol)" args => + String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle +_SliceChannel name args + = let scalarArgs + = catMaybes + [("num_outputs",) . showValue <$> + (args !? #num_outputs :: Maybe Int), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int), + ("squeeze_axis",) . showValue <$> + (args !? #squeeze_axis :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_RNN(symbol)" = + '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int), + '("bidirectional", AttrOpt Bool), + '("mode", + AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool), + '("projection_size", AttrOpt (Maybe Int)), + '("lstm_state_clip_min", AttrOpt (Maybe Double)), + '("lstm_state_clip_max", AttrOpt (Maybe Double)), + '("lstm_state_clip_nan", AttrOpt Bool), + '("use_sequence_length", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), + '("parameters", AttrOpt SymbolHandle), + '("state", AttrOpt SymbolHandle), + '("state_cell", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_RNN :: + forall args . Fullfilled "_RNN(symbol)" args => + String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle +_RNN name args + = let scalarArgs + = catMaybes + [("state_size",) . showValue <$> + (args !? #state_size :: Maybe Int), + ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int), + ("bidirectional",) . showValue <$> + (args !? #bidirectional :: Maybe Bool), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])), + ("p",) . showValue <$> (args !? #p :: Maybe Float), + ("state_outputs",) . showValue <$> + (args !? #state_outputs :: Maybe Bool), + ("projection_size",) . showValue <$> + (args !? #projection_size :: Maybe (Maybe Int)), + ("lstm_state_clip_min",) . showValue <$> + (args !? #lstm_state_clip_min :: Maybe (Maybe Double)), + ("lstm_state_clip_max",) . showValue <$> + (args !? #lstm_state_clip_max :: Maybe (Maybe Double)), + ("lstm_state_clip_nan",) . showValue <$> + (args !? #lstm_state_clip_nan :: Maybe Bool), + ("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle), + ("state",) <$> (args !? #state :: Maybe SymbolHandle), + ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_RNN(symbol)" = '[] + +_backward_RNN :: + forall args . Fullfilled "_backward_RNN(symbol)" args => + String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle +_backward_RNN name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_RNN" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pad(symbol)" = + '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])), + '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double), + '("data", AttrOpt SymbolHandle)] + +_Pad :: + forall args . Fullfilled "_Pad(symbol)" args => + String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle +_Pad name args + = let scalarArgs + = catMaybes + [("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["constant", "edge", "reflect"])), + ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]), + ("constant_value",) . showValue <$> + (args !? #constant_value :: Maybe Double)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BatchNorm_v1(symbol)" = + '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float), + '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool), + '("output_mean_var", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle), + '("beta", AttrOpt SymbolHandle)] + +_BatchNorm_v1 :: + forall args . Fullfilled "_BatchNorm_v1(symbol)" args => + String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_BatchNorm_v1 name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool), + ("use_global_stats",) . showValue <$> + (args !? #use_global_stats :: Maybe Bool), + ("output_mean_var",) . showValue <$> + (args !? #output_mean_var :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "signsgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +signsgd_update :: + forall args . Fullfilled "signsgd_update(symbol)" args => + String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle +signsgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signsgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "signum_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +signum_update :: + forall args . Fullfilled "signum_update(symbol)" args => + String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle +signum_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "signum_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "multi_sgd_update(symbol)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +multi_sgd_update :: + forall args . Fullfilled "multi_sgd_update(symbol)" args => + String -> + ArgsHMap "multi_sgd_update(symbol)" args -> IO SymbolHandle +multi_sgd_update name args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "multi_sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "multi_sgd_mom_update(symbol)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +multi_sgd_mom_update :: + forall args . Fullfilled "multi_sgd_mom_update(symbol)" args => + String -> + ArgsHMap "multi_sgd_mom_update(symbol)" args -> IO SymbolHandle +multi_sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "multi_sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "multi_mp_sgd_update(symbol)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +multi_mp_sgd_update :: + forall args . Fullfilled "multi_mp_sgd_update(symbol)" args => + String -> + ArgsHMap "multi_mp_sgd_update(symbol)" args -> IO SymbolHandle +multi_mp_sgd_update name args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "multi_mp_sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "multi_mp_sgd_mom_update(symbol)" = + '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]), + '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int), + '("data", AttrOpt [SymbolHandle])] + +multi_mp_sgd_mom_update :: + forall args . Fullfilled "multi_mp_sgd_mom_update(symbol)" args => + String -> + ArgsHMap "multi_mp_sgd_mom_update(symbol)" args -> IO SymbolHandle +multi_mp_sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]), + ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("num_weights",) . showValue <$> + (args !? #num_weights :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "multi_mp_sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)] + +sgd_update :: + forall args . Fullfilled "sgd_update(symbol)" args => + String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle +sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +sgd_mom_update :: + forall args . Fullfilled "sgd_mom_update(symbol)" args => + String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle +sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_update(symbol)" = + '[ '("lr", AttrReq Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_update :: + forall args . Fullfilled "mp_sgd_update(symbol)" args => + String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle +mp_sgd_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_sgd_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_sgd_mom_update :: + forall args . Fullfilled "mp_sgd_mom_update(symbol)" args => + String -> + ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle +mp_sgd_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_sgd_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftml_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double), + '("t", AttrReq Int), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle)] + +ftml_update :: + forall args . Fullfilled "ftml_update(symbol)" args => + String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle +ftml_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double), + ("t",) . showValue <$> (args !? #t :: Maybe Int), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("d",) <$> (args !? #d :: Maybe SymbolHandle), + ("v",) <$> (args !? #v :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftml_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "adam_update(symbol)" = + '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float), + '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)] + +adam_update :: + forall args . Fullfilled "adam_update(symbol)" args => + String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle +adam_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float), + ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("lazy_update",) . showValue <$> + (args !? #lazy_update :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mean",) <$> (args !? #mean :: Maybe SymbolHandle), + ("var",) <$> (args !? #var :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "adam_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "nag_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle)] + +nag_mom_update :: + forall args . Fullfilled "nag_mom_update(symbol)" args => + String -> ArgsHMap "nag_mom_update(symbol)" args -> IO SymbolHandle +nag_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "nag_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "mp_nag_mom_update(symbol)" = + '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("mom", AttrOpt SymbolHandle), + '("weight32", AttrOpt SymbolHandle)] + +mp_nag_mom_update :: + forall args . Fullfilled "mp_nag_mom_update(symbol)" args => + String -> + ArgsHMap "mp_nag_mom_update(symbol)" args -> IO SymbolHandle +mp_nag_mom_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("mom",) <$> (args !? #mom :: Maybe SymbolHandle), + ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "mp_nag_mom_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmsprop_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("epsilon", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle)] + +rmsprop_update :: + forall args . Fullfilled "rmsprop_update(symbol)" args => + String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle +rmsprop_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmsprop_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "rmspropalex_update(symbol)" = + '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float), + '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("clip_weights", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle), + '("delta", AttrOpt SymbolHandle)] + +rmspropalex_update :: + forall args . Fullfilled "rmspropalex_update(symbol)" args => + String -> + ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle +rmspropalex_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float), + ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float), + ("clip_weights",) . showValue <$> + (args !? #clip_weights :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle), + ("g",) <$> (args !? #g :: Maybe SymbolHandle), + ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "rmspropalex_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "ftrl_update(symbol)" = + '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float), + '("beta", AttrOpt Float), '("wd", AttrOpt Float), + '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)] + +ftrl_update :: + forall args . Fullfilled "ftrl_update(symbol)" args => + String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle +ftrl_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float), + ("beta",) . showValue <$> (args !? #beta :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("z",) <$> (args !? #z :: Maybe SymbolHandle), + ("n",) <$> (args !? #n :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ftrl_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_sparse_adagrad_update(symbol)" = + '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float), + '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float), + '("clip_gradient", AttrOpt Float), + '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle), + '("history", AttrOpt SymbolHandle)] + +_sparse_adagrad_update :: + forall args . Fullfilled "_sparse_adagrad_update(symbol)" args => + String -> + ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle +_sparse_adagrad_update name args + = let scalarArgs + = catMaybes + [("lr",) . showValue <$> (args !? #lr :: Maybe Float), + ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float), + ("wd",) . showValue <$> (args !? #wd :: Maybe Float), + ("rescale_grad",) . showValue <$> + (args !? #rescale_grad :: Maybe Float), + ("clip_gradient",) . showValue <$> + (args !? #clip_gradient :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("grad",) <$> (args !? #grad :: Maybe SymbolHandle), + ("history",) <$> (args !? #history :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_sparse_adagrad_update" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LinearRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LinearRegressionOutput :: + forall args . Fullfilled "_LinearRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle +_LinearRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LinearRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_linear_reg_out(symbol)" = + '[] + +_backward_linear_reg_out :: + forall args . Fullfilled "_backward_linear_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle +_backward_linear_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_linear_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MAERegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_MAERegressionOutput :: + forall args . Fullfilled "_MAERegressionOutput(symbol)" args => + String -> + ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle +_MAERegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MAERegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_mae_reg_out(symbol)" = '[] + +_backward_mae_reg_out :: + forall args . Fullfilled "_backward_mae_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle +_backward_mae_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_mae_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_LogisticRegressionOutput(symbol)" = + '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_LogisticRegressionOutput :: + forall args . + Fullfilled "_LogisticRegressionOutput(symbol)" args => + String -> + ArgsHMap "_LogisticRegressionOutput(symbol)" args -> + IO SymbolHandle +_LogisticRegressionOutput name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "LogisticRegressionOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_logistic_reg_out(symbol)" = + '[] + +_backward_logistic_reg_out :: + forall args . + Fullfilled "_backward_logistic_reg_out(symbol)" args => + String -> + ArgsHMap "_backward_logistic_reg_out(symbol)" args -> + IO SymbolHandle +_backward_logistic_reg_out name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_logistic_reg_out" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CustomFunction(symbol)" = '[] + +_CustomFunction :: + forall args . Fullfilled "_CustomFunction(symbol)" args => + String -> + ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle +_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_CustomFunction(symbol)" = + '[] + +_backward_CustomFunction :: + forall args . Fullfilled "_backward_CustomFunction(symbol)" args => + String -> + ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle +_backward_CustomFunction name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_CustomFunction" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__Native(symbol)" = '[] + +_backward__Native :: + forall args . Fullfilled "_backward__Native(symbol)" args => + String -> + ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle +_backward__Native name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__Native" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__NDArray(symbol)" = '[] + +_backward__NDArray :: + forall args . Fullfilled "_backward__NDArray(symbol)" args => + String -> + ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle +_backward__NDArray name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__NDArray" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxTarget(symbol)" = + '[ '("overlap_threshold", AttrOpt Float), + '("ignore_label", AttrOpt Float), + '("negative_mining_ratio", AttrOpt Float), + '("negative_mining_thresh", AttrOpt Float), + '("minimum_negative_samples", AttrOpt Int), + '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle), + '("cls_pred", AttrOpt SymbolHandle)] + +_contrib_MultiBoxTarget :: + forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxTarget name args + = let scalarArgs + = catMaybes + [("overlap_threshold",) . showValue <$> + (args !? #overlap_threshold :: Maybe Float), + ("ignore_label",) . showValue <$> + (args !? #ignore_label :: Maybe Float), + ("negative_mining_ratio",) . showValue <$> + (args !? #negative_mining_ratio :: Maybe Float), + ("negative_mining_thresh",) . showValue <$> + (args !? #negative_mining_thresh :: Maybe Float), + ("minimum_negative_samples",) . showValue <$> + (args !? #minimum_negative_samples :: Maybe Int), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle), + ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[] + +_backward__contrib_MultiBoxTarget :: + forall args . + Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxTarget name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_Proposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_Proposal :: + forall args . Fullfilled "_contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle +_contrib_Proposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_Proposal(symbol)" = + '[] + +_backward__contrib_Proposal :: + forall args . + Fullfilled "_backward__contrib_Proposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_Proposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_Proposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_Proposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_count_sketch(symbol)" = + '[ '("out_dim", AttrReq Int), + '("processing_batch_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle), + '("s", AttrOpt SymbolHandle)] + +_contrib_count_sketch :: + forall args . Fullfilled "_contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle +_contrib_count_sketch name args + = let scalarArgs + = catMaybes + [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int), + ("processing_batch_size",) . showValue <$> + (args !? #processing_batch_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("h",) <$> (args !? #h :: Maybe SymbolHandle), + ("s",) <$> (args !? #s :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_count_sketch(symbol)" = '[] + +_backward__contrib_count_sketch :: + forall args . + Fullfilled "_backward__contrib_count_sketch(symbol)" args => + String -> + ArgsHMap "_backward__contrib_count_sketch(symbol)" args -> + IO SymbolHandle +_backward__contrib_count_sketch name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_count_sketch" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxDetection(symbol)" = + '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float), + '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float), + '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]), + '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle), + '("loc_pred", AttrOpt SymbolHandle), + '("anchor", AttrOpt SymbolHandle)] + +_contrib_MultiBoxDetection :: + forall args . + Fullfilled "_contrib_MultiBoxDetection(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxDetection(symbol)" args -> + IO SymbolHandle +_contrib_MultiBoxDetection name args + = let scalarArgs + = catMaybes + [("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("background_id",) . showValue <$> + (args !? #background_id :: Maybe Int), + ("nms_threshold",) . showValue <$> + (args !? #nms_threshold :: Maybe Float), + ("force_suppress",) . showValue <$> + (args !? #force_suppress :: Maybe Bool), + ("variances",) . showValue <$> + (args !? #variances :: Maybe [Float]), + ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle), + ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[] + +_backward__contrib_MultiBoxDetection :: + forall args . + Fullfilled "_backward__contrib_MultiBoxDetection(symbol)" + args => + String -> + ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)" + args + -> IO SymbolHandle +_backward__contrib_MultiBoxDetection name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformablePSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("group_size", AttrReq Int), '("pooled_size", AttrReq Int), + '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int), + '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle), + '("trans", AttrOpt SymbolHandle)] + +_contrib_DeformablePSROIPooling :: + forall args . + Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args -> + IO SymbolHandle +_contrib_DeformablePSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int), + ("sample_per_part",) . showValue <$> + (args !? #sample_per_part :: Maybe Int), + ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float), + ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle), + ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" = + '[] + +_backward__contrib_DeformablePSROIPooling :: + forall args . + Fullfilled + "_backward__contrib_DeformablePSROIPooling(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformablePSROIPooling(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformablePSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_fft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_fft :: + forall args . Fullfilled "_contrib_fft(symbol)" args => + String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle +_contrib_fft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_fft(symbol)" = '[] + +_backward__contrib_fft :: + forall args . Fullfilled "_backward__contrib_fft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle +_backward__contrib_fft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_fft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiBoxPrior(symbol)" = + '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]), + '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)] + +_contrib_MultiBoxPrior :: + forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle +_contrib_MultiBoxPrior name args + = let scalarArgs + = catMaybes + [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("clip",) . showValue <$> (args !? #clip :: Maybe Bool), + ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]), + ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[] + +_backward__contrib_MultiBoxPrior :: + forall args . + Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiBoxPrior name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_MultiProposal(symbol)" = + '[ '("rpn_pre_nms_top_n", AttrOpt Int), + '("rpn_post_nms_top_n", AttrOpt Int), + '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int), + '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]), + '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool), + '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle), + '("bbox_pred", AttrOpt SymbolHandle), + '("im_info", AttrOpt SymbolHandle)] + +_contrib_MultiProposal :: + forall args . Fullfilled "_contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle +_contrib_MultiProposal name args + = let scalarArgs + = catMaybes + [("rpn_pre_nms_top_n",) . showValue <$> + (args !? #rpn_pre_nms_top_n :: Maybe Int), + ("rpn_post_nms_top_n",) . showValue <$> + (args !? #rpn_post_nms_top_n :: Maybe Int), + ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float), + ("rpn_min_size",) . showValue <$> + (args !? #rpn_min_size :: Maybe Int), + ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]), + ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]), + ("feature_stride",) . showValue <$> + (args !? #feature_stride :: Maybe Int), + ("output_score",) . showValue <$> + (args !? #output_score :: Maybe Bool), + ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle), + ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle), + ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_MultiProposal(symbol)" = '[] + +_backward__contrib_MultiProposal :: + forall args . + Fullfilled "_backward__contrib_MultiProposal(symbol)" args => + String -> + ArgsHMap "_backward__contrib_MultiProposal(symbol)" args -> + IO SymbolHandle +_backward__contrib_MultiProposal name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_MultiProposal" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_PSROIPooling(symbol)" = + '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int), + '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int), + '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)] + +_contrib_PSROIPooling :: + forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle +_contrib_PSROIPooling name args + = let scalarArgs + = catMaybes + [("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float), + ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int), + ("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe Int), + ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[] + +_backward__contrib_PSROIPooling :: + forall args . + Fullfilled "_backward__contrib_PSROIPooling(symbol)" args => + String -> + ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args -> + IO SymbolHandle +_backward__contrib_PSROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_PSROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_contrib_DeformableConvolution(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("num_deformable_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))), + '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle), + '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)] + +_contrib_DeformableConvolution :: + forall args . + Fullfilled "_contrib_DeformableConvolution(symbol)" args => + String -> + ArgsHMap "_contrib_DeformableConvolution(symbol)" args -> + IO SymbolHandle +_contrib_DeformableConvolution name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("num_deformable_group",) . showValue <$> + (args !? #num_deformable_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("offset",) <$> (args !? #offset :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_DeformableConvolution(symbol)" = + '[] + +_backward__contrib_DeformableConvolution :: + forall args . + Fullfilled + "_backward__contrib_DeformableConvolution(symbol)" + args => + String -> + ArgsHMap + "_backward__contrib_DeformableConvolution(symbol)" + args + -> IO SymbolHandle +_backward__contrib_DeformableConvolution name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_contrib_ifft(symbol)" = + '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)] + +_contrib_ifft :: + forall args . Fullfilled "_contrib_ifft(symbol)" args => + String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle +_contrib_ifft name args + = let scalarArgs + = catMaybes + [("compute_size",) . showValue <$> + (args !? #compute_size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__contrib_ifft(symbol)" = '[] + +_backward__contrib_ifft :: + forall args . Fullfilled "_backward__contrib_ifft(symbol)" args => + String -> + ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle +_backward__contrib_ifft name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_ifft" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[] + +_backward__contrib_SyncBatchNorm :: + forall args . + Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args => + String -> + ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args -> + IO SymbolHandle +_backward__contrib_SyncBatchNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_InstanceNorm(symbol)" = + '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle), + '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)] + +_InstanceNorm :: + forall args . Fullfilled "_InstanceNorm(symbol)" args => + String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle +_InstanceNorm name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle), + ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_InstanceNorm(symbol)" = '[] + +_backward_InstanceNorm :: + forall args . Fullfilled "_backward_InstanceNorm(symbol)" args => + String -> + ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle +_backward_InstanceNorm name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_InstanceNorm" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SVMOutput(symbol)" = + '[ '("margin", AttrOpt Float), + '("regularization_coefficient", AttrOpt Float), + '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle), + '("label", AttrOpt SymbolHandle)] + +_SVMOutput :: + forall args . Fullfilled "_SVMOutput(symbol)" args => + String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle +_SVMOutput name args + = let scalarArgs + = catMaybes + [("margin",) . showValue <$> (args !? #margin :: Maybe Float), + ("regularization_coefficient",) . showValue <$> + (args !? #regularization_coefficient :: Maybe Float), + ("use_linear",) . showValue <$> + (args !? #use_linear :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("label",) <$> (args !? #label :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SVMOutput(symbol)" = '[] + +_backward_SVMOutput :: + forall args . Fullfilled "_backward_SVMOutput(symbol)" args => + String -> + ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle +_backward_SVMOutput name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SVMOutput" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_GridGenerator(symbol)" = + '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])), + '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)] + +_GridGenerator :: + forall args . Fullfilled "_GridGenerator(symbol)" args => + String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle +_GridGenerator name args + = let scalarArgs + = catMaybes + [("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])), + ("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_GridGenerator(symbol)" = '[] + +_backward_GridGenerator :: + forall args . Fullfilled "_backward_GridGenerator(symbol)" args => + String -> + ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle +_backward_GridGenerator name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_GridGenerator" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Convolution_v1(symbol)" = + '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]), + '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("num_filter", AttrReq Int), '("num_group", AttrOpt Int), + '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool), + '("cudnn_tune", + AttrOpt + (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + '("cudnn_off", AttrOpt Bool), + '("layout", + AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))), + '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle), + '("bias", AttrOpt SymbolHandle)] + +_Convolution_v1 :: + forall args . Fullfilled "_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle +_Convolution_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]), + ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int), + ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int), + ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int), + ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool), + ("cudnn_tune",) . showValue <$> + (args !? #cudnn_tune :: + Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))), + ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool), + ("layout",) . showValue <$> + (args !? #layout :: + Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("weight",) <$> (args !? #weight :: Maybe SymbolHandle), + ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Convolution_v1(symbol)" = + '[] + +_backward_Convolution_v1 :: + forall args . Fullfilled "_backward_Convolution_v1(symbol)" args => + String -> + ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle +_backward_Convolution_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Convolution_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceReverse(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceReverse :: + forall args . Fullfilled "_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle +_SequenceReverse name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceReverse(symbol)" = + '[] + +_backward_SequenceReverse :: + forall args . + Fullfilled "_backward_SequenceReverse(symbol)" args => + String -> + ArgsHMap "_backward_SequenceReverse(symbol)" args -> + IO SymbolHandle +_backward_SequenceReverse name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceReverse" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_BilinearSampler(symbol)" = + '[ '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle), '("grid", AttrOpt SymbolHandle)] + +_BilinearSampler :: + forall args . Fullfilled "_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle +_BilinearSampler name args + = let scalarArgs + = catMaybes + [("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BilinearSampler(symbol)" = + '[] + +_backward_BilinearSampler :: + forall args . + Fullfilled "_backward_BilinearSampler(symbol)" args => + String -> + ArgsHMap "_backward_BilinearSampler(symbol)" args -> + IO SymbolHandle +_backward_BilinearSampler name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BilinearSampler" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_LeakyReLU(symbol)" = '[] + +_backward_LeakyReLU :: + forall args . Fullfilled "_backward_LeakyReLU(symbol)" args => + String -> + ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle +_backward_LeakyReLU name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_LeakyReLU" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Crop(symbol)" = + '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]), + '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool), + '("data", AttrOpt [SymbolHandle])] + +_Crop :: + forall args . Fullfilled "_Crop(symbol)" args => + String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle +_Crop name args + = let scalarArgs + = catMaybes + [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int), + ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]), + ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]), + ("center_crop",) . showValue <$> + (args !? #center_crop :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle]) + in + do op <- nnGetOpHandle "Crop" + sym <- if hasKey args #num_args then + mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals + else + mxSymbolCreateAtomicSymbol (fromOpHandle op) + ("num_args" : scalarkeys) + (showValue (length array) : scalarvals) + mxSymbolCompose sym name Nothing array + return sym + +type instance ParameterList "_backward_Crop(symbol)" = '[] + +_backward_Crop :: + forall args . Fullfilled "_backward_Crop(symbol)" args => + String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle +_backward_Crop name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Crop" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_ROIPooling(symbol)" = + '[ '("pooled_size", AttrReq [Int]), + '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle), + '("rois", AttrOpt SymbolHandle)] + +_ROIPooling :: + forall args . Fullfilled "_ROIPooling(symbol)" args => + String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle +_ROIPooling name args + = let scalarArgs + = catMaybes + [("pooled_size",) . showValue <$> + (args !? #pooled_size :: Maybe [Int]), + ("spatial_scale",) . showValue <$> + (args !? #spatial_scale :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_ROIPooling(symbol)" = '[] + +_backward_ROIPooling :: + forall args . Fullfilled "_backward_ROIPooling(symbol)" args => + String -> + ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle +_backward_ROIPooling name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_ROIPooling" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceLast(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceLast :: + forall args . Fullfilled "_SequenceLast(symbol)" args => + String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle +_SequenceLast name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceLast(symbol)" = '[] + +_backward_SequenceLast :: + forall args . Fullfilled "_backward_SequenceLast(symbol)" args => + String -> + ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle +_backward_SequenceLast name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceLast" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_CrossDeviceCopy(symbol)" = '[] + +_CrossDeviceCopy :: + forall args . Fullfilled "_CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle +_CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward__CrossDeviceCopy(symbol)" = + '[] + +_backward__CrossDeviceCopy :: + forall args . + Fullfilled "_backward__CrossDeviceCopy(symbol)" args => + String -> + ArgsHMap "_backward__CrossDeviceCopy(symbol)" args -> + IO SymbolHandle +_backward__CrossDeviceCopy name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward__CrossDeviceCopy" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SpatialTransformer(symbol)" = + '[ '("target_shape", AttrOpt [Int]), + '("transform_type", AttrReq (EnumType '["affine"])), + '("sampler_type", AttrReq (EnumType '["bilinear"])), + '("cudnn_off", AttrOpt (Maybe Bool)), + '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)] + +_SpatialTransformer :: + forall args . Fullfilled "_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle +_SpatialTransformer name args + = let scalarArgs + = catMaybes + [("target_shape",) . showValue <$> + (args !? #target_shape :: Maybe [Int]), + ("transform_type",) . showValue <$> + (args !? #transform_type :: Maybe (EnumType '["affine"])), + ("sampler_type",) . showValue <$> + (args !? #sampler_type :: Maybe (EnumType '["bilinear"])), + ("cudnn_off",) . showValue <$> + (args !? #cudnn_off :: Maybe (Maybe Bool))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SpatialTransformer(symbol)" + = '[] + +_backward_SpatialTransformer :: + forall args . + Fullfilled "_backward_SpatialTransformer(symbol)" args => + String -> + ArgsHMap "_backward_SpatialTransformer(symbol)" args -> + IO SymbolHandle +_backward_SpatialTransformer name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SpatialTransformer" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SwapAxis(symbol)" = '[] + +_backward_SwapAxis :: + forall args . Fullfilled "_backward_SwapAxis(symbol)" args => + String -> + ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle +_backward_SwapAxis name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SwapAxis" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_L2Normalization(symbol)" = + '[ '("eps", AttrOpt Float), + '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])), + '("data", AttrOpt SymbolHandle)] + +_L2Normalization :: + forall args . Fullfilled "_L2Normalization(symbol)" args => + String -> + ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle +_L2Normalization name args + = let scalarArgs + = catMaybes + [("eps",) . showValue <$> (args !? #eps :: Maybe Float), + ("mode",) . showValue <$> + (args !? #mode :: + Maybe (EnumType '["channel", "instance", "spatial"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_L2Normalization(symbol)" = + '[] + +_backward_L2Normalization :: + forall args . + Fullfilled "_backward_L2Normalization(symbol)" args => + String -> + ArgsHMap "_backward_L2Normalization(symbol)" args -> + IO SymbolHandle +_backward_L2Normalization name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_L2Normalization" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Correlation(symbol)" = + '[ '("kernel_size", AttrOpt Int), + '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int), + '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int), + '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle), + '("data2", AttrOpt SymbolHandle)] + +_Correlation :: + forall args . Fullfilled "_Correlation(symbol)" args => + String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle +_Correlation name args + = let scalarArgs + = catMaybes + [("kernel_size",) . showValue <$> + (args !? #kernel_size :: Maybe Int), + ("max_displacement",) . showValue <$> + (args !? #max_displacement :: Maybe Int), + ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int), + ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int), + ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int), + ("is_multiply",) . showValue <$> + (args !? #is_multiply :: Maybe Bool)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle), + ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Correlation(symbol)" = '[] + +_backward_Correlation :: + forall args . Fullfilled "_backward_Correlation(symbol)" args => + String -> + ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle +_backward_Correlation name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Correlation" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance + ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[] + +_backward_IdentityAttachKLSparseReg :: + forall args . + Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)" + args => + String -> + ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args + -> IO SymbolHandle +_backward_IdentityAttachKLSparseReg name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_MakeLoss(symbol)" = + '[ '("grad_scale", AttrOpt Float), + '("valid_thresh", AttrOpt Float), + '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])), + '("data", AttrOpt SymbolHandle)] + +_MakeLoss :: + forall args . Fullfilled "_MakeLoss(symbol)" args => + String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle +_MakeLoss name args + = let scalarArgs + = catMaybes + [("grad_scale",) . showValue <$> + (args !? #grad_scale :: Maybe Float), + ("valid_thresh",) . showValue <$> + (args !? #valid_thresh :: Maybe Float), + ("normalization",) . showValue <$> + (args !? #normalization :: + Maybe (EnumType '["batch", "null", "valid"]))] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_MakeLoss(symbol)" = '[] + +_backward_MakeLoss :: + forall args . Fullfilled "_backward_MakeLoss(symbol)" args => + String -> + ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle +_backward_MakeLoss name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_MakeLoss" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SliceChannel(symbol)" = '[] + +_backward_SliceChannel :: + forall args . Fullfilled "_backward_SliceChannel(symbol)" args => + String -> + ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle +_backward_SliceChannel name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SliceChannel" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_Pooling_v1(symbol)" = + '[ '("kernel", AttrOpt [Int]), + '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])), + '("global_pool", AttrOpt Bool), + '("pooling_convention", AttrOpt (EnumType '["full", "valid"])), + '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]), + '("data", AttrOpt SymbolHandle)] + +_Pooling_v1 :: + forall args . Fullfilled "_Pooling_v1(symbol)" args => + String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle +_Pooling_v1 name args + = let scalarArgs + = catMaybes + [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]), + ("pool_type",) . showValue <$> + (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])), + ("global_pool",) . showValue <$> + (args !? #global_pool :: Maybe Bool), + ("pooling_convention",) . showValue <$> + (args !? #pooling_convention :: + Maybe (EnumType '["full", "valid"])), + ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]), + ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pooling_v1(symbol)" = '[] + +_backward_Pooling_v1 :: + forall args . Fullfilled "_backward_Pooling_v1(symbol)" args => + String -> + ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle +_backward_Pooling_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pooling_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_Pad(symbol)" = '[] + +_backward_Pad :: + forall args . Fullfilled "_backward_Pad(symbol)" args => + String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle +_backward_Pad name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_Pad" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[] + +_backward_BatchNorm_v1 :: + forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args => + String -> + ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle +_backward_BatchNorm_v1 name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_BatchNorm_v1" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_SequenceMask(symbol)" = + '[ '("use_sequence_length", AttrOpt Bool), + '("value", AttrOpt Float), '("axis", AttrOpt Int), + '("data", AttrOpt SymbolHandle), + '("sequence_length", AttrOpt SymbolHandle)] + +_SequenceMask :: + forall args . Fullfilled "_SequenceMask(symbol)" args => + String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle +_SequenceMask name args + = let scalarArgs + = catMaybes + [("use_sequence_length",) . showValue <$> + (args !? #use_sequence_length :: Maybe Bool), + ("value",) . showValue <$> (args !? #value :: Maybe Float), + ("axis",) . showValue <$> (args !? #axis :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes + [("data",) <$> (args !? #data :: Maybe SymbolHandle), + ("sequence_length",) <$> + (args !? #sequence_length :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_backward_SequenceMask(symbol)" = '[] + +_backward_SequenceMask :: + forall args . Fullfilled "_backward_SequenceMask(symbol)" args => + String -> + ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle +_backward_SequenceMask name args + = let scalarArgs = catMaybes [] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_backward_SequenceMask" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_set_value(symbol)" = + '[ '("src", AttrOpt Float)] + +_set_value :: + forall args . Fullfilled "_set_value(symbol)" args => + String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle +_set_value name args + = let scalarArgs + = catMaybes + [("src",) . showValue <$> (args !? #src :: Maybe Float)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs = catMaybes [] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_set_value" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym + +type instance ParameterList "_imdecode(symbol)" = + '[ '("index", AttrOpt Int), '("x0", AttrOpt Int), + '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int), + '("c", AttrOpt Int), '("size", AttrOpt Int), + '("mean", AttrOpt SymbolHandle)] + +_imdecode :: + forall args . Fullfilled "_imdecode(symbol)" args => + String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle +_imdecode name args + = let scalarArgs + = catMaybes + [("index",) . showValue <$> (args !? #index :: Maybe Int), + ("x0",) . showValue <$> (args !? #x0 :: Maybe Int), + ("y0",) . showValue <$> (args !? #y0 :: Maybe Int), + ("x1",) . showValue <$> (args !? #x1 :: Maybe Int), + ("y1",) . showValue <$> (args !? #y1 :: Maybe Int), + ("c",) . showValue <$> (args !? #c :: Maybe Int), + ("size",) . showValue <$> (args !? #size :: Maybe Int)] + (scalarkeys, scalarvals) = unzip scalarArgs + tensorArgs + = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)] + (tensorkeys, tensorvals) = unzip tensorArgs + in + do op <- nnGetOpHandle "_imdecode" + sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys + scalarvals + mxSymbolCompose sym name (Just tensorkeys) tensorvals + return sym