`install.packages('keras')`

19,125

2.9.0

MIT + file LICENSE

May 23rd, 2022

KerasWrapper

(Deprecated) Base R6 class for Keras wrappers

KerasLayer

(Deprecated) Base R6 class for Keras layers

Metric

Metric

application_inception_resnet_v2

Inception-ResNet v2 model, with weights trained on ImageNet

application_vgg

VGG16 and VGG19 models for Keras.

application_resnet

Instantiates the ResNet architecture

application_inception_v3

Inception V3 model, with weights pre-trained on ImageNet.

fit.keras.engine.training.Model

Train a Keras model

callback_tensorboard

TensorBoard basic visualizations

callback_remote_monitor

Callback used to stream events to a server.

export_savedmodel.keras.engine.training.Model

Export a Saved Model

callback_csv_logger

Callback that streams epoch results to a csv file

bidirectional

Bidirectional wrapper for RNNs

custom_metric

Custom metric function

callback_early_stopping

Stop training when a monitored quantity has stopped improving.

create_layer_wrapper

Create a Keras Layer wrapper

dataset_boston_housing

Boston housing price regression dataset

callback_lambda

Create a custom callback

flow_images_from_dataframe

Takes the dataframe and the path to a directory and generates batches of
augmented/normalized data.

create_wrapper

(Deprecated) Create a Keras Wrapper

get_file

Downloads a file from a URL if it not already in the cache.

%<-active%

Make an Active Binding

get_config

Layer/Model configuration

hdf5_matrix

Representation of HDF5 dataset to be used instead of an R array

image_load

Loads an image into PIL format.

image_to_array

3D array representation of images

flow_images_from_directory

Generates batches of data from images in a directory (with optional
augmented/normalized data)

install_keras

Install TensorFlow and Keras, including all Python dependencies

is_keras_available

Check if Keras is Available

k_any

Bitwise reduction (logical OR).

k_arange

Creates a 1D tensor containing a sequence of integers.

dataset_cifar10

CIFAR10 small image classification

dataset_cifar100

CIFAR100 small image classification

initializer_identity

Initializer that generates the identity matrix.

initializer_ones

Initializer that generates tensors initialized to 1.

initializer_lecun_normal

LeCun normal initializer.

fit_text_tokenizer

Update tokenizer internal vocabulary based on a list of texts or list of
sequences.

k_abs

Element-wise absolute value.

initializer_lecun_uniform

LeCun uniform initializer.

k_all

Bitwise reduction (logical AND).

flow_images_from_data

Generates batches of augmented/normalized data from image data and labels

k_elu

Exponential linear unit.

k_concatenate

Concatenates a list of tensors alongside the specified axis.

k_clip

Element-wise value clipping.

k_dtype

Returns the dtype of a Keras tensor or variable, as a string.

application_nasnet

Instantiates a NASNet model.

callback_model_checkpoint

Save the model after every epoch.

callback_learning_rate_scheduler

Learning rate scheduler.

application_mobilenet_v3

Instantiates the MobileNetV3Large architecture

k_expand_dims

Adds a 1-sized dimension at index

`axis`

.k_cos

Computes cos of x element-wise.

k_eye

Instantiate an identity matrix and returns it.

k_get_value

Returns the value of a variable.

get_weights

Layer/Model weights as R arrays

create_layer

Create a Keras Layer

dataset_reuters

Reuters newswire topics classification

dataset_mnist

MNIST database of handwritten digits

count_params

Count the total number of scalars composing the weights.

fit_generator

(Deprecated) Fits the model on data yielded batch-by-batch by a generator.

initializer_glorot_normal

Glorot normal initializer, also called Xavier normal initializer.

%py_class%

Make a python class constructor

initializer_glorot_uniform

Glorot uniform initializer, also called Xavier uniform initializer.

k_count_params

Returns the static number of elements in a Keras variable or tensor.

initializer_zeros

Initializer that generates tensors initialized to 0.

initializer_variance_scaling

Initializer capable of adapting its scale to the shape of weights.

k_ctc_label_dense_to_sparse

Converts CTC labels from dense to sparse.

k_l2_normalize

Normalizes a tensor wrt the L2 norm alongside the specified axis.

