tools/family-maps.R

In rstudio/keras: R Interface to 'Keras'

r_name_to_family_map <-
  list(
    activation_elu = "activations",
    activation_exponential = "activations",
    activation_gelu = "activations",
    activation_hard_sigmoid = "activations",
    activation_leaky_relu = "activations",
    activation_linear = "activations",
    activation_log_softmax = "activations",
    activation_mish = "activations",
    activation_relu = "activations",
    activation_relu6 = "activations",
    activation_selu = "activations",
    activation_sigmoid = "activations",
    activation_silu = "activations",
    activation_softmax = "activations",
    activation_softplus = "activations",
    activation_softsign = "activations",
    activation_swish = "activations",
    activation_tanh = "activations",
    audio_dataset_from_directory = c("dataset utils", "utils"),
    backend = c("config backend", "backend"),
    backend_clear_session = "backend",
    backend_epsilon = c("config backend", "backend"),
    backend_floatx = c("config backend",
                       "backend"),
    backend_get_uid = c("utils", "backend"),
    backend_image_data_format = c("config backend",
                                  "backend"),
    backend_is_float_dtype = "backend",
    backend_is_int_dtype = "backend",
    backend_is_keras_tensor = "backend",
    backend_result_type = "backend",
    backend_set_epsilon = c("config backend", "backend"),
    backend_set_floatx = c("config backend",
                           "backend"),
    backend_set_image_data_format = c("config backend",
                                      "backend"),
    backend_standardize_dtype = "backend",
    bidirectional = c("rnn layers",
                      "layers"),
    callback = "callbacks",
    callback_backup_and_restore = "callbacks",
    callback_csv_logger = "callbacks",
    callback_early_stopping = "callbacks",
    callback_history = "callbacks",
    callback_lambda = "callbacks",
    callback_learning_rate_scheduler = "callbacks",
    callback_list = "callbacks",
    callback_model_checkpoint = "callbacks",
    callback_progbar_logger = "callbacks",
    callback_reduce_lr_on_plateau = "callbacks",
    callback_remote_monitor = "callbacks",
    callback_tensorboard = "callbacks",
    callback_terminate_on_nan = "callbacks",
    clear_session = c("backend", "utils"),
    config_backend = c("config backend",
                       "backend", "config"),
    config_disable_interactive_logging = c("io utils",
                                           "utils", "config"),
    config_disable_traceback_filtering = c("traceback utils",
                                           "utils", "config"),
    config_enable_interactive_logging = c("io utils",
                                          "utils", "config"),
    config_enable_traceback_filtering = c("traceback utils",
                                          "utils", "config"),
    config_enable_unsafe_deserialization = c("saving",
                                             "config"),
    config_epsilon = c("config backend", "backend",
                       "config"),
    config_floatx = c("config backend", "backend",
                      "config"),
    config_image_data_format = c("config backend",
                                 "backend", "config"),
    config_is_interactive_logging_enabled = c("io utils",
                                              "utils", "config"),
    config_is_traceback_filtering_enabled = c("traceback utils",
                                              "utils", "config"),
    config_set_epsilon = c("config backend",
                           "backend", "config"),
    config_set_floatx = c("config backend",
                          "backend", "config"),
    config_set_image_data_format = c("config backend",
                                     "backend", "config"),
    constraint = "constraints",
    constraint_maxnorm = "constraints",
    constraint_minmaxnorm = "constraints",
    constraint_nonneg = "constraints",
    constraint_unitnorm = "constraints",
    custom_object_scope = c("object registration saving",
                            "saving", "utils"),
    deserialize_keras_object = c("saving",
                                 "utils"),
    disable_interactive_logging = c("io utils", "utils"),
    enable_interactive_logging = c("io utils", "utils"),
    `function` = "ops",
    get_custom_objects = c("object registration saving", "saving",
                           "utils"),
    get_file = "utils",
    get_registered_name = c("object registration saving",
                            "saving", "utils"),
    get_registered_object = c("object registration saving",
                              "saving", "utils"),
    get_source_inputs = "utils",
    image_array_save = c("image utils",
                         "utils"),
    image_array_to_img = c("image utils", "utils",
                           "preprocessing"),
    image_dataset_from_directory = c("dataset utils",
                                     "image dataset utils", "utils", "preprocessing"),
    image_from_array = c("image utils",
                         "utils"),
    image_img_to_array = c("image utils", "utils",
                           "preprocessing"),
    image_load = c("image utils", "utils"),
    image_load_img = c("image utils", "utils", "preprocessing"),
    image_save_img = c("image utils", "utils", "preprocessing"),
    image_smart_resize = c("image utils", "utils", "preprocessing"),
    image_to_array = c("image utils", "utils"),
    initializer = "initializers",
    initializer_constant = c("constant initializers", "initializers"),
    initializer_glorot_normal = c("random initializers", "initializers"),
    initializer_glorot_uniform = c("random initializers",
                                   "initializers"),
    initializer_he_normal = c("random initializers",
                              "initializers"),
    initializer_he_uniform = c("random initializers",
                               "initializers"),
    initializer_identity = c("constant initializers",
                             "initializers"),
    initializer_lecun_normal = c("random initializers",
                                 "initializers"),
    initializer_lecun_uniform = c("random initializers",
                                  "initializers"),
    initializer_ones = c("constant initializers",
                         "initializers"),
    initializer_orthogonal = c("random initializers",
                               "initializers"),
    initializer_random_normal = c("random initializers",
                                  "initializers"),
    initializer_random_uniform = c("random initializers",
                                   "initializers"),
    initializer_truncated_normal = c("random initializers",
                                     "initializers"),
    initializer_variance_scaling = c("random initializers",
                                     "initializers"),
    initializer_zeros = c("constant initializers",
                          "initializers"),
    input = c("input core layers", "core layers",
              "layers"),
    input_spec = "layers",
    is_interactive_logging_enabled = c("io utils",
                                       "utils"),
    is_keras_tensor = c("backend", "utils"),
    k_abs = c("numpy ops",
              "ops"),
    k_absolute = c("numpy ops", "ops"),
    k_add = c("numpy ops",
              "ops"),
    k_all = c("numpy ops", "ops"),
    k_amax = c("numpy ops",
               "ops"),
    k_amin = c("numpy ops", "ops"),
    k_any = c("numpy ops",
              "ops"),
    k_append = c("numpy ops", "ops"),
    k_arange = c("numpy ops",
                 "ops"),
    k_arccos = c("numpy ops", "ops"),
    k_arccosh = c("numpy ops",
                  "ops"),
    k_arcsin = c("numpy ops", "ops"),
    k_arcsinh = c("numpy ops",
                  "ops"),
    k_arctan = c("numpy ops", "ops"),
    k_arctan2 = c("numpy ops",
                  "ops"),
    k_arctanh = c("numpy ops", "ops"),
    k_argmax = c("numpy ops",
                 "ops"),
    k_argmin = c("numpy ops", "ops"),
    k_argsort = c("numpy ops",
                  "ops"),
    k_array = c("numpy ops", "ops"),
    k_average = c("numpy ops",
                  "ops"),
    k_average_pool = c("nn ops", "ops"),
    k_binary_crossentropy = c("nn ops",
                              "ops"),
    k_bincount = c("numpy ops", "ops"),
    k_broadcast_to = c("numpy ops",
                       "ops"),
    k_cast = c("core ops", "ops"),
    k_categorical_crossentropy = c("nn ops",
                                   "ops"),
    k_ceil = c("numpy ops", "ops"),
    k_clip = c("numpy ops",
               "ops"),
    k_concatenate = c("numpy ops", "ops"),
    k_cond = c("core ops",
               "ops"),
    k_conj = c("numpy ops", "ops"),
    k_conjugate = c("numpy ops",
                    "ops"),
    k_conv = c("nn ops", "ops"),
    k_conv_transpose = c("nn ops",
                         "ops"),
    k_convert_to_numpy = c("core ops", "ops"),
    k_convert_to_tensor = c("core ops",
                            "ops"),
    k_copy = c("numpy ops", "ops"),
    k_cos = c("numpy ops",
              "ops"),
    k_cosh = c("numpy ops", "ops"),
    k_count_nonzero = c("numpy ops",
                        "ops"),
    k_cross = c("numpy ops", "ops"),
    k_cumprod = c("numpy ops",
                  "ops"),
    k_cumsum = c("numpy ops", "ops"),
    k_depthwise_conv = c("nn ops",
                         "ops"),
    k_diag = c("numpy ops", "ops"),
    k_diagonal = c("numpy ops",
                   "ops"),
    k_diff = c("numpy ops", "ops"),
    k_digitize = c("numpy ops",
                   "ops"),
    k_divide = c("numpy ops", "ops"),
    k_dot = c("numpy ops",
              "ops"),
    k_einsum = c("numpy ops", "ops"),
    k_elu = c("nn ops",
              "ops"),
    k_empty = c("numpy ops", "ops"),
    k_equal = c("numpy ops",
                "ops"),
    k_erf = c("math ops", "ops"),
    k_exp = c("numpy ops",
              "ops"),
    k_expand_dims = c("numpy ops", "ops"),
    k_expm1 = c("numpy ops",
                "ops"),
    k_extract_sequences = c("math ops", "ops"),
    k_eye = c("numpy ops",
              "ops"),
    k_fft = c("math ops", "ops"),
    k_fft2 = c("math ops",
               "ops"),
    k_flip = c("numpy ops", "ops"),
    k_floor = c("numpy ops",
                "ops"),
    k_floor_divide = c("numpy ops", "ops"),
    k_fori_loop = c("core ops",
                    "ops"),
    k_full = c("numpy ops", "ops"),
    k_full_like = c("numpy ops",
                    "ops"),
    k_gelu = c("nn ops", "ops"),
    k_get_item = c("numpy ops",
                   "ops"),
    k_greater = c("numpy ops", "ops"),
    k_greater_equal = c("numpy ops",
                        "ops"),
    k_hard_sigmoid = c("nn ops", "ops"),
    k_hstack = c("numpy ops",
                 "ops"),
    k_identity = c("numpy ops", "ops"),
    k_imag = c("numpy ops",
               "ops"),
    k_image_affine_transform = c("image ops", "image utils",
                                 "ops"),
    k_image_extract_patches = c("image ops", "image utils",
                                "ops"),
    k_image_map_coordinates = c("image ops", "image utils",
                                "ops"),
    k_image_pad_images = c("image ops", "image utils",
                           "ops"),
    k_image_resize = c("image ops", "image utils", "ops"),
    k_in_top_k = c("math ops", "ops"),
    k_irfft = c("math ops",
                "ops"),
    k_is_tensor = c("core ops", "ops"),
    k_isclose = c("numpy ops",
                  "ops"),
    k_isfinite = c("numpy ops", "ops"),
    k_isinf = c("numpy ops",
                "ops"),
    k_isnan = c("numpy ops", "ops"),
    k_istft = c("math ops",
                "ops"),
    k_leaky_relu = c("nn ops", "ops"),
    k_less = c("numpy ops",
               "ops"),
    k_less_equal = c("numpy ops", "ops"),
    k_linspace = c("numpy ops",
                   "ops"),
    k_log = c("numpy ops", "ops"),
    k_log_sigmoid = c("nn ops",
                      "ops"),
    k_log_softmax = c("nn ops", "ops"),
    k_log10 = c("numpy ops",
                "ops"),
    k_log1p = c("numpy ops", "ops"),
    k_log2 = c("numpy ops",
               "ops"),
    k_logaddexp = c("numpy ops", "ops"),
    k_logical_and = c("numpy ops",
                      "ops"),
    k_logical_not = c("numpy ops", "ops"),
    k_logical_or = c("numpy ops",
                     "ops"),
    k_logical_xor = c("numpy ops", "ops"),
    k_logspace = c("numpy ops",
                   "ops"),
    k_logsumexp = c("math ops", "ops"),
    k_matmul = c("numpy ops",
                 "ops"),
    k_max = c("numpy ops", "ops"),
    k_max_pool = c("nn ops",
                   "ops"),
    k_maximum = c("numpy ops", "ops"),
    k_mean = c("numpy ops",
               "ops"),
    k_median = c("numpy ops", "ops"),
    k_meshgrid = c("numpy ops",
                   "ops"),
    k_min = c("numpy ops", "ops"),
    k_minimum = c("numpy ops",
                  "ops"),
    k_mod = c("numpy ops", "ops"),
    k_moments = c("nn ops",
                  "ops"),
    k_moveaxis = c("numpy ops", "ops"),
    k_multi_hot = c("nn ops",
                    "ops"),
    k_multiply = c("numpy ops", "ops"),
    k_nan_to_num = c("numpy ops",
                     "ops"),
    k_ndim = c("numpy ops", "ops"),
    k_negative = c("numpy ops",
                   "ops"),
    k_nn_average_pool = c("nn ops", "ops"),
    k_nn_binary_crossentropy = c("nn ops",
                                 "ops"),
    k_nn_categorical_crossentropy = c("nn ops", "ops"),
    k_nn_conv = c("nn ops", "ops"),
    k_nn_conv_transpose = c("nn ops",
                            "ops"),
    k_nn_depthwise_conv = c("nn ops", "ops"),
    k_nn_elu = c("nn ops",
                 "ops"),
    k_nn_gelu = c("nn ops", "ops"),
    k_nn_hard_sigmoid = c("nn ops",
                          "ops"),
    k_nn_leaky_relu = c("nn ops", "ops"),
    k_nn_log_sigmoid = c("nn ops",
                         "ops"),
    k_nn_log_softmax = c("nn ops", "ops"),
    k_nn_max_pool = c("nn ops",
                      "ops"),
    k_nn_moments = c("nn ops", "ops"),
    k_nn_multi_hot = c("nn ops",
                       "ops"),
    k_nn_one_hot = c("nn ops", "ops"),
    k_nn_relu = c("nn ops",
                  "ops"),
    k_nn_relu6 = c("nn ops", "ops"),
    k_nn_selu = c("nn ops",
                  "ops"),
    k_nn_separable_conv = c("nn ops", "ops"),
    k_nn_sigmoid = c("nn ops",
                     "ops"),
    k_nn_silu = c("nn ops", "ops"),
    k_nn_softmax = c("nn ops",
                     "ops"),
    k_nn_softplus = c("nn ops", "ops"),
    k_nn_softsign = c("nn ops",
                      "ops"),
    k_nn_sparse_categorical_crossentropy = c("nn ops",
                                             "ops"),
    k_nn_swish = c("nn ops", "ops"),
    k_nonzero = c("numpy ops",
                  "ops"),
    k_not_equal = c("numpy ops", "ops"),
    k_numpy_abs = c("numpy ops",
                    "ops"),
    k_numpy_absolute = c("numpy ops", "ops"),
    k_numpy_add = c("numpy ops",
                    "ops"),
    k_numpy_all = c("numpy ops", "ops"),
    k_numpy_amax = c("numpy ops",
                     "ops"),
    k_numpy_amin = c("numpy ops", "ops"),
    k_numpy_any = c("numpy ops",
                    "ops"),
    k_numpy_append = c("numpy ops", "ops"),
    k_numpy_arange = c("numpy ops",
                       "ops"),
    k_numpy_arccos = c("numpy ops", "ops"),
    k_numpy_arccosh = c("numpy ops",
                        "ops"),
    k_numpy_arcsin = c("numpy ops", "ops"),
    k_numpy_arcsinh = c("numpy ops",
                        "ops"),
    k_numpy_arctan = c("numpy ops", "ops"),
    k_numpy_arctan2 = c("numpy ops",
                        "ops"),
    k_numpy_arctanh = c("numpy ops", "ops"),
    k_numpy_argmax = c("numpy ops",
                       "ops"),
    k_numpy_argmin = c("numpy ops", "ops"),
    k_numpy_argsort = c("numpy ops",
                        "ops"),
    k_numpy_array = c("numpy ops", "ops"),
    k_numpy_average = c("numpy ops",
                        "ops"),
    k_numpy_bincount = c("numpy ops", "ops"),
    k_numpy_broadcast_to = c("numpy ops",
                             "ops"),
    k_numpy_ceil = c("numpy ops", "ops"),
    k_numpy_clip = c("numpy ops",
                     "ops"),
    k_numpy_concatenate = c("numpy ops", "ops"),
    k_numpy_conj = c("numpy ops",
                     "ops"),
    k_numpy_conjugate = c("numpy ops", "ops"),
    k_numpy_copy = c("numpy ops",
                     "ops"),
    k_numpy_cos = c("numpy ops", "ops"),
    k_numpy_cosh = c("numpy ops",
                     "ops"),
    k_numpy_count_nonzero = c("numpy ops", "ops"),
    k_numpy_cross = c("numpy ops",
                      "ops"),
    k_numpy_cumprod = c("numpy ops", "ops"),
    k_numpy_cumsum = c("numpy ops",
                       "ops"),
    k_numpy_diag = c("numpy ops", "ops"),
    k_numpy_diagonal = c("numpy ops",
                         "ops"),
    k_numpy_diff = c("numpy ops", "ops"),
    k_numpy_digitize = c("numpy ops",
                         "ops"),
    k_numpy_divide = c("numpy ops", "ops"),
    k_numpy_dot = c("numpy ops",
                    "ops"),
    k_numpy_einsum = c("numpy ops", "ops"),
    k_numpy_empty = c("numpy ops",
                      "ops"),
    k_numpy_equal = c("numpy ops", "ops"),
    k_numpy_exp = c("numpy ops",
                    "ops"),
    k_numpy_expand_dims = c("numpy ops", "ops"),
    k_numpy_expm1 = c("numpy ops",
                      "ops"),
    k_numpy_eye = c("numpy ops", "ops"),
    k_numpy_flip = c("numpy ops",
                     "ops"),
    k_numpy_floor = c("numpy ops", "ops"),
    k_numpy_floor_divide = c("numpy ops",
                             "ops"),
    k_numpy_full = c("numpy ops", "ops"),
    k_numpy_full_like = c("numpy ops",
                          "ops"),
    k_numpy_get_item = c("numpy ops", "ops"),
    k_numpy_greater = c("numpy ops",
                        "ops"),
    k_numpy_greater_equal = c("numpy ops", "ops"),
    k_numpy_hstack = c("numpy ops",
                       "ops"),
    k_numpy_identity = c("numpy ops", "ops"),
    k_numpy_imag = c("numpy ops",
                     "ops"),
    k_numpy_isclose = c("numpy ops", "ops"),
    k_numpy_isfinite = c("numpy ops",
                         "ops"),
    k_numpy_isinf = c("numpy ops", "ops"),
    k_numpy_isnan = c("numpy ops",
                      "ops"),
    k_numpy_less = c("numpy ops", "ops"),
    k_numpy_less_equal = c("numpy ops",
                           "ops"),
    k_numpy_linspace = c("numpy ops", "ops"),
    k_numpy_log = c("numpy ops",
                    "ops"),
    k_numpy_log10 = c("numpy ops", "ops"),
    k_numpy_log1p = c("numpy ops",
                      "ops"),
    k_numpy_log2 = c("numpy ops", "ops"),
    k_numpy_logaddexp = c("numpy ops",
                          "ops"),
    k_numpy_logical_and = c("numpy ops", "ops"),
    k_numpy_logical_not = c("numpy ops",
                            "ops"),
    k_numpy_logical_or = c("numpy ops", "ops"),
    k_numpy_logical_xor = c("numpy ops",
                            "ops"),
    k_numpy_logspace = c("numpy ops", "ops"),
    k_numpy_matmul = c("numpy ops",
                       "ops"),
    k_numpy_max = c("numpy ops", "ops"),
    k_numpy_maximum = c("numpy ops",
                        "ops"),
    k_numpy_mean = c("numpy ops", "ops"),
    k_numpy_median = c("numpy ops",
                       "ops"),
    k_numpy_meshgrid = c("numpy ops", "ops"),
    k_numpy_min = c("numpy ops",
                    "ops"),
    k_numpy_minimum = c("numpy ops", "ops"),
    k_numpy_mod = c("numpy ops",
                    "ops"),
    k_numpy_moveaxis = c("numpy ops", "ops"),
    k_numpy_multiply = c("numpy ops",
                         "ops"),
    k_numpy_nan_to_num = c("numpy ops", "ops"),
    k_numpy_ndim = c("numpy ops",
                     "ops"),
    k_numpy_negative = c("numpy ops", "ops"),
    k_numpy_nonzero = c("numpy ops",
                        "ops"),
    k_numpy_not_equal = c("numpy ops", "ops"),
    k_numpy_ones = c("numpy ops",
                     "ops"),
    k_numpy_ones_like = c("numpy ops", "ops"),
    k_numpy_outer = c("numpy ops",
                      "ops"),
    k_numpy_pad = c("numpy ops", "ops"),
    k_numpy_power = c("numpy ops",
                      "ops"),
    k_numpy_prod = c("numpy ops", "ops"),
    k_numpy_quantile = c("numpy ops",
                         "ops"),
    k_numpy_ravel = c("numpy ops", "ops"),
    k_numpy_real = c("numpy ops",
                     "ops"),
    k_numpy_reciprocal = c("numpy ops", "ops"),
    k_numpy_repeat = c("numpy ops",
                       "ops"),
    k_numpy_reshape = c("numpy ops", "ops"),
    k_numpy_roll = c("numpy ops",
                     "ops"),
    k_numpy_round = c("numpy ops", "ops"),
    k_numpy_sign = c("numpy ops",
                     "ops"),
    k_numpy_sin = c("numpy ops", "ops"),
    k_numpy_sinh = c("numpy ops",
                     "ops"),
    k_numpy_size = c("numpy ops", "ops"),
    k_numpy_sort = c("numpy ops",
                     "ops"),
    k_numpy_split = c("numpy ops", "ops"),
    k_numpy_sqrt = c("numpy ops",
                     "ops"),
    k_numpy_square = c("numpy ops", "ops"),
    k_numpy_squeeze = c("numpy ops",
                        "ops"),
    k_numpy_stack = c("numpy ops", "ops"),
    k_numpy_std = c("numpy ops",
                    "ops"),
    k_numpy_subtract = c("numpy ops", "ops"),
    k_numpy_sum = c("numpy ops",
                    "ops"),
    k_numpy_swapaxes = c("numpy ops", "ops"),
    k_numpy_take = c("numpy ops",
                     "ops"),
    k_numpy_take_along_axis = c("numpy ops", "ops"),
    k_numpy_tan = c("numpy ops", "ops"),
    k_numpy_tanh = c("numpy ops",
                     "ops"),
    k_numpy_tensordot = c("numpy ops", "ops"),
    k_numpy_tile = c("numpy ops",
                     "ops"),
    k_numpy_trace = c("numpy ops", "ops"),
    k_numpy_transpose = c("numpy ops",
                          "ops"),
    k_numpy_tri = c("numpy ops", "ops"),
    k_numpy_tril = c("numpy ops",
                     "ops"),
    k_numpy_triu = c("numpy ops", "ops"),
    k_numpy_true_divide = c("numpy ops",
                            "ops"),
    k_numpy_var = c("numpy ops", "ops"),
    k_numpy_vdot = c("numpy ops",
                     "ops"),
    k_numpy_vstack = c("numpy ops", "ops"),
    k_numpy_where = c("numpy ops",
                      "ops"),
    k_numpy_zeros = c("numpy ops", "ops"),
    k_numpy_zeros_like = c("numpy ops",
                           "ops"),
    k_one_hot = c("nn ops", "ops"),
    k_ones = c("numpy ops",
               "ops"),
    k_ones_like = c("numpy ops", "ops"),
    k_outer = c("numpy ops",
                "ops"),
    k_pad = c("numpy ops", "ops"),
    k_power = c("numpy ops",
                "ops"),
    k_prod = c("numpy ops", "ops"),
    k_qr = c("math ops",
             "ops"),
    k_quantile = c("numpy ops", "ops"),
    k_ravel = c("numpy ops",
                "ops"),
    k_real = c("numpy ops", "ops"),
    k_reciprocal = c("numpy ops",
                     "ops"),
    k_relu = c("nn ops", "ops"),
    k_relu6 = c("nn ops",
                "ops"),
    k_repeat = c("numpy ops", "ops"),
    k_reshape = c("numpy ops",
                  "ops"),
    k_rfft = c("math ops", "ops"),
    k_roll = c("numpy ops",
               "ops"),
    k_round = c("numpy ops", "ops"),
    k_rsqrt = c("math ops",
                "ops"),
    k_scatter = c("core ops", "ops"),
    k_scatter_update = c("core ops",
                         "ops"),
    k_segment_max = c("math ops", "ops"),
    k_segment_sum = c("math ops",
                      "ops"),
    k_selu = c("nn ops", "ops"),
    k_separable_conv = c("nn ops",
                         "ops"),
    k_shape = c("core ops", "ops"),
    k_sigmoid = c("nn ops",
                  "ops"),
    k_sign = c("numpy ops", "ops"),
    k_silu = c("nn ops",
               "ops"),
    k_sin = c("numpy ops", "ops"),
    k_sinh = c("numpy ops",
               "ops"),
    k_size = c("numpy ops", "ops"),
    k_slice = c("core ops",
                "ops"),
    k_slice_update = c("core ops", "ops"),
    k_softmax = c("nn ops",
                  "ops"),
    k_softplus = c("nn ops", "ops"),
    k_softsign = c("nn ops",
                   "ops"),
    k_solve = c("math ops", "ops"),
    k_sort = c("numpy ops",
               "ops"),
    k_sparse_categorical_crossentropy = c("nn ops", "ops"),
    k_split = c("numpy ops", "ops"),
    k_sqrt = c("numpy ops",
               "ops"),
    k_square = c("numpy ops", "ops"),
    k_squeeze = c("numpy ops",
                  "ops"),
    k_stack = c("numpy ops", "ops"),
    k_std = c("numpy ops",
              "ops"),
    k_stft = c("math ops", "ops"),
    k_stop_gradient = c("core ops",
                        "ops"),
    k_subtract = c("numpy ops", "ops"),
    k_sum = c("numpy ops",
              "ops"),
    k_swapaxes = c("numpy ops", "ops"),
    k_swish = c("nn ops",
                "ops"),
    k_take = c("numpy ops", "ops"),
    k_take_along_axis = c("numpy ops",
                          "ops"),
    k_tan = c("numpy ops", "ops"),
    k_tanh = c("numpy ops",
               "ops"),
    k_tensordot = c("numpy ops", "ops"),
    k_tile = c("numpy ops",
               "ops"),
    k_top_k = c("math ops", "ops"),
    k_trace = c("numpy ops",
                "ops"),
    k_transpose = c("numpy ops", "ops"),
    k_tri = c("numpy ops",
              "ops"),
    k_tril = c("numpy ops", "ops"),
    k_triu = c("numpy ops",
               "ops"),
    k_true_divide = c("numpy ops", "ops"),
    k_unstack = c("core ops",
                  "ops"),
    k_var = c("numpy ops", "ops"),
    k_vdot = c("numpy ops",
               "ops"),
    k_vectorized_map = c("core ops", "ops"),
    k_vstack = c("numpy ops",
                 "ops"),
    k_where = c("numpy ops", "ops"),
    k_while_loop = c("core ops",
                     "ops"),
    k_zeros = c("numpy ops", "ops"),
    k_zeros_like = c("numpy ops",
                     "ops"),
    keras_tensor = "backend",
    layer = "layers",
    layer_activation = c("activation layers",
                         "layers"),
    layer_activation_elu = c("activation layers",
                             "layers"),
    layer_activation_leaky_relu = c("activation layers",
                                    "layers"),
    layer_activation_parametric_relu = c("activation layers",
                                         "layers"),
    layer_activation_relu = c("activation layers",
                              "layers"),
    layer_activation_softmax = c("activation layers",
                                 "layers"),
    layer_activity_regularization = c("regularization layers",
                                      "layers"),
    layer_add = c("add merging layers", "merging layers",
                  "layers"),
    layer_additive_attention = c("attention layers",
                                 "layers"),
    layer_attention = c("attention layers", "layers"),
    layer_average = c("average merging layers", "merging layers",
                      "layers"),
    layer_average_pooling_1d = c("pooling layers",
                                 "layers"),
    layer_average_pooling_2d = c("pooling layers",
                                 "layers"),
    layer_average_pooling_3d = c("pooling layers",
                                 "layers"),
    layer_avg_pool_1d = c("pooling layers", "layers"),
    layer_avg_pool_2d = c("pooling layers", "layers"),
    layer_avg_pool_3d = c("pooling layers",
                          "layers"),
    layer_batch_normalization = c("normalization layers",
                                  "layers"),
    layer_category_encoding = c("preprocessing layers",
                                "layers"),
    layer_center_crop = c("preprocessing layers",
                          "layers"),
    layer_concatenate = c("concatenate merging layers",
                          "merging layers", "layers"),
    layer_conv_1d = c("convolutional layers",
                      "layers"),
    layer_conv_1d_transpose = c("convolutional layers",
                                "layers"),
    layer_conv_2d = c("convolutional layers", "layers"),
    layer_conv_2d_transpose = c("convolutional layers", "layers"),
    layer_conv_3d = c("convolutional layers", "layers"),
    layer_conv_3d_transpose = c("convolutional layers",
                                "layers"),
    layer_conv_lstm_1d = c("rnn layers", "layers"),
    layer_conv_lstm_2d = c("rnn layers", "layers"),
    layer_conv_lstm_3d = c("rnn layers",
                           "layers"),
    layer_convolution_1d = c("convolutional layers",
                             "layers"),
    layer_convolution_1d_transpose = c("convolutional layers",
                                       "layers"),
    layer_convolution_2d = c("convolutional layers",
                             "layers"),
    layer_convolution_2d_transpose = c("convolutional layers",
                                       "layers"),
    layer_convolution_3d = c("convolutional layers",
                             "layers"),
    layer_convolution_3d_transpose = c("convolutional layers",
                                       "layers"),
    layer_cropping_1d = c("reshaping layers", "layers"),
    layer_cropping_2d = c("reshaping layers", "layers"),
    layer_cropping_3d = c("reshaping layers",
                          "layers"),
    layer_dense = c("core layers", "layers"),
    layer_depthwise_conv_1d = c("convolutional layers",
                                "layers"),
    layer_depthwise_conv_2d = c("convolutional layers",
                                "layers"),
    layer_discretization = c("preprocessing layers",
                             "layers"),
    layer_dot = c("dot merging layers", "merging layers",
                  "layers"),
    layer_dropout = c("regularization layers", "layers"),
    layer_einsum_dense = c("core layers", "layers"),
    layer_embedding = c("core layers",
                        "layers"),
    layer_feature_space = c("preprocessing layers",
                            "layers", "utils"),
    layer_flatten = c("reshaping layers",
                      "layers"),
    layer_gaussian_dropout = c("regularization layers",
                               "layers"),
    layer_gaussian_noise = c("regularization layers",
                             "layers"),
    layer_global_average_pooling_1d = c("pooling layers",
                                        "layers"),
    layer_global_average_pooling_2d = c("pooling layers",
                                        "layers"),
    layer_global_average_pooling_3d = c("pooling layers",
                                        "layers"),
    layer_global_avg_pool_1d = c("pooling layers",
                                 "layers"),
    layer_global_avg_pool_2d = c("pooling layers",
                                 "layers"),
    layer_global_avg_pool_3d = c("pooling layers",
                                 "layers"),
    layer_global_max_pool_1d = c("pooling layers",
                                 "layers"),
    layer_global_max_pool_2d = c("pooling layers",
                                 "layers"),
    layer_global_max_pool_3d = c("pooling layers",
                                 "layers"),
    layer_global_max_pooling_1d = c("pooling layers",
                                    "layers"),
    layer_global_max_pooling_2d = c("pooling layers",
                                    "layers"),
    layer_global_max_pooling_3d = c("pooling layers",
                                    "layers"),
    layer_group_normalization = c("normalization layers",
                                  "layers"),
    layer_group_query_attention = c("attention layers",
                                    "layers"),
    layer_gru = c("gru rnn layers", "rnn layers",
                  "layers"),
    rnn_cell_gru = c("gru rnn layers", "rnn layers",
                       "layers"),
    layer_hashed_crossing = c("preprocessing layers",
                              "layers"),
    layer_hashing = c("preprocessing layers", "layers"),
    layer_identity = c("core layers", "layers"),
    layer_input = c("input core layers",
                    "core layers", "layers"),
    layer_input_spec = "layers",
    layer_integer_lookup = c("preprocessing layers",
                             "layers"),
    layer_lambda = c("core layers", "layers"),
    layer_layer_normalization = c("normalization layers",
                                  "layers"),
    layer_lstm = c("lstm rnn layers", "rnn layers",
                   "layers"),
    rnn_cell_lstm = c("lstm rnn layers", "rnn layers",
                        "layers"),
    layer_masking = c("core layers", "layers"),
    layer_max_pool_1d = c("pooling layers",
                          "layers"),
    layer_max_pool_2d = c("pooling layers", "layers"),
    layer_max_pool_3d = c("pooling layers", "layers"),
    layer_max_pooling_1d = c("pooling layers",
                             "layers"),
    layer_max_pooling_2d = c("pooling layers", "layers"),
    layer_max_pooling_3d = c("pooling layers", "layers"),
    layer_maximum = c("maximum merging layers", "merging layers",
                      "layers"),
    layer_minimum = c("minimum merging layers", "merging layers",
                      "layers"),
    layer_multi_head_attention = c("attention layers",
                                   "layers"),
    layer_multiply = c("multiply merging layers",
                       "merging layers", "layers"),
    layer_normalization = c("preprocessing layers",
                            "layers"),
    layer_permute = c("reshaping layers", "layers"),
    layer_random_brightness = c("preprocessing layers", "layers"),
    layer_random_contrast = c("preprocessing layers", "layers"),
    layer_random_crop = c("preprocessing layers", "layers"),
    layer_random_flip = c("preprocessing layers", "layers"),
    layer_random_rotation = c("preprocessing layers", "layers"),
    layer_random_translation = c("preprocessing layers", "layers"),
    layer_random_zoom = c("preprocessing layers", "layers"),
    layer_repeat_vector = c("reshaping layers", "layers"),
    layer_rescaling = c("preprocessing layers", "layers"),
    layer_reshape = c("reshaping layers",
                      "layers"),
    layer_resizing = c("preprocessing layers", "layers"),
    layer_rnn = c("rnn layers", "layers"),
    layer_separable_conv_1d = c("convolutional layers",
                                "layers"),
    layer_separable_conv_2d = c("convolutional layers",
                                "layers"),
    layer_separable_convolution_1d = c("convolutional layers",
                                       "layers"),
    layer_separable_convolution_2d = c("convolutional layers",
                                       "layers"),
    layer_simple_rnn = c("simple rnn layers", "rnn layers",
                         "layers"),
    rnn_cell_simple = c("simple rnn layers",
                              "rnn layers", "layers"),
    layer_spatial_dropout_1d = c(
      "spatial dropout regularization layers",
      "regularization layers",
      "layers"
    ),
    layer_spatial_dropout_2d = c(
      "spatial dropout regularization layers",
      "regularization layers",
      "layers"
    ),
    layer_spatial_dropout_3d = c(
      "spatial dropout regularization layers",
      "regularization layers",
      "layers"
    ),
    layer_spectral_normalization = c("normalization layers",
                                     "layers"),
    rnn_cells_stack = c("rnn layers", "layers"),
    layer_string_lookup = c("preprocessing layers", "layers"),
    layer_subtract = c("subtract merging layers", "merging layers",
                       "layers"),
    layer_text_vectorization = c("preprocessing layers",
                                 "layers"),
    layer_tfsm = c("saving", "layers"),
    layer_time_distributed = c("rnn layers",
                               "layers"),
    layer_torch_module_wrapper = c("utils", "layers"),
    layer_unit_normalization = c("normalization layers", "layers"),
    layer_upsampling_1d = c("reshaping layers", "layers"),
    layer_upsampling_2d = c("reshaping layers", "layers"),
    layer_upsampling_3d = c("reshaping layers",
                            "layers"),
    layer_wrapper = c("core layers", "layers"),
    layer_zero_padding_1d = c("reshaping layers",
                              "layers"),
    layer_zero_padding_2d = c("reshaping layers",
                              "layers"),
    layer_zero_padding_3d = c("reshaping layers",
                              "layers"),
    learning_rate_schedule = c("learning rate schedule optimizers",
                               "schedule optimizers"),
    learning_rate_schedule_cosine_decay = c("learning rate schedule optimizers",
                                            "schedule optimizers"),
    learning_rate_schedule_cosine_decay_restarts = c("learning rate schedule optimizers",
                                                     "schedule optimizers"),
    learning_rate_schedule_exponential_decay = c("learning rate schedule optimizers",
                                                 "schedule optimizers"),
    learning_rate_schedule_inverse_time_decay = c("learning rate schedule optimizers",
                                                  "schedule optimizers"),
    learning_rate_schedule_piecewise_constant_decay = c("learning rate schedule optimizers",
                                                        "schedule optimizers"),
    learning_rate_schedule_polynomial_decay = c("learning rate schedule optimizers",
                                                "schedule optimizers"),
    legacy_deserialize_keras_object = "utils",
    legacy_serialize_keras_object = "utils",
    loss = "losses",
    loss_binary_crossentropy = "losses",
    loss_binary_focal_crossentropy = "losses",
    loss_categorical_crossentropy = "losses",
    loss_categorical_focal_crossentropy = "losses",
    loss_categorical_hinge = "losses",
    loss_cosine_similarity = "losses",
    loss_hinge = "losses",
    loss_huber = "losses",
    loss_kl_divergence = "losses",
    loss_log_cosh = "losses",
    loss_mean_absolute_error = "losses",
    loss_mean_absolute_percentage_error = "losses",
    loss_mean_squared_error = "losses",
    loss_mean_squared_logarithmic_error = "losses",
    loss_poisson = "losses",
    loss_sparse_categorical_crossentropy = "losses",
    loss_squared_hinge = "losses",
    metric = "metrics",
    metric_accuracy = c("accuracy metrics",
                        "metrics"),
    metric_auc = c("confusion metrics", "metrics"),
    metric_binary_accuracy = c("accuracy metrics", "metrics"),
    metric_binary_crossentropy = c("losses", "metrics", "probabilistic metrics"),
    metric_binary_focal_crossentropy = c("losses", "metrics"),
    metric_binary_iou = c("iou metrics", "metrics"),
    metric_categorical_accuracy = c("accuracy metrics",
                                    "metrics"),
    metric_categorical_crossentropy = c("losses",
                                        "metrics", "probabilistic metrics"),
    metric_categorical_focal_crossentropy = c("losses",
                                              "metrics"),
    metric_categorical_hinge = c("losses", "metrics",
                                 "hinge metrics"),
    metric_cosine_similarity = c("regression metrics",
                                 "metrics"),
    metric_f1_score = c("f score metrics", "metrics"),
    metric_false_negatives = c("confusion metrics", "metrics"),
    metric_false_positives = c("confusion metrics", "metrics"),
    metric_fbeta_score = c("f score metrics", "metrics"),
    metric_hinge = c("losses", "metrics", "hinge metrics"),
    metric_huber = c("losses",
                     "metrics"),
    metric_iou = c("iou metrics", "metrics"),
    metric_kl_divergence = c("losses",
                             "metrics", "probabilistic metrics"),
    metric_log_cosh = c("losses",
                        "metrics"),
    metric_log_cosh_error = c("regression metrics",
                              "metrics"),
    metric_mean = c("reduction metrics", "metrics"),
    metric_mean_absolute_error = c("losses", "metrics", "regression metrics"),
    metric_mean_absolute_percentage_error = c("losses", "metrics",
                                              "regression metrics"),
    metric_mean_iou = c("iou metrics",
                        "metrics"),
    metric_mean_squared_error = c("losses", "metrics",
                                  "regression metrics"),
    metric_mean_squared_logarithmic_error = c("losses",
                                              "metrics", "regression metrics"),
    metric_mean_wrapper = c("reduction metrics",
                            "metrics"),
    metric_one_hot_iou = c("iou metrics", "metrics"),
    metric_one_hot_mean_iou = c("iou metrics", "metrics"),
    metric_poisson = c("losses", "metrics", "probabilistic metrics"),
    metric_precision = c("confusion metrics", "metrics"),
    metric_precision_at_recall = c("confusion metrics", "metrics"),
    metric_r2_score = c("regression metrics", "metrics"),
    metric_recall = c("confusion metrics", "metrics"),
    metric_recall_at_precision = c("confusion metrics",
                                   "metrics"),
    metric_root_mean_squared_error = c("regression metrics",
                                       "metrics"),
    metric_sensitivity_at_specificity = c("confusion metrics",
                                          "metrics"),
    metric_sparse_categorical_accuracy = c("accuracy metrics",
                                           "metrics"),
    metric_sparse_categorical_crossentropy = c("losses",
                                               "metrics", "probabilistic metrics"),
    metric_sparse_top_k_categorical_accuracy = c("accuracy metrics",
                                                 "metrics"),
    metric_specificity_at_sensitivity = c("confusion metrics",
                                          "metrics"),
    metric_squared_hinge = c("losses", "metrics",
                             "hinge metrics"),
    metric_sum = c("reduction metrics", "metrics"),
    metric_top_k_categorical_accuracy = c("accuracy metrics",
                                          "metrics"),
    metric_true_negatives = c("confusion metrics",
                              "metrics"),
    metric_true_positives = c("confusion metrics",
                              "metrics"),
    mixed_precision_loss_scale_optimizer = "optimizers",
    model_load = "saving",
    model_save = "saving",
    model_to_dot = "utils",
    name_scope = "backend",
    normalize = c("numerical utils",
                  "utils"),
    operation = "ops",
    optimizer = "optimizers",
    optimizer_adadelta = "optimizers",
    optimizer_adafactor = "optimizers",
    optimizer_adagrad = "optimizers",
    optimizer_adam = "optimizers",
    optimizer_adam_w = "optimizers",
    optimizer_adamax = "optimizers",
    optimizer_ftrl = "optimizers",
    optimizer_lion = "optimizers",
    optimizer_loss_scale = "optimizers",
    optimizer_nadam = "optimizers",
    optimizer_rmsprop = "optimizers",
    optimizer_sgd = "optimizers",
    pack_x_y_sample_weight = c(
      "datum util adapter trainers",
      "datum adapter trainers",
      "trainers",
      "utils"
    ),
    pad_sequences = "utils",
    plot_model = "utils",
    progbar = "utils",
    py_dataset = c("datum adapter trainers",
                   "trainers", "utils"),
    random_categorical = "random",
    random_dropout = "random",
    random_gamma = "random",
    random_integer = "random",
    random_normal = "random",
    random_seed_generator = "random",
    random_shuffle = "random",
    random_truncated_normal = "random",
    random_uniform = "random",
    register_keras_serializable = c("object registration saving",
                                    "saving", "utils"),
    regularizer = "regularizers",
    regularizer_l1 = "regularizers",
    regularizer_l1_l2 = "regularizers",
    regularizer_l2 = "regularizers",
    regularizer_orthogonal = "regularizers",
    saving_custom_object_scope = c("object registration saving",
                                   "saving"),
    saving_deserialize_keras_object = "saving",
    saving_get_custom_objects = c("object registration saving",
                                  "saving"),
    saving_get_registered_name = c("object registration saving",
                                   "saving"),
    saving_get_registered_object = c("object registration saving",
                                     "saving"),
    saving_load_model = "saving",
    saving_register_keras_serializable = c("object registration saving",
                                           "saving"),
    saving_save_model = "saving",
    saving_serialize_keras_object = "saving",
    sequence = c("datum adapter trainers", "trainers", "utils"),
    sequence_pad_sequences = c("utils", "preprocessing"),
    serialize_keras_object = c("saving", "utils"),
    set_random_seed = "utils",
    split_dataset = c("dataset utils", "utils"),
    stateless_scope = "backend",
    text_dataset_from_directory = c("dataset utils", "text dataset utils",
                                    "utils", "preprocessing"),
    timeseries_dataset_from_array = c(
      "dataset utils",
      "timesery dataset utils",
      "utils",
      "preprocessing"
    ),
    to_categorical = c("numerical utils",
                       "utils"),
    unpack_x_y_sample_weight = c(
      "datum util adapter trainers",
      "datum adapter trainers",
      "trainers",
      "utils"
    ),
    variable = "backend"
  )
