bendtorch-core

Search uses release 0.1.0.0 · 5,204 definitions

Releases (1)

0.1.0.0 indexed

Definitions (5,204)

src/autograd/reduce_to_fold_PROOF.bend

def contribution_count
def contribution_room
def fitted_same
def run_liftThe parallel reduce over a replayed contribution, in the transport form of `Replay.Final`.
def cell_fiberA target cell of the replayed reduce holds `ReduceLaws.fiber` over the contribution's words.
def reduce_to_fiber

src/autograd/sgd.bend

type Error
def leaf_refusal
def refusal_atWhy id cannot be a parameter of a newest-first list of count nodes, or None when it is a leaf the list holds.
def first_refusal
def refusalThe refusal of the first parameter, in list order, that is not a leaf of the tape, or None when every one is.
def Walked
def descended
def descendOne parameter: p - lr * g, cell by cell, when its slot holds g; unchanged when the slot is empty.
def placed
def kept
def descend_atUpdates entry id of a newest-first list of count entries and keeps every other entry.
def continued
def descend_allEach parameter in list order, each on the entries the one before it left.
def walked_tape
def refused_if
def rate_refusalInvalidLearningRate when lr is below zero, as PyTorch's `lr < 0.0`; None for every other word, -0.0, NaN and +inf included.
def rated
def checked
def planned
def stepOne SGD step with learning rate lr over the parameters params.
def error_code

src/autograd/sgd_LAWS.bend

law sgd_descend_scalarThe cell of an SGD step: p - lr * g, with the product rounded before the difference, F32 operation by F32 operation.
law sgd_empty_slot_keptA parameter whose slot is empty, PyTorch's p.grad is None, is left as it was.
def DescendWithWhat the transport form of sgd_step_values asks of P: P holds for the entry with its node, shape and saved values, whose value is replayed over +0.0 with any history whose words are the cells of Descend{lr} over the old value p and the gradient g, and whose slot still holds g with its words, next to Done.
law sgd_step_valuesA parameter whose slot holds g gets p - lr * g on the parallel elementwise build, in transport form: for a replayed value p and a replayed gradient g whose shapes broadcast, for every P, if P holds for every result that keeps the node, the shape, the saved values and g with its words, and holds a value of the plan's shape whose word k is scalar(Descend{lr}, p[left_map(plan, k)], g[right_map(plan, k)]) (sgd_descend_scalar: p - lr * g), next to Done, then P holds for the step of that parameter.
def newer_keptThe entries newer than the parameter, kept in front of the result.
law sgd_update_reaches_targetThe update of parameter id reaches exactly the entry with id older entries below it, and keeps every other entry, whatever the list holds.
law sgd_no_paramsThe parameters are updated in list order: none leaves the entries as they are, and the first is updated before the rest, which see its result.
law sgd_params_in_order
law sgd_refusal_reads_targetWhether parameter id is refused is read from the node with id older nodes below it: a leaf is accepted, any other node refused with NotLeaf.
def operand_refusalWhat a parameter's node allows: a node with no operands, a leaf, is accepted; a node with operands is refused with NotLeaf.
law sgd_only_leaves_accepted
law sgd_refusal_unknownAn id the tape does not hold, the number of its nodes or more, is refused with UnknownNode.
law sgd_negative_rate_refusedThe learning rate is refused exactly when it is below zero, IEEE `lr < 0` on the bits (`below_zero`, stated by below_zero_words): PyTorch's `lr < 0.0`.
law sgd_rate_accepted
def from_bits
def rate_refusals
law sgd_rate_edgesAt the edge rates, as PyTorch 2.14.1 answers them: +0.0, -0.0, 0.01, the quiet NaN, a NaN with the sign bit and +inf are accepted; the smallest negative denormal, -0.25, the most negative finite word and -inf are refused.
law sgd_step_refusedA step with a refused parameter leaves the tape unchanged; with every id accepted, a refused learning rate leaves it unchanged too; otherwise the step updates the parameters in list order.
law sgd_step_rate_refused
law sgd_step_accepted

src/autograd/sgd_PROOF.bend

def ne_succA list of n nodes never has id n + 1 + extra at its head.

src/autograd/sum_dims.bend

type Error
type PlanThe kept shape, built with Shape.construct, and the dropped dimensions.
def reducesWhether the sum reduces axis `axis`: every axis for an empty list.
def kept_fromThe dimensions from axis `axis` on, each reduced one set to 1.
def kept_dimensions
def dropped_next
def dropped_fromThe dimensions from axis `axis` on, without the reduced ones.
def dropped_dimensions
def limitHow many axes an input of these dimensions has for PyTorch's check: its rank, and 1 for a rank-0 input.
def refusedPyTorch's refusal of the axes, permute's checks in permute's order: an axis at or past the limit, then an axis listed twice.
def refusal
def plan_built
def plan_checked
def planThe sum's plan for an input of this shape, or the refusal of its axes.
def transformed
def shaped
def squeezed
def summed
def sum_plannedThe sum of a planned input: reduce_to onto the kept shape, then, without keepdim, the reshape to the dropped dimensions.
def sum_checked
def sum_dimsPyTorch's input.sum(dim=axes, keepdim=keepdim).
def error_code

src/autograd/sum_dims_LAWS.bend

def as_sumreduce_to's result as a sum's: its error as a ReduceError.
def reshape_as_sum
def reshapedA sum's result with its output reshaped to `dimensions`.
def PlanKeepsWhat a plan holds: the kept shape's dimensions and the dropped ones.
law sum_dims_every_axisAn empty axis list reduces every axis, as PyTorch's dim=[]; a listed axis is reduced exactly when it is in the list.
law sum_dims_listed_axis
law sum_dims_kept_startThe kept dimensions count axes from 0, and set each reduced axis to 1.
law sum_dims_kept_step
law sum_dims_dropped_startThe dropped dimensions count axes from 0, and leave out each reduced axis.
law sum_dims_dropped_reduced
law sum_dims_dropped_kept
law sum_dims_rank_zero_limitAn input has its rank's axes, and a rank-0 input has axis 0, as in PyTorch.
law sum_dims_rank_limit
law sum_dims_axis_out_of_boundsThe axes are refused as permute refuses them, and in PyTorch's order: an axis at or past the limit first, then an axis listed twice.
law sum_dims_duplicate_axis
law sum_dims_axes_accepted
law sum_dims_plan_refusedA refused list of axes fails the plan with the refusal.
law sum_dims_plan_dimensionsA plan holds the kept dimensions as its shape and the dropped dimensions.
law sum_dims_refusedA refused plan fails the sum with its error and hands the input back.
law sum_dims_keepdimWith keepdim, the sum is exactly reduce_to onto the kept shape.
law sum_dims_dropsWithout keepdim, it is the keepdim sum reshaped to the dropped dimensions.

src/autograd/sum_dims_PROOF.bend

def built_keeps
def checked_keeps
def kept_as_sumWith keepdim, summed only renames reduce_to's error.
def reshape_renamed
def dropped_reshapedWithout keepdim, summed reshapes what it gives with keepdim.

src/autograd/sum_to_size.bend

def cloned
def decided
def sum_to_sizeThe contribution owner comes back next to the result, as with reduce_to.
def sum_to_size_dimensions_result