KerasCallback           Base R6 class for Keras callbacks
KerasConstraint         Base R6 class for Keras constraints
KerasLayer              Base R6 class for Keras layers
KerasWrapper            Base R6 class for Keras wrappers
activation_relu         Activation functions
application_densenet    Instantiates the DenseNet architecture.
application_inception_resnet_v2
                        Inception-ResNet v2 model, with weights trained
                        on ImageNet
application_inception_v3
                        Inception V3 model, with weights pre-trained on
                        ImageNet.
application_mobilenet   MobileNet model architecture.
application_mobilenet_v2
                        MobileNetV2 model architecture
application_nasnet      Instantiates a NASNet model.
application_resnet50    ResNet50 model for Keras.
application_vgg         VGG16 and VGG19 models for Keras.
application_xception    Xception V1 model for Keras.
backend                 Keras backend tensor engine
bidirectional           Bidirectional wrapper for RNNs.
callback_csv_logger     Callback that streams epoch results to a csv
                        file
callback_early_stopping
                        Stop training when a monitored quantity has
                        stopped improving.
callback_lambda         Create a custom callback
callback_learning_rate_scheduler
                        Learning rate scheduler.
callback_model_checkpoint
                        Save the model after every epoch.
callback_progbar_logger
                        Callback that prints metrics to stdout.
callback_reduce_lr_on_plateau
                        Reduce learning rate when a metric has stopped
                        improving.
callback_remote_monitor
                        Callback used to stream events to a server.
callback_tensorboard    TensorBoard basic visualizations
callback_terminate_on_naan
                        Callback that terminates training when a NaN
                        loss is encountered.
clone_model             Clone a model instance.
compile.keras.engine.training.Model
                        Configure a Keras model for training
constraints             Weight constraints
count_params            Count the total number of scalars composing the
                        weights.
create_layer            Create a Keras Layer
create_wrapper          Create a Keras Wrapper
dataset_boston_housing
                        Boston housing price regression dataset
dataset_cifar10         CIFAR10 small image classification
dataset_cifar100        CIFAR100 small image classification
dataset_fashion_mnist   Fashion-MNIST database of fashion articles
dataset_imdb            IMDB Movie reviews sentiment classification
dataset_mnist           MNIST database of handwritten digits
dataset_reuters         Reuters newswire topics classification
evaluate.keras.engine.training.Model
                        Evaluate a Keras model
evaluate_generator      Evaluates the model on a data generator.
export_savedmodel.keras.engine.training.Model
                        Export a Saved Model
fit.keras.engine.training.Model
                        Train a Keras model
fit_generator           Fits the model on data yielded batch-by-batch
                        by a generator.
fit_image_data_generator
                        Fit image data generator internal statistics to
                        some sample data.
fit_text_tokenizer      Update tokenizer internal vocabulary based on a
                        list of texts or list of sequences.
flow_images_from_data   Generates batches of augmented/normalized data
                        from image data and labels
flow_images_from_directory
                        Generates batches of data from images in a
                        directory (with optional augmented/normalized
                        data)
freeze_weights          Freeze and unfreeze weights
generator_next          Retrieve the next item from a generator
get_config              Layer/Model configuration
get_file                Downloads a file from a URL if it not already
                        in the cache.
get_input_at            Retrieve tensors for layers with multiple nodes
get_layer               Retrieves a layer based on either its name
                        (unique) or index.
get_weights             Layer/Model weights as R arrays
hdf5_matrix             Representation of HDF5 dataset to be used
                        instead of an R array
image_data_generator    Generate batches of image data with real-time
                        data augmentation. The data will be looped over
                        (in batches).
image_load              Loads an image into PIL format.
image_to_array          3D array representation of images
imagenet_decode_predictions
                        Decodes the prediction of an ImageNet model.
imagenet_preprocess_input
                        Preprocesses a tensor or array encoding a batch
                        of images.
implementation          Keras implementation
initializer_constant    Initializer that generates tensors initialized
                        to a constant value.
initializer_glorot_normal
                        Glorot normal initializer, also called Xavier
                        normal initializer.
initializer_glorot_uniform
                        Glorot uniform initializer, also called Xavier
                        uniform initializer.
initializer_he_normal   He normal initializer.
initializer_he_uniform
                        He uniform variance scaling initializer.
initializer_identity    Initializer that generates the identity matrix.
initializer_lecun_normal
                        LeCun normal initializer.
