bend-ml-tensor-array

Releases (20)

• 0.1.19.0 indexed
• 0.1.18.0 unindexed
• 0.1.17.0 unindexed
• 0.1.16.0 unindexed
• 0.1.15.0 unindexed
• 0.1.14.0 unindexed
• 0.1.13.0 unindexed
• 0.1.12.0 unindexed
• 0.1.11.0 unindexed
• 0.1.10.0 unindexed
• 0.1.9.0 unindexed
• 0.1.8.0 unindexed
• 0.1.7.0 unindexed
• 0.1.6.0 unindexed
• 0.1.5.0 unindexed
• 0.1.4.0 unindexed
• 0.1.3.0 unindexed
• 0.1.2.0 unindexed
• 0.1.1.0 unindexed
• 0.1.0.0 unindexed

Definitions (321)

main.bend

• type R
• type G
• def dotrA dot product with four partial sums.
• type D4dotr's state between two steps: the four partial sums and the two pending reads
• def dstepone step of dotr: adds the pending product to a0, rotates the sums, reads the next pair at ia, ib
• def dfin
• def dot4dotr with its loop unrolled by four: q rounds of four dstep, then the last rem (< 4) steps by dotr itself.
• def dotg
• def cwr_add
• def cwr
• def gcols
• def grows
• def gemm_ac
• def gemm
• type S3
• def lcols
• def lrows
• def lblock_fin
• def lblock
• def lpar
• def write_l
• def write_la
• def gp3
• def gp2
• def gemm_par
• def cblock_fin
• def cblock_go
• def cblock
• def cpar
• def cp2
• def gemm_par_cols
• type P2
• type AL
• def read_l
• def addl
• def bias_rows
• def relu_l
• def pos2
• def pos
• def mask_l
• def maxl2
• def maxl
• def expl
• def suml
• def divl
• def softmax2
• def softmax
• def sgd_l
• def pick
• def hit
• def grad_l
• type L2
• def ce_row2
• def ce_row
• type Mat
• def ce_rows
• type AF
• def cea_maxthe max of k + 1 cells from idx, from m (the first cell's value, already read in r)
• def cea_expcells idx..idx + k become exp(cell - m); returns their sum from s, added left to right
• def cea_gradcell idx (column j) becomes ((e / s) - onehot) / nf, for k + 1 cells
• def cea_p2
• def cea_pp[label] = e[label] / s, or 0.0 for a label past the row (pick's Nil case)
• def cea_row3
• def cea_row2
• def cea_row1
• def cea_row0a row's max starts from its first cell (maxl), then folds over the k + 1 cells from it
• def cea_rowsone row per label, in order, as ce_rows
• type CR
• def gt_head
• def argmax2
• def argmax
• def one
• def count_rows3
• def count_rows
• def BDa type chosen by a Bool: rewriting through it refutes True == False
• def leba <= b, by direct recursion
• def pow2
• def cap_picksmallest power of two >= n, by structural recursion on n: returns (depth, 2^depth)
• def cap_step
• def cap_pair
• def fst_nat
• def snd_nat
• def le_lebleb is Base's Nat.is_le, case for case.
• def leb_of
• def cap_dblthe same pair by doubling (0.1.10.0): p doubles until n <= p, log2(n) steps in a tail loop, where cap_pair takes n steps of a recursion that is not a tail call, each with a comparison of up to n steps.
• def cap_depththe depth d such that an Array with 2^d slots holds n elements (the smallest such d)
• def leb_succa <= b -> a <= 1 + b
• def leb_up_la <= b -> a <= c + b
• def leb_upa <= b -> a <= b + c
• def leb_adda <= b and c <= d -> a + c <= b + d
• def pow2_pos1 <= 2^d
• def pos_p1 <= p when p = 2^d
• def step_eqp + p == 2^(1+d) when p == 2^d
• def step_okone step: given the invariant for m, the invariant for 1+m holds whichever way the comparison goes
• def step_pair_okthe invariant for cap_step on a pair, opened
• def cap_succ
• def cap_invthe invariant of cap_pair: the second component is 2^(first) and is >= n
• def dbl_invthe invariant of cap_dbl: whichever way it ends (n <= p found, or the fuel out and cap_pair's answer), the second component is 2^(first) and is >= n
• def dbl_final
• law cap_okLAW (cap_ok): an Array with 2^cap_depth(n) slots always has room for n elements.