| R interface to Keras | keras-package |
| Make an Active Binding | %<-active% |
| Make a python class constructor | %py_class% py_class |
| Activation functions | activation_elu activation_exponential activation_gelu activation_hard_sigmoid activation_linear activation_relu activation_selu activation_sigmoid activation_softmax activation_softplus activation_softsign activation_swish activation_tanh |
| Fits the state of the preprocessing layer to the data being passed | adapt |
| Instantiates the DenseNet architecture. | application_densenet application_densenet121 application_densenet169 application_densenet201 densenet_preprocess_input |
| Instantiates the EfficientNetB0 architecture | application_efficientnet application_efficientnet_b0 application_efficientnet_b1 application_efficientnet_b2 application_efficientnet_b3 application_efficientnet_b4 application_efficientnet_b5 application_efficientnet_b6 application_efficientnet_b7 |
| Inception-ResNet v2 model, with weights trained on ImageNet | application_inception_resnet_v2 inception_resnet_v2_preprocess_input |
| Inception V3 model, with weights pre-trained on ImageNet. | application_inception_v3 inception_v3_preprocess_input |
| MobileNet model architecture. | application_mobilenet mobilenet_decode_predictions mobilenet_load_model_hdf5 mobilenet_preprocess_input |
| MobileNetV2 model architecture | application_mobilenet_v2 mobilenet_v2_decode_predictions mobilenet_v2_load_model_hdf5 mobilenet_v2_preprocess_input |
| Instantiates the MobileNetV3Large architecture | application_mobilenet_v3 application_mobilenet_v3_large application_mobilenet_v3_small |
| Instantiates a NASNet model. | application_nasnet application_nasnetlarge application_nasnetmobile nasnet_preprocess_input |
| Instantiates the ResNet architecture | application_resnet application_resnet101 application_resnet101_v2 application_resnet152 application_resnet152_v2 application_resnet50 application_resnet50_v2 resnet_preprocess_input resnet_v2_preprocess_input |
| VGG16 and VGG19 models for Keras. | application_vgg application_vgg16 application_vgg19 |
| Instantiates the Xception architecture | application_xception xception_preprocess_input |
| Keras backend tensor engine | backend |
| Bidirectional wrapper for RNNs | bidirectional |
| Callback to back up and restore the training state | callback_backup_and_restore |
| Callback that streams epoch results to a csv file | callback_csv_logger |
| Stop training when a monitored quantity has stopped improving. | callback_early_stopping |
| Create a custom callback | callback_lambda |
| Learning rate scheduler. | callback_learning_rate_scheduler |
| Save the model after every epoch. | callback_model_checkpoint |
| Callback that prints metrics to stdout. | callback_progbar_logger |
| Reduce learning rate when a metric has stopped improving. | callback_reduce_lr_on_plateau |
| Callback used to stream events to a server. | callback_remote_monitor |
| TensorBoard basic visualizations | callback_tensorboard |
| Callback that terminates training when a NaN loss is encountered. | callback_terminate_on_naan |
| Clone a model instance. | clone_model |
| Configure a Keras model for training | compile.keras.engine.training.Model |
| Weight constraints | constraints constraint_maxnorm constraint_minmaxnorm constraint_nonneg constraint_unitnorm |
| Count the total number of scalars composing the weights. | count_params |
| Create a Keras Layer | create_layer |
| Create a Keras Layer wrapper | create_layer_wrapper |
| Custom metric function | custom_metric |
| Boston housing price regression dataset | dataset_boston_housing |
| CIFAR10 small image classification | dataset_cifar10 |
| CIFAR100 small image classification | dataset_cifar100 |
| Fashion-MNIST database of fashion articles | dataset_fashion_mnist |
| IMDB Movie reviews sentiment classification | dataset_imdb dataset_imdb_word_index |
| MNIST database of handwritten digits | dataset_mnist |
| Reuters newswire topics classification | dataset_reuters dataset_reuters_word_index |
| Evaluate a Keras model | evaluate.keras.engine.training.Model |
| Export a Saved Model | export_savedmodel.keras.engine.training.Model |
| Fit image data generator internal statistics to some sample data. | fit_image_data_generator |
| Update tokenizer internal vocabulary based on a list of texts or list of sequences. | fit_text_tokenizer |
| Train a Keras model | fit.keras.engine.training.Model |
| Generates batches of augmented/normalized data from image data and labels | flow_images_from_data |
| Takes the dataframe and the path to a directory and generates batches of augmented/normalized data. | flow_images_from_dataframe |
| Generates batches of data from images in a directory (with optional augmented/normalized data) | flow_images_from_directory |
| Freeze and unfreeze weights | freeze_weights unfreeze_weights |
| Retrieve the next item from a generator | generator_next |
| Layer/Model configuration | from_config get_config |
| Downloads a file from a URL if it not already in the cache. | get_file |
| Retrieve tensors for layers with multiple nodes | get_input_at get_input_mask_at get_input_shape_at get_output_at get_output_mask_at get_output_shape_at |
| Retrieves a layer based on either its name (unique) or index. | get_layer |
| Layer/Model weights as R arrays | get_weights set_weights |
| Representation of HDF5 dataset to be used instead of an R array | hdf5_matrix |
| Deprecated Generate batches of image data with real-time data augmentation. The data will be looped over (in batches). | image_data_generator |
| Create a dataset from a directory | image_dataset_from_directory |
| Loads an image into PIL format. | image_load |
| 3D array representation of images | image_array_resize image_array_save image_to_array |
| Decodes the prediction of an ImageNet model. | imagenet_decode_predictions |
| Preprocesses a tensor or array encoding a batch of images. | imagenet_preprocess_input |
| Keras implementation | implementation |
| Initializer that generates tensors initialized to a constant value. | initializer_constant |
| Glorot normal initializer, also called Xavier normal initializer. | initializer_glorot_normal |
| Glorot uniform initializer, also called Xavier uniform initializer. | initializer_glorot_uniform |
| He normal initializer. | initializer_he_normal |
| He uniform variance scaling initializer. | initializer_he_uniform |
| Initializer that generates the identity matrix. | initializer_identity |
| LeCun normal initializer. | initializer_lecun_normal |
| LeCun uniform initializer. | initializer_lecun_uniform |
| Initializer that generates tensors initialized to 1. | initializer_ones |
| Initializer that generates a random orthogonal matrix. | initializer_orthogonal |
| Initializer that generates tensors with a normal distribution. | initializer_random_normal |
| Initializer that generates tensors with a uniform distribution. | initializer_random_uniform |
| Initializer that generates a truncated normal distribution. | initializer_truncated_normal |
| Initializer capable of adapting its scale to the shape of weights. | initializer_variance_scaling |
| Initializer that generates tensors initialized to 0. | initializer_zeros |
| Install TensorFlow and Keras, including all Python dependencies | install_keras |
| Check if Keras is Available | is_keras_available |
| Element-wise absolute value. | k_abs |
| Bitwise reduction (logical AND). | k_all |
| Bitwise reduction (logical OR). | k_any |
| Creates a 1D tensor containing a sequence of integers. | k_arange |
| Returns the index of the maximum value along an axis. | k_argmax |
| Returns the index of the minimum value along an axis. | k_argmin |
| Active Keras backend | k_backend |
| Batchwise dot product. | k_batch_dot |
| Turn a nD tensor into a 2D tensor with same 1st dimension. | k_batch_flatten |
| Returns the value of more than one tensor variable. | k_batch_get_value |
| Applies batch normalization on x given mean, var, beta and gamma. | k_batch_normalization |
| Sets the values of many tensor variables at once. | k_batch_set_value |
| Adds a bias vector to a tensor. | k_bias_add |
| Binary crossentropy between an output tensor and a target tensor. | k_binary_crossentropy |
| Casts a tensor to a different dtype and returns it. | k_cast |
| Cast an array to the default Keras float type. | k_cast_to_floatx |
| Categorical crossentropy between an output tensor and a target tensor. | k_categorical_crossentropy |
| Destroys the current TF graph and creates a new one. | k_clear_session |
| Element-wise value clipping. | k_clip |
| Concatenates a list of tensors alongside the specified axis. | k_concatenate |
| Creates a constant tensor. | k_constant |
| 1D convolution. | k_conv1d |
| 2D convolution. | k_conv2d |
| 2D deconvolution (i.e. transposed convolution). | k_conv2d_transpose |
| 3D convolution. | k_conv3d |
| 3D deconvolution (i.e. transposed convolution). | k_conv3d_transpose |
| Computes cos of x element-wise. | k_cos |
| Returns the static number of elements in a Keras variable or tensor. | k_count_params |
| Runs CTC loss algorithm on each batch element. | k_ctc_batch_cost |
| Decodes the output of a softmax. | k_ctc_decode |
| Converts CTC labels from dense to sparse. | k_ctc_label_dense_to_sparse |
| Cumulative product of the values in a tensor, alongside the specified axis. | k_cumprod |
| Cumulative sum of the values in a tensor, alongside the specified axis. | k_cumsum |
| Depthwise 2D convolution with separable filters. | k_depthwise_conv2d |
| Multiplies 2 tensors (and/or variables) and returns a _tensor_. | k_dot |
| Sets entries in 'x' to zero at random, while scaling the entire tensor. | k_dropout |
| Returns the dtype of a Keras tensor or variable, as a string. | k_dtype |
| Exponential linear unit. | k_elu |
| Fuzz factor used in numeric expressions. | k_epsilon k_set_epsilon |
| Element-wise equality between two tensors. | k_equal |
| Evaluates the value of a variable. | k_eval |
| Element-wise exponential. | k_exp |
| Adds a 1-sized dimension at index 'axis'. | k_expand_dims |
| Instantiate an identity matrix and returns it. | k_eye |
| Flatten a tensor. | k_flatten |
| Default float type | k_floatx k_set_floatx |
| Reduce elems using fn to combine them from left to right. | k_foldl |
| Reduce elems using fn to combine them from right to left. | k_foldr |
| Instantiates a Keras function | k_function |
| Retrieves the elements of indices 'indices' in the tensor 'reference'. | k_gather |
| TF session to be used by the backend. | k_get_session k_set_session |
| Get the uid for the default graph. | k_get_uid |
| Returns the value of a variable. | k_get_value |
| Returns the shape of a variable. | k_get_variable_shape |
| Returns the gradients of 'variables' w.r.t. 'loss'. | k_gradients |
| Element-wise truth value of (x > y). | k_greater |
| Element-wise truth value of (x >= y). | k_greater_equal |
| Segment-wise linear approximation of sigmoid. | k_hard_sigmoid |
| Returns a tensor with the same content as the input tensor. | k_identity |
| Default image data format convention ('channels_first' or 'channels_last'). | k_image_data_format k_set_image_data_format |
| Selects 'x' in test phase, and 'alt' otherwise. | k_in_test_phase |
| Returns whether the 'targets' are in the top 'k' 'predictions'. | k_in_top_k |
| Selects 'x' in train phase, and 'alt' otherwise. | k_in_train_phase |
| Returns the shape of tensor or variable as a list of int or NULL entries. | k_int_shape |
| Returns whether 'x' is a Keras tensor. | k_is_keras_tensor |
| Returns whether 'x' is a placeholder. | k_is_placeholder |
| Returns whether a tensor is a sparse tensor. | k_is_sparse |
| Returns whether 'x' is a symbolic tensor. | k_is_tensor |
| Normalizes a tensor wrt the L2 norm alongside the specified axis. | k_l2_normalize |
| Returns the learning phase flag. | k_learning_phase |
| Element-wise truth value of (x < y). | k_less |
| Element-wise truth value of (x <= y). | k_less_equal |
| Apply 1D conv with un-shared weights. | k_local_conv1d |
| Apply 2D conv with un-shared weights. | k_local_conv2d |
| Element-wise log. | k_log |
| Sets the manual variable initialization flag. | k_manual_variable_initialization |
| Map the function fn over the elements elems and return the outputs. | k_map_fn |
| Maximum value in a tensor. | k_max |
| Element-wise maximum of two tensors. | k_maximum |
| Mean of a tensor, alongside the specified axis. | k_mean |
| Minimum value in a tensor. | k_min |
| Element-wise minimum of two tensors. | k_minimum |
| Compute the moving average of a variable. | k_moving_average_update |
| Returns the number of axes in a tensor, as an integer. | k_ndim |
| Computes mean and std for batch then apply batch_normalization on batch. | k_normalize_batch_in_training |
| Element-wise inequality between two tensors. | k_not_equal |
| Computes the one-hot representation of an integer tensor. | k_one_hot |
| Instantiates an all-ones tensor variable and returns it. | k_ones |
| Instantiates an all-ones variable of the same shape as another tensor. | k_ones_like |
| Permutes axes in a tensor. | k_permute_dimensions |
| Instantiates a placeholder tensor and returns it. | k_placeholder |
| 2D Pooling. | k_pool2d |
| 3D Pooling. | k_pool3d |
| Element-wise exponentiation. | k_pow |
| Prints 'message' and the tensor value when evaluated. | k_print_tensor |
| Multiplies the values in a tensor, alongside the specified axis. | k_prod |
| Returns a tensor with random binomial distribution of values. | k_random_bernoulli k_random_binomial |
| Returns a tensor with normal distribution of values. | k_random_normal |
| Instantiates a variable with values drawn from a normal distribution. | k_random_normal_variable |
| Returns a tensor with uniform distribution of values. | k_random_uniform |
| Instantiates a variable with values drawn from a uniform distribution. | k_random_uniform_variable |
| Rectified linear unit. | k_relu |
| Repeats a 2D tensor. | k_repeat |
| Repeats the elements of a tensor along an axis. | k_repeat_elements |
| Reset graph identifiers. | k_reset_uids |
| Reshapes a tensor to the specified shape. | k_reshape |
| Resizes the images contained in a 4D tensor. | k_resize_images |
| Resizes the volume contained in a 5D tensor. | k_resize_volumes |
| Reverse a tensor along the specified axes. | k_reverse |
| Iterates over the time dimension of a tensor | k_rnn |
| Element-wise rounding to the closest integer. | k_round |
| 2D convolution with separable filters. | k_separable_conv2d |
| Sets the learning phase to a fixed value. | k_set_learning_phase |
| Sets the value of a variable, from an R array. | k_set_value |
| Returns the symbolic shape of a tensor or variable. | k_shape |
| Element-wise sigmoid. | k_sigmoid |
| Element-wise sign. | k_sign |
| Computes sin of x element-wise. | k_sin |
| Softmax of a tensor. | k_softmax |
| Softplus of a tensor. | k_softplus |
| Softsign of a tensor. | k_softsign |
| Categorical crossentropy with integer targets. | k_sparse_categorical_crossentropy |
| Pads the 2nd and 3rd dimensions of a 4D tensor. | k_spatial_2d_padding |
| Pads 5D tensor with zeros along the depth, height, width dimensions. | k_spatial_3d_padding |
| Element-wise square root. | k_sqrt |
| Element-wise square. | k_square |
| Removes a 1-dimension from the tensor at index 'axis'. | k_squeeze |
| Stacks a list of rank 'R' tensors into a rank 'R+1' tensor. | k_stack |
| Standard deviation of a tensor, alongside the specified axis. | k_std |
| Returns 'variables' but with zero gradient w.r.t. every other variable. | k_stop_gradient |
| Sum of the values in a tensor, alongside the specified axis. | k_sum |
| Switches between two operations depending on a scalar value. | k_switch |
| Element-wise tanh. | k_tanh |
| Pads the middle dimension of a 3D tensor. | k_temporal_padding |
| Creates a tensor by tiling 'x' by 'n'. | k_tile |
| Converts a sparse tensor into a dense tensor and returns it. | k_to_dense |
| Transposes a tensor and returns it. | k_transpose |
| Returns a tensor with truncated random normal distribution of values. | k_truncated_normal |
| Unstack rank 'R' tensor into a list of rank 'R-1' tensors. | k_unstack |
| Update the value of 'x' to 'new_x'. | k_update |
| Update the value of 'x' by adding 'increment'. | k_update_add |
| Update the value of 'x' by subtracting 'decrement'. | k_update_sub |
| Variance of a tensor, alongside the specified axis. | k_var |
| Instantiates a variable and returns it. | k_variable |
| Instantiates an all-zeros variable and returns it. | k_zeros |
| Instantiates an all-zeros variable of the same shape as another tensor. | k_zeros_like |
| Main Keras module | keras |
| Keras array object | keras_array |
| Keras Model | keras_model |
| Keras Model composed of a linear stack of layers | keras_model_sequential |
| Apply an activation function to an output. | layer_activation |
| Exponential Linear Unit. | layer_activation_elu |
| Leaky version of a Rectified Linear Unit. | layer_activation_leaky_relu |
| Parametric Rectified Linear Unit. | layer_activation_parametric_relu |
| Rectified Linear Unit activation function | layer_activation_relu |
| Scaled Exponential Linear Unit. | layer_activation_selu |
| Softmax activation function. | layer_activation_softmax |
| Thresholded Rectified Linear Unit. | layer_activation_thresholded_relu |
| Layer that applies an update to the cost function based input activity. | layer_activity_regularization |
| Layer that adds a list of inputs. | layer_add |
| Additive attention layer, a.k.a. Bahdanau-style attention | layer_additive_attention |
| Applies Alpha Dropout to the input. | layer_alpha_dropout |
| Dot-product attention layer, a.k.a. Luong-style attention | layer_attention |
| Layer that averages a list of inputs. | layer_average |
| Average pooling for temporal data. | layer_average_pooling_1d |
| Average pooling operation for spatial data. | layer_average_pooling_2d |
| Average pooling operation for 3D data (spatial or spatio-temporal). | layer_average_pooling_3d |
| Layer that normalizes its inputs | layer_batch_normalization |
| A preprocessing layer which encodes integer features. | layer_category_encoding |
| Crop the central portion of the images to target height and width | layer_center_crop |
| Layer that concatenates a list of inputs. | layer_concatenate |
| 1D convolution layer (e.g. temporal convolution). | layer_conv_1d |
| Transposed 1D convolution layer (sometimes called Deconvolution). | layer_conv_1d_transpose |
| 2D convolution layer (e.g. spatial convolution over images). | layer_conv_2d |
| Transposed 2D convolution layer (sometimes called Deconvolution). | layer_conv_2d_transpose |
| 3D convolution layer (e.g. spatial convolution over volumes). | layer_conv_3d |
| Transposed 3D convolution layer (sometimes called Deconvolution). | layer_conv_3d_transpose |
| 1D Convolutional LSTM | layer_conv_lstm_1d |
| Convolutional LSTM. | layer_conv_lstm_2d |
| 3D Convolutional LSTM | layer_conv_lstm_3d |
| Cropping layer for 1D input (e.g. temporal sequence). | layer_cropping_1d |
| Cropping layer for 2D input (e.g. picture). | layer_cropping_2d |
| Cropping layer for 3D data (e.g. spatial or spatio-temporal). | layer_cropping_3d |
| Add a densely-connected NN layer to an output | layer_dense |
| Constructs a DenseFeatures. | layer_dense_features |
| Depthwise 1D convolution | layer_depthwise_conv_1d |
| Depthwise separable 2D convolution. | layer_depthwise_conv_2d |
| A preprocessing layer which buckets continuous features by ranges. | layer_discretization |
| Layer that computes a dot product between samples in two tensors. | layer_dot |
| Applies Dropout to the input. | layer_dropout |
| Turns positive integers (indexes) into dense vectors of fixed size | layer_embedding |
| Flattens an input | layer_flatten |
| Apply multiplicative 1-centered Gaussian noise. | layer_gaussian_dropout |
| Apply additive zero-centered Gaussian noise. | layer_gaussian_noise |
| Global average pooling operation for temporal data. | layer_global_average_pooling_1d |
| Global average pooling operation for spatial data. | layer_global_average_pooling_2d |
| Global Average pooling operation for 3D data. | layer_global_average_pooling_3d |
| Global max pooling operation for temporal data. | layer_global_max_pooling_1d |
| Global max pooling operation for spatial data. | layer_global_max_pooling_2d |
| Global Max pooling operation for 3D data. | layer_global_max_pooling_3d |
| Gated Recurrent Unit - Cho et al. | layer_gru |
| Cell class for the GRU layer | layer_gru_cell |
| A preprocessing layer which hashes and bins categorical features. | layer_hashing |
| Input layer | layer_input |
| A preprocessing layer which maps integer features to contiguous ranges. | layer_integer_lookup |
| Wraps arbitrary expression as a layer | layer_lambda |
| Layer normalization layer (Ba et al., 2016). | layer_layer_normalization |
| Locally-connected layer for 1D inputs. | layer_locally_connected_1d |
| Locally-connected layer for 2D inputs. | layer_locally_connected_2d |
| Long Short-Term Memory unit - Hochreiter 1997. | layer_lstm |
| Cell class for the LSTM layer | layer_lstm_cell |
| Masks a sequence by using a mask value to skip timesteps. | layer_masking |
| Max pooling operation for temporal data. | layer_max_pooling_1d |
| Max pooling operation for spatial data. | layer_max_pooling_2d |
| Max pooling operation for 3D data (spatial or spatio-temporal). | layer_max_pooling_3d |
| Layer that computes the maximum (element-wise) a list of inputs. | layer_maximum |
| Layer that computes the minimum (element-wise) a list of inputs. | layer_minimum |
| MultiHeadAttention layer | layer_multi_head_attention |
| Layer that multiplies (element-wise) a list of inputs. | layer_multiply |
| A preprocessing layer which normalizes continuous features. | layer_normalization |
| Permute the dimensions of an input according to a given pattern | layer_permute |
| A preprocessing layer which randomly adjusts brightness during training | layer_random_brightness |
| Adjust the contrast of an image or images by a random factor | layer_random_contrast |
| Randomly crop the images to target height and width | layer_random_crop |
| Randomly flip each image horizontally and vertically | layer_random_flip |
| Randomly vary the height of a batch of images during training | layer_random_height |
| Randomly rotate each image | layer_random_rotation |
| Randomly translate each image during training | layer_random_translation |
| Randomly vary the width of a batch of images during training | layer_random_width |
| A preprocessing layer which randomly zooms images during training. | layer_random_zoom |
| Repeats the input n times. | layer_repeat_vector |
| Multiply inputs by 'scale' and adds 'offset' | layer_rescaling |
| Reshapes an output to a certain shape. | layer_reshape |
| Image resizing layer | layer_resizing |
| Base class for recurrent layers | layer_rnn |
| Depthwise separable 1D convolution. | layer_separable_conv_1d |
| Separable 2D convolution. | layer_separable_conv_2d |
| Fully-connected RNN where the output is to be fed back to input. | layer_simple_rnn |
| Cell class for SimpleRNN | layer_simple_rnn_cell |
| Spatial 1D version of Dropout. | layer_spatial_dropout_1d |
| Spatial 2D version of Dropout. | layer_spatial_dropout_2d |
| Spatial 3D version of Dropout. | layer_spatial_dropout_3d |
| Wrapper allowing a stack of RNN cells to behave as a single cell | layer_stacked_rnn_cells |
| A preprocessing layer which maps string features to integer indices. | layer_string_lookup |
| Layer that subtracts two inputs. | layer_subtract |
| A preprocessing layer which maps text features to integer sequences. | get_vocabulary layer_text_vectorization set_vocabulary |
| Unit normalization layer | layer_unit_normalization |
| Upsampling layer for 1D inputs. | layer_upsampling_1d |
| Upsampling layer for 2D inputs. | layer_upsampling_2d |
| Upsampling layer for 3D inputs. | layer_upsampling_3d |
| Zero-padding layer for 1D input (e.g. temporal sequence). | layer_zero_padding_1d |
| Zero-padding layer for 2D input (e.g. picture). | layer_zero_padding_2d |
| Zero-padding layer for 3D data (spatial or spatio-temporal). | layer_zero_padding_3d |
| A LearningRateSchedule that uses a cosine decay schedule | learning_rate_schedule_cosine_decay |
| A LearningRateSchedule that uses a cosine decay schedule with restarts | learning_rate_schedule_cosine_decay_restarts |
| A LearningRateSchedule that uses an exponential decay schedule | learning_rate_schedule_exponential_decay |
| A LearningRateSchedule that uses an inverse time decay schedule | learning_rate_schedule_inverse_time_decay |
| A LearningRateSchedule that uses a piecewise constant decay schedule | learning_rate_schedule_piecewise_constant_decay |
| A LearningRateSchedule that uses a polynomial decay schedule | learning_rate_schedule_polynomial_decay |
| Loss functions | "BinaryCrossentropy" "binary_crossentropy", loss-functions loss_binary_crossentropy loss_categorical_crossentropy loss_categorical_hinge loss_cosine_similarity loss_hinge loss_huber loss_kl_divergence loss_kullback_leibler_divergence loss_logcosh loss_mean_absolute_error loss_mean_absolute_percentage_error loss_mean_squared_error loss_mean_squared_logarithmic_error loss_poisson loss_sparse_categorical_crossentropy loss_squared_hinge |
| Generates a word rank-based probabilistic sampling table. | make_sampling_table |
| Metric | Metric |
| Calculates how often predictions equal labels | metric_accuracy |
| Approximates the AUC (Area under the curve) of the ROC or PR curves | metric_auc |
| Calculates how often predictions match binary labels | metric_binary_accuracy |
| Computes the crossentropy metric between the labels and predictions | metric_binary_crossentropy |
| Calculates how often predictions match one-hot labels | metric_categorical_accuracy |
| Computes the crossentropy metric between the labels and predictions | metric_categorical_crossentropy |
| Computes the categorical hinge metric between 'y_true' and 'y_pred' | metric_categorical_hinge |
| Computes the cosine similarity between the labels and predictions | metric_cosine_similarity |
| Calculates the number of false negatives | metric_false_negatives |
| Calculates the number of false positives | metric_false_positives |
| Computes the hinge metric between 'y_true' and 'y_pred' | metric_hinge |
| Computes Kullback-Leibler divergence | metric_kullback_leibler_divergence |
| Computes the logarithm of the hyperbolic cosine of the prediction error | metric_logcosh_error |
| Computes the (weighted) mean of the given values | metric_mean |
| Computes the mean absolute error between the labels and predictions | metric_mean_absolute_error |
| Computes the mean absolute percentage error between 'y_true' and 'y_pred' | metric_mean_absolute_percentage_error |
| Computes the mean Intersection-Over-Union metric | metric_mean_iou |
| Computes the mean relative error by normalizing with the given values | metric_mean_relative_error |
| Computes the mean squared error between labels and predictions | metric_mean_squared_error |
| Computes the mean squared logarithmic error | metric_mean_squared_logarithmic_error |
| Computes the element-wise (weighted) mean of the given tensors | metric_mean_tensor |
| Wraps a stateless metric function with the Mean metric | metric_mean_wrapper |
| Computes the Poisson metric between 'y_true' and 'y_pred' | metric_poisson |
| Computes the precision of the predictions with respect to the labels | metric_precision |
| Computes best precision where recall is >= specified value | metric_precision_at_recall |
| Computes the recall of the predictions with respect to the labels | metric_recall |
| Computes best recall where precision is >= specified value | metric_recall_at_precision |
| Computes root mean squared error metric between 'y_true' and 'y_pred' | metric_root_mean_squared_error |
| Computes best sensitivity where specificity is >= specified value | metric_sensitivity_at_specificity |
| Calculates how often predictions match integer labels | metric_sparse_categorical_accuracy |
| Computes the crossentropy metric between the labels and predictions | metric_sparse_categorical_crossentropy |
| Computes how often integer targets are in the top 'K' predictions | metric_sparse_top_k_categorical_accuracy |
| Computes best specificity where sensitivity is >= specified value | metric_specificity_at_sensitivity |
| Computes the squared hinge metric | metric_squared_hinge |
| Computes the (weighted) sum of the given values | metric_sum |
| Computes how often targets are in the top 'K' predictions | metric_top_k_categorical_accuracy |
| Calculates the number of true negatives | metric_true_negatives |
| Calculates the number of true positives | metric_true_positives |
| Load a Keras model from the Saved Model format | model_from_saved_model |
| Model configuration as JSON | model_from_json model_to_json |
| Model configuration as YAML | model_from_yaml model_to_yaml |
| Create a new learning rate schedule type | new_learning_rate_schedule_class |
| Define new keras types | mark_active new_callback_class new_layer_class new_loss_class new_metric_class new_model_class |
| Normalize a matrix or nd-array | normalize |
| Optimizer that implements the Adadelta algorithm | optimizer_adadelta |
| Optimizer that implements the Adagrad algorithm | optimizer_adagrad |
| Optimizer that implements the Adam algorithm | optimizer_adam |
| Optimizer that implements the Adamax algorithm | optimizer_adamax |
| Optimizer that implements the FTRL algorithm | optimizer_ftrl |
| Optimizer that implements the Nadam algorithm | optimizer_nadam |
| Optimizer that implements the RMSprop algorithm | optimizer_rmsprop |
| Gradient descent (with momentum) optimizer | optimizer_sgd |
| Pads sequences to the same length | pad_sequences |
| Plot training history | plot.keras_training_history |
| Plot a Keras model | plot.keras.engine.training.Model |
| Remove the last layer in a model | pop_layer |
| Returns predictions for a single batch of samples. | predict_on_batch |
| Generate predictions from a Keras model | predict.keras.engine.training.Model |
| L1 and L2 regularization | regularizer_l1 regularizer_l1_l2 regularizer_l2 |
| A regularizer that encourages input vectors to be orthogonal to each other | regularizer_orthogonal |
| Reset the states for a layer | reset_states |
| Save/Load models using HDF5 files | load_model_hdf5 save_model_hdf5 |
| Save/Load models using SavedModel format | load_model_tf save_model_tf |
| Save/Load model weights using HDF5 files | load_model_weights_hdf5 save_model_weights_hdf5 |
| Save model weights in the SavedModel format | load_model_weights_tf save_model_weights_tf |
| Save a text tokenizer to an external file | load_text_tokenizer save_text_tokenizer |
| Convert a list of sequences into a matrix. | sequences_to_matrix |
| sequential_model_input_layer | sequential_model_input_layer |
| Serialize a model to an R object | serialize_model unserialize_model |
| Generates skipgram word pairs. | skipgrams |
| Print a summary of a Keras model | format.keras.engine.training.Model print.keras.engine.training.Model summary.keras.engine.training.Model |
| Generate a 'tf.data.Dataset' from text files in a directory | text_dataset_from_directory |
| Converts a text to a sequence of indexes in a fixed-size hashing space. | text_hashing_trick |
| One-hot encode a text into a list of word indexes in a vocabulary of size n. | text_one_hot |
| Convert text to a sequence of words (or tokens). | text_to_word_sequence |
| Text tokenization utility | text_tokenizer |
| Convert a list of texts to a matrix. | texts_to_matrix |
| Transform each text in texts in a sequence of integers. | texts_to_sequences |
| Transforms each text in texts in a sequence of integers. | texts_to_sequences_generator |
| This layer wrapper allows to apply a layer to every temporal slice of an input | time_distributed |
| Creates a dataset of sliding windows over a timeseries provided as array | timeseries_dataset_from_array |
| Utility function for generating batches of temporal data. | timeseries_generator |
| Converts a class vector (integers) to binary class matrix. | to_categorical |
| Single gradient update or model evaluation over one batch of samples. | test_on_batch train_on_batch |
| Select a Keras implementation and backend | use_backend use_implementation |
| Provide a scope with mappings of names to custom objects | with_custom_object_scope |
| zip lists | zip_lists |