initializer_lecun_uniform
                        LeCun uniform initializer.
initializer_ones        Initializer that generates tensors initialized
                        to 1.
initializer_orthogonal
                        Initializer that generates a random orthogonal
                        matrix.
initializer_random_normal
                        Initializer that generates tensors with a
                        normal distribution.
initializer_random_uniform
                        Initializer that generates tensors with a
                        uniform distribution.
initializer_truncated_normal
                        Initializer that generates a truncated normal
                        distribution.
initializer_variance_scaling
                        Initializer capable of adapting its scale to
                        the shape of weights.
initializer_zeros       Initializer that generates tensors initialized
                        to 0.
install_keras           Install Keras and the TensorFlow backend
is_keras_available      Check if Keras is Available
k_abs                   Element-wise absolute value.
k_all                   Bitwise reduction (logical AND).
k_any                   Bitwise reduction (logical OR).
k_arange                Creates a 1D tensor containing a sequence of
                        integers.
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_backend               Active Keras backend
k_batch_dot             Batchwise dot product.
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.
k_batch_normalization   Applies batch normalization on x given mean,
                        var, beta and gamma.
k_batch_set_value       Sets the values of many tensor variables at
                        once.
k_bias_add              Adds a bias vector to a tensor.
k_binary_crossentropy   Binary crossentropy between an output tensor
                        and a target tensor.
k_cast                  Casts a tensor to a different dtype and returns
                        it.
k_cast_to_floatx        Cast an array to the default Keras float type.
k_categorical_crossentropy
                        Categorical crossentropy between an output
                        tensor and a target tensor.
k_clear_session         Destroys the current TF graph and creates a new
                        one.
k_clip                  Element-wise value clipping.
k_concatenate           Concatenates a list of tensors alongside the
                        specified axis.
k_constant              Creates a constant tensor.
k_conv1d                1D convolution.
k_conv2d                2D convolution.
k_conv2d_transpose      2D deconvolution (i.e. transposed convolution).
k_conv3d                3D convolution.
k_conv3d_transpose      3D deconvolution (i.e. transposed convolution).
k_cos                   Computes cos of x element-wise.
k_count_params          Returns the static number of elements in a
                        Keras variable or tensor.
k_ctc_batch_cost        Runs CTC loss algorithm on each batch element.
k_ctc_decode            Decodes the output of a softmax.
k_ctc_label_dense_to_sparse
                        Converts CTC labels from dense to sparse.
k_cumprod               Cumulative product of the values in a tensor,
                        alongside the specified axis.
k_cumsum                Cumulative sum of the values in a tensor,
                        alongside the specified axis.
k_depthwise_conv2d      Depthwise 2D convolution with separable
                        filters.
k_dot                   Multiplies 2 tensors (and/or variables) and
                        returns a _tensor_.
k_dropout               Sets entries in 'x' to zero at random, while
                        scaling the entire tensor.
k_dtype                 Returns the dtype of a Keras tensor or
                        variable, as a string.
k_elu                   Exponential linear unit.
k_epsilon               Fuzz factor used in numeric expressions.
k_equal                 Element-wise equality between two tensors.
k_eval                  Evaluates the value of a variable.
k_exp                   Element-wise exponential.
k_expand_dims           Adds a 1-sized dimension at index 'axis'.
k_eye                   Instantiate an identity matrix and returns it.
k_flatten               Flatten a tensor.
k_floatx                Default float type
k_foldl                 Reduce elems using fn to combine them from left
                        to right.
k_foldr                 Reduce elems using fn to combine them from
                        right to left.
k_function              Instantiates a Keras function
k_gather                Retrieves the elements of indices 'indices' in
                        the tensor 'reference'.
k_get_session           TF session to be used by the backend.
k_get_uid               Get the uid for the default graph.
k_get_value             Returns the value of a variable.
k_get_variable_shape    Returns the shape of a variable.
k_gradients             Returns the gradients of 'variables' w.r.t.
                        'loss'.
k_greater               Element-wise truth value of (x > y).
k_greater_equal         Element-wise truth value of (x >= y).
k_hard_sigmoid          Segment-wise linear approximation of sigmoid.
k_identity              Returns a tensor with the same content as the
                        input tensor.
k_image_data_format     Default image data format convention
                        ('channels_first' or 'channels_last').
