deepbox/nn

Losses & Initialization

Loss functions, tensor initialization helpers, and gradient clipping support.

Optimization support

type constant

export declare const constant: typeof constant_;

constant is a public const in deepbox/nn.

type kaimingNormal

export declare const kaimingNormal: typeof kaiming_normal_;

kaimingNormal is a public const in deepbox/nn.

type kaimingNormal_

export declare const kaimingNormal_: typeof kaiming_normal_;

kaimingNormal_ is a public const in deepbox/nn.

type kaimingUniform

export declare const kaimingUniform: typeof kaiming_uniform_;

kaimingUniform is a public const in deepbox/nn.

type kaimingUniform_

export declare const kaimingUniform_: typeof kaiming_uniform_;

kaimingUniform_ is a public const in deepbox/nn.

type ones

export declare const ones: typeof ones_;

ones is a public const in deepbox/nn.

type orthogonal

export declare const orthogonal: typeof orthogonal_;

orthogonal is a public const in deepbox/nn.

type xavierNormal

export declare const xavierNormal: typeof xavier_normal_;

xavierNormal is a public const in deepbox/nn.

type xavierNormal_

export declare const xavierNormal_: typeof xavier_normal_;

xavierNormal_ is a public const in deepbox/nn.

type xavierUniform

export declare const xavierUniform: typeof xavier_uniform_;

xavierUniform is a public const in deepbox/nn.

type xavierUniform_

export declare const xavierUniform_: typeof xavier_uniform_;

xavierUniform_ is a public const in deepbox/nn.

type zeros

export declare const zeros: typeof zeros_;

zeros is a public const in deepbox/nn.

constant_

export declare function constant_(tensor: Tensor, val: number): Tensor;

Fill tensor with a constant value.

kaiming_normal_

export declare function kaiming_normal_(tensor: Tensor, a?: number, mode?: "fan_in" | "fan_out", nonlinearity?: string): Tensor;

Fill tensor using Kaiming normal initialization (He initialization).

kaiming_uniform_

export declare function kaiming_uniform_(tensor: Tensor, a?: number, mode?: "fan_in" | "fan_out", nonlinearity?: string): Tensor;

Fill tensor using Kaiming uniform initialization (He initialization).

normal_

export declare function normal_(tensor: Tensor, mean?: number, std?: number): Tensor;

Fill tensor with values drawn from a normal distribution N(mean, std²).

ones_

export declare function ones_(tensor: Tensor): Tensor;

Fill tensor with ones.

orthogonal_

export declare function orthogonal_(tensor: Tensor, gain?: number): Tensor;

Fill tensor with an orthogonal matrix.

sparse_

export declare function sparse_(tensor: Tensor, sparsity?: number, std?: number): Tensor;

Fill tensor as a sparse matrix with normally distributed non-zero entries.

uniform_

export declare function uniform_(tensor: Tensor, low?: number, high?: number): Tensor;

Fill tensor with values drawn from a uniform distribution U(low, high).

xavier_normal_

export declare function xavier_normal_(tensor: Tensor, gain?: number): Tensor;

Fill tensor using Xavier normal initialization.

xavier_uniform_

export declare function xavier_uniform_(tensor: Tensor, gain?: number): Tensor;

Fill tensor using Xavier uniform initialization.

zeros_

export declare function zeros_(tensor: Tensor): Tensor;

Fill tensor with zeros.

binaryCrossEntropyLoss

export declare function binaryCrossEntropyLoss(predictions: GradTensor, targets: GradTensor, reduction?: "mean" | "sum" | "none"): GradTensor;

binaryCrossEntropyLoss is exported by deepbox/nn.

binaryCrossEntropyWithLogitsLoss

export declare function binaryCrossEntropyWithLogitsLoss(input: GradTensor, target: AnyTensor): GradTensor;

binaryCrossEntropyWithLogitsLoss is exported by deepbox/nn.

cosineEmbeddingLoss

export declare function cosineEmbeddingLoss(x1: Tensor, x2: Tensor, y: Tensor, margin?: number, reduction?: "mean" | "sum" | "none"): Tensor;

Cosine Embedding Loss for similarity/contrastive learning.

crossEntropyLoss

export declare function crossEntropyLoss(input: AnyTensor, target: AnyTensor): number | GradTensor;

crossEntropyLoss is exported by deepbox/nn.

ctcLoss

export declare function ctcLoss(logProbs: Tensor, targets: Tensor, inputLengths: Tensor, targetLengths: Tensor, options?: { blank?: number; reduction?: "mean" | "sum" | "none"; }): Tensor;

Connectionist Temporal Classification (CTC) Loss.

gaussianNLLLoss

export declare function gaussianNLLLoss(input: Tensor, target: Tensor, variance: Tensor, options?: { full?: boolean; eps?: number; reduction?: "mean" | "sum" | "none"; }): Tensor;

Gaussian Negative Log Likelihood Loss.

huberLoss

export declare function huberLoss(predictions: Tensor, targets: Tensor, delta?: number, reduction?: "mean" | "sum" | "none"): Tensor;

Huber loss function - combines MSE and MAE.

klDivLoss

export declare function klDivLoss(input: Tensor, target: Tensor, reduction?: "mean" | "sum" | "batchmean" | "none"): Tensor;

KL Divergence loss.

maeLoss

export declare function maeLoss(predictions: GradTensor, targets: GradTensor, reduction?: "mean" | "sum" | "none"): GradTensor;

maeLoss is exported by deepbox/nn.

marginRankingLoss

export declare function marginRankingLoss(x1: GradTensor, x2: GradTensor, y: GradTensor, margin?: number, reduction?: "mean" | "sum" | "none"): GradTensor;

marginRankingLoss is exported by deepbox/nn.

mseLoss

export declare function mseLoss(predictions: GradTensor, targets: GradTensor, reduction?: "mean" | "sum" | "none"): GradTensor;

mseLoss is exported by deepbox/nn.

nllLoss

export declare function nllLoss(logProbs: Tensor, targets: Tensor, reduction?: "mean" | "sum" | "none"): Tensor;

Negative Log Likelihood (NLL) loss.

poissonNLLLoss

export declare function poissonNLLLoss(input: Tensor, target: Tensor, options?: { logInput?: boolean; full?: boolean; eps?: number; reduction?: "mean" | "sum" | "none"; }): Tensor;

Poisson Negative Log Likelihood Loss.

rmseLoss

export declare function rmseLoss(predictions: GradTensor, targets: GradTensor): GradTensor;

rmseLoss is exported by deepbox/nn.

smoothL1Loss

export declare function smoothL1Loss(predictions: Tensor, targets: Tensor, beta?: number, reduction?: "mean" | "sum" | "none"): Tensor;

Smooth L1 Loss (Huber-like loss used in object detection).

tripletMarginLoss

export declare function tripletMarginLoss(anchor: Tensor, positive: Tensor, negative: Tensor, margin?: number, reduction?: "mean" | "sum" | "none"): Tensor;

Triplet Margin Loss for metric learning.

nn-losses.ts

import {  crossEntropyLoss,  kaiming_uniform_,  mseLoss,  xavier_uniform_,} from "deepbox/nn";import { tensor } from "deepbox/ndarray";const predictions = tensor([0.9, 0.1, 0.8]);const targets = tensor([1, 0, 1]);console.log(mseLoss(predictions, targets).toString());console.log(crossEntropyLoss(tensor([[2, 0.5]]), tensor([0])).toString());console.log(kaiming_uniform_(tensor([[0, 0], [0, 0]])));console.log(xavier_uniform_(tensor([[0, 0], [0, 0]])));

Activation Layers

Optimizers