Package org.diffkt.model

Types

Activation

interface Activation : LayerSingleInput<Activation>

AdamOptimizer

class AdamOptimizer<T : Model<T>> : Optimizer<T>

THIS IS A PLACEHOLDER!

AffineTransform

class AffineTransform(m: TrainableTensor, b: TrainableTensor) : TrainableLayerSingleInput<AffineTransform>

An affine transform. Multiplies by one tensor and then adds another. Like a Dense layer, except that where a dense layer performs a matmul, this one performs an element-wise multiplication.

AvgPool2d

class AvgPool2d(poolHeight: Int, poolWidth: Int) : LayerSingleInput<AvgPool2d>

Average pool 2d

BatchNorm2d

class BatchNorm2d(numFeatures: Int, momentum: Float) : BatchNormTraining

A training version of batch normalization provided for compatibility with existing code.

BatchNormResult

class BatchNormResult(result: DTensor, n: Float, sum: DTensor, sumOfSquares: DTensor, mean: DTensor, variance: DTensor)

BatchNormTraining

open class BatchNormTraining : BatchNormTrainingBase<BatchNormTraining>

A trainable Batch Normalization transform, as described in https://arxiv.org/abs/1502.03167 . When training is complete, use its @see inferenceMode property to get the computed affine transform. This version maintains an exponential moving average of the sum of the samples, sum of the squared samples, and sample count which are used to estimate the population mean and variance.

BatchNormTrainingBase

abstract class BatchNormTrainingBase<T : BatchNormTrainingBase<T>>(numFeatures: Int, momentum: Float, scaleShift: TrainableTensor) : TrainableLayerSingleInput<T> , LayerWithInferenceMode

BatchNormTrainingV1

class BatchNormTrainingV1 : BatchNormTrainingBase<BatchNormTrainingV1>

A trainable Batch Normalization transform, as described in https://arxiv.org/abs/1502.03167 . When training is complete, use its @see inferenceMode property to get the computed affine transform. This version is provided to imitate the behavior in V1, the previous implementation, in that it calculates a running mean and running variance rather than gathering the raw input to compute the mean and variance. It applies Bessel's correction (https://en.wikipedia.org/wiki/Bessel%27s_correction) to the sample variance to get an estimate of the population variance for each batch, and uses an exponential moving average of those values as an estimate the population variance when @see inferenceMode is applied.

Conv2d

open class Conv2d(filterShape: Shape, horizontalStride: Int, verticalStride: Int, activation: Activation, paddingStyle: Convolve.PaddingStyle, trainableFilter: TrainableTensor) : TrainableLayerSingleInput<Conv2d>

Conv2dWithSamePadding

class Conv2dWithSamePadding(filterShape: Shape, horizontalStride: Int, verticalStride: Int, activation: Activation, random: Random) : Conv2d

Dense

class Dense : TrainableLayerSingleInput<Dense>

Densely-connected layer

Dropout

class Dropout(dropoutPercent: Float) : Layer<Dropout> , LayerWithInferenceMode

Embedding

class Embedding(trainableWeights: TrainableTensor) : TrainableLayer<Embedding>

A trainable embedding table with size vocabSize x embeddingSize

EmbeddingBag

class EmbeddingBag(trainableWeights: TrainableTensor, reduction: EmbeddingBag.Companion.Reduction) : TrainableLayer<EmbeddingBag>

A trainable embedding table with size vocabSize x embeddingSize

FanIn

class FanIn : FanMode

FanMode

sealed class FanMode

Fan mode informs weight initializers of the dimension for the weight matrix where Fan In corresponds to the size of incoming data and Fan Out corresponds to the size of outgoing data.

FanOut

class FanOut : FanMode

FixedLearningRateOptimizer

class FixedLearningRateOptimizer<T : Model<T>>(alpha: DScalar) : Optimizer<T>

simple optimizer that just uses a fixed learning rate.

Flatten

object Flatten : LayerSingleInput<Flatten>

Flattens the input. Does not affect batch size.

GRU

abstract class GRU : RecurrentBase<GRU, DTensor>

Make a GRU you desire? See invoke in the companion object, or use the GRUEncoder or GRUDecoder helpers.

Initializer

object Initializer

Layer

interface Layer<T : Layer<T>> : OnDevice

LayerSingleInput

interface LayerSingleInput<T : LayerSingleInput<T>> : Layer<T>

LayerWithInferenceMode

interface LayerWithInferenceMode

