diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright Author name here (c) 2017 + +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,73 @@ +# mathflow(Dependently typed tensorflow modeler) + +[![Hackage version](https://img.shields.io/hackage/v/mathflow.svg?style=flat)](https://hackage.haskell.org/package/mathflow) [![Build Status](https://travis-ci.org/junjihashimoto/mathflow.png?branch=master)](https://travis-ci.org/junjihashimoto/mathflow) + +This package provides a model of tensor-operations. +The model is independent from tensorflow-binding of python and haskell, though this package generates python-code. +tensor's dimensions and constraints are described by dependent types. +The tensor-operations are based on tensorflow-api. +Currently the model can be translated into python-code. +To write this package, I refer to [this neural network document](https://blog.jle.im/entry/practical-dependent-types-in-haskell-1.html) and singletons. + + +# Install + +Install tensorflow of python and this package. + +``` +> sudo apt install python3 python3-pip +> pip3 install -U pip +> pip3 install tensorflow +> git clone git@github.com:junjihashimoto/mathflow.git +> cd mathflow +> stack install +``` + +# Usage + +## About model + +Model has a type of ```Tensor (dimensions:[Nat]) value-type output-type```. + +* ```dimensions``` are tensor-dimensions. +* ```value-type``` is a value type like Integer or Float of [tensorflow-data-types](https://www.tensorflow.org/programmers_guide/dims_types). +* ```output-type``` is a type of code which this package generates. PyString-type is used for generating python-code. + +This package makes tensorflow-graph from the mode. The model's endpoint is always a tensor-type. + +At first write graph by using arithmetic operators like (+,-,*,/), %* (which is matrix multiply) and tensorflow-functions. +Mathflow.{TF,TF.NN,TF.Train} packages define Tensorflow-functions. + +A example is below. + +``` +testMatMul :: Tensor '[2,1] Int PyString +testMatMul = + let n1 = (Tensor "tf.constant([[2],[3]])") :: Tensor '[2,1] Int PyString + n2 = (Tensor "tf.constant([[2,0],[0,1]])") :: Tensor '[2,2] Int PyString + y = (n2 %* n1) :: Tensor '[2,1] Int PyString + in y +``` + + +## Create model and run it + +Write tensorflow-model. + +``` +testMatMul :: Tensor '[2,1] Int PyString +testMatMul = + let n1 = (Tensor "tf.constant([[2],[3]])") :: Tensor '[2,1] Int PyString + n2 = (Tensor "tf.constant([[2,0],[0,1]])") :: Tensor '[2,2] Int PyString + y = n2 %* n1 :: Tensor '[2,1] Int PyString + in y +``` + +Run the model. This ```run``` function generates python-code and excecute the code by python. + +``` +main = do + (retcode,stdout,stderr) <- run testMatMul + print stdout + +``` diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/mathflow.cabal b/mathflow.cabal new file mode 100644 --- /dev/null +++ b/mathflow.cabal @@ -0,0 +1,70 @@ +name: mathflow +version: 0.1.0.0 +synopsis: Dependently typed tensorflow modeler +-- description: +homepage: https://github.com/junjihashimoto/mathflow#readme +license: BSD3 +license-file: LICENSE +author: Junji Hashimoto +maintainer: junji.hashimoto@gmail.com +copyright: 2017 Junji Hashimoto +category: Math +build-type: Simple +extra-source-files: README.md + , util/gen_function_list.py +cabal-version: >=1.10 +stability: Experimental + +source-repository head + type: git + location: https://github.com/junjihashimoto/mathflow + +Flag usepython + Description: Use Python for test + Default: False + +library + hs-source-dirs: src + exposed-modules: MathFlow + , MathFlow.Core + , MathFlow.PyString + , MathFlow.TF + , MathFlow.TF.NN + , MathFlow.TF.Train + build-depends: base >= 4.7 && < 5 + , singletons +-- , tensorflow + , process + , template-haskell + default-language: Haskell2010 + ghc-options: -Wall + +test-suite mathflow-test + type: exitcode-stdio-1.0 + hs-source-dirs: test + main-is: Spec.hs + other-modules: MathFlow.CoreSpec + , MathFlow.PyStringSpec + , MathFlow.PythonSpec + build-depends: base + , mathflow + , singletons + , hspec + , QuickCheck + , hspec-server + , shakespeare + , text + , template-haskell + ghc-options: -threaded -rtsopts -with-rtsopts=-N + if flag(usepython) + cpp-options: -DUSE_PYTHON + default-language: Haskell2010 + +test-suite doctests + type: exitcode-stdio-1.0 + hs-source-dirs: test + main-is: doctests.hs + ghc-options: -Wall -threaded + build-depends: base, + doctest + default-language: Haskell2010 diff --git a/src/MathFlow.hs b/src/MathFlow.hs new file mode 100644 --- /dev/null +++ b/src/MathFlow.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow ( + module MathFlow.Core +, module MathFlow.PyString +) where + +import MathFlow.Core +import MathFlow.PyString + diff --git a/src/MathFlow/Core.hs b/src/MathFlow/Core.hs new file mode 100644 --- /dev/null +++ b/src/MathFlow/Core.hs @@ -0,0 +1,155 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.Core where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude + +-- |IsSubSamp // Subsampling constraint +-- +-- * (f :: [Nat]) // strides for subsampling +-- * (m :: [Nat]) // dimensions of original tensor +-- * (n :: [Nat]) // dimensions of subsampled tensor +-- * :: Bool +type family IsSubSamp (f :: [Nat]) (m :: [Nat]) (n :: [Nat]) :: Bool where + IsSubSamp (1:fs) (m:ms) (n:ns) = IsSubSamp fs ms ns + IsSubSamp (f:fs) (m:ms) (n:ns) = ((n * f) :== m) :&& (IsSubSamp fs ms ns) + IsSubSamp '[] '[] '[] = 'True + IsSubSamp _ _ _ = 'False + +-- |IsMatMul // A constraint for matrix multiplication +-- +-- * (m :: [Nat]) // dimensions of a[..., i, k] +-- * (o :: [Nat]) // dimensions of b[..., k, j] +-- * (n :: [Nat]) // dimensions of output[..., i, j] = sum_k (a[..., i, k] * b[..., k, j]), for all indices i, j. +-- * :: Bool +type family IsMatMul (m :: [Nat]) (o :: [Nat]) (n :: [Nat]) :: Bool where + IsMatMul m o n = + Last n :== Last o :&& + Last m :== Head (Tail (Reverse o)) :&& + (Tail (Reverse n)) :== (Tail (Reverse m)) :&& + (Tail (Tail (Reverse n))) :== (Tail (Tail (Reverse o))) + +-- |IsConcat // A constraint for concatination of tensor +-- +-- * (m :: [Nat]) // dimensions of a[..., i, ...] +-- * (o :: [Nat]) // dimensions of b[..., k, ...] +-- * (n :: [Nat]) // dimensions of output[..., i+k, ...] = concat (a,b) +-- * :: Bool +type family IsConcat (m :: [Nat]) (o :: [Nat]) (n :: [Nat]) :: Bool where + IsConcat (m:mx) (o:ox) (n:nx) = (m :== o :&& m:== n :|| m + o :== n) :&& IsConcat mx ox nx + IsConcat '[] '[] '[] = 'True + IsConcat _ _ _ = 'False + +-- |IsSameProduct // A constraint for reshaping tensor +-- +-- * (m :: [Nat]) // dimensions of original tensor +-- * (n :: [Nat]) // dimensions of reshaped tensor +-- * :: Bool +type family IsSameProduct (m :: [Nat]) (n :: [Nat]) :: Bool where + IsSameProduct (m:mx) (n:nx) = m :== n :&& (Product mx :== Product nx) + IsSameProduct mx nx = Product mx :== Product nx + + +-- |Dependently typed tensor model +-- +-- This model includes basic arithmetic operators and tensorflow functions. +data Tensor (n::[Nat]) t a = + (Num t) => TScalar t -- ^ Scalar value + | Tensor a -- ^ Transform a value to dependently typed value + | TAdd (Tensor n t a) (Tensor n t a) -- ^ + of Num + | TSub (Tensor n t a) (Tensor n t a) -- ^ - of Num + | TMul (Tensor n t a) (Tensor n t a) -- ^ * of Num + | TAbs (Tensor n t a) -- ^ abs of Num + | TSign (Tensor n t a) -- ^ signum of Num + | TRep (Tensor (Tail n) t a) -- ^ vector wise operator + | TTr (Tensor (Reverse n) t a) -- ^ tensor tansporse operator + | forall o m. (SingI o,SingI m,SingI n,IsMatMul m o n ~ 'True) => TMatMul (Tensor m t a) (Tensor o t a) -- ^ matrix multiply + | forall o m. (SingI o,SingI m,SingI n,IsConcat m o n ~ 'True) => TConcat (Tensor m t a) (Tensor o t a) -- ^ concat operator + | forall m. (SingI m,IsSameProduct m n ~ 'True) => TReshape (Tensor m t a) -- ^ reshape function + | forall o m. + (SingI o,SingI m, + Last n ~ Last o, + Last m ~ Head (Tail (Reverse o)), + (Tail (Reverse n)) ~ (Tail (Reverse m)) + ) => + TConv2d (Tensor m t a) (Tensor o t a) -- ^ conv2d function + | forall f m. (SingI f, SingI m,IsSubSamp f m n ~ 'True) => TMaxPool (Sing f) (Tensor m t a) -- ^ max pool + | TSoftMax (Tensor n t a) + | TReLu (Tensor n t a) + | TNorm (Tensor n t a) + | forall f m. (SingI f,SingI m,IsSubSamp f m n ~ 'True) => TSubSamp (Sing f) (Tensor m t a) -- ^ subsampling function + | forall m t2. TApp (Tensor n t a) (Tensor m t2 a) + | TFunc String (Tensor n t a) + | TSym String + | TArgT String (Tensor n t a) + | TArgS String String + | TArgI String Integer + | TArgF String Float + | TArgD String Double + | forall f. (SingI f) => TArgSing String (Sing (f::[Nat])) + | TLabel String (Tensor n t a) -- ^ When generating code, this label is used. + +(<+>) :: forall n t a m t2. (Tensor n t a) -> (Tensor m t2 a) -> (Tensor n t a) +(<+>) = TApp + +infixr 4 <+> + +instance (Num t) => Num (Tensor n t a) where + (+) = TAdd + (-) = TSub + (*) = TMul + abs = TAbs + signum = TSign + fromInteger = TScalar . fromInteger + + +-- | get dimension from tensor +-- +-- >>> dim (Tensor 1 :: Tensor '[192,10] Float Int) +-- [192,10] +class Dimension a where + dim :: a -> [Integer] + +instance (SingI n) => Dimension (Tensor n t a) where + dim t = dim $ ty t + where + ty :: (SingI n) => Tensor n t a -> Sing n + ty _ = sing + +instance Dimension (Sing (n::[Nat])) where + dim t = fromSing t + +toValue :: forall n t a. Sing (n::[Nat]) -> a -> Tensor n t a +toValue _ a = Tensor a + +(%*) :: forall o m n t a. (SingI o,SingI m,SingI n,IsMatMul m o n ~ 'True) + => Tensor m t a -> Tensor o t a -> Tensor n t a +(%*) a b = TMatMul a b + +(<--) :: SingI n => String -> Tensor n t a -> Tensor n t a +(<--) = TLabel + + +class FromTensor a where + fromTensor :: Tensor n t a -> a + toString :: Tensor n t a -> String + run :: Tensor n t a -> IO (Int,String,String) + diff --git a/src/MathFlow/PyString.hs b/src/MathFlow/PyString.hs new file mode 100644 --- /dev/null +++ b/src/MathFlow/PyString.hs @@ -0,0 +1,171 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE QuasiQuotes #-} + +module MathFlow.PyString where + +import Data.Singletons + +import Data.String +import qualified Data.List as L +import Data.Monoid (Monoid,(<>)) +import MathFlow.Core +import System.Exit +import System.Process + +import Language.Haskell.TH + +data PyString = + PyString { + variables :: [String] + , expression :: String + } + deriving (Show,Eq,Read) + +instance Monoid PyString where + mempty = "" + mappend (PyString av ae) (PyString bv be) = PyString (av <> bv) (ae <> be) + +instance IsString PyString where + fromString a = PyString [] a + +instance FromTensor PyString where +-- fromTensor (TScalar (a:: Integer)) = "tf.constant([" <> fromString (show a) <> "])" + fromTensor (Tensor a) = a + fromTensor v@(TConcat a b) = wrap v + where + wrap :: SingI n => Tensor n t a -> PyString + wrap t = "tf.concat( [" <> fromTensor a <> ", " <> fromTensor b <> " ]," <> fromString (show (idx (dim t))) <> " )" + idx ii = fst $ head $ filter (\(_,b') -> b') $ map (\(i,vd,ad) -> (i, vd /= ad)) $ zip3 [0..] ii (dim a) + fromTensor (TAdd a b) = "tf.add( " <> fromTensor a <> ", " <> fromTensor b <> " )" + fromTensor (TSub a b) = "tf.add( " <> fromTensor a <> ", tf.negative( " <> fromTensor b <> " ) )" + fromTensor (TMul a b) = "tf.multiply( " <> fromTensor a <> ", " <> fromTensor b <> " )" + fromTensor (TRep a) = fromTensor a + fromTensor (TTr a) = "tf.transpose( " <> fromTensor a <> " )" + fromTensor (TAbs a) = "tf.abs( " <> fromTensor a <> " )" + fromTensor (TSign a) = "tf.sign( " <> fromTensor a <> " )" + fromTensor (TLabel str a) = PyString ((str <> " = " <> e):v) str + where + (PyString v e) = fromTensor a + fromTensor (TMatMul a b) = "tf.matmul( " <> fromTensor a <> ", " <> fromTensor b <> " )" + fromTensor (TReshape a) = "tf.reshape( " <> fromTensor a <> ", " <> fromString (show (dim a)) <> " )" + fromTensor (TConv2d a b) = "tf.nn.conv2d( " <> + fromTensor b <> + ", " <> + fromTensor a <> + ", " <> + fromString (show $ map (const (1::Integer)) (dim a) ) <> + ", padding='SAME' )" + fromTensor (TMaxPool a b) = "tf.nn.max_pool( " <> + fromTensor b <> + ", ksize=" <> + fromString (show $ dim a) <> + ", strides=" <> + fromString (show $ map (const (1::Integer)) (dim a) ) <> + ", padding='SAME' )" + fromTensor (TSoftMax a) = "tf.nn.softmax( " <> fromTensor a <> " )" + fromTensor (TReLu a) = "tf.nn.relu( " <> fromTensor a <> " )" + fromTensor (TNorm a) = "tf.nn.lrn( " <> fromTensor a <> " )" + fromTensor (TSubSamp a b) = undefined + fromTensor (TFunc a b) = fromString a <> "( " <> fromTensor b <> " )" + fromTensor (TApp (TSym func) other) = fromString func <> "(" <> fromTensor other <> ")" + fromTensor (TApp a@(TArgT name t) other) = fromTensor a <> "," <> fromTensor other + fromTensor (TApp a@(TArgS name t) other) = fromTensor a <> "," <> fromTensor other + fromTensor (TApp a@(TArgI name t) other) = fromTensor a <> "," <> fromTensor other + fromTensor (TApp a@(TArgF name t) other) = fromTensor a <> "," <> fromTensor other + fromTensor (TApp a@(TArgD name t) other) = fromTensor a <> "," <> fromTensor other + fromTensor (TApp a@(TArgSing name t) other) = fromTensor a <> "," <> fromTensor other + fromTensor (TArgT name t) = fromString name <> "=" <> fromTensor t + fromTensor (TArgS name t) = fromString name <> "=" <> fromString t + fromTensor (TArgI name t) = fromString name <> "=" <> fromString (show t) + fromTensor (TArgF name t) = fromString name <> "=" <> fromString (show t) + fromTensor (TArgD name t) = fromString name <> "=" <> fromString (show t) + fromTensor (TArgSing name t) = fromString name <> "=" <> fromString (show $ dim t) + + toString a = L.intercalate "\n" $ reverse e ++ [v] + where + (PyString e v) = fromTensor a + + run tensor = do + (e,stdout,stderr) <- readProcessWithExitCode "python3" [] $ toRunnableString $ fromTensor tensor + return (exitCode e,stdout,stderr) + where + exitCode e = case e of + ExitSuccess -> 0 + ExitFailure v -> v + +toRunnableString :: PyString -> String +toRunnableString (PyString env' value) = code + where + code = concat [ + "import tensorflow as tf\n", + (L.intercalate "\n" $ reverse env' ++ [concat ["__value__ = ", value]]) , + "\n", + "sess = tf.Session()\n", + "result = sess.run(__value__)\n", + "print(result)\n" + ] + + +-- | Get dimensions of list +-- +-- >>> listDim [1] +-- [1] +-- >>> listDim [[1]] +-- [1,1] +-- >>> listDim [[1,2]] +-- [1,2] +-- >>> listDim [[1,2],[1,2]] +-- [2,2] +class ListDimension a where + listDim :: a -> [Integer] + +instance ListDimension Integer where + listDim _ = [] + +instance ListDimension a => ListDimension [a] where + listDim [] = [] + listDim a@(x:_) = (fromIntegral (length a)) : listDim x + +genPyType :: [Integer] -> Type +genPyType dims = (ConT ''Tensor) `AppT` (loop dims) `AppT` (ConT ''Float) `AppT` (ConT ''PyString) + where + loop :: [Integer] -> Type + loop [] = PromotedNilT + loop (x:xs) = PromotedConsT `AppT` (LitT (NumTyLit x)) `AppT` (loop xs) + +genPyExp :: Show a => a -> Exp +genPyExp values = (ConE 'Tensor) `AppE` (LitE (StringL ("tf.constant(" <> show values <> ")"))) + +-- | Gen tensorflow constant expression +-- +-- $(pyConst1 [3]) means (Tensor "tf.constant([3])" :: Tensor '[1] PyString) +-- $(pyConst1 [3,3]) means (Tensor "tf.constant([3,3])" :: Tensor '[2] PyString) +-- $(pyConst2 [[3,3],[3,3]]) means (Tensor "tf.constant([[3,3],[3,3]])" :: Tensor '[2,2] PyString) +pyConst1 :: [Integer] -> ExpQ +pyConst1 = pyConst + +pyConst2 :: [[Integer]] -> ExpQ +pyConst2 = pyConst + +pyConst3 :: [[[Integer]]] -> ExpQ +pyConst3 = pyConst + +pyConst4 :: [[[[Integer]]]] -> ExpQ +pyConst4 = pyConst + +pyConst :: (Show a,ListDimension a) => a -> ExpQ +pyConst values = return (SigE (genPyExp values) (genPyType (listDim values))) diff --git a/src/MathFlow/TF.hs b/src/MathFlow/TF.hs new file mode 100644 --- /dev/null +++ b/src/MathFlow/TF.hs @@ -0,0 +1,1821 @@ + +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.TF where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow.Core +import MathFlow.PyString + + + +assert :: Tensor n t a +assert = TSym "tf.Assert" + + +noGradient :: String -> Tensor n t a +noGradient op_type = TSym "tf.NoGradient" <+> TArgS "op_type" op_type + + +notDifferentiable :: String -> Tensor n t a +notDifferentiable op_type = TSym "tf.NotDifferentiable" <+> TArgS "op_type" op_type + +tfPrint' :: String -> String -> String -> String -> String -> String -> Tensor n t a +tfPrint' input_ data' message first_n summarize name = TSym "tf.Print" <+> TArgS "input_" input_ <+> TArgS "data" data' <+> TArgS "message" message <+> TArgS "first_n" first_n <+> TArgS "summarize" summarize <+> TArgS "name" name +tfPrint :: String -> String -> Tensor n t a +tfPrint input_ data' = TSym "tf.Print" <+> TArgS "input_" input_ <+> TArgS "data" data' + +abs' :: Tensor n t a -> String -> Tensor n t a +abs' x name = TSym "tf.abs" <+> TArgT "x" x <+> TArgS "name" name + + +accumulateN' :: SingI n => String -> Sing n -> String -> String -> Tensor n t a +accumulateN' inputs shape tensor_dtype name = TSym "tf.accumulate_n" <+> TArgS "inputs" inputs <+> TArgSing "shape" shape <+> TArgS "tensor_dtype" tensor_dtype <+> TArgS "name" name +accumulateN :: String -> Tensor n t a +accumulateN inputs = TSym "tf.accumulate_n" <+> TArgS "inputs" inputs + +acos' :: Tensor n t a -> String -> Tensor n t a +acos' x name = TSym "tf.acos" <+> TArgT "x" x <+> TArgS "name" name + + +add' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +add' x y name = TSym "tf.add" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +add :: Tensor n t a -> Tensor n t a -> Tensor n t a +add x y = TSym "tf.add" <+> TArgT "x" x <+> TArgT "y" y + + +addCheckNumericsOps :: Tensor n t a +addCheckNumericsOps = TSym "tf.add_check_numerics_ops" + +addN' :: String -> String -> Tensor n t a +addN' inputs name = TSym "tf.add_n" <+> TArgS "inputs" inputs <+> TArgS "name" name +addN :: String -> Tensor n t a +addN inputs = TSym "tf.add_n" <+> TArgS "inputs" inputs + + +addToCollection :: String -> String -> Tensor n t a +addToCollection name value = TSym "tf.add_to_collection" <+> TArgS "name" name <+> TArgS "value" value + + +allVariables :: Tensor n t a +allVariables = TSym "tf.all_variables" + +argMax' :: String -> String -> String -> Tensor n t a +argMax' input dimension name = TSym "tf.arg_max" <+> TArgS "input" input <+> TArgS "dimension" dimension <+> TArgS "name" name +argMax :: String -> String -> Tensor n t a +argMax input dimension = TSym "tf.arg_max" <+> TArgS "input" input <+> TArgS "dimension" dimension + +argMin' :: String -> String -> String -> Tensor n t a +argMin' input dimension name = TSym "tf.arg_min" <+> TArgS "input" input <+> TArgS "dimension" dimension <+> TArgS "name" name +argMin :: String -> String -> Tensor n t a +argMin input dimension = TSym "tf.arg_min" <+> TArgS "input" input <+> TArgS "dimension" dimension + +argmax' :: String -> String -> String -> String -> Tensor n t a +argmax' input axis name dimension = TSym "tf.argmax" <+> TArgS "input" input <+> TArgS "axis" axis <+> TArgS "name" name <+> TArgS "dimension" dimension +argmax :: String -> Tensor n t a +argmax input = TSym "tf.argmax" <+> TArgS "input" input + +argmin' :: String -> String -> String -> String -> Tensor n t a +argmin' input axis name dimension = TSym "tf.argmin" <+> TArgS "input" input <+> TArgS "axis" axis <+> TArgS "name" name <+> TArgS "dimension" dimension +argmin :: String -> Tensor n t a +argmin input = TSym "tf.argmin" <+> TArgS "input" input + + +asDtype :: String -> Tensor n t a +asDtype type_value = TSym "tf.as_dtype" <+> TArgS "type_value" type_value + +asString' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +asString' input precision scientific shortest width fill name = TSym "tf.as_string" <+> TArgS "input" input <+> TArgS "precision" precision <+> TArgS "scientific" scientific <+> TArgS "shortest" shortest <+> TArgS "width" width <+> TArgS "fill" fill <+> TArgS "name" name +asString :: String -> Tensor n t a +asString input = TSym "tf.as_string" <+> TArgS "input" input + +asin' :: Tensor n t a -> String -> Tensor n t a +asin' x name = TSym "tf.asin" <+> TArgT "x" x <+> TArgS "name" name + + +assertEqual' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertEqual' x y data' summarize message name = TSym "tf.assert_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +assertEqual x y = TSym "tf.assert_equal" <+> TArgT "x" x <+> TArgT "y" y + +assertGreater' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertGreater' x y data' summarize message name = TSym "tf.assert_greater" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertGreater :: Tensor n t a -> Tensor n t a -> Tensor n t a +assertGreater x y = TSym "tf.assert_greater" <+> TArgT "x" x <+> TArgT "y" y + +assertGreaterEqual' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertGreaterEqual' x y data' summarize message name = TSym "tf.assert_greater_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertGreaterEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +assertGreaterEqual x y = TSym "tf.assert_greater_equal" <+> TArgT "x" x <+> TArgT "y" y + +assertInteger' :: Tensor n t a -> String -> String -> Tensor n t a +assertInteger' x message name = TSym "tf.assert_integer" <+> TArgT "x" x <+> TArgS "message" message <+> TArgS "name" name +assertInteger :: Tensor n t a -> Tensor n t a +assertInteger x = TSym "tf.assert_integer" <+> TArgT "x" x + +assertLess' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertLess' x y data' summarize message name = TSym "tf.assert_less" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertLess :: Tensor n t a -> Tensor n t a -> Tensor n t a +assertLess x y = TSym "tf.assert_less" <+> TArgT "x" x <+> TArgT "y" y + +assertLessEqual' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertLessEqual' x y data' summarize message name = TSym "tf.assert_less_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertLessEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +assertLessEqual x y = TSym "tf.assert_less_equal" <+> TArgT "x" x <+> TArgT "y" y + +assertNegative' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertNegative' x data' summarize message name = TSym "tf.assert_negative" <+> TArgT "x" x <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertNegative :: Tensor n t a -> Tensor n t a +assertNegative x = TSym "tf.assert_negative" <+> TArgT "x" x + +assertNonNegative' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertNonNegative' x data' summarize message name = TSym "tf.assert_non_negative" <+> TArgT "x" x <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertNonNegative :: Tensor n t a -> Tensor n t a +assertNonNegative x = TSym "tf.assert_non_negative" <+> TArgT "x" x + +assertNonPositive' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertNonPositive' x data' summarize message name = TSym "tf.assert_non_positive" <+> TArgT "x" x <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertNonPositive :: Tensor n t a -> Tensor n t a +assertNonPositive x = TSym "tf.assert_non_positive" <+> TArgT "x" x + +assertNoneEqual' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertNoneEqual' x y data' summarize message name = TSym "tf.assert_none_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertNoneEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +assertNoneEqual x y = TSym "tf.assert_none_equal" <+> TArgT "x" x <+> TArgT "y" y + +assertPositive' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +assertPositive' x data' summarize message name = TSym "tf.assert_positive" <+> TArgT "x" x <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertPositive :: Tensor n t a -> Tensor n t a +assertPositive x = TSym "tf.assert_positive" <+> TArgT "x" x + + +assertProperIterable :: String -> Tensor n t a +assertProperIterable values = TSym "tf.assert_proper_iterable" <+> TArgS "values" values + +assertRank' :: Tensor n t a -> String -> String -> String -> String -> String -> Tensor n t a +assertRank' x rank data' summarize message name = TSym "tf.assert_rank" <+> TArgT "x" x <+> TArgS "rank" rank <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertRank :: Tensor n t a -> String -> Tensor n t a +assertRank x rank = TSym "tf.assert_rank" <+> TArgT "x" x <+> TArgS "rank" rank + +assertRankAtLeast' :: Tensor n t a -> String -> String -> String -> String -> String -> Tensor n t a +assertRankAtLeast' x rank data' summarize message name = TSym "tf.assert_rank_at_least" <+> TArgT "x" x <+> TArgS "rank" rank <+> TArgS "data" data' <+> TArgS "summarize" summarize <+> TArgS "message" message <+> TArgS "name" name +assertRankAtLeast :: Tensor n t a -> String -> Tensor n t a +assertRankAtLeast x rank = TSym "tf.assert_rank_at_least" <+> TArgT "x" x <+> TArgS "rank" rank + + +assertSameFloatDtype :: Tensor n t a +assertSameFloatDtype = TSym "tf.assert_same_float_dtype" + +assertScalar' :: Tensor n t a -> String -> Tensor n t a +assertScalar' tensor name = TSym "tf.assert_scalar" <+> TArgT "tensor" tensor <+> TArgS "name" name +assertScalar :: Tensor n t a -> Tensor n t a +assertScalar tensor = TSym "tf.assert_scalar" <+> TArgT "tensor" tensor + +assertType' :: Tensor n t a -> String -> String -> String -> Tensor n t a +assertType' tensor tf_type message name = TSym "tf.assert_type" <+> TArgT "tensor" tensor <+> TArgS "tf_type" tf_type <+> TArgS "message" message <+> TArgS "name" name +assertType :: Tensor n t a -> String -> Tensor n t a +assertType tensor tf_type = TSym "tf.assert_type" <+> TArgT "tensor" tensor <+> TArgS "tf_type" tf_type + + +assertVariablesInitialized :: Tensor n t a +assertVariablesInitialized = TSym "tf.assert_variables_initialized" + +assign' :: String -> String -> String -> String -> String -> Tensor n t a +assign' ref value validate_shape use_locking name = TSym "tf.assign" <+> TArgS "ref" ref <+> TArgS "value" value <+> TArgS "validate_shape" validate_shape <+> TArgS "use_locking" use_locking <+> TArgS "name" name +assign :: String -> String -> Tensor n t a +assign ref value = TSym "tf.assign" <+> TArgS "ref" ref <+> TArgS "value" value + +assignAdd' :: String -> String -> String -> String -> Tensor n t a +assignAdd' ref value use_locking name = TSym "tf.assign_add" <+> TArgS "ref" ref <+> TArgS "value" value <+> TArgS "use_locking" use_locking <+> TArgS "name" name +assignAdd :: String -> String -> Tensor n t a +assignAdd ref value = TSym "tf.assign_add" <+> TArgS "ref" ref <+> TArgS "value" value + +assignSub' :: String -> String -> String -> String -> Tensor n t a +assignSub' ref value use_locking name = TSym "tf.assign_sub" <+> TArgS "ref" ref <+> TArgS "value" value <+> TArgS "use_locking" use_locking <+> TArgS "name" name +assignSub :: String -> String -> Tensor n t a +assignSub ref value = TSym "tf.assign_sub" <+> TArgS "ref" ref <+> TArgS "value" value + +atan' :: Tensor n t a -> String -> Tensor n t a +atan' x name = TSym "tf.atan" <+> TArgT "x" x <+> TArgS "name" name + + +atan2' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +atan2' y x name = TSym "tf.atan2" <+> TArgT "y" y <+> TArgT "x" x <+> TArgS "name" name +atan2 :: Tensor n t a -> Tensor n t a -> Tensor n t a +atan2 y x = TSym "tf.atan2" <+> TArgT "y" y <+> TArgT "x" x + +batchToSpace' :: String -> String -> String -> String -> Tensor n t a +batchToSpace' input crops block_size name = TSym "tf.batch_to_space" <+> TArgS "input" input <+> TArgS "crops" crops <+> TArgS "block_size" block_size <+> TArgS "name" name +batchToSpace :: String -> String -> String -> Tensor n t a +batchToSpace input crops block_size = TSym "tf.batch_to_space" <+> TArgS "input" input <+> TArgS "crops" crops <+> TArgS "block_size" block_size + +batchToSpaceNd' :: String -> String -> String -> String -> Tensor n t a +batchToSpaceNd' input block_shape crops name = TSym "tf.batch_to_space_nd" <+> TArgS "input" input <+> TArgS "block_shape" block_shape <+> TArgS "crops" crops <+> TArgS "name" name +batchToSpaceNd :: String -> String -> String -> Tensor n t a +batchToSpaceNd input block_shape crops = TSym "tf.batch_to_space_nd" <+> TArgS "input" input <+> TArgS "block_shape" block_shape <+> TArgS "crops" crops + +betainc' :: Tensor n t a -> Tensor n t a -> Tensor n t a -> String -> Tensor n t a +betainc' a b x name = TSym "tf.betainc" <+> TArgT "a" a <+> TArgT "b" b <+> TArgT "x" x <+> TArgS "name" name +betainc :: Tensor n t a -> Tensor n t a -> Tensor n t a -> Tensor n t a +betainc a b x = TSym "tf.betainc" <+> TArgT "a" a <+> TArgT "b" b <+> TArgT "x" x + +bincount' :: String -> String -> String -> String -> String -> Tensor n t a +bincount' arr weights minlength maxlength dtype = TSym "tf.bincount" <+> TArgS "arr" arr <+> TArgS "weights" weights <+> TArgS "minlength" minlength <+> TArgS "maxlength" maxlength <+> TArgS "dtype" dtype +bincount :: String -> Tensor n t a +bincount arr = TSym "tf.bincount" <+> TArgS "arr" arr + +bitcast' :: String -> String -> String -> Tensor n t a +bitcast' input type' name = TSym "tf.bitcast" <+> TArgS "input" input <+> TArgS "type" type' <+> TArgS "name" name +bitcast :: String -> String -> Tensor n t a +bitcast input type' = TSym "tf.bitcast" <+> TArgS "input" input <+> TArgS "type" type' + +booleanMask' :: Tensor n t a -> String -> String -> Tensor n t a +booleanMask' tensor mask name = TSym "tf.boolean_mask" <+> TArgT "tensor" tensor <+> TArgS "mask" mask <+> TArgS "name" name +booleanMask :: Tensor n t a -> String -> Tensor n t a +booleanMask tensor mask = TSym "tf.boolean_mask" <+> TArgT "tensor" tensor <+> TArgS "mask" mask + + +broadcastDynamicShape :: String -> String -> Tensor n t a +broadcastDynamicShape shape_x shape_y = TSym "tf.broadcast_dynamic_shape" <+> TArgS "shape_x" shape_x <+> TArgS "shape_y" shape_y + + +broadcastStaticShape :: String -> String -> Tensor n t a +broadcastStaticShape shape_x shape_y = TSym "tf.broadcast_static_shape" <+> TArgS "shape_x" shape_x <+> TArgS "shape_y" shape_y + +tfcase' :: String -> String -> String -> String -> String -> Tensor n t a +tfcase' pred_fn_pairs default' exclusive strict name = TSym "tf.case" <+> TArgS "pred_fn_pairs" pred_fn_pairs <+> TArgS "default" default' <+> TArgS "exclusive" exclusive <+> TArgS "strict" strict <+> TArgS "name" name +tfcase :: String -> String -> Tensor n t a +tfcase pred_fn_pairs default' = TSym "tf.case" <+> TArgS "pred_fn_pairs" pred_fn_pairs <+> TArgS "default" default' + +cast' :: Tensor n t a -> String -> String -> Tensor n t a +cast' x dtype name = TSym "tf.cast" <+> TArgT "x" x <+> TArgS "dtype" dtype <+> TArgS "name" name +cast :: Tensor n t a -> String -> Tensor n t a +cast x dtype = TSym "tf.cast" <+> TArgT "x" x <+> TArgS "dtype" dtype + +ceil' :: Tensor n t a -> String -> Tensor n t a +ceil' x name = TSym "tf.ceil" <+> TArgT "x" x <+> TArgS "name" name +ceil :: Tensor n t a -> Tensor n t a +ceil x = TSym "tf.ceil" <+> TArgT "x" x + +checkNumerics' :: Tensor n t a -> String -> String -> Tensor n t a +checkNumerics' tensor message name = TSym "tf.check_numerics" <+> TArgT "tensor" tensor <+> TArgS "message" message <+> TArgS "name" name +checkNumerics :: Tensor n t a -> String -> Tensor n t a +checkNumerics tensor message = TSym "tf.check_numerics" <+> TArgT "tensor" tensor <+> TArgS "message" message + +cholesky' :: String -> String -> Tensor n t a +cholesky' input name = TSym "tf.cholesky" <+> TArgS "input" input <+> TArgS "name" name +cholesky :: String -> Tensor n t a +cholesky input = TSym "tf.cholesky" <+> TArgS "input" input + +choleskySolve' :: String -> String -> String -> Tensor n t a +choleskySolve' chol rhs name = TSym "tf.cholesky_solve" <+> TArgS "chol" chol <+> TArgS "rhs" rhs <+> TArgS "name" name +choleskySolve :: String -> String -> Tensor n t a +choleskySolve chol rhs = TSym "tf.cholesky_solve" <+> TArgS "chol" chol <+> TArgS "rhs" rhs + +clipByAverageNorm' :: String -> String -> String -> Tensor n t a +clipByAverageNorm' t clip_norm name = TSym "tf.clip_by_average_norm" <+> TArgS "t" t <+> TArgS "clip_norm" clip_norm <+> TArgS "name" name +clipByAverageNorm :: String -> String -> Tensor n t a +clipByAverageNorm t clip_norm = TSym "tf.clip_by_average_norm" <+> TArgS "t" t <+> TArgS "clip_norm" clip_norm + +clipByGlobalNorm' :: String -> String -> String -> String -> Tensor n t a +clipByGlobalNorm' t_list clip_norm use_norm name = TSym "tf.clip_by_global_norm" <+> TArgS "t_list" t_list <+> TArgS "clip_norm" clip_norm <+> TArgS "use_norm" use_norm <+> TArgS "name" name +clipByGlobalNorm :: String -> String -> Tensor n t a +clipByGlobalNorm t_list clip_norm = TSym "tf.clip_by_global_norm" <+> TArgS "t_list" t_list <+> TArgS "clip_norm" clip_norm + +clipByNorm' :: String -> String -> String -> String -> Tensor n t a +clipByNorm' t clip_norm axes name = TSym "tf.clip_by_norm" <+> TArgS "t" t <+> TArgS "clip_norm" clip_norm <+> TArgS "axes" axes <+> TArgS "name" name +clipByNorm :: String -> String -> Tensor n t a +clipByNorm t clip_norm = TSym "tf.clip_by_norm" <+> TArgS "t" t <+> TArgS "clip_norm" clip_norm + +clipByValue' :: String -> String -> String -> String -> Tensor n t a +clipByValue' t clip_value_min clip_value_max name = TSym "tf.clip_by_value" <+> TArgS "t" t <+> TArgS "clip_value_min" clip_value_min <+> TArgS "clip_value_max" clip_value_max <+> TArgS "name" name +clipByValue :: String -> String -> String -> Tensor n t a +clipByValue t clip_value_min clip_value_max = TSym "tf.clip_by_value" <+> TArgS "t" t <+> TArgS "clip_value_min" clip_value_min <+> TArgS "clip_value_max" clip_value_max + +complex' :: String -> String -> String -> Tensor n t a +complex' real imag name = TSym "tf.complex" <+> TArgS "real" real <+> TArgS "imag" imag <+> TArgS "name" name +complex :: String -> String -> Tensor n t a +complex real imag = TSym "tf.complex" <+> TArgS "real" real <+> TArgS "imag" imag + +concat' :: String -> String -> String -> Tensor n t a +concat' values axis name = TSym "tf.concat" <+> TArgS "values" values <+> TArgS "axis" axis <+> TArgS "name" name +concat :: String -> String -> Tensor n t a +concat values axis = TSym "tf.concat" <+> TArgS "values" values <+> TArgS "axis" axis + + +cond :: Tensor n t a +cond = TSym "tf.cond" + +confusionMatrix' :: String -> String -> String -> String -> String -> String -> Tensor n t a +confusionMatrix' labels predictions num_classes dtype name weights = TSym "tf.confusion_matrix" <+> TArgS "labels" labels <+> TArgS "predictions" predictions <+> TArgS "num_classes" num_classes <+> TArgS "dtype" dtype <+> TArgS "name" name <+> TArgS "weights" weights +confusionMatrix :: String -> String -> Tensor n t a +confusionMatrix labels predictions = TSym "tf.confusion_matrix" <+> TArgS "labels" labels <+> TArgS "predictions" predictions + +conj' :: Tensor n t a -> String -> Tensor n t a +conj' x name = TSym "tf.conj" <+> TArgT "x" x <+> TArgS "name" name +conj :: Tensor n t a -> Tensor n t a +conj x = TSym "tf.conj" <+> TArgT "x" x + +constant' :: SingI n => String -> String -> Sing n -> String -> String -> Tensor n t a +constant' value dtype shape name verify_shape = TSym "tf.constant" <+> TArgS "value" value <+> TArgS "dtype" dtype <+> TArgSing "shape" shape <+> TArgS "name" name <+> TArgS "verify_shape" verify_shape +constant :: String -> Tensor n t a +constant value = TSym "tf.constant" <+> TArgS "value" value + + +container :: String -> Tensor n t a +container container_name = TSym "tf.container" <+> TArgS "container_name" container_name + + +controlDependencies :: String -> Tensor n t a +controlDependencies control_inputs = TSym "tf.control_dependencies" <+> TArgS "control_inputs" control_inputs + +convertToTensor' :: String -> String -> String -> String -> Tensor n t a +convertToTensor' value dtype name preferred_dtype = TSym "tf.convert_to_tensor" <+> TArgS "value" value <+> TArgS "dtype" dtype <+> TArgS "name" name <+> TArgS "preferred_dtype" preferred_dtype +convertToTensor :: String -> Tensor n t a +convertToTensor value = TSym "tf.convert_to_tensor" <+> TArgS "value" value + +convertToTensorOrIndexedSlices' :: String -> String -> String -> Tensor n t a +convertToTensorOrIndexedSlices' value dtype name = TSym "tf.convert_to_tensor_or_indexed_slices" <+> TArgS "value" value <+> TArgS "dtype" dtype <+> TArgS "name" name +convertToTensorOrIndexedSlices :: String -> Tensor n t a +convertToTensorOrIndexedSlices value = TSym "tf.convert_to_tensor_or_indexed_slices" <+> TArgS "value" value + +convertToTensorOrSparseTensor' :: String -> String -> String -> Tensor n t a +convertToTensorOrSparseTensor' value dtype name = TSym "tf.convert_to_tensor_or_sparse_tensor" <+> TArgS "value" value <+> TArgS "dtype" dtype <+> TArgS "name" name +convertToTensorOrSparseTensor :: String -> Tensor n t a +convertToTensorOrSparseTensor value = TSym "tf.convert_to_tensor_or_sparse_tensor" <+> TArgS "value" value + +cos' :: Tensor n t a -> String -> Tensor n t a +cos' x name = TSym "tf.cos" <+> TArgT "x" x <+> TArgS "name" name + + +countNonzero' :: String -> String -> String -> String -> String -> String -> Tensor n t a +countNonzero' input_tensor axis keep_dims dtype name reduction_indices = TSym "tf.count_nonzero" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "dtype" dtype <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +countNonzero :: String -> Tensor n t a +countNonzero input_tensor = TSym "tf.count_nonzero" <+> TArgS "input_tensor" input_tensor + +countUpTo' :: String -> String -> String -> Tensor n t a +countUpTo' ref limit name = TSym "tf.count_up_to" <+> TArgS "ref" ref <+> TArgS "limit" limit <+> TArgS "name" name +countUpTo :: String -> String -> Tensor n t a +countUpTo ref limit = TSym "tf.count_up_to" <+> TArgS "ref" ref <+> TArgS "limit" limit + +createPartitionedVariables' :: SingI n => Sing n -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +createPartitionedVariables' shape slicing initializer dtype trainable collections name reuse = TSym "tf.create_partitioned_variables" <+> TArgSing "shape" shape <+> TArgS "slicing" slicing <+> TArgS "initializer" initializer <+> TArgS "dtype" dtype <+> TArgS "trainable" trainable <+> TArgS "collections" collections <+> TArgS "name" name <+> TArgS "reuse" reuse +createPartitionedVariables :: SingI n => Sing n -> String -> String -> Tensor n t a +createPartitionedVariables shape slicing initializer = TSym "tf.create_partitioned_variables" <+> TArgSing "shape" shape <+> TArgS "slicing" slicing <+> TArgS "initializer" initializer + +cross' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +cross' a b name = TSym "tf.cross" <+> TArgT "a" a <+> TArgT "b" b <+> TArgS "name" name +cross :: Tensor n t a -> Tensor n t a -> Tensor n t a +cross a b = TSym "tf.cross" <+> TArgT "a" a <+> TArgT "b" b + +cumprod' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +cumprod' x axis exclusive reverse name = TSym "tf.cumprod" <+> TArgT "x" x <+> TArgS "axis" axis <+> TArgS "exclusive" exclusive <+> TArgS "reverse" reverse <+> TArgS "name" name +cumprod :: Tensor n t a -> Tensor n t a +cumprod x = TSym "tf.cumprod" <+> TArgT "x" x + +cumsum' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +cumsum' x axis exclusive reverse name = TSym "tf.cumsum" <+> TArgT "x" x <+> TArgS "axis" axis <+> TArgS "exclusive" exclusive <+> TArgS "reverse" reverse <+> TArgS "name" name +cumsum :: Tensor n t a -> Tensor n t a +cumsum x = TSym "tf.cumsum" <+> TArgT "x" x + +decodeBase64' :: String -> String -> Tensor n t a +decodeBase64' input name = TSym "tf.decode_base64" <+> TArgS "input" input <+> TArgS "name" name +decodeBase64 :: String -> Tensor n t a +decodeBase64 input = TSym "tf.decode_base64" <+> TArgS "input" input + +decodeCsv' :: String -> String -> String -> String -> Tensor n t a +decodeCsv' records record_defaults field_delim name = TSym "tf.decode_csv" <+> TArgS "records" records <+> TArgS "record_defaults" record_defaults <+> TArgS "field_delim" field_delim <+> TArgS "name" name +decodeCsv :: String -> String -> Tensor n t a +decodeCsv records record_defaults = TSym "tf.decode_csv" <+> TArgS "records" records <+> TArgS "record_defaults" record_defaults + +decodeJsonExample' :: String -> String -> Tensor n t a +decodeJsonExample' json_examples name = TSym "tf.decode_json_example" <+> TArgS "json_examples" json_examples <+> TArgS "name" name +decodeJsonExample :: String -> Tensor n t a +decodeJsonExample json_examples = TSym "tf.decode_json_example" <+> TArgS "json_examples" json_examples + +decodeRaw' :: String -> String -> String -> String -> Tensor n t a +decodeRaw' bytes out_type little_endian name = TSym "tf.decode_raw" <+> TArgS "bytes" bytes <+> TArgS "out_type" out_type <+> TArgS "little_endian" little_endian <+> TArgS "name" name +decodeRaw :: String -> String -> Tensor n t a +decodeRaw bytes out_type = TSym "tf.decode_raw" <+> TArgS "bytes" bytes <+> TArgS "out_type" out_type + +deleteSessionTensor' :: String -> String -> Tensor n t a +deleteSessionTensor' handle name = TSym "tf.delete_session_tensor" <+> TArgS "handle" handle <+> TArgS "name" name +deleteSessionTensor :: String -> Tensor n t a +deleteSessionTensor handle = TSym "tf.delete_session_tensor" <+> TArgS "handle" handle + +depthToSpace' :: String -> String -> String -> Tensor n t a +depthToSpace' input block_size name = TSym "tf.depth_to_space" <+> TArgS "input" input <+> TArgS "block_size" block_size <+> TArgS "name" name +depthToSpace :: String -> String -> Tensor n t a +depthToSpace input block_size = TSym "tf.depth_to_space" <+> TArgS "input" input <+> TArgS "block_size" block_size + +dequantize' :: String -> String -> String -> String -> String -> Tensor n t a +dequantize' input min_range max_range mode name = TSym "tf.dequantize" <+> TArgS "input" input <+> TArgS "min_range" min_range <+> TArgS "max_range" max_range <+> TArgS "mode" mode <+> TArgS "name" name +dequantize :: String -> String -> String -> Tensor n t a +dequantize input min_range max_range = TSym "tf.dequantize" <+> TArgS "input" input <+> TArgS "min_range" min_range <+> TArgS "max_range" max_range + +deserializeManySparse' :: String -> String -> String -> String -> Tensor n t a +deserializeManySparse' serialized_sparse dtype rank name = TSym "tf.deserialize_many_sparse" <+> TArgS "serialized_sparse" serialized_sparse <+> TArgS "dtype" dtype <+> TArgS "rank" rank <+> TArgS "name" name +deserializeManySparse :: String -> String -> Tensor n t a +deserializeManySparse serialized_sparse dtype = TSym "tf.deserialize_many_sparse" <+> TArgS "serialized_sparse" serialized_sparse <+> TArgS "dtype" dtype + + +device :: String -> Tensor n t a +device device_name_or_function = TSym "tf.device" <+> TArgS "device_name_or_function" device_name_or_function + +diag' :: String -> String -> Tensor n t a +diag' diagonal name = TSym "tf.diag" <+> TArgS "diagonal" diagonal <+> TArgS "name" name +diag :: String -> Tensor n t a +diag diagonal = TSym "tf.diag" <+> TArgS "diagonal" diagonal + +diagPart' :: String -> String -> Tensor n t a +diagPart' input name = TSym "tf.diag_part" <+> TArgS "input" input <+> TArgS "name" name +diagPart :: String -> Tensor n t a +diagPart input = TSym "tf.diag_part" <+> TArgS "input" input + +digamma' :: Tensor n t a -> String -> Tensor n t a +digamma' x name = TSym "tf.digamma" <+> TArgT "x" x <+> TArgS "name" name +digamma :: Tensor n t a -> Tensor n t a +digamma x = TSym "tf.digamma" <+> TArgT "x" x + +div' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +div' x y name = TSym "tf.div" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +div :: Tensor n t a -> Tensor n t a -> Tensor n t a +div x y = TSym "tf.div" <+> TArgT "x" x <+> TArgT "y" y + +divide' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +divide' x y name = TSym "tf.divide" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +divide :: Tensor n t a -> Tensor n t a -> Tensor n t a +divide x y = TSym "tf.divide" <+> TArgT "x" x <+> TArgT "y" y + +dynamicPartition' :: String -> String -> String -> String -> Tensor n t a +dynamicPartition' data' partitions num_partitions name = TSym "tf.dynamic_partition" <+> TArgS "data" data' <+> TArgS "partitions" partitions <+> TArgS "num_partitions" num_partitions <+> TArgS "name" name +dynamicPartition :: String -> String -> String -> Tensor n t a +dynamicPartition data' partitions num_partitions = TSym "tf.dynamic_partition" <+> TArgS "data" data' <+> TArgS "partitions" partitions <+> TArgS "num_partitions" num_partitions + +dynamicStitch' :: String -> String -> String -> Tensor n t a +dynamicStitch' indices data' name = TSym "tf.dynamic_stitch" <+> TArgS "indices" indices <+> TArgS "data" data' <+> TArgS "name" name +dynamicStitch :: String -> String -> Tensor n t a +dynamicStitch indices data' = TSym "tf.dynamic_stitch" <+> TArgS "indices" indices <+> TArgS "data" data' + +editDistance' :: String -> String -> String -> String -> Tensor n t a +editDistance' hypothesis truth normalize name = TSym "tf.edit_distance" <+> TArgS "hypothesis" hypothesis <+> TArgS "truth" truth <+> TArgS "normalize" normalize <+> TArgS "name" name +editDistance :: String -> String -> Tensor n t a +editDistance hypothesis truth = TSym "tf.edit_distance" <+> TArgS "hypothesis" hypothesis <+> TArgS "truth" truth + + +einsum :: String -> Tensor n t a +einsum equation = TSym "tf.einsum" <+> TArgS "equation" equation + +encodeBase64' :: String -> String -> String -> Tensor n t a +encodeBase64' input pad name = TSym "tf.encode_base64" <+> TArgS "input" input <+> TArgS "pad" pad <+> TArgS "name" name +encodeBase64 :: String -> Tensor n t a +encodeBase64 input = TSym "tf.encode_base64" <+> TArgS "input" input + +equal' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +equal' x y name = TSym "tf.equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +equal :: Tensor n t a -> Tensor n t a -> Tensor n t a +equal x y = TSym "tf.equal" <+> TArgT "x" x <+> TArgT "y" y + +erf' :: Tensor n t a -> String -> Tensor n t a +erf' x name = TSym "tf.erf" <+> TArgT "x" x <+> TArgS "name" name +erf :: Tensor n t a -> Tensor n t a +erf x = TSym "tf.erf" <+> TArgT "x" x + +erfc' :: Tensor n t a -> String -> Tensor n t a +erfc' x name = TSym "tf.erfc" <+> TArgT "x" x <+> TArgS "name" name +erfc :: Tensor n t a -> Tensor n t a +erfc x = TSym "tf.erfc" <+> TArgT "x" x + +exp' :: Tensor n t a -> String -> Tensor n t a +exp' x name = TSym "tf.exp" <+> TArgT "x" x <+> TArgS "name" name +exp :: Tensor n t a -> Tensor n t a +exp x = TSym "tf.exp" <+> TArgT "x" x + +expandDims' :: String -> String -> String -> String -> Tensor n t a +expandDims' input axis name dim = TSym "tf.expand_dims" <+> TArgS "input" input <+> TArgS "axis" axis <+> TArgS "name" name <+> TArgS "dim" dim +expandDims :: String -> Tensor n t a +expandDims input = TSym "tf.expand_dims" <+> TArgS "input" input + +expm1' :: Tensor n t a -> String -> Tensor n t a +expm1' x name = TSym "tf.expm1" <+> TArgT "x" x <+> TArgS "name" name +expm1 :: Tensor n t a -> Tensor n t a +expm1 x = TSym "tf.expm1" <+> TArgT "x" x + +extractImagePatches' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +extractImagePatches' images ksizes strides rates padding name = TSym "tf.extract_image_patches" <+> TArgS "images" images <+> TArgS "ksizes" ksizes <+> TArgSing "strides" strides <+> TArgS "rates" rates <+> TArgS "padding" padding <+> TArgS "name" name +extractImagePatches :: SingI n => String -> String -> Sing n -> String -> String -> Tensor n t a +extractImagePatches images ksizes strides rates padding = TSym "tf.extract_image_patches" <+> TArgS "images" images <+> TArgS "ksizes" ksizes <+> TArgSing "strides" strides <+> TArgS "rates" rates <+> TArgS "padding" padding + +eye' :: String -> String -> String -> String -> String -> Tensor n t a +eye' num_rows num_columns batch_shape dtype name = TSym "tf.eye" <+> TArgS "num_rows" num_rows <+> TArgS "num_columns" num_columns <+> TArgS "batch_shape" batch_shape <+> TArgS "dtype" dtype <+> TArgS "name" name +eye :: String -> Tensor n t a +eye num_rows = TSym "tf.eye" <+> TArgS "num_rows" num_rows + +fakeQuantWithMinMaxArgs' :: String -> String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxArgs' inputs min max num_bits name = TSym "tf.fake_quant_with_min_max_args" <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max <+> TArgS "num_bits" num_bits <+> TArgS "name" name +fakeQuantWithMinMaxArgs :: String -> Tensor n t a +fakeQuantWithMinMaxArgs inputs = TSym "tf.fake_quant_with_min_max_args" <+> TArgS "inputs" inputs + +fakeQuantWithMinMaxArgsGradient' :: String -> String -> String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxArgsGradient' gradients inputs min max num_bits name = TSym "tf.fake_quant_with_min_max_args_gradient" <+> TArgS "gradients" gradients <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max <+> TArgS "num_bits" num_bits <+> TArgS "name" name +fakeQuantWithMinMaxArgsGradient :: String -> String -> Tensor n t a +fakeQuantWithMinMaxArgsGradient gradients inputs = TSym "tf.fake_quant_with_min_max_args_gradient" <+> TArgS "gradients" gradients <+> TArgS "inputs" inputs + +fakeQuantWithMinMaxVars' :: String -> String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVars' inputs min max num_bits name = TSym "tf.fake_quant_with_min_max_vars" <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max <+> TArgS "num_bits" num_bits <+> TArgS "name" name +fakeQuantWithMinMaxVars :: String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVars inputs min max = TSym "tf.fake_quant_with_min_max_vars" <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max + +fakeQuantWithMinMaxVarsGradient' :: String -> String -> String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVarsGradient' gradients inputs min max num_bits name = TSym "tf.fake_quant_with_min_max_vars_gradient" <+> TArgS "gradients" gradients <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max <+> TArgS "num_bits" num_bits <+> TArgS "name" name +fakeQuantWithMinMaxVarsGradient :: String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVarsGradient gradients inputs min max = TSym "tf.fake_quant_with_min_max_vars_gradient" <+> TArgS "gradients" gradients <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max + +fakeQuantWithMinMaxVarsPerChannel' :: String -> String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVarsPerChannel' inputs min max num_bits name = TSym "tf.fake_quant_with_min_max_vars_per_channel" <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max <+> TArgS "num_bits" num_bits <+> TArgS "name" name +fakeQuantWithMinMaxVarsPerChannel :: String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVarsPerChannel inputs min max = TSym "tf.fake_quant_with_min_max_vars_per_channel" <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max + +fakeQuantWithMinMaxVarsPerChannelGradient' :: String -> String -> String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVarsPerChannelGradient' gradients inputs min max num_bits name = TSym "tf.fake_quant_with_min_max_vars_per_channel_gradient" <+> TArgS "gradients" gradients <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max <+> TArgS "num_bits" num_bits <+> TArgS "name" name +fakeQuantWithMinMaxVarsPerChannelGradient :: String -> String -> String -> String -> Tensor n t a +fakeQuantWithMinMaxVarsPerChannelGradient gradients inputs min max = TSym "tf.fake_quant_with_min_max_vars_per_channel_gradient" <+> TArgS "gradients" gradients <+> TArgS "inputs" inputs <+> TArgS "min" min <+> TArgS "max" max + +fft' :: String -> String -> Tensor n t a +fft' input name = TSym "tf.fft" <+> TArgS "input" input <+> TArgS "name" name +fft :: String -> Tensor n t a +fft input = TSym "tf.fft" <+> TArgS "input" input + +fft2d' :: String -> String -> Tensor n t a +fft2d' input name = TSym "tf.fft2d" <+> TArgS "input" input <+> TArgS "name" name +fft2d :: String -> Tensor n t a +fft2d input = TSym "tf.fft2d" <+> TArgS "input" input + +fft3d' :: String -> String -> Tensor n t a +fft3d' input name = TSym "tf.fft3d" <+> TArgS "input" input <+> TArgS "name" name +fft3d :: String -> Tensor n t a +fft3d input = TSym "tf.fft3d" <+> TArgS "input" input + +fill' :: String -> String -> String -> Tensor n t a +fill' dims value name = TSym "tf.fill" <+> TArgS "dims" dims <+> TArgS "value" value <+> TArgS "name" name +fill :: String -> String -> Tensor n t a +fill dims value = TSym "tf.fill" <+> TArgS "dims" dims <+> TArgS "value" value + +fixedSizePartitioner' :: String -> String -> Tensor n t a +fixedSizePartitioner' num_shards axis = TSym "tf.fixed_size_partitioner" <+> TArgS "num_shards" num_shards <+> TArgS "axis" axis +fixedSizePartitioner :: String -> Tensor n t a +fixedSizePartitioner num_shards = TSym "tf.fixed_size_partitioner" <+> TArgS "num_shards" num_shards + +floor' :: Tensor n t a -> String -> Tensor n t a +floor' x name = TSym "tf.floor" <+> TArgT "x" x <+> TArgS "name" name +floor :: Tensor n t a -> Tensor n t a +floor x = TSym "tf.floor" <+> TArgT "x" x + +floorDiv' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +floorDiv' x y name = TSym "tf.floor_div" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +floorDiv :: Tensor n t a -> Tensor n t a -> Tensor n t a +floorDiv x y = TSym "tf.floor_div" <+> TArgT "x" x <+> TArgT "y" y + +floordiv' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +floordiv' x y name = TSym "tf.floordiv" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +floordiv :: Tensor n t a -> Tensor n t a -> Tensor n t a +floordiv x y = TSym "tf.floordiv" <+> TArgT "x" x <+> TArgT "y" y + +floormod' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +floormod' x y name = TSym "tf.floormod" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +floormod :: Tensor n t a -> Tensor n t a -> Tensor n t a +floormod x y = TSym "tf.floormod" <+> TArgT "x" x <+> TArgT "y" y + +foldl' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +foldl' fn elems initializer parallel_iterations back_prop swap_memory name = TSym "tf.foldl" <+> TArgS "fn" fn <+> TArgS "elems" elems <+> TArgS "initializer" initializer <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "back_prop" back_prop <+> TArgS "swap_memory" swap_memory <+> TArgS "name" name +foldl :: String -> String -> Tensor n t a +foldl fn elems = TSym "tf.foldl" <+> TArgS "fn" fn <+> TArgS "elems" elems + +foldr' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +foldr' fn elems initializer parallel_iterations back_prop swap_memory name = TSym "tf.foldr" <+> TArgS "fn" fn <+> TArgS "elems" elems <+> TArgS "initializer" initializer <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "back_prop" back_prop <+> TArgS "swap_memory" swap_memory <+> TArgS "name" name +foldr :: String -> String -> Tensor n t a +foldr fn elems = TSym "tf.foldr" <+> TArgS "fn" fn <+> TArgS "elems" elems + +gather' :: String -> String -> String -> String -> Tensor n t a +gather' params indices validate_indices name = TSym "tf.gather" <+> TArgS "params" params <+> TArgS "indices" indices <+> TArgS "validate_indices" validate_indices <+> TArgS "name" name +gather :: String -> String -> Tensor n t a +gather params indices = TSym "tf.gather" <+> TArgS "params" params <+> TArgS "indices" indices + +gatherNd' :: String -> String -> String -> Tensor n t a +gatherNd' params indices name = TSym "tf.gather_nd" <+> TArgS "params" params <+> TArgS "indices" indices <+> TArgS "name" name +gatherNd :: String -> String -> Tensor n t a +gatherNd params indices = TSym "tf.gather_nd" <+> TArgS "params" params <+> TArgS "indices" indices + +getCollection' :: String -> String -> Tensor n t a +getCollection' key scope = TSym "tf.get_collection" <+> TArgS "key" key <+> TArgS "scope" scope +getCollection :: String -> Tensor n t a +getCollection key = TSym "tf.get_collection" <+> TArgS "key" key + + +getCollectionRef :: String -> Tensor n t a +getCollectionRef key = TSym "tf.get_collection_ref" <+> TArgS "key" key + + +getDefaultGraph :: Tensor n t a +getDefaultGraph = TSym "tf.get_default_graph" + + +getDefaultSession :: Tensor n t a +getDefaultSession = TSym "tf.get_default_session" + + +getLocalVariable :: Tensor n t a +getLocalVariable = TSym "tf.get_local_variable" + + +getSeed :: String -> Tensor n t a +getSeed op_seed = TSym "tf.get_seed" <+> TArgS "op_seed" op_seed + +getSessionHandle' :: String -> String -> Tensor n t a +getSessionHandle' data' name = TSym "tf.get_session_handle" <+> TArgS "data" data' <+> TArgS "name" name +getSessionHandle :: String -> Tensor n t a +getSessionHandle data' = TSym "tf.get_session_handle" <+> TArgS "data" data' + +getSessionTensor' :: String -> String -> String -> Tensor n t a +getSessionTensor' handle dtype name = TSym "tf.get_session_tensor" <+> TArgS "handle" handle <+> TArgS "dtype" dtype <+> TArgS "name" name +getSessionTensor :: String -> String -> Tensor n t a +getSessionTensor handle dtype = TSym "tf.get_session_tensor" <+> TArgS "handle" handle <+> TArgS "dtype" dtype + +getVariable' :: SingI n => String -> Sing n -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +getVariable' name shape dtype initializer regularizer trainable collections caching_device partitioner validate_shape use_resource custom_getter = TSym "tf.get_variable" <+> TArgS "name" name <+> TArgSing "shape" shape <+> TArgS "dtype" dtype <+> TArgS "initializer" initializer <+> TArgS "regularizer" regularizer <+> TArgS "trainable" trainable <+> TArgS "collections" collections <+> TArgS "caching_device" caching_device <+> TArgS "partitioner" partitioner <+> TArgS "validate_shape" validate_shape <+> TArgS "use_resource" use_resource <+> TArgS "custom_getter" custom_getter +getVariable :: String -> Tensor n t a +getVariable name = TSym "tf.get_variable" <+> TArgS "name" name + + +getVariableScope :: Tensor n t a +getVariableScope = TSym "tf.get_variable_scope" + +globalNorm' :: String -> String -> Tensor n t a +globalNorm' t_list name = TSym "tf.global_norm" <+> TArgS "t_list" t_list <+> TArgS "name" name +globalNorm :: String -> Tensor n t a +globalNorm t_list = TSym "tf.global_norm" <+> TArgS "t_list" t_list + + +globalVariables :: Tensor n t a +globalVariables = TSym "tf.global_variables" + + +globalVariablesInitializer :: Tensor n t a +globalVariablesInitializer = TSym "tf.global_variables_initializer" + +gradients' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +gradients' ys xs grad_ys name colocate_gradients_with_ops gate_gradients aggregation_method = TSym "tf.gradients" <+> TArgS "ys" ys <+> TArgS "xs" xs <+> TArgS "grad_ys" grad_ys <+> TArgS "name" name <+> TArgS "colocate_gradients_with_ops" colocate_gradients_with_ops <+> TArgS "gate_gradients" gate_gradients <+> TArgS "aggregation_method" aggregation_method +gradients :: String -> String -> Tensor n t a +gradients ys xs = TSym "tf.gradients" <+> TArgS "ys" ys <+> TArgS "xs" xs + +greater' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +greater' x y name = TSym "tf.greater" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +greater :: Tensor n t a -> Tensor n t a -> Tensor n t a +greater x y = TSym "tf.greater" <+> TArgT "x" x <+> TArgT "y" y + +greaterEqual' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +greaterEqual' x y name = TSym "tf.greater_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +greaterEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +greaterEqual x y = TSym "tf.greater_equal" <+> TArgT "x" x <+> TArgT "y" y + + +group :: Tensor n t a +group = TSym "tf.group" + +hessians' :: String -> String -> String -> String -> String -> String -> Tensor n t a +hessians' ys xs name colocate_gradients_with_ops gate_gradients aggregation_method = TSym "tf.hessians" <+> TArgS "ys" ys <+> TArgS "xs" xs <+> TArgS "name" name <+> TArgS "colocate_gradients_with_ops" colocate_gradients_with_ops <+> TArgS "gate_gradients" gate_gradients <+> TArgS "aggregation_method" aggregation_method +hessians :: String -> String -> Tensor n t a +hessians ys xs = TSym "tf.hessians" <+> TArgS "ys" ys <+> TArgS "xs" xs + +histogramFixedWidth' :: String -> String -> String -> String -> String -> Tensor n t a +histogramFixedWidth' values value_range nbins dtype name = TSym "tf.histogram_fixed_width" <+> TArgS "values" values <+> TArgS "value_range" value_range <+> TArgS "nbins" nbins <+> TArgS "dtype" dtype <+> TArgS "name" name +histogramFixedWidth :: String -> String -> Tensor n t a +histogramFixedWidth values value_range = TSym "tf.histogram_fixed_width" <+> TArgS "values" values <+> TArgS "value_range" value_range + +identity' :: String -> String -> Tensor n t a +identity' input name = TSym "tf.identity" <+> TArgS "input" input <+> TArgS "name" name +identity :: String -> Tensor n t a +identity input = TSym "tf.identity" <+> TArgS "input" input + +ifft' :: String -> String -> Tensor n t a +ifft' input name = TSym "tf.ifft" <+> TArgS "input" input <+> TArgS "name" name +ifft :: String -> Tensor n t a +ifft input = TSym "tf.ifft" <+> TArgS "input" input + +ifft2d' :: String -> String -> Tensor n t a +ifft2d' input name = TSym "tf.ifft2d" <+> TArgS "input" input <+> TArgS "name" name +ifft2d :: String -> Tensor n t a +ifft2d input = TSym "tf.ifft2d" <+> TArgS "input" input + +ifft3d' :: String -> String -> Tensor n t a +ifft3d' input name = TSym "tf.ifft3d" <+> TArgS "input" input <+> TArgS "name" name +ifft3d :: String -> Tensor n t a +ifft3d input = TSym "tf.ifft3d" <+> TArgS "input" input + +igamma' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +igamma' a x name = TSym "tf.igamma" <+> TArgT "a" a <+> TArgT "x" x <+> TArgS "name" name +igamma :: Tensor n t a -> Tensor n t a -> Tensor n t a +igamma a x = TSym "tf.igamma" <+> TArgT "a" a <+> TArgT "x" x + +igammac' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +igammac' a x name = TSym "tf.igammac" <+> TArgT "a" a <+> TArgT "x" x <+> TArgS "name" name +igammac :: Tensor n t a -> Tensor n t a -> Tensor n t a +igammac a x = TSym "tf.igammac" <+> TArgT "a" a <+> TArgT "x" x + +imag' :: String -> String -> Tensor n t a +imag' input name = TSym "tf.imag" <+> TArgS "input" input <+> TArgS "name" name +imag :: String -> Tensor n t a +imag input = TSym "tf.imag" <+> TArgS "input" input + +importGraphDef' :: String -> String -> String -> String -> String -> String -> Tensor n t a +importGraphDef' graph_def input_map return_elements name op_dict producer_op_list = TSym "tf.import_graph_def" <+> TArgS "graph_def" graph_def <+> TArgS "input_map" input_map <+> TArgS "return_elements" return_elements <+> TArgS "name" name <+> TArgS "op_dict" op_dict <+> TArgS "producer_op_list" producer_op_list +importGraphDef :: String -> Tensor n t a +importGraphDef graph_def = TSym "tf.import_graph_def" <+> TArgS "graph_def" graph_def + + +initializeAllTables :: Tensor n t a +initializeAllTables = TSym "tf.initialize_all_tables" + + +initializeAllVariables :: Tensor n t a +initializeAllVariables = TSym "tf.initialize_all_variables" + + +initializeLocalVariables :: Tensor n t a +initializeLocalVariables = TSym "tf.initialize_local_variables" + + +initializeVariables :: Tensor n t a +initializeVariables = TSym "tf.initialize_variables" + +invertPermutation' :: Tensor n t a -> String -> Tensor n t a +invertPermutation' x name = TSym "tf.invert_permutation" <+> TArgT "x" x <+> TArgS "name" name +invertPermutation :: Tensor n t a -> Tensor n t a +invertPermutation x = TSym "tf.invert_permutation" <+> TArgT "x" x + +isFinite' :: Tensor n t a -> String -> Tensor n t a +isFinite' x name = TSym "tf.is_finite" <+> TArgT "x" x <+> TArgS "name" name +isFinite :: Tensor n t a -> Tensor n t a +isFinite x = TSym "tf.is_finite" <+> TArgT "x" x + +isInf' :: Tensor n t a -> String -> Tensor n t a +isInf' x name = TSym "tf.is_inf" <+> TArgT "x" x <+> TArgS "name" name +isInf :: Tensor n t a -> Tensor n t a +isInf x = TSym "tf.is_inf" <+> TArgT "x" x + +isNan' :: Tensor n t a -> String -> Tensor n t a +isNan' x name = TSym "tf.is_nan" <+> TArgT "x" x <+> TArgS "name" name +isNan :: Tensor n t a -> Tensor n t a +isNan x = TSym "tf.is_nan" <+> TArgT "x" x + +isNonDecreasing' :: Tensor n t a -> String -> Tensor n t a +isNonDecreasing' x name = TSym "tf.is_non_decreasing" <+> TArgT "x" x <+> TArgS "name" name +isNonDecreasing :: Tensor n t a -> Tensor n t a +isNonDecreasing x = TSym "tf.is_non_decreasing" <+> TArgT "x" x + + +isNumericTensor :: Tensor n t a -> Tensor n t a +isNumericTensor tensor = TSym "tf.is_numeric_tensor" <+> TArgT "tensor" tensor + +isStrictlyIncreasing' :: Tensor n t a -> String -> Tensor n t a +isStrictlyIncreasing' x name = TSym "tf.is_strictly_increasing" <+> TArgT "x" x <+> TArgS "name" name +isStrictlyIncreasing :: Tensor n t a -> Tensor n t a +isStrictlyIncreasing x = TSym "tf.is_strictly_increasing" <+> TArgT "x" x + + +isVariableInitialized :: Tensor n t a +isVariableInitialized = TSym "tf.is_variable_initialized" + +lbeta' :: Tensor n t a -> String -> Tensor n t a +lbeta' x name = TSym "tf.lbeta" <+> TArgT "x" x <+> TArgS "name" name +lbeta :: Tensor n t a -> Tensor n t a +lbeta x = TSym "tf.lbeta" <+> TArgT "x" x + +less' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +less' x y name = TSym "tf.less" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +less :: Tensor n t a -> Tensor n t a -> Tensor n t a +less x y = TSym "tf.less" <+> TArgT "x" x <+> TArgT "y" y + +lessEqual' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +lessEqual' x y name = TSym "tf.less_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +lessEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +lessEqual x y = TSym "tf.less_equal" <+> TArgT "x" x <+> TArgT "y" y + +lgamma' :: Tensor n t a -> String -> Tensor n t a +lgamma' x name = TSym "tf.lgamma" <+> TArgT "x" x <+> TArgS "name" name +lgamma :: Tensor n t a -> Tensor n t a +lgamma x = TSym "tf.lgamma" <+> TArgT "x" x + +linSpace' :: String -> String -> String -> String -> Tensor n t a +linSpace' start stop num name = TSym "tf.lin_space" <+> TArgS "start" start <+> TArgS "stop" stop <+> TArgS "num" num <+> TArgS "name" name +linSpace :: String -> String -> String -> Tensor n t a +linSpace start stop num = TSym "tf.lin_space" <+> TArgS "start" start <+> TArgS "stop" stop <+> TArgS "num" num + +linspace' :: String -> String -> String -> String -> Tensor n t a +linspace' start stop num name = TSym "tf.linspace" <+> TArgS "start" start <+> TArgS "stop" stop <+> TArgS "num" num <+> TArgS "name" name +linspace :: String -> String -> String -> Tensor n t a +linspace start stop num = TSym "tf.linspace" <+> TArgS "start" start <+> TArgS "stop" stop <+> TArgS "num" num + + +loadFileSystemLibrary :: String -> Tensor n t a +loadFileSystemLibrary library_filename = TSym "tf.load_file_system_library" <+> TArgS "library_filename" library_filename + + +loadOpLibrary :: String -> Tensor n t a +loadOpLibrary library_filename = TSym "tf.load_op_library" <+> TArgS "library_filename" library_filename + + +localVariables :: Tensor n t a +localVariables = TSym "tf.local_variables" + + +localVariablesInitializer :: Tensor n t a +localVariablesInitializer = TSym "tf.local_variables_initializer" + +log' :: Tensor n t a -> String -> Tensor n t a +log' x name = TSym "tf.log" <+> TArgT "x" x <+> TArgS "name" name +log :: Tensor n t a -> Tensor n t a +log x = TSym "tf.log" <+> TArgT "x" x + +log1p' :: Tensor n t a -> String -> Tensor n t a +log1p' x name = TSym "tf.log1p" <+> TArgT "x" x <+> TArgS "name" name +log1p :: Tensor n t a -> Tensor n t a +log1p x = TSym "tf.log1p" <+> TArgT "x" x + +logSigmoid' :: Tensor n t a -> String -> Tensor n t a +logSigmoid' x name = TSym "tf.log_sigmoid" <+> TArgT "x" x <+> TArgS "name" name +logSigmoid :: Tensor n t a -> Tensor n t a +logSigmoid x = TSym "tf.log_sigmoid" <+> TArgT "x" x + +logicalAnd' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +logicalAnd' x y name = TSym "tf.logical_and" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +logicalAnd :: Tensor n t a -> Tensor n t a -> Tensor n t a +logicalAnd x y = TSym "tf.logical_and" <+> TArgT "x" x <+> TArgT "y" y + +logicalNot' :: Tensor n t a -> String -> Tensor n t a +logicalNot' x name = TSym "tf.logical_not" <+> TArgT "x" x <+> TArgS "name" name +logicalNot :: Tensor n t a -> Tensor n t a +logicalNot x = TSym "tf.logical_not" <+> TArgT "x" x + +logicalOr' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +logicalOr' x y name = TSym "tf.logical_or" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +logicalOr :: Tensor n t a -> Tensor n t a -> Tensor n t a +logicalOr x y = TSym "tf.logical_or" <+> TArgT "x" x <+> TArgT "y" y + +logicalXor' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +logicalXor' x y name = TSym "tf.logical_xor" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +logicalXor :: Tensor n t a -> Tensor n t a -> Tensor n t a +logicalXor x y = TSym "tf.logical_xor" <+> TArgT "x" x <+> TArgT "y" y + + +makeNdarray :: Tensor n t a -> Tensor n t a +makeNdarray tensor = TSym "tf.make_ndarray" <+> TArgT "tensor" tensor + +makeTemplate' :: String -> String -> String -> String -> String -> Tensor n t a +makeTemplate' name_ func_ create_scope_now_ unique_name_ custom_getter_ = TSym "tf.make_template" <+> TArgS "name_" name_ <+> TArgS "func_" func_ <+> TArgS "create_scope_now_" create_scope_now_ <+> TArgS "unique_name_" unique_name_ <+> TArgS "custom_getter_" custom_getter_ +makeTemplate :: String -> String -> Tensor n t a +makeTemplate name_ func_ = TSym "tf.make_template" <+> TArgS "name_" name_ <+> TArgS "func_" func_ + +makeTensorProto' :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +makeTensorProto' values dtype shape verify_shape = TSym "tf.make_tensor_proto" <+> TArgS "values" values <+> TArgS "dtype" dtype <+> TArgSing "shape" shape <+> TArgS "verify_shape" verify_shape +makeTensorProto :: String -> Tensor n t a +makeTensorProto values = TSym "tf.make_tensor_proto" <+> TArgS "values" values + +mapFn' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +mapFn' fn elems dtype parallel_iterations back_prop swap_memory infer_shape name = TSym "tf.map_fn" <+> TArgS "fn" fn <+> TArgS "elems" elems <+> TArgS "dtype" dtype <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "back_prop" back_prop <+> TArgS "swap_memory" swap_memory <+> TArgS "infer_shape" infer_shape <+> TArgS "name" name +mapFn :: String -> String -> Tensor n t a +mapFn fn elems = TSym "tf.map_fn" <+> TArgS "fn" fn <+> TArgS "elems" elems + +matchingFiles' :: String -> String -> Tensor n t a +matchingFiles' pattern name = TSym "tf.matching_files" <+> TArgS "pattern" pattern <+> TArgS "name" name +matchingFiles :: String -> Tensor n t a +matchingFiles pattern = TSym "tf.matching_files" <+> TArgS "pattern" pattern + +matmul' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +matmul' a b transpose_a transpose_b adjoint_a adjoint_b a_is_sparse b_is_sparse name = TSym "tf.matmul" <+> TArgT "a" a <+> TArgT "b" b <+> TArgS "transpose_a" transpose_a <+> TArgS "transpose_b" transpose_b <+> TArgS "adjoint_a" adjoint_a <+> TArgS "adjoint_b" adjoint_b <+> TArgS "a_is_sparse" a_is_sparse <+> TArgS "b_is_sparse" b_is_sparse <+> TArgS "name" name +matmul :: Tensor n t a -> Tensor n t a -> Tensor n t a +matmul a b = TSym "tf.matmul" <+> TArgT "a" a <+> TArgT "b" b + +matrixBandPart' :: String -> String -> String -> String -> Tensor n t a +matrixBandPart' input num_lower num_upper name = TSym "tf.matrix_band_part" <+> TArgS "input" input <+> TArgS "num_lower" num_lower <+> TArgS "num_upper" num_upper <+> TArgS "name" name +matrixBandPart :: String -> String -> String -> Tensor n t a +matrixBandPart input num_lower num_upper = TSym "tf.matrix_band_part" <+> TArgS "input" input <+> TArgS "num_lower" num_lower <+> TArgS "num_upper" num_upper + +matrixDeterminant' :: String -> String -> Tensor n t a +matrixDeterminant' input name = TSym "tf.matrix_determinant" <+> TArgS "input" input <+> TArgS "name" name +matrixDeterminant :: String -> Tensor n t a +matrixDeterminant input = TSym "tf.matrix_determinant" <+> TArgS "input" input + +matrixDiag' :: String -> String -> Tensor n t a +matrixDiag' diagonal name = TSym "tf.matrix_diag" <+> TArgS "diagonal" diagonal <+> TArgS "name" name +matrixDiag :: String -> Tensor n t a +matrixDiag diagonal = TSym "tf.matrix_diag" <+> TArgS "diagonal" diagonal + +matrixDiagPart' :: String -> String -> Tensor n t a +matrixDiagPart' input name = TSym "tf.matrix_diag_part" <+> TArgS "input" input <+> TArgS "name" name +matrixDiagPart :: String -> Tensor n t a +matrixDiagPart input = TSym "tf.matrix_diag_part" <+> TArgS "input" input + +matrixInverse' :: String -> String -> String -> Tensor n t a +matrixInverse' input adjoint name = TSym "tf.matrix_inverse" <+> TArgS "input" input <+> TArgS "adjoint" adjoint <+> TArgS "name" name +matrixInverse :: String -> Tensor n t a +matrixInverse input = TSym "tf.matrix_inverse" <+> TArgS "input" input + +matrixSetDiag' :: String -> String -> String -> Tensor n t a +matrixSetDiag' input diagonal name = TSym "tf.matrix_set_diag" <+> TArgS "input" input <+> TArgS "diagonal" diagonal <+> TArgS "name" name +matrixSetDiag :: String -> String -> Tensor n t a +matrixSetDiag input diagonal = TSym "tf.matrix_set_diag" <+> TArgS "input" input <+> TArgS "diagonal" diagonal + +matrixSolve' :: String -> String -> String -> String -> Tensor n t a +matrixSolve' matrix rhs adjoint name = TSym "tf.matrix_solve" <+> TArgS "matrix" matrix <+> TArgS "rhs" rhs <+> TArgS "adjoint" adjoint <+> TArgS "name" name +matrixSolve :: String -> String -> Tensor n t a +matrixSolve matrix rhs = TSym "tf.matrix_solve" <+> TArgS "matrix" matrix <+> TArgS "rhs" rhs + +matrixSolveLs' :: String -> String -> String -> String -> String -> Tensor n t a +matrixSolveLs' matrix rhs l2_regularizer fast name = TSym "tf.matrix_solve_ls" <+> TArgS "matrix" matrix <+> TArgS "rhs" rhs <+> TArgS "l2_regularizer" l2_regularizer <+> TArgS "fast" fast <+> TArgS "name" name +matrixSolveLs :: String -> String -> Tensor n t a +matrixSolveLs matrix rhs = TSym "tf.matrix_solve_ls" <+> TArgS "matrix" matrix <+> TArgS "rhs" rhs + +matrixTranspose' :: Tensor n t a -> String -> Tensor n t a +matrixTranspose' a name = TSym "tf.matrix_transpose" <+> TArgT "a" a <+> TArgS "name" name +matrixTranspose :: Tensor n t a -> Tensor n t a +matrixTranspose a = TSym "tf.matrix_transpose" <+> TArgT "a" a + +matrixTriangularSolve' :: String -> String -> String -> String -> String -> Tensor n t a +matrixTriangularSolve' matrix rhs lower adjoint name = TSym "tf.matrix_triangular_solve" <+> TArgS "matrix" matrix <+> TArgS "rhs" rhs <+> TArgS "lower" lower <+> TArgS "adjoint" adjoint <+> TArgS "name" name +matrixTriangularSolve :: String -> String -> Tensor n t a +matrixTriangularSolve matrix rhs = TSym "tf.matrix_triangular_solve" <+> TArgS "matrix" matrix <+> TArgS "rhs" rhs + +maximum' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +maximum' x y name = TSym "tf.maximum" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +maximum :: Tensor n t a -> Tensor n t a -> Tensor n t a +maximum x y = TSym "tf.maximum" <+> TArgT "x" x <+> TArgT "y" y + + +meshgrid :: Tensor n t a +meshgrid = TSym "tf.meshgrid" + + +minMaxVariablePartitioner :: Tensor n t a +minMaxVariablePartitioner = TSym "tf.min_max_variable_partitioner" + +minimum' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +minimum' x y name = TSym "tf.minimum" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +minimum :: Tensor n t a -> Tensor n t a -> Tensor n t a +minimum x y = TSym "tf.minimum" <+> TArgT "x" x <+> TArgT "y" y + +mod' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +mod' x y name = TSym "tf.mod" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +mod :: Tensor n t a -> Tensor n t a -> Tensor n t a +mod x y = TSym "tf.mod" <+> TArgT "x" x <+> TArgT "y" y + + +modelVariables :: Tensor n t a +modelVariables = TSym "tf.model_variables" + + +movingAverageVariables :: Tensor n t a +movingAverageVariables = TSym "tf.moving_average_variables" + +multinomial' :: String -> String -> String -> String -> Tensor n t a +multinomial' logits num_samples seed name = TSym "tf.multinomial" <+> TArgS "logits" logits <+> TArgS "num_samples" num_samples <+> TArgS "seed" seed <+> TArgS "name" name +multinomial :: String -> String -> Tensor n t a +multinomial logits num_samples = TSym "tf.multinomial" <+> TArgS "logits" logits <+> TArgS "num_samples" num_samples + +multiply' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +multiply' x y name = TSym "tf.multiply" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +multiply :: Tensor n t a -> Tensor n t a -> Tensor n t a +multiply x y = TSym "tf.multiply" <+> TArgT "x" x <+> TArgT "y" y + + +nameScope :: Tensor n t a +nameScope = TSym "tf.name_scope" + +negative' :: Tensor n t a -> String -> Tensor n t a +negative' x name = TSym "tf.negative" <+> TArgT "x" x <+> TArgS "name" name +negative :: Tensor n t a -> Tensor n t a +negative x = TSym "tf.negative" <+> TArgT "x" x + + +noOp :: Tensor n t a +noOp = TSym "tf.no_op" + + +noRegularizer :: String -> Tensor n t a +noRegularizer _' = TSym "tf.no_regularizer" <+> TArgS "_" _' + +norm' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +norm' tensor ord axis keep_dims name = TSym "tf.norm" <+> TArgT "tensor" tensor <+> TArgS "ord" ord <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name +norm :: Tensor n t a -> Tensor n t a +norm tensor = TSym "tf.norm" <+> TArgT "tensor" tensor + +notEqual' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +notEqual' x y name = TSym "tf.not_equal" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +notEqual :: Tensor n t a -> Tensor n t a -> Tensor n t a +notEqual x y = TSym "tf.not_equal" <+> TArgT "x" x <+> TArgT "y" y + +oneHot' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +oneHot' indices depth on_value off_value axis dtype name = TSym "tf.one_hot" <+> TArgS "indices" indices <+> TArgS "depth" depth <+> TArgS "on_value" on_value <+> TArgS "off_value" off_value <+> TArgS "axis" axis <+> TArgS "dtype" dtype <+> TArgS "name" name +oneHot :: String -> String -> Tensor n t a +oneHot indices depth = TSym "tf.one_hot" <+> TArgS "indices" indices <+> TArgS "depth" depth + +ones' :: SingI n => Sing n -> String -> String -> Tensor n t a +ones' shape dtype name = TSym "tf.ones" <+> TArgSing "shape" shape <+> TArgS "dtype" dtype <+> TArgS "name" name +ones :: SingI n => Sing n -> Tensor n t a +ones shape = TSym "tf.ones" <+> TArgSing "shape" shape + +onesLike' :: Tensor n t a -> String -> String -> String -> Tensor n t a +onesLike' tensor dtype name optimize = TSym "tf.ones_like" <+> TArgT "tensor" tensor <+> TArgS "dtype" dtype <+> TArgS "name" name <+> TArgS "optimize" optimize +onesLike :: Tensor n t a -> Tensor n t a +onesLike tensor = TSym "tf.ones_like" <+> TArgT "tensor" tensor + + +opScope :: Tensor n t a +opScope = TSym "tf.op_scope" + +pad' :: Tensor n t a -> String -> String -> String -> Tensor n t a +pad' tensor paddings mode name = TSym "tf.pad" <+> TArgT "tensor" tensor <+> TArgS "paddings" paddings <+> TArgS "mode" mode <+> TArgS "name" name +pad :: Tensor n t a -> String -> Tensor n t a +pad tensor paddings = TSym "tf.pad" <+> TArgT "tensor" tensor <+> TArgS "paddings" paddings + +parallelStack' :: String -> String -> Tensor n t a +parallelStack' values name = TSym "tf.parallel_stack" <+> TArgS "values" values <+> TArgS "name" name +parallelStack :: String -> Tensor n t a +parallelStack values = TSym "tf.parallel_stack" <+> TArgS "values" values + +parseExample' :: String -> String -> String -> String -> Tensor n t a +parseExample' serialized features name example_names = TSym "tf.parse_example" <+> TArgS "serialized" serialized <+> TArgS "features" features <+> TArgS "name" name <+> TArgS "example_names" example_names +parseExample :: String -> String -> Tensor n t a +parseExample serialized features = TSym "tf.parse_example" <+> TArgS "serialized" serialized <+> TArgS "features" features + +parseSingleExample' :: String -> String -> String -> String -> Tensor n t a +parseSingleExample' serialized features name example_names = TSym "tf.parse_single_example" <+> TArgS "serialized" serialized <+> TArgS "features" features <+> TArgS "name" name <+> TArgS "example_names" example_names +parseSingleExample :: String -> String -> Tensor n t a +parseSingleExample serialized features = TSym "tf.parse_single_example" <+> TArgS "serialized" serialized <+> TArgS "features" features + +parseSingleSequenceExample' :: String -> String -> String -> String -> String -> Tensor n t a +parseSingleSequenceExample' serialized context_features sequence_features example_name name = TSym "tf.parse_single_sequence_example" <+> TArgS "serialized" serialized <+> TArgS "context_features" context_features <+> TArgS "sequence_features" sequence_features <+> TArgS "example_name" example_name <+> TArgS "name" name +parseSingleSequenceExample :: String -> Tensor n t a +parseSingleSequenceExample serialized = TSym "tf.parse_single_sequence_example" <+> TArgS "serialized" serialized + +parseTensor' :: String -> String -> String -> Tensor n t a +parseTensor' serialized out_type name = TSym "tf.parse_tensor" <+> TArgS "serialized" serialized <+> TArgS "out_type" out_type <+> TArgS "name" name +parseTensor :: String -> String -> Tensor n t a +parseTensor serialized out_type = TSym "tf.parse_tensor" <+> TArgS "serialized" serialized <+> TArgS "out_type" out_type + +placeholder' :: SingI n => String -> Sing n -> String -> Tensor n t a +placeholder' dtype shape name = TSym "tf.placeholder" <+> TArgS "dtype" dtype <+> TArgSing "shape" shape <+> TArgS "name" name +placeholder :: String -> Tensor n t a +placeholder dtype = TSym "tf.placeholder" <+> TArgS "dtype" dtype + +placeholderWithDefault' :: SingI n => String -> Sing n -> String -> Tensor n t a +placeholderWithDefault' input shape name = TSym "tf.placeholder_with_default" <+> TArgS "input" input <+> TArgSing "shape" shape <+> TArgS "name" name +placeholderWithDefault :: SingI n => String -> Sing n -> Tensor n t a +placeholderWithDefault input shape = TSym "tf.placeholder_with_default" <+> TArgS "input" input <+> TArgSing "shape" shape + +polygamma' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +polygamma' a x name = TSym "tf.polygamma" <+> TArgT "a" a <+> TArgT "x" x <+> TArgS "name" name +polygamma :: Tensor n t a -> Tensor n t a -> Tensor n t a +polygamma a x = TSym "tf.polygamma" <+> TArgT "a" a <+> TArgT "x" x + +pow' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +pow' x y name = TSym "tf.pow" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +pow :: Tensor n t a -> Tensor n t a -> Tensor n t a +pow x y = TSym "tf.pow" <+> TArgT "x" x <+> TArgT "y" y + +pyFunc' :: String -> String -> String -> String -> String -> Tensor n t a +pyFunc' func inp tout stateful name = TSym "tf.py_func" <+> TArgS "func" func <+> TArgS "inp" inp <+> TArgS "Tout" tout <+> TArgS "stateful" stateful <+> TArgS "name" name +pyFunc :: String -> String -> String -> Tensor n t a +pyFunc func inp tout = TSym "tf.py_func" <+> TArgS "func" func <+> TArgS "inp" inp <+> TArgS "Tout" tout + +qr' :: String -> String -> String -> Tensor n t a +qr' input full_matrices name = TSym "tf.qr" <+> TArgS "input" input <+> TArgS "full_matrices" full_matrices <+> TArgS "name" name +qr :: String -> Tensor n t a +qr input = TSym "tf.qr" <+> TArgS "input" input + +quantizeV2' :: String -> String -> String -> String -> String -> String -> Tensor n t a +quantizeV2' input min_range max_range t mode name = TSym "tf.quantize_v2" <+> TArgS "input" input <+> TArgS "min_range" min_range <+> TArgS "max_range" max_range <+> TArgS "T" t <+> TArgS "mode" mode <+> TArgS "name" name +quantizeV2 :: String -> String -> String -> String -> Tensor n t a +quantizeV2 input min_range max_range t = TSym "tf.quantize_v2" <+> TArgS "input" input <+> TArgS "min_range" min_range <+> TArgS "max_range" max_range <+> TArgS "T" t + +quantizedConcat' :: String -> String -> String -> String -> String -> Tensor n t a +quantizedConcat' concat_dim values input_mins input_maxes name = TSym "tf.quantized_concat" <+> TArgS "concat_dim" concat_dim <+> TArgS "values" values <+> TArgS "input_mins" input_mins <+> TArgS "input_maxes" input_maxes <+> TArgS "name" name +quantizedConcat :: String -> String -> String -> String -> Tensor n t a +quantizedConcat concat_dim values input_mins input_maxes = TSym "tf.quantized_concat" <+> TArgS "concat_dim" concat_dim <+> TArgS "values" values <+> TArgS "input_mins" input_mins <+> TArgS "input_maxes" input_maxes + +randomCrop' :: String -> String -> String -> String -> Tensor n t a +randomCrop' value size seed name = TSym "tf.random_crop" <+> TArgS "value" value <+> TArgS "size" size <+> TArgS "seed" seed <+> TArgS "name" name +randomCrop :: String -> String -> Tensor n t a +randomCrop value size = TSym "tf.random_crop" <+> TArgS "value" value <+> TArgS "size" size + +randomGamma' :: SingI n => Sing n -> String -> String -> String -> String -> String -> Tensor n t a +randomGamma' shape alpha beta dtype seed name = TSym "tf.random_gamma" <+> TArgSing "shape" shape <+> TArgS "alpha" alpha <+> TArgS "beta" beta <+> TArgS "dtype" dtype <+> TArgS "seed" seed <+> TArgS "name" name +randomGamma :: SingI n => Sing n -> String -> Tensor n t a +randomGamma shape alpha = TSym "tf.random_gamma" <+> TArgSing "shape" shape <+> TArgS "alpha" alpha + +randomNormal' :: SingI n => Sing n -> String -> String -> String -> String -> String -> Tensor n t a +randomNormal' shape mean stddev dtype seed name = TSym "tf.random_normal" <+> TArgSing "shape" shape <+> TArgS "mean" mean <+> TArgS "stddev" stddev <+> TArgS "dtype" dtype <+> TArgS "seed" seed <+> TArgS "name" name +randomNormal :: SingI n => Sing n -> Tensor n t a +randomNormal shape = TSym "tf.random_normal" <+> TArgSing "shape" shape + +randomPoisson' :: SingI n => String -> Sing n -> String -> String -> String -> Tensor n t a +randomPoisson' lam shape dtype seed name = TSym "tf.random_poisson" <+> TArgS "lam" lam <+> TArgSing "shape" shape <+> TArgS "dtype" dtype <+> TArgS "seed" seed <+> TArgS "name" name +randomPoisson :: SingI n => String -> Sing n -> Tensor n t a +randomPoisson lam shape = TSym "tf.random_poisson" <+> TArgS "lam" lam <+> TArgSing "shape" shape + +randomShuffle' :: String -> String -> String -> Tensor n t a +randomShuffle' value seed name = TSym "tf.random_shuffle" <+> TArgS "value" value <+> TArgS "seed" seed <+> TArgS "name" name +randomShuffle :: String -> Tensor n t a +randomShuffle value = TSym "tf.random_shuffle" <+> TArgS "value" value + +randomUniform' :: SingI n => Sing n -> String -> String -> String -> String -> String -> Tensor n t a +randomUniform' shape minval maxval dtype seed name = TSym "tf.random_uniform" <+> TArgSing "shape" shape <+> TArgS "minval" minval <+> TArgS "maxval" maxval <+> TArgS "dtype" dtype <+> TArgS "seed" seed <+> TArgS "name" name +randomUniform :: SingI n => Sing n -> Tensor n t a +randomUniform shape = TSym "tf.random_uniform" <+> TArgSing "shape" shape + +range' :: String -> String -> String -> String -> String -> Tensor n t a +range' start limit delta dtype name = TSym "tf.range" <+> TArgS "start" start <+> TArgS "limit" limit <+> TArgS "delta" delta <+> TArgS "dtype" dtype <+> TArgS "name" name +range :: String -> Tensor n t a +range start = TSym "tf.range" <+> TArgS "start" start + +rank' :: String -> String -> Tensor n t a +rank' input name = TSym "tf.rank" <+> TArgS "input" input <+> TArgS "name" name +rank :: String -> Tensor n t a +rank input = TSym "tf.rank" <+> TArgS "input" input + +readFile' :: String -> String -> Tensor n t a +readFile' filename name = TSym "tf.read_file" <+> TArgS "filename" filename <+> TArgS "name" name +readFile :: String -> Tensor n t a +readFile filename = TSym "tf.read_file" <+> TArgS "filename" filename + +real' :: String -> String -> Tensor n t a +real' input name = TSym "tf.real" <+> TArgS "input" input <+> TArgS "name" name +real :: String -> Tensor n t a +real input = TSym "tf.real" <+> TArgS "input" input + +realdiv' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +realdiv' x y name = TSym "tf.realdiv" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +realdiv :: Tensor n t a -> Tensor n t a -> Tensor n t a +realdiv x y = TSym "tf.realdiv" <+> TArgT "x" x <+> TArgT "y" y + +reciprocal' :: Tensor n t a -> String -> Tensor n t a +reciprocal' x name = TSym "tf.reciprocal" <+> TArgT "x" x <+> TArgS "name" name +reciprocal :: Tensor n t a -> Tensor n t a +reciprocal x = TSym "tf.reciprocal" <+> TArgT "x" x + +reduceAll' :: String -> String -> String -> String -> String -> Tensor n t a +reduceAll' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_all" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceAll :: String -> Tensor n t a +reduceAll input_tensor = TSym "tf.reduce_all" <+> TArgS "input_tensor" input_tensor + +reduceAny' :: String -> String -> String -> String -> String -> Tensor n t a +reduceAny' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_any" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceAny :: String -> Tensor n t a +reduceAny input_tensor = TSym "tf.reduce_any" <+> TArgS "input_tensor" input_tensor + +reduceJoin' :: String -> String -> String -> String -> String -> String -> Tensor n t a +reduceJoin' inputs axis keep_dims separator name reduction_indices = TSym "tf.reduce_join" <+> TArgS "inputs" inputs <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "separator" separator <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceJoin :: String -> Tensor n t a +reduceJoin inputs = TSym "tf.reduce_join" <+> TArgS "inputs" inputs + +reduceLogsumexp' :: String -> String -> String -> String -> String -> Tensor n t a +reduceLogsumexp' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_logsumexp" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceLogsumexp :: String -> Tensor n t a +reduceLogsumexp input_tensor = TSym "tf.reduce_logsumexp" <+> TArgS "input_tensor" input_tensor + +reduceMax' :: String -> String -> String -> String -> String -> Tensor n t a +reduceMax' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_max" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceMax :: String -> Tensor n t a +reduceMax input_tensor = TSym "tf.reduce_max" <+> TArgS "input_tensor" input_tensor + +reduceMean' :: String -> String -> String -> String -> String -> Tensor n t a +reduceMean' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_mean" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceMean :: String -> Tensor n t a +reduceMean input_tensor = TSym "tf.reduce_mean" <+> TArgS "input_tensor" input_tensor + +reduceMin' :: String -> String -> String -> String -> String -> Tensor n t a +reduceMin' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_min" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceMin :: String -> Tensor n t a +reduceMin input_tensor = TSym "tf.reduce_min" <+> TArgS "input_tensor" input_tensor + +reduceProd' :: String -> String -> String -> String -> String -> Tensor n t a +reduceProd' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_prod" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceProd :: String -> Tensor n t a +reduceProd input_tensor = TSym "tf.reduce_prod" <+> TArgS "input_tensor" input_tensor + +reduceSum' :: String -> String -> String -> String -> String -> Tensor n t a +reduceSum' input_tensor axis keep_dims name reduction_indices = TSym "tf.reduce_sum" <+> TArgS "input_tensor" input_tensor <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name <+> TArgS "reduction_indices" reduction_indices +reduceSum :: String -> Tensor n t a +reduceSum input_tensor = TSym "tf.reduce_sum" <+> TArgS "input_tensor" input_tensor + +registerTensorConversionFunction' :: String -> String -> String -> Tensor n t a +registerTensorConversionFunction' base_type conversion_func priority = TSym "tf.register_tensor_conversion_function" <+> TArgS "base_type" base_type <+> TArgS "conversion_func" conversion_func <+> TArgS "priority" priority +registerTensorConversionFunction :: String -> String -> Tensor n t a +registerTensorConversionFunction base_type conversion_func = TSym "tf.register_tensor_conversion_function" <+> TArgS "base_type" base_type <+> TArgS "conversion_func" conversion_func + + +reportUninitializedVariables :: Tensor n t a +reportUninitializedVariables = TSym "tf.report_uninitialized_variables" + +requiredSpaceToBatchPaddings' :: String -> String -> String -> String -> Tensor n t a +requiredSpaceToBatchPaddings' input_shape block_shape base_paddings name = TSym "tf.required_space_to_batch_paddings" <+> TArgS "input_shape" input_shape <+> TArgS "block_shape" block_shape <+> TArgS "base_paddings" base_paddings <+> TArgS "name" name +requiredSpaceToBatchPaddings :: String -> String -> Tensor n t a +requiredSpaceToBatchPaddings input_shape block_shape = TSym "tf.required_space_to_batch_paddings" <+> TArgS "input_shape" input_shape <+> TArgS "block_shape" block_shape + + +resetDefaultGraph :: Tensor n t a +resetDefaultGraph = TSym "tf.reset_default_graph" + +reshape' :: SingI n => Tensor n t a -> Sing n -> String -> Tensor n t a +reshape' tensor shape name = TSym "tf.reshape" <+> TArgT "tensor" tensor <+> TArgSing "shape" shape <+> TArgS "name" name +reshape :: SingI n => Tensor n t a -> Sing n -> Tensor n t a +reshape tensor shape = TSym "tf.reshape" <+> TArgT "tensor" tensor <+> TArgSing "shape" shape + +reverse' :: Tensor n t a -> String -> String -> Tensor n t a +reverse' tensor axis name = TSym "tf.reverse" <+> TArgT "tensor" tensor <+> TArgS "axis" axis <+> TArgS "name" name +reverse :: Tensor n t a -> String -> Tensor n t a +reverse tensor axis = TSym "tf.reverse" <+> TArgT "tensor" tensor <+> TArgS "axis" axis + +reverseSequence' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +reverseSequence' input seq_lengths seq_axis batch_axis name seq_dim batch_dim = TSym "tf.reverse_sequence" <+> TArgS "input" input <+> TArgS "seq_lengths" seq_lengths <+> TArgS "seq_axis" seq_axis <+> TArgS "batch_axis" batch_axis <+> TArgS "name" name <+> TArgS "seq_dim" seq_dim <+> TArgS "batch_dim" batch_dim +reverseSequence :: String -> String -> Tensor n t a +reverseSequence input seq_lengths = TSym "tf.reverse_sequence" <+> TArgS "input" input <+> TArgS "seq_lengths" seq_lengths + +reverseV2' :: Tensor n t a -> String -> String -> Tensor n t a +reverseV2' tensor axis name = TSym "tf.reverse_v2" <+> TArgT "tensor" tensor <+> TArgS "axis" axis <+> TArgS "name" name +reverseV2 :: Tensor n t a -> String -> Tensor n t a +reverseV2 tensor axis = TSym "tf.reverse_v2" <+> TArgT "tensor" tensor <+> TArgS "axis" axis + +rint' :: Tensor n t a -> String -> Tensor n t a +rint' x name = TSym "tf.rint" <+> TArgT "x" x <+> TArgS "name" name +rint :: Tensor n t a -> Tensor n t a +rint x = TSym "tf.rint" <+> TArgT "x" x + +round' :: Tensor n t a -> String -> Tensor n t a +round' x name = TSym "tf.round" <+> TArgT "x" x <+> TArgS "name" name +round :: Tensor n t a -> Tensor n t a +round x = TSym "tf.round" <+> TArgT "x" x + +rsqrt' :: Tensor n t a -> String -> Tensor n t a +rsqrt' x name = TSym "tf.rsqrt" <+> TArgT "x" x <+> TArgS "name" name +rsqrt :: Tensor n t a -> Tensor n t a +rsqrt x = TSym "tf.rsqrt" <+> TArgT "x" x + +saturateCast' :: String -> String -> String -> Tensor n t a +saturateCast' value dtype name = TSym "tf.saturate_cast" <+> TArgS "value" value <+> TArgS "dtype" dtype <+> TArgS "name" name +saturateCast :: String -> String -> Tensor n t a +saturateCast value dtype = TSym "tf.saturate_cast" <+> TArgS "value" value <+> TArgS "dtype" dtype + + +scalarMul :: String -> Tensor n t a -> Tensor n t a +scalarMul scalar x = TSym "tf.scalar_mul" <+> TArgS "scalar" scalar <+> TArgT "x" x + +scan' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +scan' fn elems initializer parallel_iterations back_prop swap_memory infer_shape name = TSym "tf.scan" <+> TArgS "fn" fn <+> TArgS "elems" elems <+> TArgS "initializer" initializer <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "back_prop" back_prop <+> TArgS "swap_memory" swap_memory <+> TArgS "infer_shape" infer_shape <+> TArgS "name" name +scan :: String -> String -> Tensor n t a +scan fn elems = TSym "tf.scan" <+> TArgS "fn" fn <+> TArgS "elems" elems + +scatterAdd' :: String -> String -> String -> String -> String -> Tensor n t a +scatterAdd' ref indices updates use_locking name = TSym "tf.scatter_add" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterAdd :: String -> String -> String -> Tensor n t a +scatterAdd ref indices updates = TSym "tf.scatter_add" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterDiv' :: String -> String -> String -> String -> String -> Tensor n t a +scatterDiv' ref indices updates use_locking name = TSym "tf.scatter_div" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterDiv :: String -> String -> String -> Tensor n t a +scatterDiv ref indices updates = TSym "tf.scatter_div" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterMul' :: String -> String -> String -> String -> String -> Tensor n t a +scatterMul' ref indices updates use_locking name = TSym "tf.scatter_mul" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterMul :: String -> String -> String -> Tensor n t a +scatterMul ref indices updates = TSym "tf.scatter_mul" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterNd' :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +scatterNd' indices updates shape name = TSym "tf.scatter_nd" <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgSing "shape" shape <+> TArgS "name" name +scatterNd :: SingI n => String -> String -> Sing n -> Tensor n t a +scatterNd indices updates shape = TSym "tf.scatter_nd" <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgSing "shape" shape + +scatterNdAdd' :: String -> String -> String -> String -> String -> Tensor n t a +scatterNdAdd' ref indices updates use_locking name = TSym "tf.scatter_nd_add" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterNdAdd :: String -> String -> String -> Tensor n t a +scatterNdAdd ref indices updates = TSym "tf.scatter_nd_add" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterNdSub' :: String -> String -> String -> String -> String -> Tensor n t a +scatterNdSub' ref indices updates use_locking name = TSym "tf.scatter_nd_sub" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterNdSub :: String -> String -> String -> Tensor n t a +scatterNdSub ref indices updates = TSym "tf.scatter_nd_sub" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterNdUpdate' :: String -> String -> String -> String -> String -> Tensor n t a +scatterNdUpdate' ref indices updates use_locking name = TSym "tf.scatter_nd_update" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterNdUpdate :: String -> String -> String -> Tensor n t a +scatterNdUpdate ref indices updates = TSym "tf.scatter_nd_update" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterSub' :: String -> String -> String -> String -> String -> Tensor n t a +scatterSub' ref indices updates use_locking name = TSym "tf.scatter_sub" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterSub :: String -> String -> String -> Tensor n t a +scatterSub ref indices updates = TSym "tf.scatter_sub" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +scatterUpdate' :: String -> String -> String -> String -> String -> Tensor n t a +scatterUpdate' ref indices updates use_locking name = TSym "tf.scatter_update" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates <+> TArgS "use_locking" use_locking <+> TArgS "name" name +scatterUpdate :: String -> String -> String -> Tensor n t a +scatterUpdate ref indices updates = TSym "tf.scatter_update" <+> TArgS "ref" ref <+> TArgS "indices" indices <+> TArgS "updates" updates + +segmentMax' :: String -> String -> String -> Tensor n t a +segmentMax' data' segment_ids name = TSym "tf.segment_max" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +segmentMax :: String -> String -> Tensor n t a +segmentMax data' segment_ids = TSym "tf.segment_max" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids + +segmentMean' :: String -> String -> String -> Tensor n t a +segmentMean' data' segment_ids name = TSym "tf.segment_mean" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +segmentMean :: String -> String -> Tensor n t a +segmentMean data' segment_ids = TSym "tf.segment_mean" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids + +segmentMin' :: String -> String -> String -> Tensor n t a +segmentMin' data' segment_ids name = TSym "tf.segment_min" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +segmentMin :: String -> String -> Tensor n t a +segmentMin data' segment_ids = TSym "tf.segment_min" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids + +segmentProd' :: String -> String -> String -> Tensor n t a +segmentProd' data' segment_ids name = TSym "tf.segment_prod" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +segmentProd :: String -> String -> Tensor n t a +segmentProd data' segment_ids = TSym "tf.segment_prod" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids + +segmentSum' :: String -> String -> String -> Tensor n t a +segmentSum' data' segment_ids name = TSym "tf.segment_sum" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +segmentSum :: String -> String -> Tensor n t a +segmentSum data' segment_ids = TSym "tf.segment_sum" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids + +selfAdjointEig' :: Tensor n t a -> String -> Tensor n t a +selfAdjointEig' tensor name = TSym "tf.self_adjoint_eig" <+> TArgT "tensor" tensor <+> TArgS "name" name +selfAdjointEig :: Tensor n t a -> Tensor n t a +selfAdjointEig tensor = TSym "tf.self_adjoint_eig" <+> TArgT "tensor" tensor + +selfAdjointEigvals' :: Tensor n t a -> String -> Tensor n t a +selfAdjointEigvals' tensor name = TSym "tf.self_adjoint_eigvals" <+> TArgT "tensor" tensor <+> TArgS "name" name +selfAdjointEigvals :: Tensor n t a -> Tensor n t a +selfAdjointEigvals tensor = TSym "tf.self_adjoint_eigvals" <+> TArgT "tensor" tensor + +sequenceMask' :: String -> String -> String -> String -> Tensor n t a +sequenceMask' lengths maxlen dtype name = TSym "tf.sequence_mask" <+> TArgS "lengths" lengths <+> TArgS "maxlen" maxlen <+> TArgS "dtype" dtype <+> TArgS "name" name +sequenceMask :: String -> Tensor n t a +sequenceMask lengths = TSym "tf.sequence_mask" <+> TArgS "lengths" lengths + +serializeManySparse' :: String -> String -> Tensor n t a +serializeManySparse' sp_input name = TSym "tf.serialize_many_sparse" <+> TArgS "sp_input" sp_input <+> TArgS "name" name +serializeManySparse :: String -> Tensor n t a +serializeManySparse sp_input = TSym "tf.serialize_many_sparse" <+> TArgS "sp_input" sp_input + +serializeSparse' :: String -> String -> Tensor n t a +serializeSparse' sp_input name = TSym "tf.serialize_sparse" <+> TArgS "sp_input" sp_input <+> TArgS "name" name +serializeSparse :: String -> Tensor n t a +serializeSparse sp_input = TSym "tf.serialize_sparse" <+> TArgS "sp_input" sp_input + + +setRandomSeed :: String -> Tensor n t a +setRandomSeed seed = TSym "tf.set_random_seed" <+> TArgS "seed" seed + +setdiff1d' :: Tensor n t a -> Tensor n t a -> String -> String -> Tensor n t a +setdiff1d' x y index_dtype name = TSym "tf.setdiff1d" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "index_dtype" index_dtype <+> TArgS "name" name +setdiff1d :: Tensor n t a -> Tensor n t a -> Tensor n t a +setdiff1d x y = TSym "tf.setdiff1d" <+> TArgT "x" x <+> TArgT "y" y + +shape' :: String -> String -> String -> Tensor n t a +shape' input name out_type = TSym "tf.shape" <+> TArgS "input" input <+> TArgS "name" name <+> TArgS "out_type" out_type +shape :: String -> Tensor n t a +shape input = TSym "tf.shape" <+> TArgS "input" input + +shapeN' :: String -> String -> String -> Tensor n t a +shapeN' input out_type name = TSym "tf.shape_n" <+> TArgS "input" input <+> TArgS "out_type" out_type <+> TArgS "name" name +shapeN :: String -> Tensor n t a +shapeN input = TSym "tf.shape_n" <+> TArgS "input" input + +sigmoid' :: Tensor n t a -> String -> Tensor n t a +sigmoid' x name = TSym "tf.sigmoid" <+> TArgT "x" x <+> TArgS "name" name +sigmoid :: Tensor n t a -> Tensor n t a +sigmoid x = TSym "tf.sigmoid" <+> TArgT "x" x + +sign' :: Tensor n t a -> String -> Tensor n t a +sign' x name = TSym "tf.sign" <+> TArgT "x" x <+> TArgS "name" name +sign :: Tensor n t a -> Tensor n t a +sign x = TSym "tf.sign" <+> TArgT "x" x + +sin' :: Tensor n t a -> String -> Tensor n t a +sin' x name = TSym "tf.sin" <+> TArgT "x" x <+> TArgS "name" name + + +size' :: String -> String -> String -> Tensor n t a +size' input name out_type = TSym "tf.size" <+> TArgS "input" input <+> TArgS "name" name <+> TArgS "out_type" out_type +size :: String -> Tensor n t a +size input = TSym "tf.size" <+> TArgS "input" input + +slice' :: String -> String -> String -> String -> Tensor n t a +slice' input_ begin size name = TSym "tf.slice" <+> TArgS "input_" input_ <+> TArgS "begin" begin <+> TArgS "size" size <+> TArgS "name" name +slice :: String -> String -> String -> Tensor n t a +slice input_ begin size = TSym "tf.slice" <+> TArgS "input_" input_ <+> TArgS "begin" begin <+> TArgS "size" size + +spaceToBatch' :: String -> String -> String -> String -> Tensor n t a +spaceToBatch' input paddings block_size name = TSym "tf.space_to_batch" <+> TArgS "input" input <+> TArgS "paddings" paddings <+> TArgS "block_size" block_size <+> TArgS "name" name +spaceToBatch :: String -> String -> String -> Tensor n t a +spaceToBatch input paddings block_size = TSym "tf.space_to_batch" <+> TArgS "input" input <+> TArgS "paddings" paddings <+> TArgS "block_size" block_size + +spaceToBatchNd' :: String -> String -> String -> String -> Tensor n t a +spaceToBatchNd' input block_shape paddings name = TSym "tf.space_to_batch_nd" <+> TArgS "input" input <+> TArgS "block_shape" block_shape <+> TArgS "paddings" paddings <+> TArgS "name" name +spaceToBatchNd :: String -> String -> String -> Tensor n t a +spaceToBatchNd input block_shape paddings = TSym "tf.space_to_batch_nd" <+> TArgS "input" input <+> TArgS "block_shape" block_shape <+> TArgS "paddings" paddings + +spaceToDepth' :: String -> String -> String -> Tensor n t a +spaceToDepth' input block_size name = TSym "tf.space_to_depth" <+> TArgS "input" input <+> TArgS "block_size" block_size <+> TArgS "name" name +spaceToDepth :: String -> String -> Tensor n t a +spaceToDepth input block_size = TSym "tf.space_to_depth" <+> TArgS "input" input <+> TArgS "block_size" block_size + +sparseAdd' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +sparseAdd' a b thresh = TSym "tf.sparse_add" <+> TArgT "a" a <+> TArgT "b" b <+> TArgS "thresh" thresh +sparseAdd :: Tensor n t a -> Tensor n t a -> Tensor n t a +sparseAdd a b = TSym "tf.sparse_add" <+> TArgT "a" a <+> TArgT "b" b + +sparseConcat' :: String -> String -> String -> String -> String -> Tensor n t a +sparseConcat' axis sp_inputs name expand_nonconcat_dim concat_dim = TSym "tf.sparse_concat" <+> TArgS "axis" axis <+> TArgS "sp_inputs" sp_inputs <+> TArgS "name" name <+> TArgS "expand_nonconcat_dim" expand_nonconcat_dim <+> TArgS "concat_dim" concat_dim +sparseConcat :: String -> String -> Tensor n t a +sparseConcat axis sp_inputs = TSym "tf.sparse_concat" <+> TArgS "axis" axis <+> TArgS "sp_inputs" sp_inputs + +sparseFillEmptyRows' :: String -> String -> String -> Tensor n t a +sparseFillEmptyRows' sp_input default_value name = TSym "tf.sparse_fill_empty_rows" <+> TArgS "sp_input" sp_input <+> TArgS "default_value" default_value <+> TArgS "name" name +sparseFillEmptyRows :: String -> String -> Tensor n t a +sparseFillEmptyRows sp_input default_value = TSym "tf.sparse_fill_empty_rows" <+> TArgS "sp_input" sp_input <+> TArgS "default_value" default_value + +sparseMask' :: Tensor n t a -> String -> String -> Tensor n t a +sparseMask' a mask_indices name = TSym "tf.sparse_mask" <+> TArgT "a" a <+> TArgS "mask_indices" mask_indices <+> TArgS "name" name +sparseMask :: Tensor n t a -> String -> Tensor n t a +sparseMask a mask_indices = TSym "tf.sparse_mask" <+> TArgT "a" a <+> TArgS "mask_indices" mask_indices + +sparseMatmul' :: Tensor n t a -> Tensor n t a -> String -> String -> String -> String -> String -> Tensor n t a +sparseMatmul' a b transpose_a transpose_b a_is_sparse b_is_sparse name = TSym "tf.sparse_matmul" <+> TArgT "a" a <+> TArgT "b" b <+> TArgS "transpose_a" transpose_a <+> TArgS "transpose_b" transpose_b <+> TArgS "a_is_sparse" a_is_sparse <+> TArgS "b_is_sparse" b_is_sparse <+> TArgS "name" name +sparseMatmul :: Tensor n t a -> Tensor n t a -> Tensor n t a +sparseMatmul a b = TSym "tf.sparse_matmul" <+> TArgT "a" a <+> TArgT "b" b + +sparseMaximum' :: String -> String -> String -> Tensor n t a +sparseMaximum' sp_a sp_b name = TSym "tf.sparse_maximum" <+> TArgS "sp_a" sp_a <+> TArgS "sp_b" sp_b <+> TArgS "name" name +sparseMaximum :: String -> String -> Tensor n t a +sparseMaximum sp_a sp_b = TSym "tf.sparse_maximum" <+> TArgS "sp_a" sp_a <+> TArgS "sp_b" sp_b + +sparseMerge' :: String -> String -> String -> String -> String -> Tensor n t a +sparseMerge' sp_ids sp_values vocab_size name already_sorted = TSym "tf.sparse_merge" <+> TArgS "sp_ids" sp_ids <+> TArgS "sp_values" sp_values <+> TArgS "vocab_size" vocab_size <+> TArgS "name" name <+> TArgS "already_sorted" already_sorted +sparseMerge :: String -> String -> String -> Tensor n t a +sparseMerge sp_ids sp_values vocab_size = TSym "tf.sparse_merge" <+> TArgS "sp_ids" sp_ids <+> TArgS "sp_values" sp_values <+> TArgS "vocab_size" vocab_size + +sparseMinimum' :: String -> String -> String -> Tensor n t a +sparseMinimum' sp_a sp_b name = TSym "tf.sparse_minimum" <+> TArgS "sp_a" sp_a <+> TArgS "sp_b" sp_b <+> TArgS "name" name +sparseMinimum :: String -> String -> Tensor n t a +sparseMinimum sp_a sp_b = TSym "tf.sparse_minimum" <+> TArgS "sp_a" sp_a <+> TArgS "sp_b" sp_b + +sparsePlaceholder' :: SingI n => String -> Sing n -> String -> Tensor n t a +sparsePlaceholder' dtype shape name = TSym "tf.sparse_placeholder" <+> TArgS "dtype" dtype <+> TArgSing "shape" shape <+> TArgS "name" name +sparsePlaceholder :: String -> Tensor n t a +sparsePlaceholder dtype = TSym "tf.sparse_placeholder" <+> TArgS "dtype" dtype + +sparseReduceSum' :: String -> String -> String -> String -> Tensor n t a +sparseReduceSum' sp_input axis keep_dims reduction_axes = TSym "tf.sparse_reduce_sum" <+> TArgS "sp_input" sp_input <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "reduction_axes" reduction_axes +sparseReduceSum :: String -> Tensor n t a +sparseReduceSum sp_input = TSym "tf.sparse_reduce_sum" <+> TArgS "sp_input" sp_input + +sparseReduceSumSparse' :: String -> String -> String -> String -> Tensor n t a +sparseReduceSumSparse' sp_input axis keep_dims reduction_axes = TSym "tf.sparse_reduce_sum_sparse" <+> TArgS "sp_input" sp_input <+> TArgS "axis" axis <+> TArgS "keep_dims" keep_dims <+> TArgS "reduction_axes" reduction_axes +sparseReduceSumSparse :: String -> Tensor n t a +sparseReduceSumSparse sp_input = TSym "tf.sparse_reduce_sum_sparse" <+> TArgS "sp_input" sp_input + +sparseReorder' :: String -> String -> Tensor n t a +sparseReorder' sp_input name = TSym "tf.sparse_reorder" <+> TArgS "sp_input" sp_input <+> TArgS "name" name +sparseReorder :: String -> Tensor n t a +sparseReorder sp_input = TSym "tf.sparse_reorder" <+> TArgS "sp_input" sp_input + +sparseResetShape' :: String -> String -> Tensor n t a +sparseResetShape' sp_input new_shape = TSym "tf.sparse_reset_shape" <+> TArgS "sp_input" sp_input <+> TArgS "new_shape" new_shape +sparseResetShape :: String -> Tensor n t a +sparseResetShape sp_input = TSym "tf.sparse_reset_shape" <+> TArgS "sp_input" sp_input + +sparseReshape' :: SingI n => String -> Sing n -> String -> Tensor n t a +sparseReshape' sp_input shape name = TSym "tf.sparse_reshape" <+> TArgS "sp_input" sp_input <+> TArgSing "shape" shape <+> TArgS "name" name +sparseReshape :: SingI n => String -> Sing n -> Tensor n t a +sparseReshape sp_input shape = TSym "tf.sparse_reshape" <+> TArgS "sp_input" sp_input <+> TArgSing "shape" shape + + +sparseRetain :: String -> String -> Tensor n t a +sparseRetain sp_input to_retain = TSym "tf.sparse_retain" <+> TArgS "sp_input" sp_input <+> TArgS "to_retain" to_retain + +sparseSegmentMean' :: String -> String -> String -> String -> Tensor n t a +sparseSegmentMean' data' indices segment_ids name = TSym "tf.sparse_segment_mean" <+> TArgS "data" data' <+> TArgS "indices" indices <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +sparseSegmentMean :: String -> String -> String -> Tensor n t a +sparseSegmentMean data' indices segment_ids = TSym "tf.sparse_segment_mean" <+> TArgS "data" data' <+> TArgS "indices" indices <+> TArgS "segment_ids" segment_ids + +sparseSegmentSqrtN' :: String -> String -> String -> String -> Tensor n t a +sparseSegmentSqrtN' data' indices segment_ids name = TSym "tf.sparse_segment_sqrt_n" <+> TArgS "data" data' <+> TArgS "indices" indices <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +sparseSegmentSqrtN :: String -> String -> String -> Tensor n t a +sparseSegmentSqrtN data' indices segment_ids = TSym "tf.sparse_segment_sqrt_n" <+> TArgS "data" data' <+> TArgS "indices" indices <+> TArgS "segment_ids" segment_ids + +sparseSegmentSum' :: String -> String -> String -> String -> Tensor n t a +sparseSegmentSum' data' indices segment_ids name = TSym "tf.sparse_segment_sum" <+> TArgS "data" data' <+> TArgS "indices" indices <+> TArgS "segment_ids" segment_ids <+> TArgS "name" name +sparseSegmentSum :: String -> String -> String -> Tensor n t a +sparseSegmentSum data' indices segment_ids = TSym "tf.sparse_segment_sum" <+> TArgS "data" data' <+> TArgS "indices" indices <+> TArgS "segment_ids" segment_ids + +sparseSoftmax' :: String -> String -> Tensor n t a +sparseSoftmax' sp_input name = TSym "tf.sparse_softmax" <+> TArgS "sp_input" sp_input <+> TArgS "name" name +sparseSoftmax :: String -> Tensor n t a +sparseSoftmax sp_input = TSym "tf.sparse_softmax" <+> TArgS "sp_input" sp_input + + +sparseSplit :: Tensor n t a +sparseSplit = TSym "tf.sparse_split" + +sparseTensorDenseMatmul' :: String -> Tensor n t a -> String -> String -> String -> Tensor n t a +sparseTensorDenseMatmul' sp_a b adjoint_a adjoint_b name = TSym "tf.sparse_tensor_dense_matmul" <+> TArgS "sp_a" sp_a <+> TArgT "b" b <+> TArgS "adjoint_a" adjoint_a <+> TArgS "adjoint_b" adjoint_b <+> TArgS "name" name +sparseTensorDenseMatmul :: String -> Tensor n t a -> Tensor n t a +sparseTensorDenseMatmul sp_a b = TSym "tf.sparse_tensor_dense_matmul" <+> TArgS "sp_a" sp_a <+> TArgT "b" b + +sparseTensorToDense' :: String -> String -> String -> String -> Tensor n t a +sparseTensorToDense' sp_input default_value validate_indices name = TSym "tf.sparse_tensor_to_dense" <+> TArgS "sp_input" sp_input <+> TArgS "default_value" default_value <+> TArgS "validate_indices" validate_indices <+> TArgS "name" name +sparseTensorToDense :: String -> Tensor n t a +sparseTensorToDense sp_input = TSym "tf.sparse_tensor_to_dense" <+> TArgS "sp_input" sp_input + +sparseToDense' :: String -> String -> String -> String -> String -> String -> Tensor n t a +sparseToDense' sparse_indices output_shape sparse_values default_value validate_indices name = TSym "tf.sparse_to_dense" <+> TArgS "sparse_indices" sparse_indices <+> TArgS "output_shape" output_shape <+> TArgS "sparse_values" sparse_values <+> TArgS "default_value" default_value <+> TArgS "validate_indices" validate_indices <+> TArgS "name" name +sparseToDense :: String -> String -> String -> Tensor n t a +sparseToDense sparse_indices output_shape sparse_values = TSym "tf.sparse_to_dense" <+> TArgS "sparse_indices" sparse_indices <+> TArgS "output_shape" output_shape <+> TArgS "sparse_values" sparse_values + +sparseToIndicator' :: String -> String -> String -> Tensor n t a +sparseToIndicator' sp_input vocab_size name = TSym "tf.sparse_to_indicator" <+> TArgS "sp_input" sp_input <+> TArgS "vocab_size" vocab_size <+> TArgS "name" name +sparseToIndicator :: String -> String -> Tensor n t a +sparseToIndicator sp_input vocab_size = TSym "tf.sparse_to_indicator" <+> TArgS "sp_input" sp_input <+> TArgS "vocab_size" vocab_size + +sparseTranspose' :: String -> String -> String -> Tensor n t a +sparseTranspose' sp_input perm name = TSym "tf.sparse_transpose" <+> TArgS "sp_input" sp_input <+> TArgS "perm" perm <+> TArgS "name" name +sparseTranspose :: String -> Tensor n t a +sparseTranspose sp_input = TSym "tf.sparse_transpose" <+> TArgS "sp_input" sp_input + +split' :: String -> String -> String -> String -> String -> Tensor n t a +split' value num_or_size_splits axis num name = TSym "tf.split" <+> TArgS "value" value <+> TArgS "num_or_size_splits" num_or_size_splits <+> TArgS "axis" axis <+> TArgS "num" num <+> TArgS "name" name +split :: String -> String -> Tensor n t a +split value num_or_size_splits = TSym "tf.split" <+> TArgS "value" value <+> TArgS "num_or_size_splits" num_or_size_splits + +sqrt' :: Tensor n t a -> String -> Tensor n t a +sqrt' x name = TSym "tf.sqrt" <+> TArgT "x" x <+> TArgS "name" name +sqrt :: Tensor n t a -> Tensor n t a +sqrt x = TSym "tf.sqrt" <+> TArgT "x" x + +square' :: Tensor n t a -> String -> Tensor n t a +square' x name = TSym "tf.square" <+> TArgT "x" x <+> TArgS "name" name +square :: Tensor n t a -> Tensor n t a +square x = TSym "tf.square" <+> TArgT "x" x + +squaredDifference' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +squaredDifference' x y name = TSym "tf.squared_difference" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +squaredDifference :: Tensor n t a -> Tensor n t a -> Tensor n t a +squaredDifference x y = TSym "tf.squared_difference" <+> TArgT "x" x <+> TArgT "y" y + +squeeze' :: String -> String -> String -> String -> Tensor n t a +squeeze' input axis name squeeze_dims = TSym "tf.squeeze" <+> TArgS "input" input <+> TArgS "axis" axis <+> TArgS "name" name <+> TArgS "squeeze_dims" squeeze_dims +squeeze :: String -> Tensor n t a +squeeze input = TSym "tf.squeeze" <+> TArgS "input" input + +stack' :: String -> String -> String -> Tensor n t a +stack' values axis name = TSym "tf.stack" <+> TArgS "values" values <+> TArgS "axis" axis <+> TArgS "name" name +stack :: String -> Tensor n t a +stack values = TSym "tf.stack" <+> TArgS "values" values + +stopGradient' :: String -> String -> Tensor n t a +stopGradient' input name = TSym "tf.stop_gradient" <+> TArgS "input" input <+> TArgS "name" name +stopGradient :: String -> Tensor n t a +stopGradient input = TSym "tf.stop_gradient" <+> TArgS "input" input + +stridedSlice' :: SingI n => String -> String -> String -> Sing n -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +stridedSlice' input_ begin end strides begin_mask end_mask ellipsis_mask new_axis_mask shrink_axis_mask var name = TSym "tf.strided_slice" <+> TArgS "input_" input_ <+> TArgS "begin" begin <+> TArgS "end" end <+> TArgSing "strides" strides <+> TArgS "begin_mask" begin_mask <+> TArgS "end_mask" end_mask <+> TArgS "ellipsis_mask" ellipsis_mask <+> TArgS "new_axis_mask" new_axis_mask <+> TArgS "shrink_axis_mask" shrink_axis_mask <+> TArgS "var" var <+> TArgS "name" name +stridedSlice :: String -> String -> String -> Tensor n t a +stridedSlice input_ begin end = TSym "tf.strided_slice" <+> TArgS "input_" input_ <+> TArgS "begin" begin <+> TArgS "end" end + +stringJoin' :: String -> String -> String -> Tensor n t a +stringJoin' inputs separator name = TSym "tf.string_join" <+> TArgS "inputs" inputs <+> TArgS "separator" separator <+> TArgS "name" name +stringJoin :: String -> Tensor n t a +stringJoin inputs = TSym "tf.string_join" <+> TArgS "inputs" inputs + +stringSplit' :: String -> String -> Tensor n t a +stringSplit' source delimiter = TSym "tf.string_split" <+> TArgS "source" source <+> TArgS "delimiter" delimiter +stringSplit :: String -> Tensor n t a +stringSplit source = TSym "tf.string_split" <+> TArgS "source" source + +stringToHashBucket' :: String -> String -> String -> Tensor n t a +stringToHashBucket' string_tensor num_buckets name = TSym "tf.string_to_hash_bucket" <+> TArgS "string_tensor" string_tensor <+> TArgS "num_buckets" num_buckets <+> TArgS "name" name +stringToHashBucket :: String -> String -> Tensor n t a +stringToHashBucket string_tensor num_buckets = TSym "tf.string_to_hash_bucket" <+> TArgS "string_tensor" string_tensor <+> TArgS "num_buckets" num_buckets + +stringToHashBucketFast' :: String -> String -> String -> Tensor n t a +stringToHashBucketFast' input num_buckets name = TSym "tf.string_to_hash_bucket_fast" <+> TArgS "input" input <+> TArgS "num_buckets" num_buckets <+> TArgS "name" name +stringToHashBucketFast :: String -> String -> Tensor n t a +stringToHashBucketFast input num_buckets = TSym "tf.string_to_hash_bucket_fast" <+> TArgS "input" input <+> TArgS "num_buckets" num_buckets + +stringToHashBucketStrong' :: String -> String -> String -> String -> Tensor n t a +stringToHashBucketStrong' input num_buckets key name = TSym "tf.string_to_hash_bucket_strong" <+> TArgS "input" input <+> TArgS "num_buckets" num_buckets <+> TArgS "key" key <+> TArgS "name" name +stringToHashBucketStrong :: String -> String -> String -> Tensor n t a +stringToHashBucketStrong input num_buckets key = TSym "tf.string_to_hash_bucket_strong" <+> TArgS "input" input <+> TArgS "num_buckets" num_buckets <+> TArgS "key" key + +stringToNumber' :: String -> String -> String -> Tensor n t a +stringToNumber' string_tensor out_type name = TSym "tf.string_to_number" <+> TArgS "string_tensor" string_tensor <+> TArgS "out_type" out_type <+> TArgS "name" name +stringToNumber :: String -> Tensor n t a +stringToNumber string_tensor = TSym "tf.string_to_number" <+> TArgS "string_tensor" string_tensor + +substr' :: String -> String -> String -> String -> Tensor n t a +substr' input pos len name = TSym "tf.substr" <+> TArgS "input" input <+> TArgS "pos" pos <+> TArgS "len" len <+> TArgS "name" name +substr :: String -> String -> String -> Tensor n t a +substr input pos len = TSym "tf.substr" <+> TArgS "input" input <+> TArgS "pos" pos <+> TArgS "len" len + +subtract' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +subtract' x y name = TSym "tf.subtract" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +subtract :: Tensor n t a -> Tensor n t a -> Tensor n t a +subtract x y = TSym "tf.subtract" <+> TArgT "x" x <+> TArgT "y" y + +svd' :: Tensor n t a -> String -> String -> String -> Tensor n t a +svd' tensor full_matrices compute_uv name = TSym "tf.svd" <+> TArgT "tensor" tensor <+> TArgS "full_matrices" full_matrices <+> TArgS "compute_uv" compute_uv <+> TArgS "name" name +svd :: Tensor n t a -> Tensor n t a +svd tensor = TSym "tf.svd" <+> TArgT "tensor" tensor + + +tablesInitializer :: Tensor n t a +tablesInitializer = TSym "tf.tables_initializer" + +tan' :: Tensor n t a -> String -> Tensor n t a +tan' x name = TSym "tf.tan" <+> TArgT "x" x <+> TArgS "name" name + + +tanh' :: Tensor n t a -> String -> Tensor n t a +tanh' x name = TSym "tf.tanh" <+> TArgT "x" x <+> TArgS "name" name +tanh :: Tensor n t a -> Tensor n t a +tanh x = TSym "tf.tanh" <+> TArgT "x" x + +tensordot' :: Tensor n t a -> Tensor n t a -> String -> String -> Tensor n t a +tensordot' a b axes name = TSym "tf.tensordot" <+> TArgT "a" a <+> TArgT "b" b <+> TArgS "axes" axes <+> TArgS "name" name +tensordot :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +tensordot a b axes = TSym "tf.tensordot" <+> TArgT "a" a <+> TArgT "b" b <+> TArgS "axes" axes + +tile' :: String -> String -> String -> Tensor n t a +tile' input multiples name = TSym "tf.tile" <+> TArgS "input" input <+> TArgS "multiples" multiples <+> TArgS "name" name +tile :: String -> String -> Tensor n t a +tile input multiples = TSym "tf.tile" <+> TArgS "input" input <+> TArgS "multiples" multiples + +toBfloat16' :: Tensor n t a -> String -> Tensor n t a +toBfloat16' x name = TSym "tf.to_bfloat16" <+> TArgT "x" x <+> TArgS "name" name +toBfloat16 :: Tensor n t a -> Tensor n t a +toBfloat16 x = TSym "tf.to_bfloat16" <+> TArgT "x" x + +toDouble' :: Tensor n t a -> String -> Tensor n t a +toDouble' x name = TSym "tf.to_double" <+> TArgT "x" x <+> TArgS "name" name +toDouble :: Tensor n t a -> Tensor n t a +toDouble x = TSym "tf.to_double" <+> TArgT "x" x + +toFloat' :: Tensor n t a -> String -> Tensor n t a +toFloat' x name = TSym "tf.to_float" <+> TArgT "x" x <+> TArgS "name" name +toFloat :: Tensor n t a -> Tensor n t a +toFloat x = TSym "tf.to_float" <+> TArgT "x" x + +toInt32' :: Tensor n t a -> String -> Tensor n t a +toInt32' x name = TSym "tf.to_int32" <+> TArgT "x" x <+> TArgS "name" name +toInt32 :: Tensor n t a -> Tensor n t a +toInt32 x = TSym "tf.to_int32" <+> TArgT "x" x + +toInt64' :: Tensor n t a -> String -> Tensor n t a +toInt64' x name = TSym "tf.to_int64" <+> TArgT "x" x <+> TArgS "name" name +toInt64 :: Tensor n t a -> Tensor n t a +toInt64 x = TSym "tf.to_int64" <+> TArgT "x" x + +trace' :: Tensor n t a -> String -> Tensor n t a +trace' x name = TSym "tf.trace" <+> TArgT "x" x <+> TArgS "name" name +trace :: Tensor n t a -> Tensor n t a +trace x = TSym "tf.trace" <+> TArgT "x" x + + +trainableVariables :: Tensor n t a +trainableVariables = TSym "tf.trainable_variables" + +transpose' :: Tensor n t a -> String -> String -> Tensor n t a +transpose' a perm name = TSym "tf.transpose" <+> TArgT "a" a <+> TArgS "perm" perm <+> TArgS "name" name +transpose :: Tensor n t a -> Tensor n t a +transpose a = TSym "tf.transpose" <+> TArgT "a" a + +truediv' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +truediv' x y name = TSym "tf.truediv" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +truediv :: Tensor n t a -> Tensor n t a -> Tensor n t a +truediv x y = TSym "tf.truediv" <+> TArgT "x" x <+> TArgT "y" y + +truncatedNormal' :: SingI n => Sing n -> String -> String -> String -> String -> String -> Tensor n t a +truncatedNormal' shape mean stddev dtype seed name = TSym "tf.truncated_normal" <+> TArgSing "shape" shape <+> TArgS "mean" mean <+> TArgS "stddev" stddev <+> TArgS "dtype" dtype <+> TArgS "seed" seed <+> TArgS "name" name +truncatedNormal :: SingI n => Sing n -> Tensor n t a +truncatedNormal shape = TSym "tf.truncated_normal" <+> TArgSing "shape" shape + +truncatediv' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +truncatediv' x y name = TSym "tf.truncatediv" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +truncatediv :: Tensor n t a -> Tensor n t a -> Tensor n t a +truncatediv x y = TSym "tf.truncatediv" <+> TArgT "x" x <+> TArgT "y" y + +truncatemod' :: Tensor n t a -> Tensor n t a -> String -> Tensor n t a +truncatemod' x y name = TSym "tf.truncatemod" <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +truncatemod :: Tensor n t a -> Tensor n t a -> Tensor n t a +truncatemod x y = TSym "tf.truncatemod" <+> TArgT "x" x <+> TArgT "y" y + +tuple' :: String -> String -> String -> Tensor n t a +tuple' tensors name control_inputs = TSym "tf.tuple" <+> TArgS "tensors" tensors <+> TArgS "name" name <+> TArgS "control_inputs" control_inputs +tuple :: String -> Tensor n t a +tuple tensors = TSym "tf.tuple" <+> TArgS "tensors" tensors + +unique' :: Tensor n t a -> String -> String -> Tensor n t a +unique' x out_idx name = TSym "tf.unique" <+> TArgT "x" x <+> TArgS "out_idx" out_idx <+> TArgS "name" name +unique :: Tensor n t a -> Tensor n t a +unique x = TSym "tf.unique" <+> TArgT "x" x + +uniqueWithCounts' :: Tensor n t a -> String -> String -> Tensor n t a +uniqueWithCounts' x out_idx name = TSym "tf.unique_with_counts" <+> TArgT "x" x <+> TArgS "out_idx" out_idx <+> TArgS "name" name +uniqueWithCounts :: Tensor n t a -> Tensor n t a +uniqueWithCounts x = TSym "tf.unique_with_counts" <+> TArgT "x" x + +unsortedSegmentMax' :: String -> String -> String -> String -> Tensor n t a +unsortedSegmentMax' data' segment_ids num_segments name = TSym "tf.unsorted_segment_max" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "num_segments" num_segments <+> TArgS "name" name +unsortedSegmentMax :: String -> String -> String -> Tensor n t a +unsortedSegmentMax data' segment_ids num_segments = TSym "tf.unsorted_segment_max" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "num_segments" num_segments + +unsortedSegmentSum' :: String -> String -> String -> String -> Tensor n t a +unsortedSegmentSum' data' segment_ids num_segments name = TSym "tf.unsorted_segment_sum" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "num_segments" num_segments <+> TArgS "name" name +unsortedSegmentSum :: String -> String -> String -> Tensor n t a +unsortedSegmentSum data' segment_ids num_segments = TSym "tf.unsorted_segment_sum" <+> TArgS "data" data' <+> TArgS "segment_ids" segment_ids <+> TArgS "num_segments" num_segments + +unstack' :: String -> String -> String -> String -> Tensor n t a +unstack' value num axis name = TSym "tf.unstack" <+> TArgS "value" value <+> TArgS "num" num <+> TArgS "axis" axis <+> TArgS "name" name +unstack :: String -> Tensor n t a +unstack value = TSym "tf.unstack" <+> TArgS "value" value + +variableAxisSizePartitioner' :: String -> String -> String -> String -> Tensor n t a +variableAxisSizePartitioner' max_shard_bytes axis bytes_per_string_element max_shards = TSym "tf.variable_axis_size_partitioner" <+> TArgS "max_shard_bytes" max_shard_bytes <+> TArgS "axis" axis <+> TArgS "bytes_per_string_element" bytes_per_string_element <+> TArgS "max_shards" max_shards +variableAxisSizePartitioner :: String -> Tensor n t a +variableAxisSizePartitioner max_shard_bytes = TSym "tf.variable_axis_size_partitioner" <+> TArgS "max_shard_bytes" max_shard_bytes + + +variableOpScope :: Tensor n t a +variableOpScope = TSym "tf.variable_op_scope" + + +variableScope :: Tensor n t a +variableScope = TSym "tf.variable_scope" + +variablesInitializer' :: String -> String -> Tensor n t a +variablesInitializer' var_list name = TSym "tf.variables_initializer" <+> TArgS "var_list" var_list <+> TArgS "name" name +variablesInitializer :: String -> Tensor n t a +variablesInitializer var_list = TSym "tf.variables_initializer" <+> TArgS "var_list" var_list + +verifyTensorAllFinite' :: String -> String -> String -> Tensor n t a +verifyTensorAllFinite' t msg name = TSym "tf.verify_tensor_all_finite" <+> TArgS "t" t <+> TArgS "msg" msg <+> TArgS "name" name +verifyTensorAllFinite :: String -> String -> Tensor n t a +verifyTensorAllFinite t msg = TSym "tf.verify_tensor_all_finite" <+> TArgS "t" t <+> TArgS "msg" msg + +tfwhere' :: String -> Tensor n t a -> Tensor n t a -> String -> Tensor n t a +tfwhere' condition x y name = TSym "tf.where" <+> TArgS "condition" condition <+> TArgT "x" x <+> TArgT "y" y <+> TArgS "name" name +tfwhere :: String -> Tensor n t a +tfwhere condition = TSym "tf.where" <+> TArgS "condition" condition + +whileLoop' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +whileLoop' cond body loop_vars shape_invariants parallel_iterations back_prop swap_memory name = TSym "tf.while_loop" <+> TArgS "cond" cond <+> TArgS "body" body <+> TArgS "loop_vars" loop_vars <+> TArgS "shape_invariants" shape_invariants <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "back_prop" back_prop <+> TArgS "swap_memory" swap_memory <+> TArgS "name" name +whileLoop :: String -> String -> String -> Tensor n t a +whileLoop cond body loop_vars = TSym "tf.while_loop" <+> TArgS "cond" cond <+> TArgS "body" body <+> TArgS "loop_vars" loop_vars + +writeFile' :: String -> String -> String -> Tensor n t a +writeFile' filename contents name = TSym "tf.write_file" <+> TArgS "filename" filename <+> TArgS "contents" contents <+> TArgS "name" name +writeFile :: String -> String -> Tensor n t a +writeFile filename contents = TSym "tf.write_file" <+> TArgS "filename" filename <+> TArgS "contents" contents + +zeros' :: SingI n => Sing n -> String -> String -> Tensor n t a +zeros' shape dtype name = TSym "tf.zeros" <+> TArgSing "shape" shape <+> TArgS "dtype" dtype <+> TArgS "name" name +zeros :: SingI n => Sing n -> Tensor n t a +zeros shape = TSym "tf.zeros" <+> TArgSing "shape" shape + +zerosLike' :: Tensor n t a -> String -> String -> String -> Tensor n t a +zerosLike' tensor dtype name optimize = TSym "tf.zeros_like" <+> TArgT "tensor" tensor <+> TArgS "dtype" dtype <+> TArgS "name" name <+> TArgS "optimize" optimize +zerosLike :: Tensor n t a -> Tensor n t a +zerosLike tensor = TSym "tf.zeros_like" <+> TArgT "tensor" tensor + +zeta' :: Tensor n t a -> String -> String -> Tensor n t a +zeta' x q name = TSym "tf.zeta" <+> TArgT "x" x <+> TArgS "q" q <+> TArgS "name" name +zeta :: Tensor n t a -> String -> Tensor n t a +zeta x q = TSym "tf.zeta" <+> TArgT "x" x <+> TArgS "q" q + diff --git a/src/MathFlow/TF/NN.hs b/src/MathFlow/TF/NN.hs new file mode 100644 --- /dev/null +++ b/src/MathFlow/TF/NN.hs @@ -0,0 +1,440 @@ + +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.TF.NN where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow.Core +import MathFlow.PyString + + +allCandidateSampler' :: String -> String -> String -> String -> String -> String -> Tensor n t a +allCandidateSampler' true_classes num_true num_sampled unique seed name = TSym "tf.all_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "seed" seed <+> TArgS "name" name +allCandidateSampler :: String -> String -> String -> String -> Tensor n t a +allCandidateSampler true_classes num_true num_sampled unique = TSym "tf.all_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique + +atrousConv2d' :: String -> String -> String -> String -> String -> Tensor n t a +atrousConv2d' value filters rate padding name = TSym "tf.atrous_conv2d" <+> TArgS "value" value <+> TArgS "filters" filters <+> TArgS "rate" rate <+> TArgS "padding" padding <+> TArgS "name" name +atrousConv2d :: String -> String -> String -> String -> Tensor n t a +atrousConv2d value filters rate padding = TSym "tf.atrous_conv2d" <+> TArgS "value" value <+> TArgS "filters" filters <+> TArgS "rate" rate <+> TArgS "padding" padding + +atrousConv2dTranspose' :: String -> String -> String -> String -> String -> String -> Tensor n t a +atrousConv2dTranspose' value filters output_shape rate padding name = TSym "tf.atrous_conv2d_transpose" <+> TArgS "value" value <+> TArgS "filters" filters <+> TArgS "output_shape" output_shape <+> TArgS "rate" rate <+> TArgS "padding" padding <+> TArgS "name" name +atrousConv2dTranspose :: String -> String -> String -> String -> String -> Tensor n t a +atrousConv2dTranspose value filters output_shape rate padding = TSym "tf.atrous_conv2d_transpose" <+> TArgS "value" value <+> TArgS "filters" filters <+> TArgS "output_shape" output_shape <+> TArgS "rate" rate <+> TArgS "padding" padding + +avgPool' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +avgPool' value ksize strides padding data_format name = TSym "tf.avg_pool" <+> TArgS "value" value <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +avgPool :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +avgPool value ksize strides padding = TSym "tf.avg_pool" <+> TArgS "value" value <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +avgPool3d' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +avgPool3d' input ksize strides padding data_format name = TSym "tf.avg_pool3d" <+> TArgS "input" input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +avgPool3d :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +avgPool3d input ksize strides padding = TSym "tf.avg_pool3d" <+> TArgS "input" input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +batchNormWithGlobalNormalization' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +batchNormWithGlobalNormalization' t m v beta gamma variance_epsilon scale_after_normalization name = TSym "tf.batch_norm_with_global_normalization" <+> TArgS "t" t <+> TArgS "m" m <+> TArgS "v" v <+> TArgS "beta" beta <+> TArgS "gamma" gamma <+> TArgS "variance_epsilon" variance_epsilon <+> TArgS "scale_after_normalization" scale_after_normalization <+> TArgS "name" name +batchNormWithGlobalNormalization :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +batchNormWithGlobalNormalization t m v beta gamma variance_epsilon scale_after_normalization = TSym "tf.batch_norm_with_global_normalization" <+> TArgS "t" t <+> TArgS "m" m <+> TArgS "v" v <+> TArgS "beta" beta <+> TArgS "gamma" gamma <+> TArgS "variance_epsilon" variance_epsilon <+> TArgS "scale_after_normalization" scale_after_normalization + +batchNormalization' :: Tensor n t a -> String -> String -> String -> String -> String -> String -> Tensor n t a +batchNormalization' x mean variance offset scale variance_epsilon name = TSym "tf.batch_normalization" <+> TArgT "x" x <+> TArgS "mean" mean <+> TArgS "variance" variance <+> TArgS "offset" offset <+> TArgS "scale" scale <+> TArgS "variance_epsilon" variance_epsilon <+> TArgS "name" name +batchNormalization :: Tensor n t a -> String -> String -> String -> String -> String -> Tensor n t a +batchNormalization x mean variance offset scale variance_epsilon = TSym "tf.batch_normalization" <+> TArgT "x" x <+> TArgS "mean" mean <+> TArgS "variance" variance <+> TArgS "offset" offset <+> TArgS "scale" scale <+> TArgS "variance_epsilon" variance_epsilon + +biasAdd' :: String -> String -> String -> String -> Tensor n t a +biasAdd' value bias data_format name = TSym "tf.bias_add" <+> TArgS "value" value <+> TArgS "bias" bias <+> TArgS "data_format" data_format <+> TArgS "name" name +biasAdd :: String -> String -> Tensor n t a +biasAdd value bias = TSym "tf.bias_add" <+> TArgS "value" value <+> TArgS "bias" bias + +bidirectionalDynamicRnn' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +bidirectionalDynamicRnn' cell_fw cell_bw inputs sequence_length initial_state_fw initial_state_bw dtype parallel_iterations swap_memory time_major scope = TSym "tf.bidirectional_dynamic_rnn" <+> TArgS "cell_fw" cell_fw <+> TArgS "cell_bw" cell_bw <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length <+> TArgS "initial_state_fw" initial_state_fw <+> TArgS "initial_state_bw" initial_state_bw <+> TArgS "dtype" dtype <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "swap_memory" swap_memory <+> TArgS "time_major" time_major <+> TArgS "scope" scope +bidirectionalDynamicRnn :: String -> String -> String -> Tensor n t a +bidirectionalDynamicRnn cell_fw cell_bw inputs = TSym "tf.bidirectional_dynamic_rnn" <+> TArgS "cell_fw" cell_fw <+> TArgS "cell_bw" cell_bw <+> TArgS "inputs" inputs + +computeAccidentalHits' :: String -> String -> String -> String -> String -> Tensor n t a +computeAccidentalHits' true_classes sampled_candidates num_true seed name = TSym "tf.compute_accidental_hits" <+> TArgS "true_classes" true_classes <+> TArgS "sampled_candidates" sampled_candidates <+> TArgS "num_true" num_true <+> TArgS "seed" seed <+> TArgS "name" name +computeAccidentalHits :: String -> String -> String -> Tensor n t a +computeAccidentalHits true_classes sampled_candidates num_true = TSym "tf.compute_accidental_hits" <+> TArgS "true_classes" true_classes <+> TArgS "sampled_candidates" sampled_candidates <+> TArgS "num_true" num_true + +conv1d' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +conv1d' value filters stride padding use_cudnn_on_gpu data_format name = TSym "tf.conv1d" <+> TArgS "value" value <+> TArgS "filters" filters <+> TArgS "stride" stride <+> TArgS "padding" padding <+> TArgS "use_cudnn_on_gpu" use_cudnn_on_gpu <+> TArgS "data_format" data_format <+> TArgS "name" name +conv1d :: String -> String -> String -> String -> Tensor n t a +conv1d value filters stride padding = TSym "tf.conv1d" <+> TArgS "value" value <+> TArgS "filters" filters <+> TArgS "stride" stride <+> TArgS "padding" padding + +conv2d' :: SingI n => String -> Tensor n t a -> Sing n -> String -> String -> String -> String -> Tensor n t a +conv2d' input filter strides padding use_cudnn_on_gpu data_format name = TSym "tf.conv2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "use_cudnn_on_gpu" use_cudnn_on_gpu <+> TArgS "data_format" data_format <+> TArgS "name" name +conv2d :: SingI n => String -> Tensor n t a -> Sing n -> String -> Tensor n t a +conv2d input filter strides padding = TSym "tf.conv2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding + +conv2dBackpropFilter' :: SingI n => String -> String -> String -> Sing n -> String -> String -> String -> String -> Tensor n t a +conv2dBackpropFilter' input filter_sizes out_backprop strides padding use_cudnn_on_gpu data_format name = TSym "tf.conv2d_backprop_filter" <+> TArgS "input" input <+> TArgS "filter_sizes" filter_sizes <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "use_cudnn_on_gpu" use_cudnn_on_gpu <+> TArgS "data_format" data_format <+> TArgS "name" name +conv2dBackpropFilter :: SingI n => String -> String -> String -> Sing n -> String -> Tensor n t a +conv2dBackpropFilter input filter_sizes out_backprop strides padding = TSym "tf.conv2d_backprop_filter" <+> TArgS "input" input <+> TArgS "filter_sizes" filter_sizes <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding + +conv2dBackpropInput' :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> String -> String -> String -> Tensor n t a +conv2dBackpropInput' input_sizes filter out_backprop strides padding use_cudnn_on_gpu data_format name = TSym "tf.conv2d_backprop_input" <+> TArgS "input_sizes" input_sizes <+> TArgT "filter" filter <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "use_cudnn_on_gpu" use_cudnn_on_gpu <+> TArgS "data_format" data_format <+> TArgS "name" name +conv2dBackpropInput :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> Tensor n t a +conv2dBackpropInput input_sizes filter out_backprop strides padding = TSym "tf.conv2d_backprop_input" <+> TArgS "input_sizes" input_sizes <+> TArgT "filter" filter <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding + +conv2dTranspose' :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> String -> String -> Tensor n t a +conv2dTranspose' value filter output_shape strides padding data_format name = TSym "tf.conv2d_transpose" <+> TArgS "value" value <+> TArgT "filter" filter <+> TArgS "output_shape" output_shape <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +conv2dTranspose :: SingI n => String -> Tensor n t a -> String -> Sing n -> Tensor n t a +conv2dTranspose value filter output_shape strides = TSym "tf.conv2d_transpose" <+> TArgS "value" value <+> TArgT "filter" filter <+> TArgS "output_shape" output_shape <+> TArgSing "strides" strides + +conv3d' :: SingI n => String -> Tensor n t a -> Sing n -> String -> String -> String -> Tensor n t a +conv3d' input filter strides padding data_format name = TSym "tf.conv3d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +conv3d :: SingI n => String -> Tensor n t a -> Sing n -> String -> Tensor n t a +conv3d input filter strides padding = TSym "tf.conv3d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding + +conv3dBackpropFilterV2' :: SingI n => String -> String -> String -> Sing n -> String -> String -> String -> Tensor n t a +conv3dBackpropFilterV2' input filter_sizes out_backprop strides padding data_format name = TSym "tf.conv3d_backprop_filter_v2" <+> TArgS "input" input <+> TArgS "filter_sizes" filter_sizes <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +conv3dBackpropFilterV2 :: SingI n => String -> String -> String -> Sing n -> String -> Tensor n t a +conv3dBackpropFilterV2 input filter_sizes out_backprop strides padding = TSym "tf.conv3d_backprop_filter_v2" <+> TArgS "input" input <+> TArgS "filter_sizes" filter_sizes <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding + +conv3dTranspose' :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> String -> String -> Tensor n t a +conv3dTranspose' value filter output_shape strides padding data_format name = TSym "tf.conv3d_transpose" <+> TArgS "value" value <+> TArgT "filter" filter <+> TArgS "output_shape" output_shape <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +conv3dTranspose :: SingI n => String -> Tensor n t a -> String -> Sing n -> Tensor n t a +conv3dTranspose value filter output_shape strides = TSym "tf.conv3d_transpose" <+> TArgS "value" value <+> TArgT "filter" filter <+> TArgS "output_shape" output_shape <+> TArgSing "strides" strides + +convolution' :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> String -> String -> Tensor n t a +convolution' input filter padding strides dilation_rate name data_format = TSym "tf.convolution" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgS "padding" padding <+> TArgSing "strides" strides <+> TArgS "dilation_rate" dilation_rate <+> TArgS "name" name <+> TArgS "data_format" data_format +convolution :: String -> Tensor n t a -> String -> Tensor n t a +convolution input filter padding = TSym "tf.convolution" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgS "padding" padding + +crelu' :: String -> String -> Tensor n t a +crelu' features name = TSym "tf.crelu" <+> TArgS "features" features <+> TArgS "name" name +crelu :: String -> Tensor n t a +crelu features = TSym "tf.crelu" <+> TArgS "features" features + +ctcBeamSearchDecoder' :: String -> String -> String -> String -> String -> Tensor n t a +ctcBeamSearchDecoder' inputs sequence_length beam_width top_paths merge_repeated = TSym "tf.ctc_beam_search_decoder" <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length <+> TArgS "beam_width" beam_width <+> TArgS "top_paths" top_paths <+> TArgS "merge_repeated" merge_repeated +ctcBeamSearchDecoder :: String -> String -> Tensor n t a +ctcBeamSearchDecoder inputs sequence_length = TSym "tf.ctc_beam_search_decoder" <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length + +ctcGreedyDecoder' :: String -> String -> String -> Tensor n t a +ctcGreedyDecoder' inputs sequence_length merge_repeated = TSym "tf.ctc_greedy_decoder" <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length <+> TArgS "merge_repeated" merge_repeated +ctcGreedyDecoder :: String -> String -> Tensor n t a +ctcGreedyDecoder inputs sequence_length = TSym "tf.ctc_greedy_decoder" <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length + +ctcLoss' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +ctcLoss' labels inputs sequence_length preprocess_collapse_repeated ctc_merge_repeated ignore_longer_outputs_than_inputs time_major = TSym "tf.ctc_loss" <+> TArgS "labels" labels <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length <+> TArgS "preprocess_collapse_repeated" preprocess_collapse_repeated <+> TArgS "ctc_merge_repeated" ctc_merge_repeated <+> TArgS "ignore_longer_outputs_than_inputs" ignore_longer_outputs_than_inputs <+> TArgS "time_major" time_major +ctcLoss :: String -> String -> String -> Tensor n t a +ctcLoss labels inputs sequence_length = TSym "tf.ctc_loss" <+> TArgS "labels" labels <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length + +depthwiseConv2d' :: SingI n => String -> Tensor n t a -> Sing n -> String -> String -> String -> String -> Tensor n t a +depthwiseConv2d' input filter strides padding rate name data_format = TSym "tf.depthwise_conv2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "rate" rate <+> TArgS "name" name <+> TArgS "data_format" data_format +depthwiseConv2d :: SingI n => String -> Tensor n t a -> Sing n -> String -> Tensor n t a +depthwiseConv2d input filter strides padding = TSym "tf.depthwise_conv2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding + +depthwiseConv2dNative' :: SingI n => String -> Tensor n t a -> Sing n -> String -> String -> String -> Tensor n t a +depthwiseConv2dNative' input filter strides padding data_format name = TSym "tf.depthwise_conv2d_native" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +depthwiseConv2dNative :: SingI n => String -> Tensor n t a -> Sing n -> String -> Tensor n t a +depthwiseConv2dNative input filter strides padding = TSym "tf.depthwise_conv2d_native" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "padding" padding + +depthwiseConv2dNativeBackpropFilter' :: SingI n => String -> String -> String -> Sing n -> String -> String -> String -> Tensor n t a +depthwiseConv2dNativeBackpropFilter' input filter_sizes out_backprop strides padding data_format name = TSym "tf.depthwise_conv2d_native_backprop_filter" <+> TArgS "input" input <+> TArgS "filter_sizes" filter_sizes <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +depthwiseConv2dNativeBackpropFilter :: SingI n => String -> String -> String -> Sing n -> String -> Tensor n t a +depthwiseConv2dNativeBackpropFilter input filter_sizes out_backprop strides padding = TSym "tf.depthwise_conv2d_native_backprop_filter" <+> TArgS "input" input <+> TArgS "filter_sizes" filter_sizes <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding + +depthwiseConv2dNativeBackpropInput' :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> String -> String -> Tensor n t a +depthwiseConv2dNativeBackpropInput' input_sizes filter out_backprop strides padding data_format name = TSym "tf.depthwise_conv2d_native_backprop_input" <+> TArgS "input_sizes" input_sizes <+> TArgT "filter" filter <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +depthwiseConv2dNativeBackpropInput :: SingI n => String -> Tensor n t a -> String -> Sing n -> String -> Tensor n t a +depthwiseConv2dNativeBackpropInput input_sizes filter out_backprop strides padding = TSym "tf.depthwise_conv2d_native_backprop_input" <+> TArgS "input_sizes" input_sizes <+> TArgT "filter" filter <+> TArgS "out_backprop" out_backprop <+> TArgSing "strides" strides <+> TArgS "padding" padding + +dilation2d' :: SingI n => String -> Tensor n t a -> Sing n -> String -> String -> String -> Tensor n t a +dilation2d' input filter strides rates padding name = TSym "tf.dilation2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "rates" rates <+> TArgS "padding" padding <+> TArgS "name" name +dilation2d :: SingI n => String -> Tensor n t a -> Sing n -> String -> String -> Tensor n t a +dilation2d input filter strides rates padding = TSym "tf.dilation2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgSing "strides" strides <+> TArgS "rates" rates <+> TArgS "padding" padding + +dropout' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +dropout' x keep_prob noise_shape seed name = TSym "tf.dropout" <+> TArgT "x" x <+> TArgS "keep_prob" keep_prob <+> TArgS "noise_shape" noise_shape <+> TArgS "seed" seed <+> TArgS "name" name +dropout :: Tensor n t a -> String -> Tensor n t a +dropout x keep_prob = TSym "tf.dropout" <+> TArgT "x" x <+> TArgS "keep_prob" keep_prob + +dynamicRnn' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +dynamicRnn' cell inputs sequence_length initial_state dtype parallel_iterations swap_memory time_major scope = TSym "tf.dynamic_rnn" <+> TArgS "cell" cell <+> TArgS "inputs" inputs <+> TArgS "sequence_length" sequence_length <+> TArgS "initial_state" initial_state <+> TArgS "dtype" dtype <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "swap_memory" swap_memory <+> TArgS "time_major" time_major <+> TArgS "scope" scope +dynamicRnn :: String -> String -> Tensor n t a +dynamicRnn cell inputs = TSym "tf.dynamic_rnn" <+> TArgS "cell" cell <+> TArgS "inputs" inputs + +elu' :: String -> String -> Tensor n t a +elu' features name = TSym "tf.elu" <+> TArgS "features" features <+> TArgS "name" name +elu :: String -> Tensor n t a +elu features = TSym "tf.elu" <+> TArgS "features" features + +embeddingLookup' :: String -> String -> String -> String -> String -> String -> Tensor n t a +embeddingLookup' params ids partition_strategy name validate_indices max_norm = TSym "tf.embedding_lookup" <+> TArgS "params" params <+> TArgS "ids" ids <+> TArgS "partition_strategy" partition_strategy <+> TArgS "name" name <+> TArgS "validate_indices" validate_indices <+> TArgS "max_norm" max_norm +embeddingLookup :: String -> String -> Tensor n t a +embeddingLookup params ids = TSym "tf.embedding_lookup" <+> TArgS "params" params <+> TArgS "ids" ids + +embeddingLookupSparse' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +embeddingLookupSparse' params sp_ids sp_weights partition_strategy name combiner max_norm = TSym "tf.embedding_lookup_sparse" <+> TArgS "params" params <+> TArgS "sp_ids" sp_ids <+> TArgS "sp_weights" sp_weights <+> TArgS "partition_strategy" partition_strategy <+> TArgS "name" name <+> TArgS "combiner" combiner <+> TArgS "max_norm" max_norm +embeddingLookupSparse :: String -> String -> String -> Tensor n t a +embeddingLookupSparse params sp_ids sp_weights = TSym "tf.embedding_lookup_sparse" <+> TArgS "params" params <+> TArgS "sp_ids" sp_ids <+> TArgS "sp_weights" sp_weights + +erosion2d' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +erosion2d' value kernel strides rates padding name = TSym "tf.erosion2d" <+> TArgS "value" value <+> TArgS "kernel" kernel <+> TArgSing "strides" strides <+> TArgS "rates" rates <+> TArgS "padding" padding <+> TArgS "name" name +erosion2d :: SingI n => String -> String -> Sing n -> String -> String -> Tensor n t a +erosion2d value kernel strides rates padding = TSym "tf.erosion2d" <+> TArgS "value" value <+> TArgS "kernel" kernel <+> TArgSing "strides" strides <+> TArgS "rates" rates <+> TArgS "padding" padding + +fixedUnigramCandidateSampler' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +fixedUnigramCandidateSampler' true_classes num_true num_sampled unique range_max vocab_file distortion num_reserved_ids num_shards shard unigrams seed name = TSym "tf.fixed_unigram_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max <+> TArgS "vocab_file" vocab_file <+> TArgS "distortion" distortion <+> TArgS "num_reserved_ids" num_reserved_ids <+> TArgS "num_shards" num_shards <+> TArgS "shard" shard <+> TArgS "unigrams" unigrams <+> TArgS "seed" seed <+> TArgS "name" name +fixedUnigramCandidateSampler :: String -> String -> String -> String -> String -> Tensor n t a +fixedUnigramCandidateSampler true_classes num_true num_sampled unique range_max = TSym "tf.fixed_unigram_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max + +fractionalAvgPool' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +fractionalAvgPool' value pooling_ratio pseudo_random overlapping deterministic seed seed2 name = TSym "tf.fractional_avg_pool" <+> TArgS "value" value <+> TArgS "pooling_ratio" pooling_ratio <+> TArgS "pseudo_random" pseudo_random <+> TArgS "overlapping" overlapping <+> TArgS "deterministic" deterministic <+> TArgS "seed" seed <+> TArgS "seed2" seed2 <+> TArgS "name" name +fractionalAvgPool :: String -> String -> Tensor n t a +fractionalAvgPool value pooling_ratio = TSym "tf.fractional_avg_pool" <+> TArgS "value" value <+> TArgS "pooling_ratio" pooling_ratio + +fractionalMaxPool' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +fractionalMaxPool' value pooling_ratio pseudo_random overlapping deterministic seed seed2 name = TSym "tf.fractional_max_pool" <+> TArgS "value" value <+> TArgS "pooling_ratio" pooling_ratio <+> TArgS "pseudo_random" pseudo_random <+> TArgS "overlapping" overlapping <+> TArgS "deterministic" deterministic <+> TArgS "seed" seed <+> TArgS "seed2" seed2 <+> TArgS "name" name +fractionalMaxPool :: String -> String -> Tensor n t a +fractionalMaxPool value pooling_ratio = TSym "tf.fractional_max_pool" <+> TArgS "value" value <+> TArgS "pooling_ratio" pooling_ratio + +fusedBatchNorm' :: Tensor n t a -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +fusedBatchNorm' x scale offset mean variance epsilon data_format is_training name = TSym "tf.fused_batch_norm" <+> TArgT "x" x <+> TArgS "scale" scale <+> TArgS "offset" offset <+> TArgS "mean" mean <+> TArgS "variance" variance <+> TArgS "epsilon" epsilon <+> TArgS "data_format" data_format <+> TArgS "is_training" is_training <+> TArgS "name" name +fusedBatchNorm :: Tensor n t a -> String -> String -> Tensor n t a +fusedBatchNorm x scale offset = TSym "tf.fused_batch_norm" <+> TArgT "x" x <+> TArgS "scale" scale <+> TArgS "offset" offset + +inTopK' :: String -> String -> String -> String -> Tensor n t a +inTopK' predictions targets k name = TSym "tf.in_top_k" <+> TArgS "predictions" predictions <+> TArgS "targets" targets <+> TArgS "k" k <+> TArgS "name" name +inTopK :: String -> String -> String -> Tensor n t a +inTopK predictions targets k = TSym "tf.in_top_k" <+> TArgS "predictions" predictions <+> TArgS "targets" targets <+> TArgS "k" k + +l2Loss' :: String -> String -> Tensor n t a +l2Loss' t name = TSym "tf.l2_loss" <+> TArgS "t" t <+> TArgS "name" name +l2Loss :: String -> Tensor n t a +l2Loss t = TSym "tf.l2_loss" <+> TArgS "t" t + +l2Normalize' :: Tensor n t a -> String -> String -> String -> Tensor n t a +l2Normalize' x dim epsilon name = TSym "tf.l2_normalize" <+> TArgT "x" x <+> TArgS "dim" dim <+> TArgS "epsilon" epsilon <+> TArgS "name" name +l2Normalize :: Tensor n t a -> String -> Tensor n t a +l2Normalize x dim = TSym "tf.l2_normalize" <+> TArgT "x" x <+> TArgS "dim" dim + +learnedUnigramCandidateSampler' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +learnedUnigramCandidateSampler' true_classes num_true num_sampled unique range_max seed name = TSym "tf.learned_unigram_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max <+> TArgS "seed" seed <+> TArgS "name" name +learnedUnigramCandidateSampler :: String -> String -> String -> String -> String -> Tensor n t a +learnedUnigramCandidateSampler true_classes num_true num_sampled unique range_max = TSym "tf.learned_unigram_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max + +localResponseNormalization' :: String -> String -> String -> String -> String -> String -> Tensor n t a +localResponseNormalization' input depth_radius bias alpha beta name = TSym "tf.local_response_normalization" <+> TArgS "input" input <+> TArgS "depth_radius" depth_radius <+> TArgS "bias" bias <+> TArgS "alpha" alpha <+> TArgS "beta" beta <+> TArgS "name" name +localResponseNormalization :: String -> Tensor n t a +localResponseNormalization input = TSym "tf.local_response_normalization" <+> TArgS "input" input + +logPoissonLoss' :: String -> String -> String -> String -> Tensor n t a +logPoissonLoss' targets log_input compute_full_loss name = TSym "tf.log_poisson_loss" <+> TArgS "targets" targets <+> TArgS "log_input" log_input <+> TArgS "compute_full_loss" compute_full_loss <+> TArgS "name" name +logPoissonLoss :: String -> String -> Tensor n t a +logPoissonLoss targets log_input = TSym "tf.log_poisson_loss" <+> TArgS "targets" targets <+> TArgS "log_input" log_input + +logSoftmax' :: String -> String -> String -> Tensor n t a +logSoftmax' logits dim name = TSym "tf.log_softmax" <+> TArgS "logits" logits <+> TArgS "dim" dim <+> TArgS "name" name +logSoftmax :: String -> Tensor n t a +logSoftmax logits = TSym "tf.log_softmax" <+> TArgS "logits" logits + +logUniformCandidateSampler' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +logUniformCandidateSampler' true_classes num_true num_sampled unique range_max seed name = TSym "tf.log_uniform_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max <+> TArgS "seed" seed <+> TArgS "name" name +logUniformCandidateSampler :: String -> String -> String -> String -> String -> Tensor n t a +logUniformCandidateSampler true_classes num_true num_sampled unique range_max = TSym "tf.log_uniform_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max + +lrn' :: String -> String -> String -> String -> String -> String -> Tensor n t a +lrn' input depth_radius bias alpha beta name = TSym "tf.lrn" <+> TArgS "input" input <+> TArgS "depth_radius" depth_radius <+> TArgS "bias" bias <+> TArgS "alpha" alpha <+> TArgS "beta" beta <+> TArgS "name" name +lrn :: String -> Tensor n t a +lrn input = TSym "tf.lrn" <+> TArgS "input" input + +maxPool' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +maxPool' value ksize strides padding data_format name = TSym "tf.max_pool" <+> TArgS "value" value <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +maxPool :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +maxPool value ksize strides padding = TSym "tf.max_pool" <+> TArgS "value" value <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +maxPool3d' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +maxPool3d' input ksize strides padding data_format name = TSym "tf.max_pool3d" <+> TArgS "input" input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "data_format" data_format <+> TArgS "name" name +maxPool3d :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +maxPool3d input ksize strides padding = TSym "tf.max_pool3d" <+> TArgS "input" input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +maxPoolWithArgmax' :: SingI n => String -> String -> Sing n -> String -> String -> String -> Tensor n t a +maxPoolWithArgmax' input ksize strides padding targmax name = TSym "tf.max_pool_with_argmax" <+> TArgS "input" input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "Targmax" targmax <+> TArgS "name" name +maxPoolWithArgmax :: SingI n => String -> String -> Sing n -> String -> Tensor n t a +maxPoolWithArgmax input ksize strides padding = TSym "tf.max_pool_with_argmax" <+> TArgS "input" input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +moments' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +moments' x axes shift name keep_dims = TSym "tf.moments" <+> TArgT "x" x <+> TArgS "axes" axes <+> TArgS "shift" shift <+> TArgS "name" name <+> TArgS "keep_dims" keep_dims +moments :: Tensor n t a -> String -> Tensor n t a +moments x axes = TSym "tf.moments" <+> TArgT "x" x <+> TArgS "axes" axes + +nceLoss' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +nceLoss' weights biases labels inputs num_sampled num_classes num_true sampled_values remove_accidental_hits partition_strategy name = TSym "tf.nce_loss" <+> TArgS "weights" weights <+> TArgS "biases" biases <+> TArgS "labels" labels <+> TArgS "inputs" inputs <+> TArgS "num_sampled" num_sampled <+> TArgS "num_classes" num_classes <+> TArgS "num_true" num_true <+> TArgS "sampled_values" sampled_values <+> TArgS "remove_accidental_hits" remove_accidental_hits <+> TArgS "partition_strategy" partition_strategy <+> TArgS "name" name +nceLoss :: String -> String -> String -> String -> String -> String -> Tensor n t a +nceLoss weights biases labels inputs num_sampled num_classes = TSym "tf.nce_loss" <+> TArgS "weights" weights <+> TArgS "biases" biases <+> TArgS "labels" labels <+> TArgS "inputs" inputs <+> TArgS "num_sampled" num_sampled <+> TArgS "num_classes" num_classes + +normalizeMoments' :: String -> String -> String -> String -> String -> Tensor n t a +normalizeMoments' counts mean_ss variance_ss shift name = TSym "tf.normalize_moments" <+> TArgS "counts" counts <+> TArgS "mean_ss" mean_ss <+> TArgS "variance_ss" variance_ss <+> TArgS "shift" shift <+> TArgS "name" name +normalizeMoments :: String -> String -> String -> String -> Tensor n t a +normalizeMoments counts mean_ss variance_ss shift = TSym "tf.normalize_moments" <+> TArgS "counts" counts <+> TArgS "mean_ss" mean_ss <+> TArgS "variance_ss" variance_ss <+> TArgS "shift" shift + +pool' :: SingI n => String -> String -> String -> String -> String -> Sing n -> String -> String -> Tensor n t a +pool' input window_shape pooling_type padding dilation_rate strides name data_format = TSym "tf.pool" <+> TArgS "input" input <+> TArgS "window_shape" window_shape <+> TArgS "pooling_type" pooling_type <+> TArgS "padding" padding <+> TArgS "dilation_rate" dilation_rate <+> TArgSing "strides" strides <+> TArgS "name" name <+> TArgS "data_format" data_format +pool :: String -> String -> String -> String -> Tensor n t a +pool input window_shape pooling_type padding = TSym "tf.pool" <+> TArgS "input" input <+> TArgS "window_shape" window_shape <+> TArgS "pooling_type" pooling_type <+> TArgS "padding" padding + +quantizedAvgPool' :: SingI n => String -> String -> String -> String -> Sing n -> String -> String -> Tensor n t a +quantizedAvgPool' input min_input max_input ksize strides padding name = TSym "tf.quantized_avg_pool" <+> TArgS "input" input <+> TArgS "min_input" min_input <+> TArgS "max_input" max_input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "name" name +quantizedAvgPool :: SingI n => String -> String -> String -> String -> Sing n -> String -> Tensor n t a +quantizedAvgPool input min_input max_input ksize strides padding = TSym "tf.quantized_avg_pool" <+> TArgS "input" input <+> TArgS "min_input" min_input <+> TArgS "max_input" max_input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +quantizedConv2d' :: SingI n => String -> Tensor n t a -> String -> String -> String -> String -> Sing n -> String -> String -> String -> Tensor n t a +quantizedConv2d' input filter min_input max_input min_filter max_filter strides padding out_type name = TSym "tf.quantized_conv2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgS "min_input" min_input <+> TArgS "max_input" max_input <+> TArgS "min_filter" min_filter <+> TArgS "max_filter" max_filter <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "out_type" out_type <+> TArgS "name" name +quantizedConv2d :: SingI n => String -> Tensor n t a -> String -> String -> String -> String -> Sing n -> String -> Tensor n t a +quantizedConv2d input filter min_input max_input min_filter max_filter strides padding = TSym "tf.quantized_conv2d" <+> TArgS "input" input <+> TArgT "filter" filter <+> TArgS "min_input" min_input <+> TArgS "max_input" max_input <+> TArgS "min_filter" min_filter <+> TArgS "max_filter" max_filter <+> TArgSing "strides" strides <+> TArgS "padding" padding + +quantizedMaxPool' :: SingI n => String -> String -> String -> String -> Sing n -> String -> String -> Tensor n t a +quantizedMaxPool' input min_input max_input ksize strides padding name = TSym "tf.quantized_max_pool" <+> TArgS "input" input <+> TArgS "min_input" min_input <+> TArgS "max_input" max_input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "name" name +quantizedMaxPool :: SingI n => String -> String -> String -> String -> Sing n -> String -> Tensor n t a +quantizedMaxPool input min_input max_input ksize strides padding = TSym "tf.quantized_max_pool" <+> TArgS "input" input <+> TArgS "min_input" min_input <+> TArgS "max_input" max_input <+> TArgS "ksize" ksize <+> TArgSing "strides" strides <+> TArgS "padding" padding + +quantizedReluX' :: String -> String -> String -> String -> String -> String -> Tensor n t a +quantizedReluX' features max_value min_features max_features out_type name = TSym "tf.quantized_relu_x" <+> TArgS "features" features <+> TArgS "max_value" max_value <+> TArgS "min_features" min_features <+> TArgS "max_features" max_features <+> TArgS "out_type" out_type <+> TArgS "name" name +quantizedReluX :: String -> String -> String -> String -> Tensor n t a +quantizedReluX features max_value min_features max_features = TSym "tf.quantized_relu_x" <+> TArgS "features" features <+> TArgS "max_value" max_value <+> TArgS "min_features" min_features <+> TArgS "max_features" max_features + +rawRnn' :: String -> String -> String -> String -> String -> Tensor n t a +rawRnn' cell loop_fn parallel_iterations swap_memory scope = TSym "tf.raw_rnn" <+> TArgS "cell" cell <+> TArgS "loop_fn" loop_fn <+> TArgS "parallel_iterations" parallel_iterations <+> TArgS "swap_memory" swap_memory <+> TArgS "scope" scope +rawRnn :: String -> String -> Tensor n t a +rawRnn cell loop_fn = TSym "tf.raw_rnn" <+> TArgS "cell" cell <+> TArgS "loop_fn" loop_fn + +relu' :: String -> String -> Tensor n t a +relu' features name = TSym "tf.relu" <+> TArgS "features" features <+> TArgS "name" name +relu :: String -> Tensor n t a +relu features = TSym "tf.relu" <+> TArgS "features" features + +relu6' :: String -> String -> Tensor n t a +relu6' features name = TSym "tf.relu6" <+> TArgS "features" features <+> TArgS "name" name +relu6 :: String -> Tensor n t a +relu6 features = TSym "tf.relu6" <+> TArgS "features" features + +reluLayer' :: Tensor n t a -> String -> String -> String -> Tensor n t a +reluLayer' x weights biases name = TSym "tf.relu_layer" <+> TArgT "x" x <+> TArgS "weights" weights <+> TArgS "biases" biases <+> TArgS "name" name +reluLayer :: Tensor n t a -> String -> String -> Tensor n t a +reluLayer x weights biases = TSym "tf.relu_layer" <+> TArgT "x" x <+> TArgS "weights" weights <+> TArgS "biases" biases + +sampledSoftmaxLoss' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +sampledSoftmaxLoss' weights biases labels inputs num_sampled num_classes num_true sampled_values remove_accidental_hits partition_strategy name = TSym "tf.sampled_softmax_loss" <+> TArgS "weights" weights <+> TArgS "biases" biases <+> TArgS "labels" labels <+> TArgS "inputs" inputs <+> TArgS "num_sampled" num_sampled <+> TArgS "num_classes" num_classes <+> TArgS "num_true" num_true <+> TArgS "sampled_values" sampled_values <+> TArgS "remove_accidental_hits" remove_accidental_hits <+> TArgS "partition_strategy" partition_strategy <+> TArgS "name" name +sampledSoftmaxLoss :: String -> String -> String -> String -> String -> String -> Tensor n t a +sampledSoftmaxLoss weights biases labels inputs num_sampled num_classes = TSym "tf.sampled_softmax_loss" <+> TArgS "weights" weights <+> TArgS "biases" biases <+> TArgS "labels" labels <+> TArgS "inputs" inputs <+> TArgS "num_sampled" num_sampled <+> TArgS "num_classes" num_classes + +separableConv2d' :: SingI n => String -> String -> String -> Sing n -> String -> String -> String -> String -> Tensor n t a +separableConv2d' input depthwise_filter pointwise_filter strides padding rate name data_format = TSym "tf.separable_conv2d" <+> TArgS "input" input <+> TArgS "depthwise_filter" depthwise_filter <+> TArgS "pointwise_filter" pointwise_filter <+> TArgSing "strides" strides <+> TArgS "padding" padding <+> TArgS "rate" rate <+> TArgS "name" name <+> TArgS "data_format" data_format +separableConv2d :: SingI n => String -> String -> String -> Sing n -> String -> Tensor n t a +separableConv2d input depthwise_filter pointwise_filter strides padding = TSym "tf.separable_conv2d" <+> TArgS "input" input <+> TArgS "depthwise_filter" depthwise_filter <+> TArgS "pointwise_filter" pointwise_filter <+> TArgSing "strides" strides <+> TArgS "padding" padding + +sigmoid' :: Tensor n t a -> String -> Tensor n t a +sigmoid' x name = TSym "tf.sigmoid" <+> TArgT "x" x <+> TArgS "name" name +sigmoid :: Tensor n t a -> Tensor n t a +sigmoid x = TSym "tf.sigmoid" <+> TArgT "x" x + + +sigmoidCrossEntropyWithLogits :: Tensor n t a +sigmoidCrossEntropyWithLogits = TSym "tf.sigmoid_cross_entropy_with_logits" + +softmax' :: String -> String -> String -> Tensor n t a +softmax' logits dim name = TSym "tf.softmax" <+> TArgS "logits" logits <+> TArgS "dim" dim <+> TArgS "name" name +softmax :: String -> Tensor n t a +softmax logits = TSym "tf.softmax" <+> TArgS "logits" logits + + +softmaxCrossEntropyWithLogits :: Tensor n t a +softmaxCrossEntropyWithLogits = TSym "tf.softmax_cross_entropy_with_logits" + +softplus' :: String -> String -> Tensor n t a +softplus' features name = TSym "tf.softplus" <+> TArgS "features" features <+> TArgS "name" name +softplus :: String -> Tensor n t a +softplus features = TSym "tf.softplus" <+> TArgS "features" features + +softsign' :: String -> String -> Tensor n t a +softsign' features name = TSym "tf.softsign" <+> TArgS "features" features <+> TArgS "name" name +softsign :: String -> Tensor n t a +softsign features = TSym "tf.softsign" <+> TArgS "features" features + + +sparseSoftmaxCrossEntropyWithLogits :: Tensor n t a +sparseSoftmaxCrossEntropyWithLogits = TSym "tf.sparse_softmax_cross_entropy_with_logits" + +staticBidirectionalRnn' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +staticBidirectionalRnn' cell_fw cell_bw inputs initial_state_fw initial_state_bw dtype sequence_length scope = TSym "tf.static_bidirectional_rnn" <+> TArgS "cell_fw" cell_fw <+> TArgS "cell_bw" cell_bw <+> TArgS "inputs" inputs <+> TArgS "initial_state_fw" initial_state_fw <+> TArgS "initial_state_bw" initial_state_bw <+> TArgS "dtype" dtype <+> TArgS "sequence_length" sequence_length <+> TArgS "scope" scope +staticBidirectionalRnn :: String -> String -> String -> Tensor n t a +staticBidirectionalRnn cell_fw cell_bw inputs = TSym "tf.static_bidirectional_rnn" <+> TArgS "cell_fw" cell_fw <+> TArgS "cell_bw" cell_bw <+> TArgS "inputs" inputs + +staticRnn' :: String -> String -> String -> String -> String -> String -> Tensor n t a +staticRnn' cell inputs initial_state dtype sequence_length scope = TSym "tf.static_rnn" <+> TArgS "cell" cell <+> TArgS "inputs" inputs <+> TArgS "initial_state" initial_state <+> TArgS "dtype" dtype <+> TArgS "sequence_length" sequence_length <+> TArgS "scope" scope +staticRnn :: String -> String -> Tensor n t a +staticRnn cell inputs = TSym "tf.static_rnn" <+> TArgS "cell" cell <+> TArgS "inputs" inputs + +staticStateSavingRnn' :: String -> String -> String -> String -> String -> String -> Tensor n t a +staticStateSavingRnn' cell inputs state_saver state_name sequence_length scope = TSym "tf.static_state_saving_rnn" <+> TArgS "cell" cell <+> TArgS "inputs" inputs <+> TArgS "state_saver" state_saver <+> TArgS "state_name" state_name <+> TArgS "sequence_length" sequence_length <+> TArgS "scope" scope +staticStateSavingRnn :: String -> String -> String -> String -> Tensor n t a +staticStateSavingRnn cell inputs state_saver state_name = TSym "tf.static_state_saving_rnn" <+> TArgS "cell" cell <+> TArgS "inputs" inputs <+> TArgS "state_saver" state_saver <+> TArgS "state_name" state_name + +sufficientStatistics' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +sufficientStatistics' x axes shift keep_dims name = TSym "tf.sufficient_statistics" <+> TArgT "x" x <+> TArgS "axes" axes <+> TArgS "shift" shift <+> TArgS "keep_dims" keep_dims <+> TArgS "name" name +sufficientStatistics :: Tensor n t a -> String -> Tensor n t a +sufficientStatistics x axes = TSym "tf.sufficient_statistics" <+> TArgT "x" x <+> TArgS "axes" axes + +tanh' :: Tensor n t a -> String -> Tensor n t a +tanh' x name = TSym "tf.tanh" <+> TArgT "x" x <+> TArgS "name" name +tanh :: Tensor n t a -> Tensor n t a +tanh x = TSym "tf.tanh" <+> TArgT "x" x + +topK' :: String -> String -> String -> String -> Tensor n t a +topK' input k sorted name = TSym "tf.top_k" <+> TArgS "input" input <+> TArgS "k" k <+> TArgS "sorted" sorted <+> TArgS "name" name +topK :: String -> Tensor n t a +topK input = TSym "tf.top_k" <+> TArgS "input" input + +uniformCandidateSampler' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +uniformCandidateSampler' true_classes num_true num_sampled unique range_max seed name = TSym "tf.uniform_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max <+> TArgS "seed" seed <+> TArgS "name" name +uniformCandidateSampler :: String -> String -> String -> String -> String -> Tensor n t a +uniformCandidateSampler true_classes num_true num_sampled unique range_max = TSym "tf.uniform_candidate_sampler" <+> TArgS "true_classes" true_classes <+> TArgS "num_true" num_true <+> TArgS "num_sampled" num_sampled <+> TArgS "unique" unique <+> TArgS "range_max" range_max + +weightedCrossEntropyWithLogits' :: String -> String -> String -> String -> Tensor n t a +weightedCrossEntropyWithLogits' targets logits pos_weight name = TSym "tf.weighted_cross_entropy_with_logits" <+> TArgS "targets" targets <+> TArgS "logits" logits <+> TArgS "pos_weight" pos_weight <+> TArgS "name" name +weightedCrossEntropyWithLogits :: String -> String -> String -> Tensor n t a +weightedCrossEntropyWithLogits targets logits pos_weight = TSym "tf.weighted_cross_entropy_with_logits" <+> TArgS "targets" targets <+> TArgS "logits" logits <+> TArgS "pos_weight" pos_weight + +weightedMoments' :: Tensor n t a -> String -> String -> String -> String -> Tensor n t a +weightedMoments' x axes frequency_weights name keep_dims = TSym "tf.weighted_moments" <+> TArgT "x" x <+> TArgS "axes" axes <+> TArgS "frequency_weights" frequency_weights <+> TArgS "name" name <+> TArgS "keep_dims" keep_dims +weightedMoments :: Tensor n t a -> String -> String -> Tensor n t a +weightedMoments x axes frequency_weights = TSym "tf.weighted_moments" <+> TArgT "x" x <+> TArgS "axes" axes <+> TArgS "frequency_weights" frequency_weights + +withSpaceToBatch' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +withSpaceToBatch' input dilation_rate padding op filter_shape spatial_dims data_format = TSym "tf.with_space_to_batch" <+> TArgS "input" input <+> TArgS "dilation_rate" dilation_rate <+> TArgS "padding" padding <+> TArgS "op" op <+> TArgS "filter_shape" filter_shape <+> TArgS "spatial_dims" spatial_dims <+> TArgS "data_format" data_format +withSpaceToBatch :: String -> String -> String -> String -> Tensor n t a +withSpaceToBatch input dilation_rate padding op = TSym "tf.with_space_to_batch" <+> TArgS "input" input <+> TArgS "dilation_rate" dilation_rate <+> TArgS "padding" padding <+> TArgS "op" op + +xwPlusB' :: Tensor n t a -> String -> String -> String -> Tensor n t a +xwPlusB' x weights biases name = TSym "tf.xw_plus_b" <+> TArgT "x" x <+> TArgS "weights" weights <+> TArgS "biases" biases <+> TArgS "name" name +xwPlusB :: Tensor n t a -> String -> String -> Tensor n t a +xwPlusB x weights biases = TSym "tf.xw_plus_b" <+> TArgT "x" x <+> TArgS "weights" weights <+> TArgS "biases" biases + +zeroFraction' :: String -> String -> Tensor n t a +zeroFraction' value name = TSym "tf.zero_fraction" <+> TArgS "value" value <+> TArgS "name" name +zeroFraction :: String -> Tensor n t a +zeroFraction value = TSym "tf.zero_fraction" <+> TArgS "value" value + diff --git a/src/MathFlow/TF/Train.hs b/src/MathFlow/TF/Train.hs new file mode 100644 --- /dev/null +++ b/src/MathFlow/TF/Train.hs @@ -0,0 +1,234 @@ + +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.TF.Train where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow.Core +import MathFlow.PyString + + + +monitoredTrainingSession :: Tensor n t a +monitoredTrainingSession = TSym "tf.MonitoredTrainingSession" + + +newCheckpointReader :: String -> Tensor n t a +newCheckpointReader filepattern = TSym "tf.NewCheckpointReader" <+> TArgS "filepattern" filepattern + +addQueueRunner' :: String -> String -> Tensor n t a +addQueueRunner' qr collection = TSym "tf.add_queue_runner" <+> TArgS "qr" qr <+> TArgS "collection" collection +addQueueRunner :: String -> Tensor n t a +addQueueRunner qr = TSym "tf.add_queue_runner" <+> TArgS "qr" qr + + +assertGlobalStep :: String -> Tensor n t a +assertGlobalStep global_step_tensor = TSym "tf.assert_global_step" <+> TArgS "global_step_tensor" global_step_tensor + +basicTrainLoop' :: String -> String -> String -> String -> String -> Tensor n t a +basicTrainLoop' supervisor train_step_fn args kwargs master = TSym "tf.basic_train_loop" <+> TArgS "supervisor" supervisor <+> TArgS "train_step_fn" train_step_fn <+> TArgS "args" args <+> TArgS "kwargs" kwargs <+> TArgS "master" master +basicTrainLoop :: String -> String -> Tensor n t a +basicTrainLoop supervisor train_step_fn = TSym "tf.basic_train_loop" <+> TArgS "supervisor" supervisor <+> TArgS "train_step_fn" train_step_fn + +batch' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +batch' tensors batch_size num_threads capacity enqueue_many shapes dynamic_pad allow_smaller_final_batch shared_name name = TSym "tf.batch" <+> TArgS "tensors" tensors <+> TArgS "batch_size" batch_size <+> TArgS "num_threads" num_threads <+> TArgS "capacity" capacity <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "dynamic_pad" dynamic_pad <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +batch :: String -> String -> Tensor n t a +batch tensors batch_size = TSym "tf.batch" <+> TArgS "tensors" tensors <+> TArgS "batch_size" batch_size + +batchJoin' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +batchJoin' tensors_list batch_size capacity enqueue_many shapes dynamic_pad allow_smaller_final_batch shared_name name = TSym "tf.batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "dynamic_pad" dynamic_pad <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +batchJoin :: String -> String -> Tensor n t a +batchJoin tensors_list batch_size = TSym "tf.batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "batch_size" batch_size + + +checkpointExists :: String -> Tensor n t a +checkpointExists checkpoint_prefix = TSym "tf.checkpoint_exists" <+> TArgS "checkpoint_prefix" checkpoint_prefix + + +createGlobalStep :: Tensor n t a +createGlobalStep = TSym "tf.create_global_step" + + +doQuantizeTrainingOnGraphdef :: String -> String -> Tensor n t a +doQuantizeTrainingOnGraphdef input_graph num_bits = TSym "tf.do_quantize_training_on_graphdef" <+> TArgS "input_graph" input_graph <+> TArgS "num_bits" num_bits + +exponentialDecay' :: String -> String -> String -> String -> String -> String -> Tensor n t a +exponentialDecay' learning_rate global_step decay_steps decay_rate staircase name = TSym "tf.exponential_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "decay_rate" decay_rate <+> TArgS "staircase" staircase <+> TArgS "name" name +exponentialDecay :: String -> String -> String -> String -> Tensor n t a +exponentialDecay learning_rate global_step decay_steps decay_rate = TSym "tf.exponential_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "decay_rate" decay_rate + + +exportMetaGraph :: Tensor n t a +exportMetaGraph = TSym "tf.export_meta_graph" + +generateCheckpointStateProto' :: String -> String -> String -> Tensor n t a +generateCheckpointStateProto' save_dir model_checkpoint_path all_model_checkpoint_paths = TSym "tf.generate_checkpoint_state_proto" <+> TArgS "save_dir" save_dir <+> TArgS "model_checkpoint_path" model_checkpoint_path <+> TArgS "all_model_checkpoint_paths" all_model_checkpoint_paths +generateCheckpointStateProto :: String -> String -> Tensor n t a +generateCheckpointStateProto save_dir model_checkpoint_path = TSym "tf.generate_checkpoint_state_proto" <+> TArgS "save_dir" save_dir <+> TArgS "model_checkpoint_path" model_checkpoint_path + + +getCheckpointMtimes :: String -> Tensor n t a +getCheckpointMtimes checkpoint_prefixes = TSym "tf.get_checkpoint_mtimes" <+> TArgS "checkpoint_prefixes" checkpoint_prefixes + +getCheckpointState' :: String -> String -> Tensor n t a +getCheckpointState' checkpoint_dir latest_filename = TSym "tf.get_checkpoint_state" <+> TArgS "checkpoint_dir" checkpoint_dir <+> TArgS "latest_filename" latest_filename +getCheckpointState :: String -> Tensor n t a +getCheckpointState checkpoint_dir = TSym "tf.get_checkpoint_state" <+> TArgS "checkpoint_dir" checkpoint_dir + + +getGlobalStep :: Tensor n t a +getGlobalStep = TSym "tf.get_global_step" + + +getOrCreateGlobalStep :: Tensor n t a +getOrCreateGlobalStep = TSym "tf.get_or_create_global_step" + + +globalStep :: String -> String -> Tensor n t a +globalStep sess global_step_tensor = TSym "tf.global_step" <+> TArgS "sess" sess <+> TArgS "global_step_tensor" global_step_tensor + +importMetaGraph' :: String -> String -> String -> Tensor n t a +importMetaGraph' meta_graph_or_file clear_devices import_scope = TSym "tf.import_meta_graph" <+> TArgS "meta_graph_or_file" meta_graph_or_file <+> TArgS "clear_devices" clear_devices <+> TArgS "import_scope" import_scope +importMetaGraph :: String -> Tensor n t a +importMetaGraph meta_graph_or_file = TSym "tf.import_meta_graph" <+> TArgS "meta_graph_or_file" meta_graph_or_file + +inputProducer' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +inputProducer' input_tensor element_shape num_epochs shuffle seed capacity shared_name summary_name name cancel_op = TSym "tf.input_producer" <+> TArgS "input_tensor" input_tensor <+> TArgS "element_shape" element_shape <+> TArgS "num_epochs" num_epochs <+> TArgS "shuffle" shuffle <+> TArgS "seed" seed <+> TArgS "capacity" capacity <+> TArgS "shared_name" shared_name <+> TArgS "summary_name" summary_name <+> TArgS "name" name <+> TArgS "cancel_op" cancel_op +inputProducer :: String -> Tensor n t a +inputProducer input_tensor = TSym "tf.input_producer" <+> TArgS "input_tensor" input_tensor + +inverseTimeDecay' :: String -> String -> String -> String -> String -> String -> Tensor n t a +inverseTimeDecay' learning_rate global_step decay_steps decay_rate staircase name = TSym "tf.inverse_time_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "decay_rate" decay_rate <+> TArgS "staircase" staircase <+> TArgS "name" name +inverseTimeDecay :: String -> String -> String -> String -> Tensor n t a +inverseTimeDecay learning_rate global_step decay_steps decay_rate = TSym "tf.inverse_time_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "decay_rate" decay_rate + +latestCheckpoint' :: String -> String -> Tensor n t a +latestCheckpoint' checkpoint_dir latest_filename = TSym "tf.latest_checkpoint" <+> TArgS "checkpoint_dir" checkpoint_dir <+> TArgS "latest_filename" latest_filename +latestCheckpoint :: String -> Tensor n t a +latestCheckpoint checkpoint_dir = TSym "tf.latest_checkpoint" <+> TArgS "checkpoint_dir" checkpoint_dir + +limitEpochs' :: Tensor n t a -> String -> String -> Tensor n t a +limitEpochs' tensor num_epochs name = TSym "tf.limit_epochs" <+> TArgT "tensor" tensor <+> TArgS "num_epochs" num_epochs <+> TArgS "name" name +limitEpochs :: Tensor n t a -> Tensor n t a +limitEpochs tensor = TSym "tf.limit_epochs" <+> TArgT "tensor" tensor + +matchFilenamesOnce' :: String -> String -> Tensor n t a +matchFilenamesOnce' pattern name = TSym "tf.match_filenames_once" <+> TArgS "pattern" pattern <+> TArgS "name" name +matchFilenamesOnce :: String -> Tensor n t a +matchFilenamesOnce pattern = TSym "tf.match_filenames_once" <+> TArgS "pattern" pattern + +maybeBatch' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +maybeBatch' tensors keep_input batch_size num_threads capacity enqueue_many shapes dynamic_pad allow_smaller_final_batch shared_name name = TSym "tf.maybe_batch" <+> TArgS "tensors" tensors <+> TArgS "keep_input" keep_input <+> TArgS "batch_size" batch_size <+> TArgS "num_threads" num_threads <+> TArgS "capacity" capacity <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "dynamic_pad" dynamic_pad <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +maybeBatch :: String -> String -> String -> Tensor n t a +maybeBatch tensors keep_input batch_size = TSym "tf.maybe_batch" <+> TArgS "tensors" tensors <+> TArgS "keep_input" keep_input <+> TArgS "batch_size" batch_size + +maybeBatchJoin' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +maybeBatchJoin' tensors_list keep_input batch_size capacity enqueue_many shapes dynamic_pad allow_smaller_final_batch shared_name name = TSym "tf.maybe_batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "keep_input" keep_input <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "dynamic_pad" dynamic_pad <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +maybeBatchJoin :: String -> String -> String -> Tensor n t a +maybeBatchJoin tensors_list keep_input batch_size = TSym "tf.maybe_batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "keep_input" keep_input <+> TArgS "batch_size" batch_size + +maybeShuffleBatch' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +maybeShuffleBatch' tensors batch_size capacity min_after_dequeue keep_input num_threads seed enqueue_many shapes allow_smaller_final_batch shared_name name = TSym "tf.maybe_shuffle_batch" <+> TArgS "tensors" tensors <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue <+> TArgS "keep_input" keep_input <+> TArgS "num_threads" num_threads <+> TArgS "seed" seed <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +maybeShuffleBatch :: String -> String -> String -> String -> String -> Tensor n t a +maybeShuffleBatch tensors batch_size capacity min_after_dequeue keep_input = TSym "tf.maybe_shuffle_batch" <+> TArgS "tensors" tensors <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue <+> TArgS "keep_input" keep_input + +maybeShuffleBatchJoin' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +maybeShuffleBatchJoin' tensors_list batch_size capacity min_after_dequeue keep_input seed enqueue_many shapes allow_smaller_final_batch shared_name name = TSym "tf.maybe_shuffle_batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue <+> TArgS "keep_input" keep_input <+> TArgS "seed" seed <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +maybeShuffleBatchJoin :: String -> String -> String -> String -> String -> Tensor n t a +maybeShuffleBatchJoin tensors_list batch_size capacity min_after_dequeue keep_input = TSym "tf.maybe_shuffle_batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue <+> TArgS "keep_input" keep_input + +naturalExpDecay' :: String -> String -> String -> String -> String -> String -> Tensor n t a +naturalExpDecay' learning_rate global_step decay_steps decay_rate staircase name = TSym "tf.natural_exp_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "decay_rate" decay_rate <+> TArgS "staircase" staircase <+> TArgS "name" name +naturalExpDecay :: String -> String -> String -> String -> Tensor n t a +naturalExpDecay learning_rate global_step decay_steps decay_rate = TSym "tf.natural_exp_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "decay_rate" decay_rate + +piecewiseConstant' :: Tensor n t a -> String -> String -> String -> Tensor n t a +piecewiseConstant' x boundaries values name = TSym "tf.piecewise_constant" <+> TArgT "x" x <+> TArgS "boundaries" boundaries <+> TArgS "values" values <+> TArgS "name" name +piecewiseConstant :: Tensor n t a -> String -> String -> Tensor n t a +piecewiseConstant x boundaries values = TSym "tf.piecewise_constant" <+> TArgT "x" x <+> TArgS "boundaries" boundaries <+> TArgS "values" values + +polynomialDecay' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +polynomialDecay' learning_rate global_step decay_steps end_learning_rate power cycle name = TSym "tf.polynomial_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps <+> TArgS "end_learning_rate" end_learning_rate <+> TArgS "power" power <+> TArgS "cycle" cycle <+> TArgS "name" name +polynomialDecay :: String -> String -> String -> Tensor n t a +polynomialDecay learning_rate global_step decay_steps = TSym "tf.polynomial_decay" <+> TArgS "learning_rate" learning_rate <+> TArgS "global_step" global_step <+> TArgS "decay_steps" decay_steps + +rangeInputProducer' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +rangeInputProducer' limit num_epochs shuffle seed capacity shared_name name = TSym "tf.range_input_producer" <+> TArgS "limit" limit <+> TArgS "num_epochs" num_epochs <+> TArgS "shuffle" shuffle <+> TArgS "seed" seed <+> TArgS "capacity" capacity <+> TArgS "shared_name" shared_name <+> TArgS "name" name +rangeInputProducer :: String -> Tensor n t a +rangeInputProducer limit = TSym "tf.range_input_producer" <+> TArgS "limit" limit + + +replicaDeviceSetter :: Tensor n t a +replicaDeviceSetter = TSym "tf.replica_device_setter" + +sdcaFprint' :: String -> String -> Tensor n t a +sdcaFprint' input name = TSym "tf.sdca_fprint" <+> TArgS "input" input <+> TArgS "name" name +sdcaFprint :: String -> Tensor n t a +sdcaFprint input = TSym "tf.sdca_fprint" <+> TArgS "input" input + +sdcaOptimizer' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +sdcaOptimizer' sparse_example_indices sparse_feature_indices sparse_feature_values dense_features example_weights example_labels sparse_indices sparse_weights dense_weights example_state_data loss_type l1 l2 num_loss_partitions num_inner_iterations adaptative name = TSym "tf.sdca_optimizer" <+> TArgS "sparse_example_indices" sparse_example_indices <+> TArgS "sparse_feature_indices" sparse_feature_indices <+> TArgS "sparse_feature_values" sparse_feature_values <+> TArgS "dense_features" dense_features <+> TArgS "example_weights" example_weights <+> TArgS "example_labels" example_labels <+> TArgS "sparse_indices" sparse_indices <+> TArgS "sparse_weights" sparse_weights <+> TArgS "dense_weights" dense_weights <+> TArgS "example_state_data" example_state_data <+> TArgS "loss_type" loss_type <+> TArgS "l1" l1 <+> TArgS "l2" l2 <+> TArgS "num_loss_partitions" num_loss_partitions <+> TArgS "num_inner_iterations" num_inner_iterations <+> TArgS "adaptative" adaptative <+> TArgS "name" name +sdcaOptimizer :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +sdcaOptimizer sparse_example_indices sparse_feature_indices sparse_feature_values dense_features example_weights example_labels sparse_indices sparse_weights dense_weights example_state_data loss_type l1 l2 num_loss_partitions num_inner_iterations = TSym "tf.sdca_optimizer" <+> TArgS "sparse_example_indices" sparse_example_indices <+> TArgS "sparse_feature_indices" sparse_feature_indices <+> TArgS "sparse_feature_values" sparse_feature_values <+> TArgS "dense_features" dense_features <+> TArgS "example_weights" example_weights <+> TArgS "example_labels" example_labels <+> TArgS "sparse_indices" sparse_indices <+> TArgS "sparse_weights" sparse_weights <+> TArgS "dense_weights" dense_weights <+> TArgS "example_state_data" example_state_data <+> TArgS "loss_type" loss_type <+> TArgS "l1" l1 <+> TArgS "l2" l2 <+> TArgS "num_loss_partitions" num_loss_partitions <+> TArgS "num_inner_iterations" num_inner_iterations + +sdcaShrinkL1' :: String -> String -> String -> String -> Tensor n t a +sdcaShrinkL1' weights l1 l2 name = TSym "tf.sdca_shrink_l1" <+> TArgS "weights" weights <+> TArgS "l1" l1 <+> TArgS "l2" l2 <+> TArgS "name" name +sdcaShrinkL1 :: String -> String -> String -> Tensor n t a +sdcaShrinkL1 weights l1 l2 = TSym "tf.sdca_shrink_l1" <+> TArgS "weights" weights <+> TArgS "l1" l1 <+> TArgS "l2" l2 + +shuffleBatch' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +shuffleBatch' tensors batch_size capacity min_after_dequeue num_threads seed enqueue_many shapes allow_smaller_final_batch shared_name name = TSym "tf.shuffle_batch" <+> TArgS "tensors" tensors <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue <+> TArgS "num_threads" num_threads <+> TArgS "seed" seed <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +shuffleBatch :: String -> String -> String -> String -> Tensor n t a +shuffleBatch tensors batch_size capacity min_after_dequeue = TSym "tf.shuffle_batch" <+> TArgS "tensors" tensors <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue + +shuffleBatchJoin' :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +shuffleBatchJoin' tensors_list batch_size capacity min_after_dequeue seed enqueue_many shapes allow_smaller_final_batch shared_name name = TSym "tf.shuffle_batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue <+> TArgS "seed" seed <+> TArgS "enqueue_many" enqueue_many <+> TArgS "shapes" shapes <+> TArgS "allow_smaller_final_batch" allow_smaller_final_batch <+> TArgS "shared_name" shared_name <+> TArgS "name" name +shuffleBatchJoin :: String -> String -> String -> String -> Tensor n t a +shuffleBatchJoin tensors_list batch_size capacity min_after_dequeue = TSym "tf.shuffle_batch_join" <+> TArgS "tensors_list" tensors_list <+> TArgS "batch_size" batch_size <+> TArgS "capacity" capacity <+> TArgS "min_after_dequeue" min_after_dequeue + +sliceInputProducer' :: String -> String -> String -> String -> String -> String -> String -> Tensor n t a +sliceInputProducer' tensor_list num_epochs shuffle seed capacity shared_name name = TSym "tf.slice_input_producer" <+> TArgS "tensor_list" tensor_list <+> TArgS "num_epochs" num_epochs <+> TArgS "shuffle" shuffle <+> TArgS "seed" seed <+> TArgS "capacity" capacity <+> TArgS "shared_name" shared_name <+> TArgS "name" name +sliceInputProducer :: String -> Tensor n t a +sliceInputProducer tensor_list = TSym "tf.slice_input_producer" <+> TArgS "tensor_list" tensor_list + + +startQueueRunners :: Tensor n t a +startQueueRunners = TSym "tf.start_queue_runners" + +stringInputProducer' :: String -> String -> String -> String -> String -> String -> String -> String -> Tensor n t a +stringInputProducer' string_tensor num_epochs shuffle seed capacity shared_name name cancel_op = TSym "tf.string_input_producer" <+> TArgS "string_tensor" string_tensor <+> TArgS "num_epochs" num_epochs <+> TArgS "shuffle" shuffle <+> TArgS "seed" seed <+> TArgS "capacity" capacity <+> TArgS "shared_name" shared_name <+> TArgS "name" name <+> TArgS "cancel_op" cancel_op +stringInputProducer :: String -> Tensor n t a +stringInputProducer string_tensor = TSym "tf.string_input_producer" <+> TArgS "string_tensor" string_tensor + + +summaryIterator :: String -> Tensor n t a +summaryIterator path = TSym "tf.summary_iterator" <+> TArgS "path" path + +updateCheckpointState' :: String -> String -> String -> String -> Tensor n t a +updateCheckpointState' save_dir model_checkpoint_path all_model_checkpoint_paths latest_filename = TSym "tf.update_checkpoint_state" <+> TArgS "save_dir" save_dir <+> TArgS "model_checkpoint_path" model_checkpoint_path <+> TArgS "all_model_checkpoint_paths" all_model_checkpoint_paths <+> TArgS "latest_filename" latest_filename +updateCheckpointState :: String -> String -> Tensor n t a +updateCheckpointState save_dir model_checkpoint_path = TSym "tf.update_checkpoint_state" <+> TArgS "save_dir" save_dir <+> TArgS "model_checkpoint_path" model_checkpoint_path + +writeGraph' :: String -> String -> String -> String -> Tensor n t a +writeGraph' graph_or_graph_def logdir name as_text = TSym "tf.write_graph" <+> TArgS "graph_or_graph_def" graph_or_graph_def <+> TArgS "logdir" logdir <+> TArgS "name" name <+> TArgS "as_text" as_text +writeGraph :: String -> String -> String -> Tensor n t a +writeGraph graph_or_graph_def logdir name = TSym "tf.write_graph" <+> TArgS "graph_or_graph_def" graph_or_graph_def <+> TArgS "logdir" logdir <+> TArgS "name" name + diff --git a/test/MathFlow/CoreSpec.hs b/test/MathFlow/CoreSpec.hs new file mode 100644 --- /dev/null +++ b/test/MathFlow/CoreSpec.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + +module MathFlow.CoreSpec where + +import GHC.TypeLits +import Data.Proxy +import Data.Singletons +import Data.Singletons.TypeLits +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow + +import Test.Hspec + +testSingleNet :: Tensor '[100,10] Float PyString +testSingleNet = + let x = "x" <-- (Tensor "x") :: Tensor '[100,784] Float PyString + w = "w" <-- (Tensor "w") :: Tensor '[784,10] Float PyString + b = "b" <-- (Tensor "b") :: Tensor '[10] Float PyString + z = "z" <-- TRep b :: Tensor '[100,10] Float PyString + y' = (x %* w) + z :: Tensor '[100,10] Float PyString + y = "y" <-- TFunc "softmax" y' :: Tensor '[100,10] Float PyString + in y + +type IMAGE_SIZE = 32 +type IMAGE_SIZE_2 = 16 +type IMAGE_SIZE_4 = 8 +type BATCH_SIZE = 100 + +--images :: T' [s,IMAGE_SIZE,IMAGE_SIZE,3] + +testConvNet0 :: forall s. (SingI s) => Tensor '[s,IMAGE_SIZE,IMAGE_SIZE,3] Float PyString -> Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString +testConvNet0 x1 = + let k1 = TLabel "k1" (Tensor "") :: Tensor '[5,5,3,64] Float PyString + b1 = TLabel "b1" (Tensor "") :: Tensor '[64] Float PyString + y1' = (TConv2d x1 k1) :: Tensor '[s,IMAGE_SIZE,IMAGE_SIZE,64] Float PyString + y1 = TReLu y1' :: Tensor '[s,IMAGE_SIZE,IMAGE_SIZE,64] Float PyString + opt = sing :: Sing '[1,2,2,1] + y2 = TMaxPool opt y1 :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + y3 = TLabel "y1" (TNorm y2) :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + in y3 + +testConvNet1 :: forall s. (SingI s) => Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString -> Tensor '[s,IMAGE_SIZE_4,IMAGE_SIZE_4,64] Float PyString +testConvNet1 x1 = + let k1 = Tensor "" :: Tensor '[5,5,64,64] Float PyString + b1 = Tensor "" :: Tensor '[64] Float PyString + y1' = (TConv2d x1 k1) :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + y1 = TNorm (TReLu y1') :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + opt = sing :: Sing '[1,2,2,1] + y2 = TMaxPool opt y1 :: Tensor '[s,IMAGE_SIZE_4,IMAGE_SIZE_4,64] Float PyString + in y2 + +testConvNet2 :: forall s. (SingI s) => Tensor '[s,IMAGE_SIZE_4,IMAGE_SIZE_4,64] Float PyString -> Tensor '[s,384] Float PyString +testConvNet2 x' = + let x = TReshape x' :: Tensor '[s,IMAGE_SIZE_4*IMAGE_SIZE_4*64] Float PyString + w = Tensor "" :: Tensor '[IMAGE_SIZE_4*IMAGE_SIZE_4*64,384] Float PyString + b = Tensor "" :: Tensor '[384] Float PyString + z = TRep b :: Tensor '[s,384] Float PyString + y' = (x %* w) + z :: Tensor '[s,384] Float PyString + y = TReLu y' :: Tensor '[s,384] Float PyString + in y + +testConvNet3 :: forall s. (SingI s) => Tensor '[s,384] Float PyString -> Tensor '[s,192] Float PyString +testConvNet3 x = + let w = Tensor "" :: Tensor '[384,192] Float PyString + b = Tensor "" :: Tensor '[192] Float PyString + z = TRep b :: Tensor '[s,192] Float PyString + y' = (x %* w) + z :: Tensor '[s,192] Float PyString + y = TReLu y' :: Tensor '[s,192] Float PyString + in y + +testConvNet4 :: forall s. (SingI s) => Tensor '[s,192] Float PyString -> Tensor '[s,10] Float PyString +testConvNet4 x = + let w = Tensor "" :: Tensor '[192,10] Float PyString + b = Tensor "" :: Tensor '[10] Float PyString + z = TRep b :: Tensor '[s,10] Float PyString + y = (x %* w) + z :: Tensor '[s,10] Float PyString + in y + +testImage :: Tensor '[BATCH_SIZE,IMAGE_SIZE,IMAGE_SIZE,3] Float PyString +testImage = Tensor "" + +testConvNet :: Tensor '[BATCH_SIZE,IMAGE_SIZE,IMAGE_SIZE,3] Float PyString -> Tensor '[BATCH_SIZE,10] Float PyString +testConvNet = testConvNet4.testConvNet3.testConvNet2.testConvNet1.testConvNet0 + +spec = do + describe "tensor dimention" $ do + it "type to value" $ do + dim (Tensor "" :: Tensor '[192,10] Float PyString) `shouldBe` [192,10] + diff --git a/test/MathFlow/PyStringSpec.hs b/test/MathFlow/PyStringSpec.hs new file mode 100644 --- /dev/null +++ b/test/MathFlow/PyStringSpec.hs @@ -0,0 +1,121 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE QuasiQuotes #-} + +module MathFlow.PyStringSpec where + +import GHC.TypeLits +import Data.Proxy +import Data.Singletons +import Data.Singletons.TypeLits +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow + +import Test.Hspec + +testSingleNet :: Tensor '[100,10] Float PyString +testSingleNet = + let x = "x" <-- (Tensor "x") :: Tensor '[100,784] Float PyString + w = "w" <-- (Tensor "w") :: Tensor '[784,10] Float PyString + b = "b" <-- (Tensor "b") :: Tensor '[10] Float PyString + z = "z" <-- TRep b :: Tensor '[100,10] Float PyString + y' = (x %* w) + z :: Tensor '[100,10] Float PyString + y = "y" <-- TFunc "softmax" y' :: Tensor '[100,10] Float PyString + in y + +type IMAGE_SIZE = 32 +type IMAGE_SIZE_2 = 16 +type IMAGE_SIZE_4 = 8 +type BATCH_SIZE = 100 + +--images :: T' [s,IMAGE_SIZE,IMAGE_SIZE,3] + +testConvNet0 :: forall s. (SingI s) => Tensor '[s,IMAGE_SIZE,IMAGE_SIZE,3] Float PyString -> Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString +testConvNet0 x1 = + let k1 = TLabel "k1" (Tensor "") :: Tensor '[5,5,3,64] Float PyString + b1 = TLabel "b1" (Tensor "") :: Tensor '[64] Float PyString + y1' = (TConv2d x1 k1) :: Tensor '[s,IMAGE_SIZE,IMAGE_SIZE,64] Float PyString + y1 = TReLu y1' :: Tensor '[s,IMAGE_SIZE,IMAGE_SIZE,64] Float PyString + opt = sing :: Sing '[1,2,2,1] + y2 = TMaxPool opt y1 :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + y3 = TLabel "y1" (TNorm y2) :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + in y3 + +testConvNet1 :: forall s. (SingI s) => Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString -> Tensor '[s,IMAGE_SIZE_4,IMAGE_SIZE_4,64] Float PyString +testConvNet1 x1 = + let k1 = Tensor "" :: Tensor '[5,5,64,64] Float PyString + b1 = Tensor "" :: Tensor '[64] Float PyString + y1' = (TConv2d x1 k1) :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + y1 = TNorm (TReLu y1') :: Tensor '[s,IMAGE_SIZE_2,IMAGE_SIZE_2,64] Float PyString + opt = sing :: Sing '[1,2,2,1] + y2 = TMaxPool opt y1 :: Tensor '[s,IMAGE_SIZE_4,IMAGE_SIZE_4,64] Float PyString + in y2 + +testConvNet2 :: forall s. (SingI s) => Tensor '[s,IMAGE_SIZE_4,IMAGE_SIZE_4,64] Float PyString -> Tensor '[s,384] Float PyString +testConvNet2 x' = + let x = TReshape x' :: Tensor '[s,IMAGE_SIZE_4*IMAGE_SIZE_4*64] Float PyString + w = Tensor "" :: Tensor '[IMAGE_SIZE_4*IMAGE_SIZE_4*64,384] Float PyString + b = Tensor "" :: Tensor '[384] Float PyString + z = TRep b :: Tensor '[s,384] Float PyString + y' = (x %* w) + z :: Tensor '[s,384] Float PyString + y = TReLu y' :: Tensor '[s,384] Float PyString + in y + +testConvNet3 :: forall s. (SingI s) => Tensor '[s,384] Float PyString -> Tensor '[s,192] Float PyString +testConvNet3 x = + let w = Tensor "" :: Tensor '[384,192] Float PyString + b = Tensor "" :: Tensor '[192] Float PyString + z = TRep b :: Tensor '[s,192] Float PyString + y' = (x %* w) + z :: Tensor '[s,192] Float PyString + y = TReLu y' :: Tensor '[s,192] Float PyString + in y + +testConvNet4 :: forall s. (SingI s) => Tensor '[s,192] Float PyString -> Tensor '[s,10] Float PyString +testConvNet4 x = + let w = Tensor "" :: Tensor '[192,10] Float PyString + b = Tensor "" :: Tensor '[10] Float PyString + z = TRep b :: Tensor '[s,10] Float PyString + y = (x %* w) + z :: Tensor '[s,10] Float PyString + in y + +testImage :: Tensor '[BATCH_SIZE,IMAGE_SIZE,IMAGE_SIZE,3] Float PyString +testImage = Tensor "" + +testConvNet :: Tensor '[BATCH_SIZE,IMAGE_SIZE,IMAGE_SIZE,3] Float PyString -> Tensor '[BATCH_SIZE,10] Float PyString +testConvNet = testConvNet4.testConvNet3.testConvNet2.testConvNet1.testConvNet0 + +spec = do + describe "model to value" $ do + it "single layer net" $ do + fromTensor testSingleNet `shouldBe` PyString {variables = ["y = softmax( tf.add( tf.matmul( x, w ), z ) )","x = x","w = w","z = b","b = b"], expression = "y"} + it "multible layer net" $ do + fromTensor (testConvNet testImage) `shouldBe` PyString {variables = ["y1 = tf.nn.lrn( tf.nn.max_pool( tf.nn.relu( tf.nn.conv2d( k1, , [1,1,1,1], padding='SAME' ) ), ksize=[1,2,2,1], strides=[1,1,1,1], padding='SAME' ) )","k1 = "], expression = "tf.add( tf.matmul( tf.nn.relu( tf.add( tf.matmul( tf.nn.relu( tf.add( tf.matmul( tf.reshape( tf.nn.max_pool( tf.nn.lrn( tf.nn.relu( tf.nn.conv2d( , y1, [1,1,1,1], padding='SAME' ) ) ), ksize=[1,2,2,1], strides=[1,1,1,1], padding='SAME' ), [100,8,8,64] ), ), ) ), ), ) ), ), )"} + describe "model to string" $ do + it "single layer net" $ do + toString testSingleNet `shouldBe` "b = b\nz = b\nw = w\nx = x\ny = softmax( tf.add( tf.matmul( x, w ), z ) )\ny" + it "multible layer net" $ do + toString (testConvNet testImage) `shouldBe` "k1 = \ny1 = tf.nn.lrn( tf.nn.max_pool( tf.nn.relu( tf.nn.conv2d( k1, , [1,1,1,1], padding='SAME' ) ), ksize=[1,2,2,1], strides=[1,1,1,1], padding='SAME' ) )\ntf.add( tf.matmul( tf.nn.relu( tf.add( tf.matmul( tf.nn.relu( tf.add( tf.matmul( tf.reshape( tf.nn.max_pool( tf.nn.lrn( tf.nn.relu( tf.nn.conv2d( , y1, [1,1,1,1], padding='SAME' ) ) ), ksize=[1,2,2,1], strides=[1,1,1,1], padding='SAME' ), [100,8,8,64] ), ), ) ), ), ) ), ), )" + + +testBuild :: Tensor '[1] Float PyString +testBuild = (Tensor "tf.constant([1])" :: Tensor '[1] Float PyString) + +testBuild2 :: Tensor '[1] Float PyString +testBuild2 = $(pyConst [1::Integer]) + +testBuild3 :: Tensor '[1,1,1] Float PyString +testBuild3 = $(pyConst3 [[[1]]]) diff --git a/test/MathFlow/PythonSpec.hs b/test/MathFlow/PythonSpec.hs new file mode 100644 --- /dev/null +++ b/test/MathFlow/PythonSpec.hs @@ -0,0 +1,113 @@ +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE CPP #-} + +module MathFlow.PythonSpec where + +import GHC.TypeLits +import Data.Proxy +import Data.Singletons +import Data.Singletons.TypeLits +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow +import MathFlow.TF + +import Test.Hspec +import Test.Hspec.Server +import Text.Shakespeare.Text +import qualified Data.Text.Lazy as T +import Data.Monoid +import Control.Monad.IO.Class + +src = [lbt| + |import tensorflow as tf + |num1 = tf.constant(1) + |num2 = tf.constant(2) + |num3 = tf.constant(3) + |num1PlusNum2 = tf.add(num1,num2) + |num1PlusNum2PlusNum3 = tf.add(num1PlusNum2,num3) + |sess = tf.Session() + |result = sess.run(num1PlusNum2PlusNum3) + |print(result) + |] + + +testNet :: Tensor '[1] Float PyString +testNet = + let n1 = "n1" <-- (Tensor "tf.constant(1)") :: Tensor '[1] Float PyString + n2 = "n2" <-- (Tensor "tf.constant(2)") :: Tensor '[1] Float PyString + n3 = "n3" <-- (Tensor "tf.constant(3)") :: Tensor '[1] Float PyString + y = "y" <-- (n1 + n2 + n3) :: Tensor '[1] Float PyString + in y + +testSub :: Tensor '[1] Float PyString +testSub = + let n1 = "n1" <-- (Tensor "tf.constant(100)") :: Tensor '[1] Float PyString + n2 = "n2" <-- (Tensor "tf.constant(50)") :: Tensor '[1] Float PyString + n3 = "n3" <-- (Tensor "tf.constant(2)") :: Tensor '[1] Float PyString + y = "y" <-- (n3 * (n1 - n2)) :: Tensor '[1] Float PyString + in y + +testMatMul :: Tensor '[2,1] Float PyString +testMatMul = + let n1 = "n1" <-- $(pyConst2 [[2],[3]]) :: Tensor '[2,1] Float PyString + n2 = "n2" <-- $(pyConst2 [[2,0],[0,1]]) :: Tensor '[2,2] Float PyString + y = "y" <-- (n2 %* n1) :: Tensor '[2,1] Float PyString + in y + +testConcat :: Tensor '[2,2] Float PyString +testConcat = + let n1 = "n1" <-- (Tensor "tf.constant([[2],[3]])") :: Tensor '[2,1] Float PyString + n2 = "n2" <-- (Tensor "tf.constant([[2],[3]])") :: Tensor '[2,1] Float PyString + y = "y" <-- (TConcat n1 n2) :: Tensor '[2,2] Float PyString + in y + +testReplicate :: Tensor '[2,2] Float PyString +testReplicate = + let n1 = "n1" <-- (Tensor "tf.constant([[2],[3]])") :: Tensor '[2,1] Float PyString + n2 = "n2" <-- (Tensor "tf.constant([[2],[3]])") :: Tensor '[2,1] Float PyString + y = "y" <-- (TConcat n1 n2) :: Tensor '[2,2] Float PyString + in y + +#ifdef USE_PYTHON +spec = do + describe "run tensorflow" $ with localhost $ do + it "command test" $ do + command "python3" [] (T.unpack src) @>= exit 0 <> stdout "6\n" + describe "run pystring" $ with localhost $ do + it "abs" $ do + let src = toRunnableString (fromTensor (abs' (Tensor "tf.constant(-100)" :: Tensor '[1] Float PyString) "\"x\"")) + liftIO $ putStr src + command "python3" [] src @>= exit 0 <> stdout "100\n" + it "adder" $ do + command "python3" [] (toRunnableString (fromTensor testNet)) @>= exit 0 <> stdout "6\n" + it "subtract" $ do + command "python3" [] (toRunnableString (fromTensor testSub)) @>= exit 0 <> stdout "100\n" + it "matmul" $ do + let src = toRunnableString (fromTensor testMatMul) + command "python3" [] src @>= exit 0 <> stdout "[[4]\n [3]]\n" + it "concat" $ do + let src = toRunnableString (fromTensor testConcat) + liftIO $ putStr src + command "python3" [] src @>= exit 0 <> stdout "[[2 2]\n [3 3]]\n" + +#else +spec :: Spec +spec = return () +#endif + diff --git a/test/Spec.hs b/test/Spec.hs new file mode 100644 --- /dev/null +++ b/test/Spec.hs @@ -0,0 +1,1 @@ +{-# OPTIONS_GHC -F -pgmF hspec-discover #-} diff --git a/test/doctests.hs b/test/doctests.hs new file mode 100644 --- /dev/null +++ b/test/doctests.hs @@ -0,0 +1,28 @@ +module Main where + +import Test.DocTest + +main :: IO () +main = do + doctest $ + [ + "-XOverloadedStrings", + "-XScopedTypeVariables", + "-XTemplateHaskell", + "-XTypeFamilies", + "-XGADTs", + "-XKindSignatures", + "-XTypeOperators", + "-XFlexibleContexts", + "-XRankNTypes", + "-XUndecidableInstances", + "-XFlexibleInstances", + "-XInstanceSigs", + "-XDefaultSignatures", + "-XTypeInType", + "src/MathFlow/Core.hs", + "src/MathFlow/PyString.hs", + "src/MathFlow/TF.hs", + "src/MathFlow/TF/NN.hs", + "src/MathFlow/TF/Train.hs" + ] diff --git a/util/gen_function_list.py b/util/gen_function_list.py new file mode 100644 --- /dev/null +++ b/util/gen_function_list.py @@ -0,0 +1,261 @@ +#!/usr/bin/python3 + +import tensorflow as tf +import inspect +import yaml +import re +from typing import Any + + +#sigs = i.signature(tf) +def genType(arg:str) -> str : + if arg == 'a' or \ + arg == 'b' or \ + arg == 'x' or \ + arg == 'y' or \ + arg == 'filter' or \ + arg == 'tensor': + return 'tensor' + elif arg == 'name': + return 'string' + elif arg == 'shape'or \ + arg == 'strides': + return 'dimensions' + elif arg == 'dtype': + return 'type' + else: + return 'string' + +def genRetType(n:str,arg:str) -> str : + return 'tensor' + + +def getFuncType(package): + members = inspect.getmembers(package) + members = filter((lambda m: re.match('^[A-Za-z]',m[0]) ),members) + members = filter((lambda m: inspect.isfunction(m[1]) ),members) + ret = {} + for (name,ptr) in members: + s = inspect.getfullargspec(ptr) + v = [] + if s.defaults is not None: + v = list(s.defaults) + ret[name]={'args':s.args,'defaults':v, 'types': list(map(genType,s.args)), 'rtype': genRetType(name,s.args)} + return ret + #print(list(members)) +# with open(n,'w') as f : +# f.write(yaml.dump(ret,default_flow_style=False)); + +# genDef(name,ret[name]) + +def genSym(prefix:str ,n:str,suffix:str) -> str: + stat=0 + ret=prefix + i=0 + if n == "Print" or \ + n == "case" or \ + n == "where": + return ("tf"+n+suffix) + else: + while i str: + s = "" + s += n[0].lower() + for i in range(len(n)-1): + s += n[i+1] + if n == "type": + s = "type'" + elif n == "data": + s = "data'" + elif n == "default": + s = "default'" + elif n == "_": + s = "_'" + return s + + +def isReserved(n:str) -> str: + reserved=["abs","sin","cos","tan","asin","acos","atan"] + for i in reserved: + if i == n: + return True + return False + + +def genDef(f,prefix,name,defs): + for d in ["'",""] : + sym = genSym(prefix,name,d) + hasSing = False + + if (len(defs['args']) == len(defs['defaults']) and d == "'") or \ + (0 == len(defs['defaults']) and d == "'") or \ + (isReserved(name) and d == "") : + print('',file=f) + else: + print('%s :: ' % sym,end="",file=f) + if d == "": + args = defs['args'][:(len(defs['args'])-len(defs['defaults']))] + else: + args = defs['args'] + + + for (a,t) in zip(args,defs['types']): + if t == 'dimensions': + hasSing = True + if hasSing: + print('SingI n => ',end="",file=f) + + + for (a,t) in zip(args,defs['types']): + if t == 'tensor': + print('Tensor n t a -> ',end="",file=f) + elif t == 'dimensions': + print('Sing n -> ',end="",file=f) + elif t == 'string': + print('String -> ',end="",file=f) + else: + print('String -> ',end="",file=f) + + if defs['rtype'] == 'tensor': + print('Tensor n t a ',file=f) + elif defs['rtype'] == 'dimensions': + print('Sing n ',file=f) + elif defs['rtype'] == 'string': + print('String ',file=f) + else: + print('String ',file=f) + + print('%s ' % sym,end="",file=f) + for a in args: + print('%s ' % modName(a),end="",file=f) + print('= ',end="",file=f) + + print('TSym "tf.%s" ' % (name),end="",file=f) + l = len(args) + i = 0 + for (a,t) in zip(args,defs['types']): + if t == 'tensor': + print('<+> TArgT "%s" %s ' % (a,modName(a)),end="",file=f) + elif t == 'dimensions': + print('<+> TArgSing "%s" %s ' % (a,modName(a)),end="",file=f) + else: + print('<+> TArgS "%s" %s ' % (a,modName(a)),end="",file=f) + i=i+1 + print('',file=f) + +with open('../src/MathFlow/TF.hs',"w") as f: + header = """ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.TF where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow.Core +import MathFlow.PyString + +""" + m = getFuncType(tf) + print(header,file=f) + for i in m : + genDef(f,"",i,m[i]) + print('',file=f) +with open('../src/MathFlow/TF/NN.hs',"w") as f: + header = """ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.TF.NN where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow.Core +import MathFlow.PyString + +""" + m = getFuncType(tf.nn) + print(header,file=f) + for i in m : + genDef(f,"",i,m[i]) + print('',file=f) +with open('../src/MathFlow/TF/Train.hs',"w") as f: + header = """ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE TypeOperators #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE InstanceSigs #-} +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeInType #-} + +{-# LANGUAGE OverloadedStrings #-} + + +module MathFlow.TF.Train where + +import GHC.TypeLits +import Data.Singletons +import Data.Singletons.TH +import Data.Promotion.Prelude +import MathFlow.Core +import MathFlow.PyString + +""" + m = getFuncType(tf.train) + print(header,file=f) + for i in m : + genDef(f,"",i,m[i]) + print('',file=f) +