k_get_variable_shape

Returns the shape of a variable.

fit_image_data_generator

Fit image data generator internal statistics to some sample data.

k_batch_dot

Batchwise dot product.

k_backend

Active Keras backend

imagenet_preprocess_input

Preprocesses a tensor or array encoding a batch of images.

get_layer

Retrieves a layer based on either its name (unique) or index.

get_input_at

Retrieve tensors for layers with multiple nodes

imagenet_decode_predictions

Decodes the prediction of an ImageNet model.

initializer_random_uniform

Initializer that generates tensors with a uniform distribution.

k_cumprod

Cumulative product of the values in a tensor, alongside the specified axis.

k_learning_phase

Returns the learning phase flag.

k_exp

Element-wise exponential.

k_eval

Evaluates the value of a variable.

k_get_session

TF session to be used by the backend.

adapt

Fits the state of the preprocessing layer to the data being passed

application_mobilenet_v2

MobileNetV2 model architecture

callback_reduce_lr_on_plateau

Reduce learning rate when a metric has stopped improving.

application_mobilenet

MobileNet model architecture.

activation_relu

Activation functions

k_bias_add

Adds a bias vector to a tensor.

callback_progbar_logger

Callback that prints metrics to stdout.

k_get_uid

Get the uid for the default graph.

initializer_truncated_normal

Initializer that generates a truncated normal distribution.

k_ones_like

Instantiates an all-ones variable of the same shape as another tensor.

k_local_conv2d

Apply 2D conv with un-shared weights.

k_local_conv1d

Apply 1D conv with un-shared weights.

k_ones

Instantiates an all-ones tensor variable and returns it.

k_batch_normalization

Applies batch normalization on x given mean, var, beta and gamma.

k_argmax

Returns the index of the maximum value along an axis.

k_argmin

Returns the index of the minimum value along an axis.

k_sin

Computes sin of x element-wise.

k_sparse_categorical_crossentropy

Categorical crossentropy with integer targets.

k_pool2d

2D Pooling.

k_pool3d

3D Pooling.

k_softmax

Softmax of a tensor.

k_batch_set_value

Sets the values of many tensor variables at once.

k_constant

Creates a constant tensor.

k_in_test_phase

Selects

`x`

in test phase, and `alt`

otherwise.k_binary_crossentropy

Binary crossentropy between an output tensor and a target tensor.

constraints

Weight constraints

dataset_imdb

IMDB Movie reviews sentiment classification

dataset_fashion_mnist

Fashion-MNIST database of fashion articles

initializer_he_normal

He normal initializer.

compile.keras.engine.training.Model

Configure a Keras model for training

k_epsilon

Fuzz factor used in numeric expressions.

k_conv1d

1D convolution.

k_in_top_k

Returns whether the

`targets`

are in the top `k`

`predictions`

.k_conv3d

3D convolution.

k_log

Element-wise log.

k_logsumexp

(Deprecated) Computes log(sum(exp(elements across dimensions of a tensor))).

initializer_he_uniform

He uniform variance scaling initializer.

k_equal

Element-wise equality between two tensors.

layer_activation_elu

Exponential Linear Unit.

k_switch

Switches between two operations depending on a scalar value.

k_tanh

Element-wise tanh.

k_spatial_2d_padding

Pads the 2nd and 3rd dimensions of a 4D tensor.

layer_attention

Creates attention layer

layer_activation_leaky_relu

Leaky version of a Rectified Linear Unit.

layer_alpha_dropout

Applies Alpha Dropout to the input.

k_foldl

Reduce elems using fn to combine them from left to right.

k_gradients

Returns the gradients of

`variables`

w.r.t. `loss`

.k_foldr

Reduce elems using fn to combine them from right to left.

layer_conv_3d

3D convolution layer (e.g. spatial convolution over volumes).

layer_conv_3d_transpose

Transposed 3D convolution layer (sometimes called Deconvolution).

k_moving_average_update

Compute the moving average of a variable.

k_repeat

Repeats a 2D tensor.

k_sigmoid

Element-wise sigmoid.

k_relu

Rectified linear unit.

k_minimum

Element-wise minimum of two tensors.