k_in_test_phase         Selects 'x' in test phase, and 'alt' otherwise.
k_in_top_k              Returns whether the 'targets' are in the top
                        'k' 'predictions'.
k_in_train_phase        Selects 'x' in train phase, and 'alt'
                        otherwise.
k_int_shape             Returns the shape of tensor or variable as a
                        list of int or NULL entries.
k_is_keras_tensor       Returns whether 'x' is a Keras tensor.
k_is_placeholder        Returns whether 'x' is a placeholder.
k_is_sparse             Returns whether a tensor is a sparse tensor.
k_is_tensor             Returns whether 'x' is a symbolic tensor.
k_l2_normalize          Normalizes a tensor wrt the L2 norm alongside
                        the specified axis.
k_learning_phase        Returns the learning phase flag.
k_less                  Element-wise truth value of (x < y).
k_less_equal            Element-wise truth value of (x <= y).
k_local_conv1d          Apply 1D conv with un-shared weights.
k_local_conv2d          Apply 2D conv with un-shared weights.
k_log                   Element-wise log.
k_logsumexp             Computes log(sum(exp(elements across dimensions
                        of a tensor))).
k_manual_variable_initialization
                        Sets the manual variable initialization flag.
k_map_fn                Map the function fn over the elements elems and
                        return the outputs.
k_max                   Maximum value in a tensor.
k_maximum               Element-wise maximum of two tensors.
k_mean                  Mean of a tensor, alongside the specified axis.
k_min                   Minimum value in a tensor.
k_minimum               Element-wise minimum of two tensors.
k_moving_average_update
                        Compute the moving average of a variable.
k_ndim                  Returns the number of axes in a tensor, as an
                        integer.
k_normalize_batch_in_training
                        Computes mean and std for batch then apply
                        batch_normalization on batch.
k_not_equal             Element-wise inequality between two tensors.
k_one_hot               Computes the one-hot representation of an
                        integer tensor.
k_ones                  Instantiates an all-ones tensor variable and
                        returns it.
k_ones_like             Instantiates an all-ones variable of the same
                        shape as another tensor.
k_permute_dimensions    Permutes axes in a tensor.
k_placeholder           Instantiates a placeholder tensor and returns
                        it.
k_pool2d                2D Pooling.
k_pool3d                3D Pooling.
k_pow                   Element-wise exponentiation.
k_print_tensor          Prints 'message' and the tensor value when
                        evaluated.
k_prod                  Multiplies the values in a tensor, alongside
                        the specified axis.
k_random_binomial       Returns a tensor with random binomial
                        distribution of values.
k_random_normal         Returns a tensor with normal distribution of
                        values.
k_random_normal_variable
                        Instantiates a variable with values drawn from
                        a normal distribution.
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.
k_relu                  Rectified linear unit.
k_repeat                Repeats a 2D tensor.
k_repeat_elements       Repeats the elements of a tensor along an axis.
k_reset_uids            Reset graph identifiers.
k_reshape               Reshapes a tensor to the specified shape.
k_resize_images         Resizes the images contained in a 4D tensor.
k_resize_volumes        Resizes the volume contained in a 5D tensor.
k_reverse               Reverse a tensor along the specified axes.
k_rnn                   Iterates over the time dimension of a tensor
k_round                 Element-wise rounding to the closest integer.
k_separable_conv2d      2D convolution with separable filters.
k_set_learning_phase    Sets the learning phase to a fixed value.
k_set_value             Sets the value of a variable, from an R array.
k_shape                 Returns the symbolic shape of a tensor or
                        variable.
k_sigmoid               Element-wise sigmoid.
k_sign                  Element-wise sign.
k_sin                   Computes sin of x element-wise.
k_softmax               Softmax of a tensor.
k_softplus              Softplus of a tensor.
k_softsign              Softsign of a tensor.
k_sparse_categorical_crossentropy
                        Categorical crossentropy with integer targets.
k_spatial_2d_padding    Pads the 2nd and 3rd dimensions of a 4D tensor.
k_spatial_3d_padding    Pads 5D tensor with zeros along the depth,
                        height, width dimensions.
k_sqrt                  Element-wise square root.
k_square                Element-wise square.
k_squeeze               Removes a 1-dimension from the tensor at index
                        'axis'.
k_stack                 Stacks a list of rank 'R' tensors into a rank
                        'R+1' tensor.
k_std                   Standard deviation of a tensor, alongside the
                        specified axis.
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_switch                Switches between two operations depending on a
                        scalar value.
