Implementation:Tensorflow Tfjs Exports Layers

Knowledge Sources	Tensorflow_Tfjs TensorFlow.js API
Domains	Deep_Learning, Layers_API
Last Updated	2026-02-10 06:00 GMT

Overview

The exports_layers.ts module serves as the public API surface for creating layer instances in TensorFlow.js. It exports factory functions (available under tf.layers.*) that instantiate the corresponding layer classes. Each factory function accepts a typed configuration object and returns a new layer instance. This module imports from all layer implementation files and re-exports them through a unified, user-friendly API.

The module covers the complete set of layer types: input, core, advanced activations, convolutional, pooling, recurrent, normalization, merge, wrapper, embedding, noise, padding, and preprocessing layers.

Code Reference

Source Location

tfjs-layers/src/exports_layers.ts (View on GitHub)

Key Signatures (Selected)

// Input
export function inputLayer(args: InputLayerArgs): InputLayer;

// Advanced Activations
export function elu(args?: ELULayerArgs): ELU;
export function reLU(args?: ReLULayerArgs): ReLU;
export function leakyReLU(args?: LeakyReLULayerArgs): LeakyReLU;
export function prelu(args?: PReLULayerArgs): PReLU;
export function softmax(args?: SoftmaxLayerArgs): Softmax;
export function thresholdedReLU(args?: ThresholdedReLULayerArgs): ThresholdedReLU;

// Core
export function dense(args: DenseLayerArgs): Dense;
export function dropout(args: DropoutLayerArgs): Dropout;
export function flatten(args?: FlattenLayerArgs): Flatten;
export function reshape(args: ReshapeLayerArgs): Reshape;
export function embedding(args: EmbeddingLayerArgs): Embedding;
export function activation(args: ActivationLayerArgs): Activation;

// Convolutional
export function conv1d(args: ConvLayerArgs): Conv1D;
export function conv2d(args: ConvLayerArgs): Conv2D;
export function conv2dTranspose(args: ConvLayerArgs): Conv2DTranspose;
export function conv3d(args: ConvLayerArgs): Conv3D;
export function separableConv2d(args: SeparableConvLayerArgs): SeparableConv2D;
export function depthwiseConv2d(args: DepthwiseConv2DLayerArgs): DepthwiseConv2D;
export function upSampling2d(args: UpSampling2DLayerArgs): UpSampling2D;
export function cropping2D(args: Cropping2DLayerArgs): Cropping2D;

// Pooling
export function maxPooling1d(args: Pooling1DLayerArgs): MaxPooling1D;
export function maxPooling2d(args: Pooling2DLayerArgs): MaxPooling2D;
export function averagePooling1d(args: Pooling1DLayerArgs): AveragePooling1D;
export function averagePooling2d(args: Pooling2DLayerArgs): AveragePooling2D;
export function globalAveragePooling1d(args?: LayerArgs): GlobalAveragePooling1D;
export function globalAveragePooling2d(args: GlobalPooling2DLayerArgs): GlobalAveragePooling2D;
export function globalMaxPooling1d(args?: LayerArgs): GlobalMaxPooling1D;
export function globalMaxPooling2d(args: GlobalPooling2DLayerArgs): GlobalMaxPooling2D;

// Recurrent
export function simpleRNN(args: SimpleRNNLayerArgs): SimpleRNN;
export function gru(args: GRULayerArgs): GRU;
export function lstm(args: LSTMLayerArgs): LSTM;
export function rnn(args: RNNLayerArgs): RNN;
export function stackedRNNCells(args: StackedRNNCellsArgs): StackedRNNCells;
export function convLstm2d(args: ConvLSTM2DArgs): ConvLSTM2D;

// Normalization
export function batchNormalization(args?: BatchNormalizationLayerArgs): BatchNormalization;
export function layerNormalization(args?: LayerNormalizationLayerArgs): LayerNormalization;

// Merge
export function add(args?: LayerArgs): Add;
export function multiply(args?: LayerArgs): Multiply;
export function average(args?: LayerArgs): Average;
export function maximum(args?: LayerArgs): Maximum;
export function minimum(args?: LayerArgs): Minimum;
export function concatenate(args?: ConcatenateLayerArgs): Concatenate;
export function dot(args: DotLayerArgs): Dot;

// Wrappers
export function timeDistributed(args: WrapperLayerArgs): TimeDistributed;
export function bidirectional(args: BidirectionalLayerArgs): Bidirectional;

// Preprocessing
export function rescaling(args?: RescalingArgs): Rescaling;
export function resizing(args?: ResizingArgs): Resizing;
export function centerCrop(args?: CenterCropArgs): CenterCrop;
export function categoryEncoding(args: CategoryEncodingArgs): CategoryEncoding;
export function randomWidth(args: RandomWidthArgs): RandomWidth;

Import

// Users access these via the tf.layers namespace:
import * as tf from '@tensorflow/tfjs';
const layer = tf.layers.dense({ units: 32, activation: 'relu' });

I/O Contract

Input

Each factory function accepts a typed arguments object (e.g., DenseLayerArgs, ConvLayerArgs) that configures the layer. All arguments extend LayerArgs, which provides common properties such as name, dtype, inputShape, and batchInputShape.

Output

Each function returns a new instance of the corresponding layer class, ready to be used in a tf.Sequential or tf.Model.

Usage Examples

import * as tf from '@tensorflow/tfjs';

// Build a simple sequential model using exported layer factories
const model = tf.sequential();
model.add(tf.layers.dense({ inputShape: [784], units: 128, activation: 'relu' }));
model.add(tf.layers.dropout({ rate: 0.2 }));
model.add(tf.layers.batchNormalization());
model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));

// Convolutional model
const convModel = tf.sequential();
convModel.add(tf.layers.conv2d({
  inputShape: [28, 28, 1], filters: 32, kernelSize: 3, activation: 'relu'
}));
convModel.add(tf.layers.maxPooling2d({ poolSize: 2 }));
convModel.add(tf.layers.flatten());
convModel.add(tf.layers.dense({ units: 10, activation: 'softmax' }));

Related Pages

• Tensorflow_Tfjs_Advanced_Activations - Implementation of advanced activation layer classes
• Tensorflow_Tfjs_Convolutional_Layers - Implementation of convolutional layer classes
• Tensorflow_Tfjs_Pooling_Layers - Implementation of pooling layer classes
• Tensorflow_Tfjs_Recurrent_Layers - Implementation of recurrent layer classes
• Tensorflow_Tfjs_Merge_Layers - Implementation of merge layer classes
• Tensorflow_Tfjs_Normalization_Layers - Implementation of normalization layer classes
• Tensorflow_Tfjs_Wrapper_Layers - Implementation of wrapper layer classes
• Tensorflow_Tfjs_Exports_Metrics - Public API for metric functions