initializer_orthogonal

Initializer that generates a random orthogonal matrix.

k_cumsum

Cumulative sum of the values in a tensor, alongside the specified axis.

k_conv3d_transpose

3D deconvolution (i.e. transposed convolution).

k_cast

Casts a tensor to a different dtype and returns it.

initializer_random_normal

Initializer that generates tensors with a normal distribution.

k_sign

Element-wise sign.

k_in_train_phase

Selects

`x`

in train phase, and `alt`

otherwise.k_manual_variable_initialization

Sets the manual variable initialization flag.

k_greater

Element-wise truth value of (x > y).

k_int_shape

Returns the shape of tensor or variable as a list of int or NULL entries.

k_depthwise_conv2d

Depthwise 2D convolution with separable filters.

k_identity

Returns a tensor with the same content as the input tensor.

k_softsign

Softsign of a tensor.

k_softplus

Softplus of a tensor.

k_is_sparse

Returns whether a tensor is a sparse tensor.

k_image_data_format

Default image data format convention ('channels_first' or 'channels_last').

k_cast_to_floatx

Cast an array to the default Keras float type.

k_not_equal

Element-wise inequality between two tensors.

k_one_hot

Computes the one-hot representation of an integer tensor.

k_map_fn

Map the function fn over the elements elems and return the outputs.

k_conv2d_transpose

2D deconvolution (i.e. transposed convolution).

k_conv2d

2D convolution.

k_flatten

Flatten a tensor.

application_efficientnet

Instantiates the EfficientNetB0 architecture

application_densenet

Instantiates the DenseNet architecture.

application_xception

Instantiates the Xception architecture

layer_cudnn_gru

backend

Keras backend tensor engine

k_placeholder

Instantiates a placeholder tensor and returns it.

k_permute_dimensions

Permutes axes in a tensor.

k_truncated_normal

Returns a tensor with truncated random normal distribution of values.

layer_dense

Add a densely-connected NN layer to an output

k_unstack

Unstack rank

`R`

tensor into a list of rank `R-1`

tensors.callback_terminate_on_naan

Callback that terminates training when a NaN loss is encountered.

k_repeat_elements

Repeats the elements of a tensor along an axis.

k_reset_uids

Reset graph identifiers.

layer_conv_lstm_1d

1D Convolutional LSTM

k_set_value

Sets the value of a variable, from an R array.

layer_category_encoding

A preprocessing layer which encodes integer features.

k_variable

Instantiates a variable and returns it.

clone_model

Clone a model instance.

evaluate_generator

(Deprecated) Evaluates the model on a data generator.

evaluate.keras.engine.training.Model

Evaluate a Keras model

freeze_weights

Freeze and unfreeze weights

generator_next

Retrieve the next item from a generator

k_shape

Returns the symbolic shape of a tensor or variable.

k_less

Element-wise truth value of (x < y).

k_random_normal_variable

Instantiates a variable with values drawn from a normal distribution.

k_less_equal

Element-wise truth value of (x <= y).

k_is_tensor

Returns whether

`x`

is a symbolic tensor.k_floatx

Default float type

k_greater_equal

Element-wise truth value of (x >= y).

k_stack

Stacks a list of rank

`R`

tensors into a rank `R+1`

tensor.keras_model_sequential

Keras Model composed of a linear stack of layers

layer_cudnn_lstm

k_hard_sigmoid

Segment-wise linear approximation of sigmoid.

k_zeros

Instantiates an all-zeros variable and returns it.

layer_global_average_pooling_1d

Global average pooling operation for temporal data.

layer_activation_selu

Scaled Exponential Linear Unit.

layer_dot

Layer that computes a dot product between samples in two tensors.

layer_global_max_pooling_1d

Global max pooling operation for temporal data.

layer_discretization

A preprocessing layer which buckets continuous features by ranges.

k_stop_gradient

Returns

`variables`

but with zero gradient w.r.t. every other variable.k_sum

Sum of the values in a tensor, alongside the specified axis.

k_std

Standard deviation of a tensor, alongside the specified axis.

k_mean

Mean of a tensor, alongside the specified axis.

k_normalize_batch_in_training