k_tanh                  Element-wise tanh.
k_temporal_padding      Pads the middle dimension of a 3D tensor.
k_tile                  Creates a tensor by tiling 'x' by 'n'.
k_to_dense              Converts a sparse tensor into a dense tensor
                        and returns it.
k_transpose             Transposes a tensor and returns it.
k_truncated_normal      Returns a tensor with truncated random normal
                        distribution of values.
k_update                Update the value of 'x' to 'new_x'.
k_update_add            Update the value of 'x' by adding 'increment'.
k_update_sub            Update the value of 'x' by subtracting
                        'decrement'.
k_var                   Variance of a tensor, alongside the specified
                        axis.
k_variable              Instantiates a variable and returns it.
k_zeros                 Instantiates an all-zeros variable and returns
                        it.
k_zeros_like            Instantiates an all-zeros variable of the same
                        shape as another tensor.
keras-package           R interface to Keras
keras_array             Keras array object
keras_model             Keras Model
keras_model_custom      Create a Keras custom model
keras_model_sequential
                        Keras Model composed of a linear stack of
                        layers
layer_activation        Apply an activation function to an output.
layer_activation_elu    Exponential Linear Unit.
layer_activation_leaky_relu
                        Leaky version of a Rectified Linear Unit.
layer_activation_parametric_relu
                        Parametric Rectified Linear Unit.
layer_activation_relu   Rectified Linear Unit activation function
layer_activation_selu   Scaled Exponential Linear Unit.
layer_activation_softmax
                        Softmax activation function.
layer_activation_thresholded_relu
                        Thresholded Rectified Linear Unit.
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_alpha_dropout     Applies Alpha Dropout to the input.
layer_average           Layer that averages a list of inputs.
layer_average_pooling_1d
                        Average pooling for temporal data.
layer_average_pooling_2d
                        Average pooling operation for spatial data.
layer_average_pooling_3d
                        Average pooling operation for 3D data (spatial
                        or spatio-temporal).
layer_batch_normalization
                        Batch normalization layer (Ioffe and Szegedy,
                        2014).
layer_concatenate       Layer that concatenates a list of inputs.
layer_conv_1d           1D convolution layer (e.g. temporal
                        convolution).
layer_conv_2d           2D convolution layer (e.g. spatial convolution
                        over images).
layer_conv_2d_transpose
                        Transposed 2D convolution layer (sometimes
                        called Deconvolution).
layer_conv_3d           3D convolution layer (e.g. spatial convolution
                        over volumes).
layer_conv_3d_transpose
                        Transposed 3D convolution layer (sometimes
                        called Deconvolution).
layer_conv_lstm_2d      Convolutional LSTM.
layer_cropping_1d       Cropping layer for 1D input (e.g. temporal
                        sequence).
layer_cropping_2d       Cropping layer for 2D input (e.g. picture).
layer_cropping_3d       Cropping layer for 3D data (e.g. spatial or
                        spatio-temporal).
layer_cudnn_gru         Fast GRU implementation backed by CuDNN.
layer_cudnn_lstm        Fast LSTM implementation backed by CuDNN.
layer_dense             Add a densely-connected NN layer to an output
layer_depthwise_conv_2d
                        Depthwise separable 2D convolution.
layer_dot               Layer that computes a dot product between
                        samples in two tensors.
layer_dropout           Applies Dropout to the input.
layer_embedding         Turns positive integers (indexes) into dense
                        vectors of fixed size.
layer_flatten           Flattens an input
layer_gaussian_dropout
                        Apply multiplicative 1-centered Gaussian noise.
layer_gaussian_noise    Apply additive zero-centered Gaussian noise.
layer_global_average_pooling_1d
                        Global average pooling operation for temporal
                        data.
layer_global_average_pooling_2d
                        Global average pooling operation for spatial
                        data.
layer_global_average_pooling_3d
                        Global Average pooling operation for 3D data.
layer_global_max_pooling_1d
                        Global max pooling operation for temporal data.
layer_global_max_pooling_2d
                        Global max pooling operation for spatial data.
layer_global_max_pooling_3d
                        Global Max pooling operation for 3D data.
layer_gru               Gated Recurrent Unit - Cho et al.
layer_input             Input layer
layer_lambda            Wraps arbitrary expression as a layer
layer_locally_connected_1d
                        Locally-connected layer for 1D inputs.
