vortex_torch.cache.elementwise_binary

Classes

Add([alpha, beta])	Affine combination \(\alpha x + \beta y\) (an Elementwise_Binary).
Elementwise_Binary([alpha, beta])	Pointwise binary op over two cache blocks (cache side).
Maximum([alpha, beta])	Elementwise maximum (an Elementwise_Binary).
Minimum([alpha, beta])	Elementwise minimum (an Elementwise_Binary).
Multiply([alpha, beta])	Elementwise product (an Elementwise_Binary).

class Elementwise_Binary(alpha=1.0, beta=1.0)

Bases: vOp

Pointwise binary op over two cache blocks (cache side).

Math:

For \(X, Y \in \mathbb{R}^{B\times N\times D}\) and a scalar function \(g\) fixed by the subclass (max / min / affine / product / comparison mask):

\[Z_{b,n,d} = g(X_{b,n,d},\, Y_{b,n,d};\, \alpha, \beta).\]

N and D broadcast when one operand’s extent is 1.

__init__:

Elementwise_Binary(alpha=1.0, beta=1.0) — scalars consumed only by the ops that need them (e.g. Add); abstract, pick a concrete subclass.

__call__:

z = op(x, y, output, loc=loc, ctx=ctx) — x [B, N_x, D_x], y [B, N_y, D_y] → [B, max(N_x,N_y), max(D_x,D_y)]. PAGED iff a PAGED output is supplied, else RAGGED.

Note:

subclasses — Maximum, Minimum, Add, Multiply, and the comparison masks WhereEqual, WhereNotEqual, WhereGreater, WhereGreaterEqual, WhereLess, WhereLessEqual.

Parameters:

• alpha (float)

• beta (float)

class Maximum(alpha=1.0, beta=1.0)

Bases: Elementwise_Binary

Elementwise maximum (an Elementwise_Binary).

Math:

\[Z_{b,n,d} = \max(X_{b,n,d},\, Y_{b,n,d}).\]

__init__:

Maximum(alpha=1.0, beta=1.0) — alpha / beta unused.

Parameters:

• alpha (float)

• beta (float)

class Minimum(alpha=1.0, beta=1.0)

Bases: Elementwise_Binary

Elementwise minimum (an Elementwise_Binary).

Math:

\[Z_{b,n,d} = \min(X_{b,n,d},\, Y_{b,n,d}).\]

__init__:

Minimum(alpha=1.0, beta=1.0) — alpha / beta unused.

Parameters:

• alpha (float)

• beta (float)

class Add(alpha=1.0, beta=1.0)

Bases: Elementwise_Binary

Affine combination \(\alpha x + \beta y\) (an Elementwise_Binary).

Math:

\[Z_{b,n,d} = \alpha\,X_{b,n,d} + \beta\,Y_{b,n,d}.\]

__init__:

Add(alpha=1.0, beta=1.0) — multipliers for \(x\) and \(y\) (defaults give \(x+y\)).

Parameters:

• alpha (float)

• beta (float)

class Multiply(alpha=1.0, beta=1.0)

Bases: Elementwise_Binary

Elementwise product (an Elementwise_Binary).

Math:

\[Z_{b,n,d} = X_{b,n,d}\cdot Y_{b,n,d}.\]

__init__:

Multiply(alpha=1.0, beta=1.0) — alpha / beta unused.

Parameters:

• alpha (float)

• beta (float)

class WhereEqual

Bases: Elementwise_Binary

Comparison mask \(x = y\) (an Elementwise_Binary).

Math:

\[\begin{split}Z_{b,n,d} = \begin{cases} 0, & X_{b,n,d} = Y_{b,n,d}, \\ -\infty, & \text{otherwise}. \end{cases}\end{split}\]

__init__:

WhereEqual() — no arguments.

Note:

additive mask for score-space gating.

class WhereNotEqual

Bases: Elementwise_Binary

Comparison mask \(x \ne y\) (an Elementwise_Binary).

Math:

\[\begin{split}Z_{b,n,d} = \begin{cases} 0, & X_{b,n,d} \ne Y_{b,n,d}, \\ -\infty, & \text{otherwise}. \end{cases}\end{split}\]

__init__:

WhereNotEqual() — no arguments.

class WhereGreater

Bases: Elementwise_Binary

Comparison mask \(x > y\) (an Elementwise_Binary).

Math:

\[\begin{split}Z_{b,n,d} = \begin{cases} 0, & X_{b,n,d} > Y_{b,n,d}, \\ -\infty, & \text{otherwise}. \end{cases}\end{split}\]

__init__:

WhereGreater() — no arguments.

class WhereGreaterEqual

Bases: Elementwise_Binary

Comparison mask \(x \ge y\) (an Elementwise_Binary).

Math:

\[\begin{split}Z_{b,n,d} = \begin{cases} 0, & X_{b,n,d} \ge Y_{b,n,d}, \\ -\infty, & \text{otherwise}. \end{cases}\end{split}\]

__init__:

WhereGreaterEqual() — no arguments.

class WhereLess

Bases: Elementwise_Binary

Comparison mask \(x < y\) (an Elementwise_Binary).

Math:

\[\begin{split}Z_{b,n,d} = \begin{cases} 0, & X_{b,n,d} < Y_{b,n,d}, \\ -\infty, & \text{otherwise}. \end{cases}\end{split}\]

__init__:

WhereLess() — no arguments.

class WhereLessEqual

Bases: Elementwise_Binary

Comparison mask \(x \le y\) (an Elementwise_Binary).

Math:

\[\begin{split}Z_{b,n,d} = \begin{cases} 0, & X_{b,n,d} \le Y_{b,n,d}, \\ -\infty, & \text{otherwise}. \end{cases}\end{split}\]

__init__:

WhereLessEqual() — no arguments.