Computes mean and std for batch then apply batch_normalization on batch.

k_ndim

Returns the number of axes in a tensor, as an integer.

k_min

Minimum value in a tensor.

image_dataset_from_directory

Create a dataset from a directory

implementation

Keras implementation

image_data_generator

Generate batches of image data with real-time data augmentation. The data will be
looped over (in batches).

layer_masking

Masks a sequence by using a mask value to skip timesteps.

layer_global_max_pooling_2d

Global max pooling operation for spatial data.

layer_multiply

Layer that multiplies (element-wise) a list of inputs.

layer_max_pooling_1d

Max pooling operation for temporal data.

layer_multi_head_attention

MultiHeadAttention layer

keras-package

R interface to Keras

k_random_normal

Returns a tensor with normal distribution of values.

k_resize_images

Resizes the images contained in a 4D tensor.

k_reshape

Reshapes a tensor to the specified shape.

k_update_sub

Update the value of

`x`

by subtracting `decrement`

.k_zeros_like

Instantiates an all-zeros variable of the same shape as another tensor.

layer_gru_cell

Cell class for the GRU layer

keras_model

Keras Model

k_print_tensor

Prints

`message`

and the tensor value when evaluated.k_pow

Element-wise exponentiation.

k_var

Variance of a tensor, alongside the specified axis.

layer_activation

Apply an activation function to an output.

layer_batch_normalization

Batch normalization layer (Ioffe and Szegedy, 2014).

layer_resizing

Image resizing layer

layer_rnn

Base class for recurrent layers

layer_activation_thresholded_relu

Thresholded Rectified Linear Unit.

k_reverse

Reverse a tensor along the specified axes.

k_resize_volumes

Resizes the volume contained in a 5D tensor.

initializer_constant

Initializer that generates tensors initialized to a constant value.

k_set_learning_phase

Sets the learning phase to a fixed value.

k_squeeze

Removes a 1-dimension from the tensor at index

`axis`

.k_separable_conv2d

2D convolution with separable filters.

k_square

Element-wise square.

k_batch_flatten

Turn a nD tensor into a 2D tensor with same 1st dimension.

k_batch_get_value

Returns the value of more than one tensor variable.

layer_spatial_dropout_3d

Spatial 3D version of Dropout.

layer_lstm_cell

Cell class for the LSTM layer

layer_activation_softmax

Softmax activation function.

layer_activity_regularization

Layer that applies an update to the cost function based input activity.

layer_add

Layer that adds a list of inputs.

layer_additive_attention

Additive attention layer, a.k.a. Bahdanau-style attention

keras_model_custom

(Deprecated) Create a Keras custom model

layer_conv_lstm_2d

Convolutional LSTM.

layer_random_flip

Randomly flip each image horizontally and vertically

layer_random_height

Randomly vary the height of a batch of images during training

k_clear_session

Destroys the current TF graph and creates a new one.

k_categorical_crossentropy

Categorical crossentropy between an output tensor and a target tensor.

k_ctc_batch_cost

Runs CTC loss algorithm on each batch element.

k_temporal_padding

Pads the middle dimension of a 3D tensor.

layer_random_crop

Randomly crop the images to target height and width

layer_locally_connected_1d

Locally-connected layer for 1D inputs.

layer_locally_connected_2d

Locally-connected layer for 2D inputs.

layer_dropout

Applies Dropout to the input.

layer_simple_rnn_cell

Cell class for SimpleRNN

layer_simple_rnn

Fully-connected RNN where the output is to be fed back to input.

learning_rate_schedule_cosine_decay

A LearningRateSchedule that uses a cosine decay schedule

keras

Main Keras module

keras_array

Keras array object

k_tile

Creates a tensor by tiling

`x`

by `n`

.layer_activation_parametric_relu

Parametric Rectified Linear Unit.

layer_average_pooling_2d

Average pooling operation for spatial data.

layer_activation_relu

Rectified Linear Unit activation function

learning_rate_schedule_cosine_decay_restarts

A LearningRateSchedule that uses a cosine decay schedule with restarts

learning_rate_schedule_inverse_time_decay

A LearningRateSchedule that uses an inverse time decay schedule

learning_rate_schedule_exponential_decay