layer_locally_connected_2d
                        Locally-connected layer for 2D inputs.
layer_lstm              Long Short-Term Memory unit - Hochreiter 1997.
layer_masking           Masks a sequence by using a mask value to skip
                        timesteps.
layer_max_pooling_1d    Max pooling operation for temporal data.
layer_max_pooling_2d    Max pooling operation for spatial data.
layer_max_pooling_3d    Max pooling operation for 3D data (spatial or
                        spatio-temporal).
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_multiply          Layer that multiplies (element-wise) a list of
                        inputs.
layer_permute           Permute the dimensions of an input according to
                        a given pattern
layer_repeat_vector     Repeats the input n times.
layer_reshape           Reshapes an output to a certain shape.
layer_separable_conv_1d
                        Depthwise separable 1D convolution.
layer_separable_conv_2d
                        Separable 2D convolution.
layer_simple_rnn        Fully-connected RNN where the output is to be
                        fed back to input.
layer_spatial_dropout_1d
                        Spatial 1D version of Dropout.
layer_spatial_dropout_2d
                        Spatial 2D version of Dropout.
layer_spatial_dropout_3d
                        Spatial 3D version of Dropout.
layer_subtract          Layer that subtracts two inputs.
layer_upsampling_1d     Upsampling layer for 1D inputs.
layer_upsampling_2d     Upsampling layer for 2D inputs.
layer_upsampling_3d     Upsampling layer for 3D inputs.
layer_zero_padding_1d   Zero-padding layer for 1D input (e.g. temporal
                        sequence).
layer_zero_padding_2d   Zero-padding layer for 2D input (e.g. picture).
layer_zero_padding_3d   Zero-padding layer for 3D data (spatial or
                        spatio-temporal).
loss_mean_squared_error
                        Model loss functions
make_sampling_table     Generates a word rank-based probabilistic
                        sampling table.
metric_binary_accuracy
                        Model performance metrics
model_to_json           Model configuration as JSON
model_to_yaml           Model configuration as YAML
multi_gpu_model         Replicates a model on different GPUs.
normalize               Normalize a matrix or nd-array
optimizer_adadelta      Adadelta optimizer.
optimizer_adagrad       Adagrad optimizer.
optimizer_adam          Adam optimizer
optimizer_adamax        Adamax optimizer
optimizer_nadam         Nesterov Adam optimizer
optimizer_rmsprop       RMSProp optimizer
optimizer_sgd           Stochastic gradient descent optimizer
pad_sequences           Pads sequences to the same length
plot.keras_training_history
                        Plot training history
pop_layer               Remove the last layer in a model
predict.keras.engine.training.Model
                        Generate predictions from a Keras model
predict_generator       Generates predictions for the input samples
                        from a data generator.
predict_on_batch        Returns predictions for a single batch of
                        samples.
predict_proba           Generates probability or class probability
                        predictions for the input samples.
regularizer_l1          L1 and L2 regularization
reset_states            Reset the states for a layer
save_model_hdf5         Save/Load models using HDF5 files
save_model_weights_hdf5
                        Save/Load model weights using HDF5 files
save_text_tokenizer     Save a text tokenizer to an external file
sequences_to_matrix     Convert a list of sequences into a matrix.
serialize_model         Serialize a model to an R object
skipgrams               Generates skipgram word pairs.
summary.keras.engine.training.Model
                        Print a summary of a Keras model
text_hashing_trick      Converts a text to a sequence of indexes in a
                        fixed-size hashing space.
text_one_hot            One-hot encode a text into a list of word
                        indexes in a vocabulary of size n.
text_to_word_sequence   Convert text to a sequence of words (or
                        tokens).
text_tokenizer          Text tokenization utility
texts_to_matrix         Convert a list of texts to a matrix.
texts_to_sequences      Transform each text in texts in a sequence of
                        integers.
texts_to_sequences_generator
                        Transforms each text in texts in a sequence of
                        integers.
time_distributed        Apply a layer to every temporal slice of an
                        input.
timeseries_generator    Utility function for generating batches of
                        temporal data.
to_categorical          Converts a class vector (integers) to binary
                        class matrix.
train_on_batch          Single gradient update or model evaluation over
                        one batch of samples.
use_implementation      Select a Keras implementation and backend
with_custom_object_scope
                        Provide a scope with mappings of names to
                        custom objects