family_to_r_names_map <-
  list(
    `accuracy metrics` = c(
      "metric_accuracy",
      "metric_binary_accuracy",
      "metric_categorical_accuracy",
      "metric_sparse_categorical_accuracy",
      "metric_sparse_top_k_categorical_accuracy",
      "metric_top_k_categorical_accuracy"
    ),
    `activation layers` = c(
      "layer_activation",
      "layer_activation_elu",
      "layer_activation_leaky_relu",
      "layer_activation_parametric_relu",
      "layer_activation_relu",
      "layer_activation_softmax"
    ),
    activations = c(
      "activation_elu",
      "activation_exponential",
      "activation_gelu",
      "activation_hard_sigmoid",
      "activation_leaky_relu",
      "activation_linear",
      "activation_log_softmax",
      "activation_mish",
      "activation_relu",
      "activation_relu6",
      "activation_selu",
      "activation_sigmoid",
      "activation_silu",
      "activation_softmax",
      "activation_softplus",
      "activation_softsign",
      "activation_swish",
      "activation_tanh"
    ),
    `add merging layers` = "layer_add",
    `attention layers` = c(
      "layer_additive_attention",
      "layer_attention",
      "layer_group_query_attention",
      "layer_multi_head_attention"
    ),
    `average merging layers` = "layer_average",
    backend = c(
      "backend",
      "backend_clear_session",
      "backend_epsilon",
      "backend_floatx",
      "backend_get_uid",
      "backend_image_data_format",
      "backend_is_float_dtype",
      "backend_is_int_dtype",
      "backend_is_keras_tensor",
      "backend_result_type",
      "backend_set_epsilon",
      "backend_set_floatx",
      "backend_set_image_data_format",
      "backend_standardize_dtype",
      "config_backend",
      "config_epsilon",
      "config_floatx",
      "config_image_data_format",
      "config_set_epsilon",
      "config_set_floatx",
      "config_set_image_data_format",
      "keras_tensor",
      "name_scope",
      "stateless_scope",
      "clear_session",
      "is_keras_tensor",
      "variable"
    ),
    callbacks = c(
      "callback_backup_and_restore",
      "callback",
      "callback_list",
      "callback_csv_logger",
      "callback_early_stopping",
      "callback_history",
      "callback_lambda",
      "callback_learning_rate_scheduler",
      "callback_model_checkpoint",
      "callback_progbar_logger",
      "callback_reduce_lr_on_plateau",
      "callback_remote_monitor",
      "callback_tensorboard",
      "callback_terminate_on_nan"
    ),
    `concatenate merging layers` = "layer_concatenate",
    config = c(
      "config_backend",
      "config_disable_interactive_logging",
      "config_disable_traceback_filtering",
      "config_enable_interactive_logging",
      "config_enable_traceback_filtering",
      "config_enable_unsafe_deserialization",
      "config_epsilon",
      "config_floatx",
      "config_image_data_format",
      "config_is_interactive_logging_enabled",
      "config_is_traceback_filtering_enabled",
      "config_set_epsilon",
      "config_set_floatx",
      "config_set_image_data_format"
    ),
    `config backend` = c(
      "backend",
      "backend_epsilon",
      "backend_floatx",
      "backend_image_data_format",
      "backend_set_epsilon",
      "backend_set_floatx",
      "backend_set_image_data_format",
      "config_backend",
      "config_epsilon",
      "config_floatx",
      "config_image_data_format",
      "config_set_epsilon",
      "config_set_floatx",
      "config_set_image_data_format"
    ),
    `confusion metrics` = c(
      "metric_auc",
      "metric_false_negatives",
      "metric_false_positives",
      "metric_precision",
      "metric_precision_at_recall",
      "metric_recall",
      "metric_recall_at_precision",
      "metric_sensitivity_at_specificity",
      "metric_specificity_at_sensitivity",
      "metric_true_negatives",
      "metric_true_positives"
    ),
    `constant initializers` = c(
      "initializer_constant",
      "initializer_identity",
      "initializer_ones",
      "initializer_zeros"
    ),
    constraints = c(
      "constraint",
      "constraint_maxnorm",
      "constraint_minmaxnorm",
      "constraint_nonneg",
      "constraint_unitnorm"
    ),
    `convolutional layers` = c(
      "layer_conv_1d",
      "layer_conv_1d_transpose",
      "layer_conv_2d",
      "layer_conv_2d_transpose",
      "layer_conv_3d",
      "layer_conv_3d_transpose",
      "layer_convolution_1d",
      "layer_convolution_1d_transpose",
      "layer_convolution_2d",
      "layer_convolution_2d_transpose",
      "layer_convolution_3d",
      "layer_convolution_3d_transpose",
      "layer_depthwise_conv_1d",
      "layer_depthwise_conv_2d",
      "layer_separable_conv_1d",
      "layer_separable_conv_2d",
      "layer_separable_convolution_1d",
      "layer_separable_convolution_2d"
    ),
    `core layers` = c(
      "input",
      "layer_dense",
      "layer_einsum_dense",
      "layer_embedding",
      "layer_identity",
      "layer_input",
      "layer_lambda",
      "layer_masking",
      "layer_wrapper"
    ),
    `core ops` = c(
      "k_cast",
      "k_cond",
      "k_convert_to_numpy",
      "k_convert_to_tensor",
      "k_fori_loop",
      "k_is_tensor",
      "k_scatter",
      "k_scatter_update",
      "k_shape",
      "k_slice",
      "k_slice_update",
      "k_stop_gradient",
      "k_unstack",
      "k_vectorized_map",
      "k_while_loop"
    ),
    `dataset utils` = c(
      "image_dataset_from_directory",
      "text_dataset_from_directory",
      "timeseries_dataset_from_array",
      "audio_dataset_from_directory",
      "split_dataset"
    ),
    `datum adapter trainers` = c(
      "pack_x_y_sample_weight",
      "py_dataset",
      "sequence",
      "unpack_x_y_sample_weight"
    ),
    `datum util adapter trainers` = c("pack_x_y_sample_weight",
                                      "unpack_x_y_sample_weight"),
    `dot merging layers` = "layer_dot",
    `f score metrics` = c("metric_f1_score", "metric_fbeta_score"),
    `gru rnn layers` = c("layer_gru", "rnn_cell_gru"),
    `hinge metrics` = c(
      "metric_categorical_hinge",
      "metric_hinge",
      "metric_squared_hinge"
    ),
    `image dataset utils` = "image_dataset_from_directory",
    `image ops` = c(
      "k_image_affine_transform",
      "k_image_extract_patches",
      "k_image_map_coordinates",
      "k_image_pad_images",
      "k_image_resize"
    ),
    `image utils` = c(
      "k_image_affine_transform",
      "k_image_extract_patches",
      "k_image_map_coordinates",
      "k_image_pad_images",
      "k_image_resize",
      "image_array_to_img",
      "image_img_to_array",
      "image_load_img",
      "image_save_img",
      "image_smart_resize",
      "image_from_array",
      "image_to_array",
      "image_load",
      "image_array_save"
    ),
    initializers = c(
      "initializer",
      "initializer_constant",
      "initializer_glorot_normal",
      "initializer_glorot_uniform",
      "initializer_he_normal",
      "initializer_he_uniform",
      "initializer_identity",
      "initializer_lecun_normal",
      "initializer_lecun_uniform",
      "initializer_ones",
      "initializer_orthogonal",
      "initializer_random_normal",
      "initializer_random_uniform",
      "initializer_truncated_normal",
      "initializer_variance_scaling",
      "initializer_zeros"
    ),
    `input core layers` = c("input",
                            "layer_input"),
    `io utils` = c(
      "config_disable_interactive_logging",
      "config_enable_interactive_logging",
      "config_is_interactive_logging_enabled",
      "disable_interactive_logging",
      "enable_interactive_logging",
      "is_interactive_logging_enabled"
    ),
    `iou metrics` = c(
      "metric_binary_iou",
      "metric_iou",
      "metric_mean_iou",
      "metric_one_hot_iou",
      "metric_one_hot_mean_iou"
    ),
    layers = c(
      "input",
      "input_spec",
      "layer",
      "layer_activation",
      "layer_activity_regularization",
      "layer_add",
      "layer_additive_attention",
      "layer_attention",
      "layer_average",
      "layer_average_pooling_1d",
      "layer_average_pooling_2d",
      "layer_average_pooling_3d",
      "layer_avg_pool_1d",
      "layer_avg_pool_2d",
      "layer_avg_pool_3d",
      "layer_batch_normalization",
      "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_convolution_1d",
      "layer_convolution_1d_transpose",
      "layer_convolution_2d",
      "layer_convolution_2d_transpose",
      "layer_convolution_3d",
      "layer_convolution_3d_transpose",
      "layer_cropping_1d",
      "layer_cropping_2d",
      "layer_cropping_3d",
      "layer_dense",
      "layer_depthwise_conv_1d",
      "layer_depthwise_conv_2d",
      "layer_discretization",
      "layer_dot",
      "layer_dropout",
      "layer_einsum_dense",
      "layer_activation_elu",
      "layer_embedding",
      "layer_flatten",
      "layer_gaussian_dropout",
      "layer_gaussian_noise",
      "layer_global_average_pooling_1d",
      "layer_global_average_pooling_2d",
      "layer_global_average_pooling_3d",
      "layer_global_avg_pool_1d",
      "layer_global_avg_pool_2d",
      "layer_global_avg_pool_3d",
      "layer_global_max_pool_1d",
      "layer_global_max_pool_2d",
      "layer_global_max_pool_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",
      "rnn_cell_gru",
      "layer_hashed_crossing",
      "layer_hashing",
      "layer_identity",
      "layer_input",
      "layer_input_spec",
      "layer_integer_lookup",
      "layer_lambda",
      "layer_layer_normalization",
      "layer_activation_leaky_relu",
      "layer_lstm",
      "rnn_cell_lstm",
      "layer_masking",
      "layer_maximum",
      "layer_max_pool_1d",
      "layer_max_pool_2d",
      "layer_max_pool_3d",
      "layer_max_pooling_1d",
      "layer_max_pooling_2d",
      "layer_max_pooling_3d",
      "layer_minimum",
      "layer_multi_head_attention",
      "layer_multiply",
      "layer_normalization",
      "layer_permute",
      "layer_activation_parametric_relu",
      "layer_random_brightness",
      "layer_random_contrast",
      "layer_random_crop",
      "layer_random_flip",
      "layer_random_rotation",
      "layer_random_translation",
      "layer_random_zoom",
      "layer_activation_relu",
      "layer_repeat_vector",
      "layer_rescaling",
      "layer_reshape",
      "layer_resizing",
      "layer_rnn",
      "layer_separable_conv_1d",
      "layer_separable_conv_2d",
      "layer_separable_convolution_1d",
      "layer_separable_convolution_2d",
      "layer_simple_rnn",
      "rnn_cell_simple",
      "layer_activation_softmax",
      "layer_spatial_dropout_1d",
      "layer_spatial_dropout_2d",
      "layer_spatial_dropout_3d",
      "layer_spectral_normalization",
      "rnn_cells_stack",
      "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_wrapper",
      "layer_zero_padding_1d",
      "layer_zero_padding_2d",
      "layer_zero_padding_3d",
      "layer_feature_space"
    ),
    `learning rate schedule optimizers` = c(
      "learning_rate_schedule_cosine_decay",
      "learning_rate_schedule_cosine_decay_restarts",
      "learning_rate_schedule_exponential_decay",
      "learning_rate_schedule_inverse_time_decay",
      "learning_rate_schedule",
      "learning_rate_schedule_piecewise_constant_decay",
      "learning_rate_schedule_polynomial_decay"
    ),
    losses = c(
      "loss",
      "loss_binary_crossentropy",
      "loss_binary_focal_crossentropy",
      "loss_categorical_crossentropy",
      "loss_categorical_focal_crossentropy",
      "loss_categorical_hinge",
      "loss_cosine_similarity",
      "loss_hinge",
      "loss_huber",
      "loss_kl_divergence",
      "loss_log_cosh",
      "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",
      "metric_binary_crossentropy",
      "metric_binary_focal_crossentropy",
      "metric_categorical_crossentropy",
      "metric_categorical_focal_crossentropy",
      "metric_categorical_hinge",
      "metric_hinge",
      "metric_huber",
      "metric_kl_divergence",
      "metric_log_cosh",
      "metric_mean_absolute_error",
      "metric_mean_absolute_percentage_error",
      "metric_mean_squared_error",
      "metric_mean_squared_logarithmic_error",
      "metric_poisson",
      "metric_sparse_categorical_crossentropy",
      "metric_squared_hinge"
    ),
    `lstm rnn layers` = c("layer_lstm", "rnn_cell_lstm"),
    `math ops` = c(
      "k_erf",
      "k_extract_sequences",
      "k_fft",
      "k_fft2",
      "k_in_top_k",
      "k_irfft",
      "k_istft",
      "k_logsumexp",
      "k_qr",
      "k_rfft",
      "k_rsqrt",
      "k_segment_max",
      "k_segment_sum",
      "k_solve",
      "k_stft",
      "k_top_k"
    ),
    `maximum merging layers` = "layer_maximum",
    `merging layers` = c(
      "layer_add",
      "layer_average",
      "layer_concatenate",
      "layer_dot",
      "layer_maximum",
      "layer_minimum",
      "layer_multiply",
      "layer_subtract"
    ),
    metrics = c(
      "metric",
      "metric_accuracy",
      "metric_auc",
      "metric_binary_accuracy",
      "metric_binary_crossentropy",
      "metric_binary_focal_crossentropy",
      "metric_binary_iou",
      "metric_categorical_accuracy",
      "metric_categorical_crossentropy",
      "metric_categorical_focal_crossentropy",
      "metric_categorical_hinge",
      "metric_cosine_similarity",
      "metric_f1_score",
      "metric_false_negatives",
      "metric_false_positives",
      "metric_fbeta_score",
      "metric_hinge",
      "metric_huber",
      "metric_iou",
      "metric_kl_divergence",
      "metric_log_cosh",
      "metric_log_cosh_error",
      "metric_mean",
      "metric_mean_absolute_error",
      "metric_mean_absolute_percentage_error",
      "metric_mean_squared_error",
      "metric_mean_squared_logarithmic_error",
      "metric_mean_iou",
      "metric_mean_wrapper",
      "metric_one_hot_iou",
      "metric_one_hot_mean_iou",
      "metric_poisson",
      "metric_precision",
      "metric_precision_at_recall",
      "metric_r2_score",
      "metric_recall",
      "metric_recall_at_precision",
      "metric_root_mean_squared_error",
      "metric_sensitivity_at_specificity",
      "metric_sparse_categorical_accuracy",
      "metric_sparse_categorical_crossentropy",
      "metric_sparse_top_k_categorical_accuracy",
      "metric_specificity_at_sensitivity",
      "metric_squared_hinge",
      "metric_sum",
      "metric_top_k_categorical_accuracy",
      "metric_true_negatives",
      "metric_true_positives"
    ),
    `minimum merging layers` = "layer_minimum",
    `multiply merging layers` = "layer_multiply",
    `nn ops` = c(
      "k_average_pool",
      "k_binary_crossentropy",
      "k_categorical_crossentropy",
      "k_conv",
      "k_conv_transpose",
      "k_depthwise_conv",
      "k_elu",
      "k_gelu",
      "k_hard_sigmoid",
      "k_leaky_relu",
      "k_log_sigmoid",
      "k_log_softmax",
      "k_max_pool",
      "k_moments",
      "k_multi_hot",
      "k_nn_average_pool",
      "k_nn_binary_crossentropy",
      "k_nn_categorical_crossentropy",
      "k_nn_conv",
      "k_nn_conv_transpose",
      "k_nn_depthwise_conv",
      "k_nn_elu",
      "k_nn_gelu",
      "k_nn_hard_sigmoid",
      "k_nn_leaky_relu",
      "k_nn_log_sigmoid",
      "k_nn_log_softmax",
      "k_nn_max_pool",
      "k_nn_moments",
      "k_nn_multi_hot",
      "k_nn_one_hot",
      "k_nn_relu",
      "k_nn_relu6",
      "k_nn_selu",
      "k_nn_separable_conv",
      "k_nn_sigmoid",
      "k_nn_silu",
      "k_nn_softmax",
      "k_nn_softplus",
      "k_nn_softsign",
      "k_nn_sparse_categorical_crossentropy",
      "k_nn_swish",
      "k_one_hot",
      "k_relu",
      "k_relu6",
      "k_selu",
      "k_separable_conv",
      "k_sigmoid",
      "k_silu",
      "k_softmax",
      "k_softplus",
      "k_softsign",
      "k_sparse_categorical_crossentropy",
      "k_swish"
    ),
    `normalization layers` = c(
      "layer_batch_normalization",
      "layer_group_normalization",
      "layer_layer_normalization",
      "layer_spectral_normalization",
      "layer_unit_normalization"
    ),
    `numerical utils` = c("normalize", "to_categorical"),
    `numpy ops` = c(
      "k_abs",
      "k_absolute",
      "k_add",
      "k_all",
      "k_amax",
      "k_amin",
      "k_any",
      "k_append",
      "k_arange",
      "k_arccos",
      "k_arccosh",
      "k_arcsin",
      "k_arcsinh",
      "k_arctan",
      "k_arctan2",
      "k_arctanh",
      "k_argmax",
      "k_argmin",
      "k_argsort",
      "k_array",
      "k_average",
      "k_bincount",
      "k_broadcast_to",
      "k_ceil",
      "k_clip",
      "k_concatenate",
      "k_conj",
      "k_conjugate",
      "k_copy",
      "k_cos",
      "k_cosh",
      "k_count_nonzero",
      "k_cross",
      "k_cumprod",
      "k_cumsum",
      "k_diag",
      "k_diagonal",
      "k_diff",
      "k_digitize",
      "k_divide",
      "k_dot",
      "k_einsum",
      "k_empty",
      "k_equal",
      "k_exp",
      "k_expand_dims",
      "k_expm1",
      "k_eye",
      "k_flip",
      "k_floor",
      "k_floor_divide",
      "k_full",
      "k_full_like",
      "k_get_item",
      "k_greater",
      "k_greater_equal",
      "k_hstack",
      "k_identity",
      "k_imag",
      "k_isclose",
      "k_isfinite",
      "k_isinf",
      "k_isnan",
      "k_less",
      "k_less_equal",
      "k_linspace",
      "k_log",
      "k_log10",
      "k_log1p",
      "k_log2",
      "k_logaddexp",
      "k_logical_and",
      "k_logical_not",
      "k_logical_or",
      "k_logical_xor",
      "k_logspace",
      "k_matmul",
      "k_max",
      "k_maximum",
      "k_mean",
      "k_median",
      "k_meshgrid",
      "k_min",
      "k_minimum",
      "k_mod",
      "k_moveaxis",
      "k_multiply",
      "k_nan_to_num",
      "k_ndim",
      "k_negative",
      "k_nonzero",
      "k_not_equal",
      "k_numpy_abs",
      "k_numpy_absolute",
      "k_numpy_add",
      "k_numpy_all",
      "k_numpy_amax",
      "k_numpy_amin",
      "k_numpy_any",
      "k_numpy_append",
      "k_numpy_arange",
      "k_numpy_arccos",
      "k_numpy_arccosh",
      "k_numpy_arcsin",
      "k_numpy_arcsinh",
      "k_numpy_arctan",
      "k_numpy_arctan2",
      "k_numpy_arctanh",
      "k_numpy_argmax",
      "k_numpy_argmin",
      "k_numpy_argsort",
      "k_numpy_array",
      "k_numpy_average",
      "k_numpy_bincount",
      "k_numpy_broadcast_to",
      "k_numpy_ceil",
      "k_numpy_clip",
      "k_numpy_concatenate",
      "k_numpy_conj",
      "k_numpy_conjugate",
      "k_numpy_copy",
      "k_numpy_cos",
      "k_numpy_cosh",
      "k_numpy_count_nonzero",
      "k_numpy_cross",
      "k_numpy_cumprod",
      "k_numpy_cumsum",
      "k_numpy_diag",
      "k_numpy_diagonal",
      "k_numpy_diff",
      "k_numpy_digitize",
      "k_numpy_divide",
      "k_numpy_dot",
      "k_numpy_einsum",
      "k_numpy_empty",
      "k_numpy_equal",
      "k_numpy_exp",
      "k_numpy_expand_dims",
      "k_numpy_expm1",
      "k_numpy_eye",
      "k_numpy_flip",
      "k_numpy_floor",
      "k_numpy_floor_divide",
      "k_numpy_full",
      "k_numpy_full_like",
      "k_numpy_get_item",
      "k_numpy_greater",
      "k_numpy_greater_equal",
      "k_numpy_hstack",
      "k_numpy_identity",
      "k_numpy_imag",
      "k_numpy_isclose",
      "k_numpy_isfinite",
      "k_numpy_isinf",
      "k_numpy_isnan",
      "k_numpy_less",
      "k_numpy_less_equal",
      "k_numpy_linspace",
      "k_numpy_log",
      "k_numpy_log10",
      "k_numpy_log1p",
      "k_numpy_log2",
      "k_numpy_logaddexp",
      "k_numpy_logical_and",
      "k_numpy_logical_not",
      "k_numpy_logical_or",
      "k_numpy_logical_xor",
      "k_numpy_logspace",
      "k_numpy_matmul",
      "k_numpy_max",
      "k_numpy_maximum",
      "k_numpy_mean",
      "k_numpy_median",
      "k_numpy_meshgrid",
      "k_numpy_min",
      "k_numpy_minimum",
      "k_numpy_mod",
      "k_numpy_moveaxis",
      "k_numpy_multiply",
      "k_numpy_nan_to_num",
      "k_numpy_ndim",
      "k_numpy_negative",
      "k_numpy_nonzero",
      "k_numpy_not_equal",
      "k_numpy_ones",
      "k_numpy_ones_like",
      "k_numpy_outer",
      "k_numpy_pad",
      "k_numpy_power",
      "k_numpy_prod",
      "k_numpy_quantile",
      "k_numpy_ravel",
      "k_numpy_real",
      "k_numpy_reciprocal",
      "k_numpy_repeat",
      "k_numpy_reshape",
      "k_numpy_roll",
      "k_numpy_round",
      "k_numpy_sign",
      "k_numpy_sin",
      "k_numpy_sinh",
      "k_numpy_size",
      "k_numpy_sort",
      "k_numpy_split",
      "k_numpy_sqrt",
      "k_numpy_square",
      "k_numpy_squeeze",
      "k_numpy_stack",
      "k_numpy_std",
      "k_numpy_subtract",
      "k_numpy_sum",
      "k_numpy_swapaxes",
      "k_numpy_take",
      "k_numpy_take_along_axis",
      "k_numpy_tan",
      "k_numpy_tanh",
      "k_numpy_tensordot",
      "k_numpy_tile",
      "k_numpy_trace",
      "k_numpy_transpose",
      "k_numpy_tri",
      "k_numpy_tril",
      "k_numpy_triu",
      "k_numpy_true_divide",
      "k_numpy_var",
      "k_numpy_vdot",
      "k_numpy_vstack",
      "k_numpy_where",
      "k_numpy_zeros",
      "k_numpy_zeros_like",
      "k_ones",
      "k_ones_like",
      "k_outer",
      "k_pad",
      "k_power",
      "k_prod",
      "k_quantile",
      "k_ravel",
      "k_real",
      "k_reciprocal",
      "k_repeat",
      "k_reshape",
      "k_roll",
      "k_round",
      "k_sign",
      "k_sin",
      "k_sinh",
      "k_size",
      "k_sort",
      "k_split",
      "k_sqrt",
      "k_square",
      "k_squeeze",
      "k_stack",
      "k_std",
      "k_subtract",
      "k_sum",
      "k_swapaxes",
      "k_take",
      "k_take_along_axis",
      "k_tan",
      "k_tanh",
      "k_tensordot",
      "k_tile",
      "k_trace",
      "k_transpose",
      "k_tri",
      "k_tril",
      "k_triu",
      "k_true_divide",
      "k_var",
      "k_vdot",
      "k_vstack",
      "k_where",
      "k_zeros",
      "k_zeros_like"
    ),
    `object registration saving` = c(
      "saving_custom_object_scope",
      "saving_get_custom_objects",
      "saving_get_registered_name",
      "saving_get_registered_object",
      "saving_register_keras_serializable",
      "custom_object_scope",
      "get_custom_objects",
      "get_registered_name",
      "get_registered_object",
      "register_keras_serializable"
    ),
    ops = c(
      "function",
      "operation",
      "k_abs",
      "k_absolute",
      "k_add",
      "k_all",
      "k_amax",
      "k_amin",
      "k_any",
      "k_append",
      "k_arange",
      "k_arccos",
      "k_arccosh",
      "k_arcsin",
      "k_arcsinh",
      "k_arctan",
      "k_arctan2",
      "k_arctanh",
      "k_argmax",
      "k_argmin",
      "k_argsort",
      "k_array",
      "k_average",
      "k_average_pool",
      "k_binary_crossentropy",
      "k_bincount",
      "k_broadcast_to",
      "k_cast",
      "k_categorical_crossentropy",
      "k_ceil",
      "k_clip",
      "k_concatenate",
      "k_cond",
      "k_conj",
      "k_conjugate",
      "k_conv",
      "k_conv_transpose",
      "k_convert_to_numpy",
      "k_convert_to_tensor",
      "k_copy",
      "k_cos",
      "k_cosh",
      "k_count_nonzero",
      "k_cross",
      "k_cumprod",
      "k_cumsum",
      "k_depthwise_conv",
      "k_diag",
      "k_diagonal",
      "k_diff",
      "k_digitize",
      "k_divide",
      "k_dot",
      "k_einsum",
      "k_elu",
      "k_empty",
      "k_equal",
      "k_erf",
      "k_exp",
      "k_expand_dims",
      "k_expm1",
      "k_extract_sequences",
      "k_eye",
      "k_fft",
      "k_fft2",
      "k_flip",
      "k_floor",
      "k_floor_divide",
      "k_fori_loop",
      "k_full",
      "k_full_like",
      "k_gelu",
      "k_get_item",
      "k_greater",
      "k_greater_equal",
      "k_hard_sigmoid",
      "k_hstack",
      "k_identity",
      "k_imag",
      "k_image_affine_transform",
      "k_image_extract_patches",
      "k_image_map_coordinates",
      "k_image_pad_images",
      "k_image_resize",
      "k_in_top_k",
      "k_irfft",
      "k_is_tensor",
      "k_isclose",
      "k_isfinite",
      "k_isinf",
      "k_isnan",
      "k_istft",
      "k_leaky_relu",
      "k_less",
      "k_less_equal",
      "k_linspace",
      "k_log",
      "k_log_sigmoid",
      "k_log_softmax",
      "k_log10",
      "k_log1p",
      "k_log2",
      "k_logaddexp",
      "k_logical_and",
      "k_logical_not",
      "k_logical_or",
      "k_logical_xor",
      "k_logspace",
      "k_logsumexp",
      "k_matmul",
      "k_max",
      "k_max_pool",
      "k_maximum",
      "k_mean",
      "k_median",
      "k_meshgrid",
      "k_min",
      "k_minimum",
      "k_mod",
      "k_moments",
      "k_moveaxis",
      "k_multi_hot",
      "k_multiply",
      "k_nan_to_num",
      "k_ndim",
      "k_negative",
      "k_nn_average_pool",
      "k_nn_binary_crossentropy",
      "k_nn_categorical_crossentropy",
      "k_nn_conv",
      "k_nn_conv_transpose",
      "k_nn_depthwise_conv",
      "k_nn_elu",
      "k_nn_gelu",
      "k_nn_hard_sigmoid",
      "k_nn_leaky_relu",
      "k_nn_log_sigmoid",
      "k_nn_log_softmax",
      "k_nn_max_pool",
      "k_nn_moments",
      "k_nn_multi_hot",
      "k_nn_one_hot",
      "k_nn_relu",
      "k_nn_relu6",
      "k_nn_selu",
      "k_nn_separable_conv",
      "k_nn_sigmoid",
      "k_nn_silu",
      "k_nn_softmax",
      "k_nn_softplus",
      "k_nn_softsign",
      "k_nn_sparse_categorical_crossentropy",
      "k_nn_swish",
      "k_nonzero",
      "k_not_equal",
      "k_numpy_abs",
      "k_numpy_absolute",
      "k_numpy_add",
      "k_numpy_all",
      "k_numpy_amax",
      "k_numpy_amin",
      "k_numpy_any",
      "k_numpy_append",
      "k_numpy_arange",
      "k_numpy_arccos",
      "k_numpy_arccosh",
      "k_numpy_arcsin",
      "k_numpy_arcsinh",
      "k_numpy_arctan",
      "k_numpy_arctan2",
      "k_numpy_arctanh",
      "k_numpy_argmax",
      "k_numpy_argmin",
      "k_numpy_argsort",
      "k_numpy_array",
      "k_numpy_average",
      "k_numpy_bincount",
      "k_numpy_broadcast_to",
      "k_numpy_ceil",
      "k_numpy_clip",
      "k_numpy_concatenate",
      "k_numpy_conj",
      "k_numpy_conjugate",
      "k_numpy_copy",
      "k_numpy_cos",
      "k_numpy_cosh",
      "k_numpy_count_nonzero",
      "k_numpy_cross",
      "k_numpy_cumprod",
      "k_numpy_cumsum",
      "k_numpy_diag",
      "k_numpy_diagonal",
      "k_numpy_diff",
      "k_numpy_digitize",
      "k_numpy_divide",
      "k_numpy_dot",
      "k_numpy_einsum",
      "k_numpy_empty",
      "k_numpy_equal",
      "k_numpy_exp",
      "k_numpy_expand_dims",
      "k_numpy_expm1",
      "k_numpy_eye",
      "k_numpy_flip",
      "k_numpy_floor",
      "k_numpy_floor_divide",
      "k_numpy_full",
      "k_numpy_full_like",
      "k_numpy_get_item",
      "k_numpy_greater",
      "k_numpy_greater_equal",
      "k_numpy_hstack",
      "k_numpy_identity",
      "k_numpy_imag",
      "k_numpy_isclose",
      "k_numpy_isfinite",
      "k_numpy_isinf",
      "k_numpy_isnan",
      "k_numpy_less",
      "k_numpy_less_equal",
      "k_numpy_linspace",
      "k_numpy_log",
      "k_numpy_log10",
      "k_numpy_log1p",
      "k_numpy_log2",
      "k_numpy_logaddexp",
      "k_numpy_logical_and",
      "k_numpy_logical_not",
      "k_numpy_logical_or",
      "k_numpy_logical_xor",
      "k_numpy_logspace",
      "k_numpy_matmul",
      "k_numpy_max",
      "k_numpy_maximum",
      "k_numpy_mean",
      "k_numpy_median",
      "k_numpy_meshgrid",
      "k_numpy_min",
      "k_numpy_minimum",
      "k_numpy_mod",
      "k_numpy_moveaxis",
      "k_numpy_multiply",
      "k_numpy_nan_to_num",
      "k_numpy_ndim",
      "k_numpy_negative",
      "k_numpy_nonzero",
      "k_numpy_not_equal",
      "k_numpy_ones",
      "k_numpy_ones_like",
      "k_numpy_outer",
      "k_numpy_pad",
      "k_numpy_power",
      "k_numpy_prod",
      "k_numpy_quantile",
      "k_numpy_ravel",
      "k_numpy_real",
      "k_numpy_reciprocal",
      "k_numpy_repeat",
      "k_numpy_reshape",
      "k_numpy_roll",
      "k_numpy_round",
      "k_numpy_sign",
      "k_numpy_sin",
      "k_numpy_sinh",
      "k_numpy_size",
      "k_numpy_sort",
      "k_numpy_split",
      "k_numpy_sqrt",
      "k_numpy_square",
      "k_numpy_squeeze",
      "k_numpy_stack",
      "k_numpy_std",
      "k_numpy_subtract",
      "k_numpy_sum",
      "k_numpy_swapaxes",
      "k_numpy_take",
      "k_numpy_take_along_axis",
      "k_numpy_tan",
      "k_numpy_tanh",
      "k_numpy_tensordot",
      "k_numpy_tile",
      "k_numpy_trace",
      "k_numpy_transpose",
      "k_numpy_tri",
      "k_numpy_tril",
      "k_numpy_triu",
      "k_numpy_true_divide",
      "k_numpy_var",
      "k_numpy_vdot",
      "k_numpy_vstack",
      "k_numpy_where",
      "k_numpy_zeros",
      "k_numpy_zeros_like",
      "k_one_hot",
      "k_ones",
      "k_ones_like",
      "k_outer",
      "k_pad",
      "k_power",
      "k_prod",
      "k_qr",
      "k_quantile",
      "k_ravel",
      "k_real",
      "k_reciprocal",
      "k_relu",
      "k_relu6",
      "k_repeat",
      "k_reshape",
      "k_rfft",
      "k_roll",
      "k_round",
      "k_rsqrt",
      "k_scatter",
      "k_scatter_update",
      "k_segment_max",
      "k_segment_sum",
      "k_selu",
      "k_separable_conv",
      "k_shape",
      "k_sigmoid",
      "k_sign",
      "k_silu",
      "k_sin",
      "k_sinh",
      "k_size",
      "k_slice",
      "k_slice_update",
      "k_softmax",
      "k_softplus",
      "k_softsign",
      "k_solve",
      "k_sort",
      "k_sparse_categorical_crossentropy",
      "k_split",
      "k_sqrt",
      "k_square",
      "k_squeeze",
      "k_stack",
      "k_std",
      "k_stft",
      "k_stop_gradient",
      "k_subtract",
      "k_sum",
      "k_swapaxes",
      "k_swish",
      "k_take",
      "k_take_along_axis",
      "k_tan",
      "k_tanh",
      "k_tensordot",
      "k_tile",
      "k_top_k",
      "k_trace",
      "k_transpose",
      "k_tri",
      "k_tril",
      "k_triu",
      "k_true_divide",
      "k_unstack",
      "k_var",
      "k_vdot",
      "k_vectorized_map",
      "k_vstack",
      "k_where",
      "k_while_loop",
      "k_zeros",
      "k_zeros_like"
    ),
    optimizers = c(
      "mixed_precision_loss_scale_optimizer",
      "optimizer",
      "optimizer_adadelta",
      "optimizer_adafactor",
      "optimizer_adagrad",
      "optimizer_adam",
      "optimizer_adamax",
      "optimizer_adam_w",
      "optimizer_ftrl",
      "optimizer_lion",
      "optimizer_loss_scale",
      "optimizer_nadam",
      "optimizer_rmsprop",
      "optimizer_sgd"
    ),
    `pooling layers` = c(
      "layer_average_pooling_1d",
      "layer_average_pooling_2d",
      "layer_average_pooling_3d",
      "layer_avg_pool_1d",
      "layer_avg_pool_2d",
      "layer_avg_pool_3d",
      "layer_global_average_pooling_1d",
      "layer_global_average_pooling_2d",
      "layer_global_average_pooling_3d",
      "layer_global_avg_pool_1d",
      "layer_global_avg_pool_2d",
      "layer_global_avg_pool_3d",
      "layer_global_max_pool_1d",
      "layer_global_max_pool_2d",
      "layer_global_max_pool_3d",
      "layer_global_max_pooling_1d",
      "layer_global_max_pooling_2d",
      "layer_global_max_pooling_3d",
      "layer_max_pool_1d",
      "layer_max_pool_2d",
      "layer_max_pool_3d",
      "layer_max_pooling_1d",
      "layer_max_pooling_2d",
      "layer_max_pooling_3d"
    ),
    preprocessing = c(
      "image_array_to_img",
      "image_img_to_array",
      "image_load_img",
      "image_save_img",
      "image_smart_resize",
      "image_dataset_from_directory",
      "sequence_pad_sequences",
      "text_dataset_from_directory",
      "timeseries_dataset_from_array"
    ),
    `preprocessing layers` = c(
      "layer_category_encoding",
      "layer_center_crop",
      "layer_discretization",
      "layer_hashed_crossing",
      "layer_hashing",
      "layer_integer_lookup",
      "layer_normalization",
      "layer_random_brightness",
      "layer_random_contrast",
      "layer_random_crop",
      "layer_random_flip",
      "layer_random_rotation",
      "layer_random_translation",
      "layer_random_zoom",
      "layer_rescaling",
      "layer_resizing",
      "layer_string_lookup",
      "layer_text_vectorization",
      "layer_feature_space"
    ),
    `probabilistic metrics` = c(
      "metric_binary_crossentropy",
      "metric_categorical_crossentropy",
      "metric_kl_divergence",
      "metric_poisson",
      "metric_sparse_categorical_crossentropy"
    ),
    random = c(
      "random_categorical",
      "random_dropout",
      "random_gamma",
      "random_normal",
      "random_integer",
      "random_seed_generator",
      "random_shuffle",
      "random_truncated_normal",
      "random_uniform"
    ),
    `random initializers` = c(
      "initializer_glorot_normal",
      "initializer_glorot_uniform",
      "initializer_he_normal",
      "initializer_he_uniform",
      "initializer_lecun_normal",
      "initializer_lecun_uniform",
      "initializer_orthogonal",
      "initializer_random_normal",
      "initializer_random_uniform",
      "initializer_truncated_normal",
      "initializer_variance_scaling"
    ),
    `reduction metrics` = c("metric_mean", "metric_mean_wrapper",
                            "metric_sum"),
    `regression metrics` = c(
      "metric_cosine_similarity",
      "metric_log_cosh_error",
      "metric_mean_absolute_error",
      "metric_mean_absolute_percentage_error",
      "metric_mean_squared_error",
      "metric_mean_squared_logarithmic_error",
      "metric_r2_score",
      "metric_root_mean_squared_error"
    ),
    `regularization layers` = c(
      "layer_activity_regularization",
      "layer_dropout",
      "layer_gaussian_dropout",
      "layer_gaussian_noise",
      "layer_spatial_dropout_1d",
      "layer_spatial_dropout_2d",
      "layer_spatial_dropout_3d"
    ),
    regularizers = c(
      "regularizer",
      "regularizer_l1",
      "regularizer_l1_l2",
      "regularizer_l2",
      "regularizer_orthogonal"
    ),
    `reshaping layers` = c(
      "layer_cropping_1d",
      "layer_cropping_2d",
      "layer_cropping_3d",
      "layer_flatten",
      "layer_permute",
      "layer_repeat_vector",
      "layer_reshape",
      "layer_upsampling_1d",
      "layer_upsampling_2d",
      "layer_upsampling_3d",
      "layer_zero_padding_1d",
      "layer_zero_padding_2d",
      "layer_zero_padding_3d"
    ),
    `rnn layers` = c(
      "bidirectional",
      "layer_conv_lstm_1d",
      "layer_conv_lstm_2d",
      "layer_conv_lstm_3d",
      "layer_gru",
      "rnn_cell_gru",
      "layer_lstm",
      "rnn_cell_lstm",
      "layer_rnn",
      "layer_simple_rnn",
      "rnn_cell_simple",
      "rnn_cells_stack",
      "layer_time_distributed"
    ),
    saving = c(
      "config_enable_unsafe_deserialization",
      "layer_tfsm",
      "model_load",
      "model_save",
      "saving_custom_object_scope",
      "saving_deserialize_keras_object",
      "saving_get_custom_objects",
      "saving_get_registered_name",
      "saving_get_registered_object",
      "saving_load_model",
      "saving_register_keras_serializable",
      "saving_save_model",
      "saving_serialize_keras_object",
      "custom_object_scope",
      "deserialize_keras_object",
      "get_custom_objects",
      "get_registered_name",
      "get_registered_object",
      "register_keras_serializable",
      "serialize_keras_object"
    ),
    `schedule optimizers` = c(
      "learning_rate_schedule_cosine_decay",
      "learning_rate_schedule_cosine_decay_restarts",
      "learning_rate_schedule_exponential_decay",
      "learning_rate_schedule_inverse_time_decay",
      "learning_rate_schedule",
      "learning_rate_schedule_piecewise_constant_decay",
      "learning_rate_schedule_polynomial_decay"
    ),
    `simple rnn layers` = c("layer_simple_rnn", "rnn_cell_simple"),
    `spatial dropout regularization layers` = c(
      "layer_spatial_dropout_1d",
      "layer_spatial_dropout_2d",
      "layer_spatial_dropout_3d"
    ),
    `subtract merging layers` = "layer_subtract",
    `text dataset utils` = "text_dataset_from_directory",
    `timesery dataset utils` = "timeseries_dataset_from_array",
    `traceback utils` = c(
      "config_disable_traceback_filtering",
      "config_enable_traceback_filtering",
      "config_is_traceback_filtering_enabled"
    ),
    trainers = c(
      "pack_x_y_sample_weight",
      "py_dataset",
      "sequence",
      "unpack_x_y_sample_weight"
    ),
    utils = c(
      "backend_get_uid",
      "config_disable_interactive_logging",
      "config_disable_traceback_filtering",
      "config_enable_interactive_logging",
      "config_enable_traceback_filtering",
      "config_is_interactive_logging_enabled",
      "config_is_traceback_filtering_enabled",
      "layer_torch_module_wrapper",
      "image_array_to_img",
      "image_img_to_array",
      "image_load_img",
      "image_save_img",
      "image_smart_resize",
      "image_dataset_from_directory",
      "sequence_pad_sequences",
      "text_dataset_from_directory",
      "timeseries_dataset_from_array",
      "image_from_array",
      "audio_dataset_from_directory",
      "clear_session",
      "custom_object_scope",
      "deserialize_keras_object",
      "disable_interactive_logging",
      "enable_interactive_logging",
      "layer_feature_space",
      "get_custom_objects",
      "get_file",
      "get_registered_name",
      "get_registered_object",
      "get_source_inputs",
      "image_to_array",
      "is_interactive_logging_enabled",
      "is_keras_tensor",
      "legacy_deserialize_keras_object",
      "legacy_serialize_keras_object",
      "image_load",
      "model_to_dot",
      "normalize",
      "pack_x_y_sample_weight",
      "pad_sequences",
      "plot_model",
      "progbar",
      "py_dataset",
      "register_keras_serializable",
      "image_array_save",
      "sequence",
      "serialize_keras_object",
      "set_random_seed",
      "split_dataset",
      "to_categorical",
      "unpack_x_y_sample_weight"
    )
  )