A LearningRateSchedule that uses an exponential decay schedule

layer_stacked_rnn_cells

Wrapper allowing a stack of RNN cells to behave as a single cell

layer_concatenate

Layer that concatenates a list of inputs.

layer_dense_features

Constructs a DenseFeatures.

layer_gaussian_noise

Apply additive zero-centered Gaussian noise.

layer_center_crop

Crop the central portion of the images to target height and width

layer_average_pooling_3d

Average pooling operation for 3D data (spatial or spatio-temporal).

layer_embedding

Turns positive integers (indexes) into dense vectors of fixed size.

layer_gru

Gated Recurrent Unit - Cho et al.

layer_global_max_pooling_3d

Global Max pooling operation for 3D data.

k_ctc_decode

Decodes the output of a softmax.

layer_random_brightness

A preprocessing layer which randomly adjusts brightness during training

metric_hinge

Computes the hinge metric between

`y_true`

and `y_pred`

metric_false_positives

Calculates the number of false positives

layer_hashing

A preprocessing layer which hashes and bins categorical features.

layer_lambda

Wraps arbitrary expression as a layer

layer_string_lookup

A preprocessing layer which maps string features to integer indices.

layer_unit_normalization

Unit normalization layer

layer_layer_normalization

Layer normalization layer (Ba et al., 2016).

layer_subtract

Layer that subtracts two inputs.

layer_random_contrast

Adjust the contrast of an image or images by a random factor

layer_rescaling

Multiply inputs by

`scale`

and adds `offset`

layer_random_zoom

A preprocessing layer which randomly zooms images during training.

k_dot

Multiplies 2 tensors (and/or variables) and returns a *tensor*.

layer_lstm

Long Short-Term Memory unit - Hochreiter 1997.

metric_logcosh_error

Computes the logarithm of the hyperbolic cosine of the prediction error

metric_kullback_leibler_divergence

Computes Kullback-Leibler divergence

k_gather

Retrieves the elements of indices

`indices`

in the tensor `reference`

.k_maximum

Element-wise maximum of two tensors.

k_is_placeholder

Returns whether

`x`

is a placeholder.k_dropout

Sets entries in

`x`

to zero at random, while scaling the entire tensor.k_function

Instantiates a Keras function

k_max

Maximum value in a tensor.

k_is_keras_tensor

Returns whether

`x`

is a Keras tensor.make_sampling_table

Generates a word rank-based probabilistic sampling table.

layer_conv_2d

2D convolution layer (e.g. spatial convolution over images).

k_prod

Multiplies the values in a tensor, alongside the specified axis.

layer_reshape

Reshapes an output to a certain shape.

layer_text_vectorization

A preprocessing layer which maps text features to integer sequences.

metric_sparse_categorical_accuracy

Calculates how often predictions match integer labels

metric_sparse_categorical_crossentropy

Computes the crossentropy metric between the labels and predictions

metric_binary_accuracy

Calculates how often predictions match binary labels

metric_recall

Computes the recall of the predictions with respect to the labels

metric-or-Metric

metric-or-Metric

metric_binary_crossentropy

Computes the crossentropy metric between the labels and predictions

layer_repeat_vector

Repeats the input n times.

loss-functions

Loss functions

metric_mean_absolute_percentage_error

Computes the mean absolute percentage error between

`y_true`

and `y_pred`

metric_categorical_hinge

Computes the categorical hinge metric between

`y_true`

and `y_pred`

layer_random_rotation

Randomly rotate each image

layer_separable_conv_2d

Separable 2D convolution.

metric_mean

Computes the (weighted) mean of the given values

k_random_binomial

Returns a tensor with random binomial distribution of values.

metric_mean_absolute_error

Computes the mean absolute error between the labels and predictions

metric_true_negatives

Calculates the number of true negatives

metric_recall_at_precision

Computes best recall where precision is >= specified value

metric_squared_hinge

Computes the squared hinge metric

layer_conv_2d_transpose

Transposed 2D convolution layer (sometimes called Deconvolution).

optimizer_sgd

Stochastic gradient descent optimizer

metric_top_k_categorical_accuracy

Computes how often targets are in the top

