bendtorch-core

Search uses release 0.1.0.0 · 5,204 definitions

Releases (1)

0.1.0.0 indexed

Definitions (5,204)

src/autograd/backward.bend

type Error
type Node
type Entry
type Tape
type Contribution
type Binary
def empty
def size
def picked
def findThe element with id `id` in a newest-first list of count elements: the head has id count - 1, and the walk counts down from it.
def lookup
def accumulate
def bumped
def bump
def vjpThe vector-Jacobian product of one node: the contribution each operand receives when the node's gradient is g, in operand order.
def deliver
def contribute
def sweep
def nones
def chosen
def passThe gradient of output with respect to each of count nodes, newest first: None for the nodes newer than output and for every node output does not reach.
def operands_below
def wired
def nodes
def checked
def planned
def gradientsThe gradients of one backward of output, newest first, read from the nodes alone.
def merge
def merged
def backwardRuns one backward of output and accumulates its gradients into the slots.
def cleared
def zero_gradEmpties every gradient slot, like PyTorch's zero_grad(set_to_none=True).
def entry_value
def entry_grad
def value
def gradThe gradient slot of node id: None until a backward reaches it.
def leafRecords a leaf; its id is the number of entries before it.
def forward
def operands
def binaryRecords `a op b`.
def add
def sub
def mul
def negated
def negRecords -a, with the same refusal as binary.
def error_code

src/autograd/backward_LAWS.bend

def marked
def mark
def targets
def mark_all
def spread
def reach
def falses
def reached_chosen
def reached
def boundedOperand bounds, stated without the engine's validator: a node may name only nodes older than itself, so each operand id must be below the number of older nodes.
def well_formed
def entry_node
def somes
def nodes_of
def slots
def tape_slots
def slots_after
def grad_after
def again
def observe
def tape_of
def recorded
def program_binary
def program_neg
def program_unusedx = 0, y = 1, z = 2, x * y = 3, z + z = 4.
def program_fan_outx = 0, a = 1, b = 2, c = 3, p = x * a = 4, q = x * b = 5, r = x * c = 6, s = p + q = 7, t = s + r = 8.
law vjp_leaf
law vjp_add
law vjp_sub
law vjp_muld(a*b)/da = b and d(a*b)/db = a, with the operand values saved at record time: the first operand receives g * right, the second g * left.
law vjp_neg
law backward_add
law backward_sub
law backward_mul
law backward_neg
law seed_selected_outputThe seed is the selected output (C1).
law reached_exactlyOnly the reachable graph: a node has a gradient exactly when the selected output reaches it.
law unused_leaf_noneWith x, y and z recorded and z only used by a node newer than the output x * y, backward of x * y seeds the output, leaves z and the newer node None, and gives x and y their VJP.
law accumulate_moves_inFan-out: a node's first contribution moves in, and each later one is added to the held total with one F32 add, total first.
law accumulate_adds_total_first
law accumulate_keeps_without_contribution
law bump_targetA contribution to node target reaches exactly the slot of that node and no other, for any list of slots.
law fan_out_arrival_orderThe contributions of x's three consumers arrive newest consumer first, and each is added to the held total.
law lookup_exactIds (C2): id k reads exactly the element with k older elements, and an id the list does not hold reads None, never another element.
law lookup_unknown
law bump_unknown
law value_unknown
law grad_unknown
law record_unknown_leftRecording with an operand id the tape does not hold is refused with UnknownNode, and the tape comes back unchanged.
law record_unknown_right
law neg_unknown
law backward_unknownbackward of an output the tape does not hold is refused with UnknownNode.
law backward_danglingA tape with a node that refers to itself, to a newer node or to a missing node is refused with DanglingOperand.
law wired_matches_operand_boundsThe engine's wiring check is exactly the operand-bound specification above.