bend-tensors

Search uses release 0.0.0.2 · 306 definitions

Releases (2)

0.0.0.2 indexed
0.0.0.1 unindexed

Definitions (306)

bend_tensors.bend

def MatT.transpose
def MatT.add4the four quadrant sums of a product node, in one balanced fork
def MatT.add2r
def MatT.add2c
def MatT.matmul.sqa * b for square operands of one depth: the same recursion with one depth riding instead of three, which measures 3x faster per node
def MatT.matmul.anya * b for any shapes: MatT(r, k) times MatT(k, c) is MatT(r, c).
def MatT.matmula * b: MatT(r, k) times MatT(k, c) is MatT(r, c).
def VecT.add2
def MatT.matvecm * v: MatT(r, c) times VecT(c) is VecT(r)
def MatT.sumthe sum of every cell
def MatT.sum_rowseach row's sum: VecT(r)
def MatT.sum_colseach column's sum: VecT(c)
def VecT.max2
def MatT.max_rowseach row's largest element: VecT(r)
def MatT.add_rowv added to every row: v is a VecT(c)
def MatT.sub_colrow i minus v_i: v is a VecT(r), one scalar per row
def MatT.scale_rowsrow i times v_i: v is a VecT(r), one scalar per row
def MatT.softmax_rows.fin
def MatT.softmax_rowssoftmax along each row: exp(row - max row) / sum
def MatT.rows_takethe first w of every row
def MatT.rows_dropevery row past its first w
def MatT.rows_catthe rows of xs side by side with the rows of ys
def MatT.from_rows.leafa leaf from up to four rows; missing rows and cells pad with 0.0
def MatT.from_rowsa MatT(r, c) from its rows, row-major; short or missing rows pad with 0.0
def MatT.to_rowsthe rows of a MatT(r, c), row-major
def MatT.chunksxs cut into n rows of w
def MatT.from_lista MatT(r, c) from 4 * 2^r times 4 * 2^c floats in row-major order
def MatT.to_listthe cells in row-major order
def MatT.show.row
def MatT.show
def VecT.depth.gothe smallest n with 4 * 2^n >= m; the fuel is m itself, log2(m) steps
def VecT.depth
def VecT.maskelements at index >= m set to 0.0
def VecT.max_uptothe largest element among the first m
def VecT.min_upto
def VecT.argmax_upto.jointhe right half's winner counts only when the right half starts before m
def VecT.argmax_uptothe index and value of the largest among the first m; the first wins ties
def MatT.maskrows at index >= rows and columns at index >= cols set to 0.0
def MatT.max_rows_uptoeach row's largest among its first cols columns; a padding row answers 0.0
type Vec
def Vec.zeros
def Vec.full
def Vec.ones
def Vec.arange0, 1, .., m - 1
def Vec.from_listthe first m of xs, padded with 0.0
def Vec.to_listread borrowed: a bias is shared by every pass of a model
def Vec.map
def Vec.zip
def Vec.add
def Vec.sub
def Vec.mul
def Vec.exp
def Vec.scale
def Vec.shift
def Vec.sum
def Vec.dot
def Vec.max
def Vec.min
def Vec.argmax
def Vec.mask
def Vec.softmax.fin
def Vec.softmaxexp(v - max v) / sum, over the m elements
def Vec.show
type Mat
def Mat.zeros
def Mat.full
def Mat.ones
def Mat.eye
def Mat.from_rowsa matrix from its rows, row-major; short or missing rows pad with 0.0
def Mat.from_lista matrix from rows * cols floats in row-major order
def Mat.to_rows
def Mat.to_list
def Mat.map
def Mat.zip
def Mat.add
def Mat.sub
def Mat.mulelementwise (Hadamard) product; the matrix product is Mat.matmul
def Mat.exp
def Mat.scale
def Mat.transpose
def Mat.matmula * b: Mat<rows, k> times Mat<k, cols> is Mat<rows, cols>
def Mat.matmul.sqa * b for two Mat<n, n>: the one-depth recursion, 3x faster per node
def Mat.matvecm * v: Mat<rows, cols> times Vec<cols> is Vec<rows>
def Mat.sum
def Mat.sum_rows
def Mat.sum_cols
def Mat.max_rows
def Mat.add_rowv added to every row.
def Mat.sub_colrow i minus v_i.
def Mat.scale_rowsrow i times v_i.
def Mat.mask
def Mat.softmax_rows.fin
def Mat.softmax_rowssoftmax along each row over its cols columns
def Mat.show
def Mat.from_treea Mat<rows, cols> around a tree, masked: what the IO products below answer, and what their padding law is about
def Vec4.Padded
def VecT.Padded
def Blk.kcolrow i of a block is padded past kj when i < ki, and entirely when not
def Blk.Padded
def MatT.Padded