bendtorch-core

Search uses release 0.1.0.0 · 5,204 definitions

Releases (1)

law backward_rejects_unbound_operandAn entry with an operand that is itself, a newer entry or a missing entry makes backward of any output on the tape fail with DanglingOperand.
law backward_accepts_bound_operandsA tape whose every operand is bound is accepted for every output it holds.
law backward_successOtherwise backward accumulates the gradients of pass into the slots.
law backward_twice_accumulatesRepeated backward, like PyTorch's backward(retain_graph=True): the second backward computes the same gradients and accumulates them again.
law backward_twice_mul
law zero_grad_emptieszero_grad empties every slot and keeps every node.
law zero_grad_keeps_nodes

def owner
def succeeded
def source_valueThe input value that the specification assigns to one output position: the input offset of its right-aligned broadcast projection.
def planned_source
def MappingWith
def Mapping
type Retained
type MappingModel
type Success
law keep_left_scalar
law broadcast_retains_inputThe input owner comes back with the same dimensions and observations.
law broadcast_mappingOn success the output has the target's dimensions, and each in-bounds output position observes the input at the offset that the independent broadcast projection specification assigns to it.
law broadcast_valid_successA request whose right-aligned broadcast with the input shape is the target itself always succeeds.
law broadcast_shape_errorWhen the broadcast planner rejects the input and target shapes, broadcast_to fails with exactly that planner error and returns the input owner.
law broadcast_not_targetWhen the planned broadcast is not the target itself (for example [3] to [1]), broadcast_to fails with NotBroadcastable and returns the input owner.

def succeeded
def output_dimensions
def output_point
def input_point
type BroadcastToContractWhat broadcast_to promises, stated only through the result: it succeeds with the target's dimensions, every in-bounds output index i holds cell(i), and the returned input still holds every word.
def cellsThe words of broadcast_to's output in index order: word k is the input word at left_map(plan, k), its right-aligned broadcast projection.
def BroadcastWithWhat the transport form of broadcast_to_replayed asks of P: P holds for the input, replayed with any history that keeps its words, next to an output of the plan's shape, replayed over +0.0 with any history whose words are `cells`.
law broadcast_to_pointwisePointwise family, broadcast_to instance: when the input shape broadcasts to exactly the target, broadcasting a replayed input succeeds with the target's dimensions, output index i holds the input word at left_map(plan, i), its right-aligned broadcast projection, and the returned input keeps every word.
law broadcast_to_replayedThe broadcast_to result is replayed: for every P, if P holds for every result that hands back the input with its words and gives an output of the plan's shape whose words are `cells`, then P holds for broadcast_to.

def cells_keepThe pointwise family's KeepLeft words, with the input on the left and the +0.0 tensor of the target on the right, are broadcast_to's `cells`.
def cells_length
def cells_stepWord `position` of `cells` is the input word at left_map(plan, position).
def cells_at
def listed_valueA replayed tensor whose first `count` words are `values` holds, below `count`, the word `values` lists there.
def run_liftbroadcast_to on a replayed input whose shape broadcasts to exactly the target: the planner and the target check pass, the zero tensor of the target is allocated, and the parallel build runs KeepLeft with the input on the left and the zero tensor on the right, whose words are `cells`.
def output_below
def broadcast_to_pointwise