`K`

predictionspad_sequences

Pads sequences to the same length

optimizer_adadelta

Adadelta optimizer.

metric_sum

Computes the (weighted) sum of the given values

optimizer_adagrad

Adagrad optimizer.

layer_separable_conv_1d

Depthwise separable 1D convolution.

metric_auc

Approximates the AUC (Area under the curve) of the ROC or PR curves

metric_categorical_accuracy

Calculates how often predictions match one-hot labels

model_to_json

Model configuration as JSON

regularizer_orthogonal

A regularizer that encourages input vectors to be orthogonal to each other

reset_states

Reset the states for a layer

layer_upsampling_1d

Upsampling layer for 1D inputs.

loss_cosine_proximity

(Deprecated) loss_cosine_proximity

save_model_weights_hdf5

Save/Load model weights using HDF5 files

save_text_tokenizer

Save a text tokenizer to an external file

save_model_weights_tf

Save model weights in the SavedModel format

sequences_to_matrix

Convert a list of sequences into a matrix.

layer_flatten

Flattens an input

layer_cropping_3d

Cropping layer for 3D data (e.g. spatial or spatio-temporal).

learning_rate_schedule_piecewise_constant_decay

A LearningRateSchedule that uses a piecewise constant decay schedule

layer_gaussian_dropout

Apply multiplicative 1-centered Gaussian noise.

layer_cropping_2d

Cropping layer for 2D input (e.g. picture).

layer_global_average_pooling_3d

Global Average pooling operation for 3D data.

layer_upsampling_2d

Upsampling layer for 2D inputs.

layer_global_average_pooling_2d

Global average pooling operation for spatial data.

k_random_uniform

Returns a tensor with uniform distribution of values.

k_random_uniform_variable

Instantiates a variable with values drawn from a uniform distribution.

metric_mean_tensor

Computes the element-wise (weighted) mean of the given tensors

metric_true_positives

Calculates the number of true positives

metric_cosine_proximity

(Deprecated) metric_cosine_proximity

metric_mean_iou

Computes the mean Intersection-Over-Union metric

new_learning_rate_schedule_class

Create a new learning rate schedule type

normalize

Normalize a matrix or nd-array

model_from_saved_model

Load a Keras model from the Saved Model format

layer_max_pooling_2d

Max pooling operation for spatial data.

metric_sparse_top_k_categorical_accuracy

Computes how often integer targets are in the top

`K`

predictionslayer_max_pooling_3d

Max pooling operation for 3D data (spatial or spatio-temporal).

metric_accuracy

Calculates how often predictions equal labels

k_rnn

Iterates over the time dimension of a tensor

metric_mean_relative_error

Computes the mean relative error by normalizing with the given values

metric_categorical_crossentropy

Computes the crossentropy metric between the labels and predictions

metric_mean_squared_error

Computes the mean squared error between labels and predictions

predict.keras.engine.training.Model

Generate predictions from a Keras model

text_dataset_from_directory

Generate a

`tf.data.Dataset`

from text files in a directorytext_hashing_trick

Converts a text to a sequence of indexes in a fixed-size hashing space.

predict_generator

(Deprecated) Generates predictions for the input samples from a data generator.

metric_root_mean_squared_error

Computes root mean squared error metric between

`y_true`

and `y_pred`

save_model_tf

Save/Load models using SavedModel format

layer_normalization

A preprocessing layer which normalizes continuous features.

k_round

Element-wise rounding to the closest integer.

time_distributed

This layer wrapper allows to apply a layer to every temporal slice of an input

text_one_hot

One-hot encode a text into a list of word indexes in a vocabulary of size n.

timeseries_generator

Utility function for generating batches of temporal data.

timeseries_dataset_from_array

Creates a dataset of sliding windows over a timeseries provided as array

text_to_word_sequence

Convert text to a sequence of words (or tokens).

k_spatial_3d_padding

Pads 5D tensor with zeros along the depth, height, width dimensions.

layer_conv_1d_transpose

Transposed 1D convolution layer (sometimes called Deconvolution).

k_sqrt

Element-wise square root.

k_to_dense

Converts a sparse tensor into a dense tensor and returns it.

to_categorical

