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 Vec.Padded
def Mat.Padded
def Blas.sgemmEffects ------- C = op(A) op(B) on row-major arrays.
def Blas.sgemm_w
def Weights.load.effn float32 (little-endian, as numpy writes them) from a file, into the weight registry (answers the id) or into a fresh array
def Weights.of_array.eff
def Flat.load.eff
type Weights
def Weights.wrap
def Weights.loadrows * cols float32 from a file, as numpy's tofile writes a C-ordered array
type Flat
def Flat.depth.gothe smallest d with 2^d >= n; the fuel bounds the doubling steps
def Flat.depth
def Flat.count
def Flat.full
def Flat.zeros
def Flat.ones
def Flat.fill.go
def Flat.from_listthe first rows * cols of xs, row-major, the rest 0.0
def Flat.wrap
def Flat.from_filerows * cols float32 from a file, row-major
def Weights.of_flata Flat's floats copied into the weight registry; the Flat is consumed
def Flat.to_list.gothe cells in row-major order; i counts down from the last
def Flat.to_list.of
def Flat.to_list
def Vec.wrap
def Vec.from_filem float32 from a file, as a Vec (Data: share it, it is never consumed)
def Flat.clone.fin
def Flat.clonetwo copies; open the pair in a def of your own (a do block cannot)
def Flat.clone.fst
def Flat.clone.snd
def Flat.to_rows
def Flat.show
def Flat.map.step
def Flat.map.go
def Flat.map
def Flat.exp
def F32.relu
def Flat.relu
def F32.gelugelu, the tanh form: 0.5 x (1 + tanh(sqrt(2 / pi) (x + 0.044715 x^3)))
def Flat.gelu
def Flat.scale.step
def Flat.scale.go
def Flat.scale
def Flat.zip.step2
def Flat.zip.step
def Flat.zip.go
def Flat.zip.fin
def Flat.zipf over the pairs of cells; both operands are consumed
def Flat.add
def Flat.sub
def Flat.mulelementwise product; the matrix product is Flat.matmul
def Flat.mask_causal.stepcells above the diagonal (j > i) set to -3.4e38, the most negative finite float, which a softmax turns into 0 with no inf - inf
def Flat.mask_causal.go
def Flat.mask_causal
def Flat.add_row.step
def Flat.add_row.rowthe bias as a list, walked from its head for every row
def Flat.add_row.go
def Flat.add_rowv added to every row; v is a Vec, Data, so it is shared, not consumed
def Flat.rowmax.gothe largest cell of a row segment
def Flat.rowexp.stepexp(x - mx) written back, the row's sum answered
def Flat.rowexp.go
def Flat.rowscale.go
def Flat.softmax.row3one row of softmax: max, exp and sum, scale
def Flat.softmax.row2
def Flat.softmax.row
def Flat.softmax.go
def Flat.softmax_rowssoftmax along each row
def F32.sqdevlayer norm over each row: (x - mean) / sqrt(var + eps), var the mean of the squared deviations; a pass for the sum, one for the squares, one to write
def Flat.rowsq.go
def Flat.rowsum.go
def Flat.rownorm.step
def Flat.rownorm.go
def Flat.layer_norm.row3
def Flat.layer_norm.row2
def Flat.layer_norm.row
def Flat.layer_norm.go
def Flat.layer_norm_rows
def Flat.rowarg.pickthe index of the largest cell of a row segment; the first wins ties
def Flat.rowarg.bestthe better of the best so far and cell j
def Flat.rowarg.go
def Flat.argmax.row
def Flat.argmax.gorows from the last down to the first, so the list comes out in row order; r is the row just done
def Flat.argmax.of
def Flat.argmax_rowseach row's argmax, in row order; the matrix is consumed
def Flat.sum.go
def Flat.sum.of
def Flat.sum
def Flat.mean
def Flat.max.go
def Flat.max.of
def Flat.max
def Flat.transpose.step2
def Flat.transpose.step
def Flat.transpose.gocell (i, j) of a at idx = i * cols + j goes to j * rows + i in b
def Flat.transpose.fin
def Flat.transpose
def Flat.matmul.fin
def Flat.matmul.run
def Flat.matmul