bendtorch-core

Releases (1)

• 0.1.0.0 indexed

Definitions (5,204)

src/autograd/gradient_PROOF.bend

• def agreed_success
• def checked_success
• def accumulated_keeps
• def slot_kept
• def held_checked_refusal
• def held_refusal
• def agreed_refusal
• def checked_refusal
• def reset_checked
• def checked_wrong_shape

src/autograd/loss.bend

• type Error
• def error_code
• type RecordedA loss next to the two tensors its backward reads.
• def count_f32A count as an F32, rounded as PyTorch converts an integer count.
• def mse_scale2 / N, the factor of PyTorch's mse_loss backward with mean reduction, for the N cells of the broadcast shape.
• def first_dimensionThe first dimension of [rows, columns] logits, the batch.
• def rows
• def single_columnWhether [rows, columns] logits have one column, one class.
• def one_class
• def max_stepPyTorch's maximum: NaN when either word is NaN, else the larger word, and on a tie the later word, as `_mm512_max_ps(m, v)` keeps its second operand.
• def row_next
• def row_restmax_step of m and the `fuel` words from `position` on, left to right.
• def row_first
• def from_wordThe F32 of a word.
• def row_maxThe maximum of row `row` of a row-major [rows, columns] array: its first word, then max_step with each later word, left to right.
• type Width
• def width
• def max_cellThe cell function of the row-maximum build: cell `position` is the maximum of row `position`.
• def max_build
• def max_balanced
• def max_rows
• def max_allocated
• def row_maxesThe maximum of each row of [rows, columns] logits, a [rows, 1] tensor.
• def quotientThe result of a binary operation whose operands the caller no longer needs.
• def divided_by
• def total_overThe sum of every word, in ascending flat order from +0.0 (Reduction.sum_dynamic), divided by `count`: a rank-0 tensor.
• def mean_shaped
• def meanPyTorch's mean of every element: the ordered sum divided by the element count, F32.div of the two.
• def recordedThe loss next to the two tensors the backward reads.
• def mse_squared
• def mse_copied
• def mse_both
• def mse_differences
• def mse_first
• def mse_lossPyTorch's mse_loss(input, target) with mean reduction: d = input - target and e = target - input over the broadcast shape, then the mean of d * d.
• def targets_fitWhether every target is below `columns`, and there are `rows` of them.
• def as_words
• def classesThe class numbers 0.0, 1.0, ...
• def one_hot_pair
• def one_hotThe one-hot rows of the targets, [rows, columns]: 1.0 where the column is the row's target, +0.0 elsewhere.
• def ce_total
• def ce_picked
• def ce_logged
• def ce_lse
• def ce_summed
• def ce_exps
• def ce_shifted
• def ce_maxed
• def ce_targeted
• def ce_checked
• def ce_dimensioned
• def ce_shaped
• def cross_entropyPyTorch's cross_entropy(logits, targets) with mean reduction, for logits of [rows, columns] and one class index below `columns` per row.

src/autograd/reduce.bend

• type Error
• def leaf_add
• def spanHow many digits a row walks for a target cell: every digit of an axis the target reduces (left stride 0), else one.
• def first_span
• def first_digitThe first digit a row walks: 0 on a reduced axis (`Nat.div` by 0 is 0), else the digit `target` names there.
• def walk_next
• def fiberThe words of the fiber of `target` below these rows, added to `accumulator` in increasing position.
• def single_rowsWhether every row here takes one digit (span 1), so that the fiber below a digit of the row above is one word.
• def single_below`single_rows` of the rows below the first one.
• def single_offsetThe offset of the one word that rows of span 1 reach from `base`.
• def step_offsetThe contribution offset of digit d of a row whose right stride is `step`.
• def strided_offset
• def strided_runThe fuel + 1 words at offsets base + step * d + lift for d = digit, digit + 1, ..., added to `accumulator` in that order; `pair` is the read of the first.
• def strided
• def fiber_fast`fiber`, the same words added in the same order, except that a row whose rows below all take one digit (`single`, which is `single_below` of the rows; a later digit of the same row passes False) walks its digits in one strided loop: below digit d it reads the one word at base + right * d + single_offset(rest, others, target % left, 0), with no closure per word.
• def fiber_ofCell `target` of the reduction: its whole fiber from +0.0.
• def cellOne target cell: its fiber sum from +0.0 when the cell is below `count`, else +0.0.
• type FibersWhat every cell of a build needs: the index rows of the plan and the contribution extent of each row.
• def fibersEach thread below the forks reads its own copy.
• def keepThe cell function `Parallel.build` runs: its state is the contribution array, next to a Unit that fills the build's second state slot.
• def cell_at
• def halvesEach half of a fork gets its own clone of the contribution array.
• def split
• def build
• def build_balancedThe parallel build returns a balanced tree of its depth, whatever the split.
• def termsA target cell costs one term per contribution word that lands on it.
• def kept_afterWhether some axis below these rows has extent above 1 and is kept by the target (left stride above 0).
• def contiguousWhether every fiber is one contiguous run of the contribution: no axis the target keeps comes after an axis it reduces, counting only axes of extent above 1.
• def splitsHow many top levels of the target tree fork.
• def parallel_rows
• def parallel_indexedAn empty contribution leaves every target cell at +0.0.
• def parallel_allocated
• def fitted
• def planned
• def reduce_toThe contribution owner comes back unchanged next to the result.
• def reduce_to_dimensions_result
• def reduce_to_dimensions