package tensorflow

You can search for identifiers within the package.

in-package search v0.2.0

package tensorflow

tensorflow
- Tensorflow
  - Cell
  - Fnn
    
    Input_id
    
    Loss
    
    Model
    
    Optimizer
    
    Shape
  - Gradients
  - Graph_piqi
    
    Attr_value
    
    Attr_value_list_value
    
    Function_def
    
    Function_def_library
    
    Function_def_node
    
    Function_def_node_attr_entry
    
    Gradient_def
    
    Graph_def
    
    Graph_piqi
    
    Name_attr_list
    
    Name_attr_list_attr_entry
    
    Node_def
    
    Node_def_attr_entry
    
    Op_def
    
    Op_def_arg_def
    
    Op_def_attr_def
    
    Op_deprecation
    
    Op_list
    
    Tensor_proto
    
    Tensor_shape_proto
    
    Tensor_shape_proto_dim
    
    Version_def
  - Mnist_helper
  - Nn
    
    Input_name
    
    Shape
    
    Shared_var
  - Node
    
    Attr_list
    
    Dim
    
    Tensor
    
    Type
    
    Weak_table
  - Node_protobuf
  - Ops
    
    Op_names
    
    Placeholder
  - Ops_generated
    
    Op_names
  - Ops_gradients
  - Ops_manual
    
    Placeholder
  - Optimizers
  - Piqirun
    
    IBuf
    
    List
    
    OBuf
  - Protobuf
  - Registered_gradients
  - Rnn
  - Session
    
    Input
    
    Output
  - Tensor
  - Var
  - Wrapper
    
    Session
    
    Session_options
    
    Status

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Input_name : sig ... end

type _1d

type _2d

type _3d

module Shape : sig ... end

type ('a, 'b) t

type init = [

| `const of float
| `normal of float
| `truncated_normal of float

]

val shape : ('a, 'b) t -> 'a Shape.t

val default_input : ('a, 'b) t -> 'b Input_name.t option

val node : ('a, 'b) t -> 'b Node.t

val type_ : ('a, 'b) t -> 'b Node.Type.t

val input : shape:'a Shape.t -> type_:'b Node.Type.t -> ('a, 'b) t

val named_input : 
  shape:'a Shape.t ->
  type_:'b Node.Type.t ->
  'b Input_name.t * ('a, 'b) t

val dense : 
  ?w_init:init ->
  ?b_init:init ->
  (_1d, [< `double | `float ] as 'b) t ->
  shape:int ->
  (_1d, 'b) t

val conv2d : 
  ?w_init:init ->
  ?b_init:init ->
  (_3d, [< `double | `float ] as 'b) t ->
  filter:(int * int) ->
  out_channels:int ->
  strides:(int * int) ->
  padding:[ `same | `valid ] ->
  (_3d, 'b) t

val sigmoid : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t

val tanh : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t

val relu : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t

val softmax : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t

val max_pool : 
  (_3d, [ `float ]) t ->
  filter:(int * int) ->
  strides:(int * int) ->
  padding:[ `same | `valid ] ->
  (_3d, [ `float ]) t

val concat : (_1d, 'a) t -> (_1d, 'a) t -> (_1d, 'a) t

val (+) : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t -> ('a, 'c) t

val (-) : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t -> ('a, 'c) t

val (*) : ('a, [< `double | `float ] as 'c) t -> ('a, 'c) t -> ('a, 'c) t

val f : float -> shape:'a Shape.t -> ('a, [ `float ]) t

val reshape : ('a, 'c) t -> shape:'b Shape.t -> ('b, 'c) t

val flatten : ('a, 'b) t -> (_1d, 'b) t

val split : (_2d, 'a) t -> (_1d, 'a) t list

val concatN : (_1d, 'a) t list -> (_2d, 'a) t

module Shared_var : sig ... end