3 releases
0.1.5alpha.0  Mar 25, 2023 

0.1.4alpha.0  Mar 3, 2023 
0.1.3alpha.0  Mar 2, 2023 
1MB
6.5K
SLoC
caffe2opaffine
is a Rust crate that provides
a mathematical operator commonly used in DSP and
machine learning computations. This operator is
called "affine" because it performs an affine
transformation of its input data, which consists
of a set of vectors or matrices. The affine
transformation involves scaling, shifting, and
adding a bias term to each input vector or matrix.
Note: This crate is currently being translated from C++ to Rust, and some function bodies may still be in the process of translation.
In this crate, you will find several functions and types that implement the affine operator and its associated computations. These include:

AffineChannelScaleBiasBackwardNCHW
andAffineChannelScaleBiasBackwardNHWC
: These are two variants of the backward pass computation for the affine operator. They differ in the layout of the input data, which can be either in NCHW (batchsize, channel, height, width) or NHWC (batchsize, height, width, channel) format. 
AffineChannelGradientOp
: This is an operator that computes the gradient of the affine operator with respect to its input data. It takes as input the gradient of the output data (computed by the subsequent layer) and the scaling and bias terms used in the affine transformation. 
AffineChannelGradient
: This is a helper function that computes the gradient of the affine operator in a memoryefficient way, by reusing some intermediate computations. 
RowwiseMul
: This is a function that performs a rowwise multiplication of a matrix by a vector. It is used in the computation of the affine operator when the input data has a matrix structure. 
dscale
anddbias
: These are types that represent the gradients of the scaling and bias terms, respectively, in the affine operator.
The caffe2opaffine
crate also supports
"learnable" affine operators, where the scaling
and bias terms are not fixed but are learned from
the data during training. In this case, the
learnable
type is used to represent the scaling
and bias terms, and the gradients of these terms
are computed during the backward pass.
Overall, caffe2opaffine
is a useful tool for
implementing affine transformations in your DSP
and machine learning applications, and for
building learnable models that can adapt to the
data they are trained on.
6> could you please teach me the mathematics of the affine transform in detail?
Sure, I'd be happy to explain the mathematics behind the affine transform.
An affine transformation is a linear transformation that includes a translation. It can be represented using a matrix multiplication and a vector addition.
In two dimensions, an affine transformation can be represented as:
x' = a*x + b*y + c
y' = d*x + e*y + f
where (x,y)
are the original coordinates,
(x',y')
are the transformed coordinates, and
a
, b
, c
, d
, e
, and f
are the
transformation parameters.
This can also be represented using matrix notation as:
[x'] [a b c] [x]
[y'] = [d e f] * [y]
[1 ] [0 0 1] [1]
where the 3x3 matrix [a b c; d e f; 0 0 1]
represents the affine transformation matrix.
In the context of machine learning, the affine transform is often used as part of a neural network. It is used to apply a linear transformation to the input data, followed by a translation, which can be learned during training using backpropagation.
In the case of the caffe2opaffine
crate, it
appears to be specifically related to the affine
transformation of an image using a scale and
bias. This can be represented mathematically as:
x' = a*x + c
y' = b*y + d
where a
and b
represent the scaling factors
along the x and y axes, respectively, and c
and
d
represent the translation (bias) along the
x and y axes, respectively.
In matrix notation, this can be represented as:
[x'] [a 0 c] [x]
[y'] = [0 b d] * [y]
[1 ] [0 0 1] [1]
where the 3x3 matrix [a 0 c; 0 b d; 0 0 1]
represents the affine transformation matrix for
scaling and translation.
I hope this helps! Let me know if you have any further questions.
Dependencies
~34MB
~361K SLoC