Dense
implements the operation:
output = activation(dot(input, kernel) + bias)
where activation
is the elementwise activation function
passed as the activation
argument, kernel
is a weights matrix
created by the layer, and bias
is a bias vector created by the layer
(only applicable if use_bias
is TRUE
).
Usage
layer_dense(
object,
units,
activation = NULL,
use_bias = TRUE,
kernel_initializer = "glorot_uniform",
bias_initializer = "zeros",
kernel_regularizer = NULL,
bias_regularizer = NULL,
activity_regularizer = NULL,
kernel_constraint = NULL,
bias_constraint = NULL,
lora_rank = NULL,
...
)
Arguments
 object
Object to compose the layer with. A tensor, array, or sequential model.
 units
Positive integer, dimensionality of the output space.
 activation
Activation function to use. If you don't specify anything, no activation is applied (ie. "linear" activation:
a(x) = x
). use_bias
Boolean, whether the layer uses a bias vector.
 kernel_initializer
Initializer for the
kernel
weights matrix. bias_initializer
Initializer for the bias vector.
 kernel_regularizer
Regularizer function applied to the
kernel
weights matrix. bias_regularizer
Regularizer function applied to the bias vector.
 activity_regularizer
Regularizer function applied to the output of the layer (its "activation").
 kernel_constraint
Constraint function applied to the
kernel
weights matrix. bias_constraint
Constraint function applied to the bias vector.
 lora_rank
Optional integer. If set, the layer's forward pass will implement LoRA (LowRank Adaptation) with the provided rank. LoRA sets the layer's kernel to nontrainable and replaces it with a delta over the original kernel, obtained via multiplying two lowerrank trainable matrices. This can be useful to reduce the computation cost of finetuning large dense layers. You can also enable LoRA on an existing
Dense
layer by callinglayer$enable_lora(rank)
. ...
For forward/backward compatability.
Value
The return value depends on the value provided for the first argument.
If object
is:
a
keras_model_sequential()
, then the layer is added to the sequential model (which is modified in place). To enable piping, the sequential model is also returned, invisibly.a
keras_input()
, then the output tensor from callinglayer(input)
is returned.NULL
or missing, then aLayer
instance is returned.
Note
If the input to the layer has a rank greater than 2, Dense
computes the dot product between the inputs
and the kernel
along the
last axis of the inputs
and axis 0 of the kernel
(using tf.tensordot
).
For example, if input has dimensions (batch_size, d0, d1)
, then we create
a kernel
with shape (d1, units)
, and the kernel
operates along axis 2
of the input
, on every subtensor of shape (1, 1, d1)
(there are
batch_size * d0
such subtensors). The output in this case will have
shape (batch_size, d0, units)
.
Input Shape
ND tensor with shape: (batch_size, ..., input_dim)
.
The most common situation would be
a 2D input with shape (batch_size, input_dim)
.
Output Shape
ND tensor with shape: (batch_size, ..., units)
.
For instance, for a 2D input with shape (batch_size, input_dim)
,
the output would have shape (batch_size, units)
.
Methods

enable_lora( rank, a_initializer = 'he_uniform', b_initializer = 'zeros' )

quantize(mode, type_check = TRUE)
See also
Other core layers: layer_einsum_dense()
layer_embedding()
layer_identity()
layer_lambda()
layer_masking()
Other layers: Layer()
layer_activation()
layer_activation_elu()
layer_activation_leaky_relu()
layer_activation_parametric_relu()
layer_activation_relu()
layer_activation_softmax()
layer_activity_regularization()
layer_add()
layer_additive_attention()
layer_alpha_dropout()
layer_attention()
layer_average()
layer_average_pooling_1d()
layer_average_pooling_2d()
layer_average_pooling_3d()
layer_batch_normalization()
layer_bidirectional()
layer_category_encoding()
layer_center_crop()
layer_concatenate()
layer_conv_1d()
layer_conv_1d_transpose()
layer_conv_2d()
layer_conv_2d_transpose()
layer_conv_3d()
layer_conv_3d_transpose()
layer_conv_lstm_1d()
layer_conv_lstm_2d()
layer_conv_lstm_3d()
layer_cropping_1d()
layer_cropping_2d()
layer_cropping_3d()
layer_depthwise_conv_1d()
layer_depthwise_conv_2d()
layer_discretization()
layer_dot()
layer_dropout()
layer_einsum_dense()
layer_embedding()
layer_feature_space()
layer_flatten()
layer_flax_module_wrapper()
layer_gaussian_dropout()
layer_gaussian_noise()
layer_global_average_pooling_1d()
layer_global_average_pooling_2d()
layer_global_average_pooling_3d()
layer_global_max_pooling_1d()
layer_global_max_pooling_2d()
layer_global_max_pooling_3d()
layer_group_normalization()
layer_group_query_attention()
layer_gru()
layer_hashed_crossing()
layer_hashing()
layer_identity()
layer_integer_lookup()
layer_jax_model_wrapper()
layer_lambda()
layer_layer_normalization()
layer_lstm()
layer_masking()
layer_max_pooling_1d()
layer_max_pooling_2d()
layer_max_pooling_3d()
layer_maximum()
layer_mel_spectrogram()
layer_minimum()
layer_multi_head_attention()
layer_multiply()
layer_normalization()
layer_permute()
layer_random_brightness()
layer_random_contrast()
layer_random_crop()
layer_random_flip()
layer_random_rotation()
layer_random_translation()
layer_random_zoom()
layer_repeat_vector()
layer_rescaling()
layer_reshape()
layer_resizing()
layer_rnn()
layer_separable_conv_1d()
layer_separable_conv_2d()
layer_simple_rnn()
layer_spatial_dropout_1d()
layer_spatial_dropout_2d()
layer_spatial_dropout_3d()
layer_spectral_normalization()
layer_string_lookup()
layer_subtract()
layer_text_vectorization()
layer_tfsm()
layer_time_distributed()
layer_torch_module_wrapper()
layer_unit_normalization()
layer_upsampling_1d()
layer_upsampling_2d()
layer_upsampling_3d()
layer_zero_padding_1d()
layer_zero_padding_2d()
layer_zero_padding_3d()
rnn_cell_gru()
rnn_cell_lstm()
rnn_cell_simple()
rnn_cells_stack()