Converts a class vector (integers) to binary class matrix.

metric_sensitivity_at_specificity

Computes best sensitivity where specificity is >= specified value

model_to_saved_model

(Deprecated) Export to Saved Model format

model_to_yaml

Model configuration as YAML

%<-%

Assign values to names

layer_zero_padding_3d

Zero-padding layer for 3D data (spatial or spatio-temporal).

k_transpose

Transposes a tensor and returns it.

layer_average

Layer that averages a list of inputs.

k_update

Update the value of

`x`

to `new_x`

.k_update_add

Update the value of

`x`

by adding `increment`

.layer_average_pooling_1d

Average pooling for temporal data.

multi_gpu_model

(Deprecated) Replicates a model on different GPUs.

layer_cropping_1d

Cropping layer for 1D input (e.g. temporal sequence).

optimizer_nadam

Nesterov Adam optimizer

optimizer_rmsprop

RMSProp optimizer

learning_rate_schedule_polynomial_decay

A LearningRateSchedule that uses a polynomial decay schedule

layer_permute

Permute the dimensions of an input according to a given pattern

layer_zero_padding_2d

Zero-padding layer for 2D input (e.g. picture).

save_model_hdf5

Save/Load models using HDF5 files

train_on_batch

Single gradient update or model evaluation over one batch of samples.

serialize_model

Serialize a model to an R object

sequential_model_input_layer

sequential_model_input_layer

use_implementation

Select a Keras implementation and backend

metric_poisson

Computes the Poisson metric between

`y_true`

and `y_pred`

metric_specificity_at_sensitivity

Computes best specificity where sensitivity is >= specified value

metric_cosine_similarity

Computes the cosine similarity between the labels and predictions

metric_false_negatives

Calculates the number of false negatives

metric_precision

Computes the precision of the predictions with respect to the labels

layer_integer_lookup

A preprocessing layer which maps integer features to contiguous ranges.

layer_conv_1d

1D convolution layer (e.g. temporal convolution).

layer_conv_lstm_3d

3D Convolutional LSTM

layer_input

Input layer

layer_depthwise_conv_2d

Depthwise separable 2D convolution.

layer_spatial_dropout_2d

Spatial 2D version of Dropout.

text_tokenizer

Text tokenization utility

metric_mean_wrapper

Wraps a stateless metric function with the Mean metric

metric_mean_squared_logarithmic_error

Computes the mean squared logarithmic error

optimizer_adam

Adam optimizer

plot.keras_training_history

Plot training history

optimizer_adamax

Adamax optimizer

texts_to_matrix

Convert a list of texts to a matrix.

predict_on_batch

Returns predictions for a single batch of samples.

pop_layer

Remove the last layer in a model

predict_proba

(Deprecated) Generates probability or class probability predictions for the input samples.

layer_depthwise_conv_1d

Depthwise 1D convolution

layer_maximum

Layer that computes the maximum (element-wise) a list of inputs.

layer_minimum

Layer that computes the minimum (element-wise) a list of inputs.

layer_random_translation

Randomly translate each image during training

with_custom_object_scope

Provide a scope with mappings of names to custom objects

layer_spatial_dropout_1d

Spatial 1D version of Dropout.

layer_upsampling_3d

Upsampling layer for 3D inputs.

layer_zero_padding_1d

Zero-padding layer for 1D input (e.g. temporal sequence).

texts_to_sequences

Transform each text in texts in a sequence of integers.

layer_random_width

Randomly vary the width of a batch of images during training

summary.keras.engine.training.Model

Print a summary of a Keras model

%>%

Pipe operator

mark_active

Define new keras types

metric_precision_at_recall

Computes best precision where recall is >= specified value

reexports

Objects exported from other packages

plot.keras.engine.training.Model

Plot a Keras model

skipgrams

Generates skipgram word pairs.

regularizer_l1

L1 and L2 regularization

texts_to_sequences_generator

Transforms each text in texts in a sequence of integers.

zip_lists

zip lists

KerasConstraint

(Deprecated) Base R6 class for Keras constraints

KerasCallback

(Deprecated) Base R6 class for Keras callbacks

Layer

(Deprecated) Create a custom Layer