caisar 2.1 (latest) · OCaml Package

Nodes descriptions

A node is composed of

a unique id of type int
a node description of type descr

descr describes several operations. When an operation shares the same name as an ONNX operation, it follows the standard defined in the ONNX IR v8 and ONNX Opset v13 standards, described here: https://onnx.ai/onnx/operators/index.html.

Nodes only require their inputs: it is assumed that a node only returns one value.

type ty =

| Float
| Int64

val pp_ty : 
  Ppx_deriving_runtime.Format.formatter ->
  ty ->
  Ppx_deriving_runtime.unit

val show_ty : ty -> Ppx_deriving_runtime.string

type descr =

| Constant of {
1. data : Gentensor.t;
}
(*
A constant tensor, used to store non-varying parameters during inference.
*)
| Add of {
1. input1 : t;
2. input2 : t;
}
| Sub of {
1. input1 : t;
2. input2 : t;
}
| Mul of {
1. input1 : t;
2. input2 : t;
}
| Div of {
1. input1 : t;
2. input2 : t;
}
| Matmul of {
1. input1 : t;
2. input2 : t;
}
| Gemm of {
1. inputA : t;
2. inputB : t;
3. inputC : t Base.option;
4. alpha : Base.float;
5. beta : Base.float;
6. transA : Base.int;
7. transB : Base.int;
}
| LogSoftmax
| ReLu of {
1. input : t;
}
| Transpose of {
1. input : t;
  (*
  Called "data" in ONNX documentation : https://onnx.ai/onnx/operators/onnx__Transpose.html .
  *)
2. perm : Base.int Base.list;
}
| Squeeze of {
1. data : t;
2. axes : t Base.option;
}
| MaxPool
| Conv
| Reshape of {
1. input : t;
2. shape : t;
}
| Flatten of {
1. input : t;
2. axis : Base.int;
}
| Identity of {
1. input : t;
}
| Input of {
1. shape : Shape.t;
}
| RW_Linearized_ReLu
| Concat of {
1. inputs : t Base.list;
2. axis : Base.int;
}
| Gather of {
1. input : t;
2. indices : t;
3. axis : Base.int;
}
| ReduceSum of {
1. input : t;
2. axes : t Base.option;
3. keepdims : Base.int;
4. noop_with_empty_axes : Base.int;
}
| GatherND of {
1. data : t;
2. indices : t;
3. batch_dims : Base.int;
}
| RandomNormal of {
1. dtype : Base.int;
2. mean : Base.float;
3. scale : Base.float;
4. seed : Base.float;
5. shape : Base.int Base.array;
}
| Abs of {
1. input : t;
}
| Log of {
1. input : t;
}

and t = private {

id : Base.int;
descr : descr;
shape : Shape.t;
ty : ty;
(*
Describes the shape of the result of the node computation.
*)

}

val pp_descr : 
  Ppx_deriving_runtime.Format.formatter ->
  descr ->
  Ppx_deriving_runtime.unit

val show_descr : descr -> Ppx_deriving_runtime.string

val pp : 
  Ppx_deriving_runtime.Format.formatter ->
  t ->
  Ppx_deriving_runtime.unit

val show : t -> Ppx_deriving_runtime.string

val equal : t -> t -> Base.bool

include Base.Hashtbl.Key.S with type t := t

val compare : t -> t -> int

val sexp_of_t : t -> Sexplib0.Sexp.t

val hash : t -> int

Two ts that compare equal must have equal hashes for the hashtable to behave properly.

include Base.Comparator.S with type t := t

type comparator_witness

val comparator : (t, comparator_witness) Base.Comparator.comparator

val create : descr -> t

create descr returns a value of type node with proper indexing and the shape according to the ONNX semantic.

val gather_int : ?encode:Base.bool -> t -> Base.int -> t

val map : (t -> t) -> t -> t

map f n replace the direct inputs i of n by f i

val map_rec : (t -> t) -> t -> t

map_rec f n replace top-bottom the nodes i accessible from n by f i

val replace_input : (Base.unit -> t) -> t -> t

replace_input f n replace the input in n by f ()

val preds : t -> t Base.list

Direct predecessors of a t

val iter_rec : (t -> Base.unit) -> t -> Base.unit

Iterate on the predecessors of a t and itself. Repect topological order.

val compute_shape : t -> Shape.t

val mul_float : t -> Base.float -> t

val div_float : ?encode:Base.bool -> t -> Base.float -> t

val concat_0 : t Base.list -> t

val reshape : Shape.t -> t -> t

package caisar

Nodes descriptions