LinearAfterResetGru

class LinearAfterResetGru(numInputs: Int, numHidden: Int, initialHidden: DTensor?, accType: RecurrentBase.RecurrentBase.AccType, xh2u: Dense, xh2r: Dense, xh2n: Dense) : GRU

Linear-after-reset GRU

LinearBeforeResetGRU

class LinearBeforeResetGRU(numInputs: Int, numHidden: Int, initialHidden: DTensor?, accType: RecurrentBase.RecurrentBase.AccType, xh2u: Dense, xh2r: Dense, x2n: Dense, h2n: Dense) : GRU

Linear-before-reset GRU

MaxPool2d

class MaxPool2d(poolHeight: Int, poolWidth: Int) : LayerSingleInput<MaxPool2d>

Model

abstract class Model<T : Model<T>> : TrainableComponent<T>

Optimizer

abstract class Optimizer<T : Trainable<T>>

RecurrentBase

interface RecurrentBase<Recurrent : RecurrentBase<Recurrent, T>, T> : TrainableLayer<Recurrent>

ReluLayer

object ReluLayer : LayerSingleInput<ReluLayer>

RMSpropOptimizer

open class RMSpropOptimizer<T : Model<T>>(alpha: Float, beta: Float) : Optimizer<T>

An optimizer that implements the RMSprop optimization algorithm.

Sequential

class Sequential(layers: List<Layer<*>>) : TrainableLayerSingleInput<Sequential>

SGDOptimizer

class SGDOptimizer<T : TrainableComponent<T>>(initialLearningRate: Float, weightDecay: Float, momentum: Float) : Optimizer<T>

Stochastic gradient descent optimizer with optional weight decay regularization and momentum parameters.

Trainable

interface Trainable<T : Trainable<T>> : Differentiable<T> , OnDevice

TrainableComponent

interface TrainableComponent<T : TrainableComponent<T>> : Trainable<T>

TrainableLayer

interface TrainableLayer<T : TrainableLayer<T>> : TrainableComponent<T> , Layer<T>

TrainableLayerSingleInput

interface TrainableLayerSingleInput<T : TrainableLayerSingleInput<T>> : TrainableLayer<T> , TrainableComponent<T> , LayerSingleInput<T>

TrainableTensor

class TrainableTensor(tensor: DTensor) : Trainable<TrainableTensor>

Functions

avgPool

fun avgPool(x: DTensor, poolHeight: Int, poolWidth: Int): DTensor

Computes the average of the pool (poolHeight x poolWidth) for each pool in x with a stride of (poolHeight, poolWidth). Requires that dim H on x be divisible by poolHeight and dim W on x be divisible by poolWidth.

avgPoolGrad

fun avgPoolGrad(x: DTensor, poolHeight: Int, poolWidth: Int): DTensor

batchNorm

fun batchNorm(input: DTensor, scaleShift: DTensor): BatchNormResult

The batchNorm op used for training

batchNormTrainV1

fun batchNormTrainV1(input: DTensor, scaleShift: DTensor, runningMean: DTensor, runningVariance: DTensor, momentum: Float): Triple<DTensor, DTensor, DTensor>

The batchNorm op for training, V1 compatibility version

batchNormTrainV2

fun batchNormTrainV2(input: DTensor, scaleShift: DTensor, runningN: Float, runningSum: DTensor, runningSumOfSquares: DTensor, momentum: Float): Pair<DTensor, Triple<Float, DTensor, DTensor>>

The batchNorm op for training

freezeBatchNorm

fun freezeBatchNorm(scaleShift: DTensor, mean: DTensor, variance: DTensor): AffineTransform

into

infix fun <T : Layer<T>> DTensor.into(layer: Layer<T>): DTensor

maxPool

fun maxPool(x: DTensor, poolHeight: Int, poolWidth: Int): DTensor

Returns the max of the pool (poolHeight x poolWidth) for each pool in x with a stride of (poolHeight, poolWidth). Requires that dim H on x be divisible by poolHeight and dim W on x be divisible by poolWidth

momentumUpdated

fun Float.momentumUpdated(new: Float, momentum: Float): Float

Returns the current (this) value updated by the new value (new) scaled by momentum

fun DTensor.momentumUpdated(new: DTensor, momentum: Float): DTensor

Returns the current (this) tensor updated by the new tensor (new) scaled by momentum

Properties

BATCHNORM_EPSILON

const val BATCHNORM_EPSILON: Float = 1.0E-5f