Add files using upload-large-folder tool

lib/python3.10/site-packages/keras_core/_tf_keras/__init__.py

@@ -0,0 +1,54 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core import activations
+from keras_core import applications
+from keras_core import callbacks
+from keras_core import config
+from keras_core import constraints
+from keras_core import datasets
+from keras_core import distribution
+from keras_core import export
+from keras_core import initializers
+from keras_core import legacy
+from keras_core import metrics
+from keras_core import mixed_precision
+from keras_core import models
+from keras_core import ops
+from keras_core import optimizers
+from keras_core import random
+from keras_core import regularizers
+from keras_core import utils
+from keras_core.src.backend.common.keras_tensor import KerasTensor
+from keras_core.src.backend.common.stateless_scope import StatelessScope
+from keras_core.src.backend.exports import Variable
+from keras_core.src.backend.exports import name_scope
+from keras_core.src.initializers.initializer import Initializer
+from keras_core.src.layers.core.input_layer import Input
+from keras_core.src.layers.input_spec import InputSpec
+from keras_core.src.layers.layer import Layer
+from keras_core.src.losses.loss import Loss
+from keras_core.src.metrics.metric import Metric
+from keras_core.src.models.model import Model
+from keras_core.src.models.sequential import Sequential
+from keras_core.src.ops.function import Function
+from keras_core.src.ops.operation import Operation
+from keras_core.src.optimizers.optimizer import Optimizer
+from keras_core.src.regularizers.regularizers import Regularizer
+
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core._tf_keras import backend
+from keras_core._tf_keras import layers
+from keras_core._tf_keras import losses
+from keras_core._tf_keras import metrics
+from keras_core._tf_keras import preprocessing

lib/python3.10/site-packages/keras_core/_tf_keras/applications/__init__.py

@@ -0,0 +1,64 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.applications import convnext
+from keras_core.applications import densenet
+from keras_core.applications import efficientnet
+from keras_core.applications import efficientnet_v2
+from keras_core.applications import imagenet_utils
+from keras_core.applications import inception_resnet_v2
+from keras_core.applications import inception_v3
+from keras_core.applications import mobilenet
+from keras_core.applications import mobilenet_v2
+from keras_core.applications import mobilenet_v3
+from keras_core.applications import nasnet
+from keras_core.applications import resnet
+from keras_core.applications import resnet50
+from keras_core.applications import resnet_v2
+from keras_core.applications import vgg16
+from keras_core.applications import vgg19
+from keras_core.applications import xception
+from keras_core.src.applications.convnext import ConvNeXtBase
+from keras_core.src.applications.convnext import ConvNeXtLarge
+from keras_core.src.applications.convnext import ConvNeXtSmall
+from keras_core.src.applications.convnext import ConvNeXtTiny
+from keras_core.src.applications.convnext import ConvNeXtXLarge
+from keras_core.src.applications.densenet import DenseNet121
+from keras_core.src.applications.densenet import DenseNet169
+from keras_core.src.applications.densenet import DenseNet201
+from keras_core.src.applications.efficientnet import EfficientNetB0
+from keras_core.src.applications.efficientnet import EfficientNetB1
+from keras_core.src.applications.efficientnet import EfficientNetB2
+from keras_core.src.applications.efficientnet import EfficientNetB3
+from keras_core.src.applications.efficientnet import EfficientNetB4
+from keras_core.src.applications.efficientnet import EfficientNetB5
+from keras_core.src.applications.efficientnet import EfficientNetB6
+from keras_core.src.applications.efficientnet import EfficientNetB7
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2B0
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2B1
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2B2
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2B3
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2L
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2M
+from keras_core.src.applications.efficientnet_v2 import EfficientNetV2S
+from keras_core.src.applications.inception_resnet_v2 import InceptionResNetV2
+from keras_core.src.applications.inception_v3 import InceptionV3
+from keras_core.src.applications.mobilenet import MobileNet
+from keras_core.src.applications.mobilenet_v2 import MobileNetV2
+from keras_core.src.applications.mobilenet_v3 import MobileNetV3Large
+from keras_core.src.applications.mobilenet_v3 import MobileNetV3Small
+from keras_core.src.applications.nasnet import NASNetLarge
+from keras_core.src.applications.nasnet import NASNetMobile
+from keras_core.src.applications.resnet import ResNet101
+from keras_core.src.applications.resnet import ResNet152
+from keras_core.src.applications.resnet import ResNet50
+from keras_core.src.applications.resnet_v2 import ResNet101V2
+from keras_core.src.applications.resnet_v2 import ResNet152V2
+from keras_core.src.applications.resnet_v2 import ResNet50V2
+from keras_core.src.applications.vgg16 import VGG16
+from keras_core.src.applications.vgg19 import VGG19
+from keras_core.src.applications.xception import Xception

lib/python3.10/site-packages/keras_core/_tf_keras/applications/convnext/__init__.py

@@ -0,0 +1,14 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.convnext import ConvNeXtBase
+from keras_core.src.applications.convnext import ConvNeXtLarge
+from keras_core.src.applications.convnext import ConvNeXtSmall
+from keras_core.src.applications.convnext import ConvNeXtTiny
+from keras_core.src.applications.convnext import ConvNeXtXLarge
+from keras_core.src.applications.convnext import decode_predictions
+from keras_core.src.applications.convnext import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/densenet/__init__.py

@@ -0,0 +1,12 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.densenet import DenseNet121
+from keras_core.src.applications.densenet import DenseNet169
+from keras_core.src.applications.densenet import DenseNet201
+from keras_core.src.applications.densenet import decode_predictions
+from keras_core.src.applications.densenet import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/mobilenet/__init__.py

@@ -0,0 +1,10 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.mobilenet import MobileNet
+from keras_core.src.applications.mobilenet import decode_predictions
+from keras_core.src.applications.mobilenet import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/mobilenet_v2/__init__.py

@@ -0,0 +1,10 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.mobilenet_v2 import MobileNetV2
+from keras_core.src.applications.mobilenet_v2 import decode_predictions
+from keras_core.src.applications.mobilenet_v2 import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/mobilenet_v3/__init__.py

@@ -0,0 +1,9 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.mobilenet_v3 import decode_predictions
+from keras_core.src.applications.mobilenet_v3 import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/resnet/__init__.py

@@ -0,0 +1,12 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.resnet import ResNet101
+from keras_core.src.applications.resnet import ResNet152
+from keras_core.src.applications.resnet import ResNet50
+from keras_core.src.applications.resnet import decode_predictions
+from keras_core.src.applications.resnet import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/resnet50/__init__.py

@@ -0,0 +1,10 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.resnet import ResNet50
+from keras_core.src.applications.resnet import decode_predictions
+from keras_core.src.applications.resnet import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/resnet_v2/__init__.py

@@ -0,0 +1,12 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.resnet_v2 import ResNet101V2
+from keras_core.src.applications.resnet_v2 import ResNet152V2
+from keras_core.src.applications.resnet_v2 import ResNet50V2
+from keras_core.src.applications.resnet_v2 import decode_predictions
+from keras_core.src.applications.resnet_v2 import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/applications/vgg16/__init__.py

@@ -0,0 +1,10 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.applications.vgg16 import VGG16
+from keras_core.src.applications.vgg16 import decode_predictions
+from keras_core.src.applications.vgg16 import preprocess_input

lib/python3.10/site-packages/keras_core/_tf_keras/callbacks/__init__.py

@@ -0,0 +1,20 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.callbacks.callback import Callback
+from keras_core.src.callbacks.callback_list import CallbackList
+from keras_core.src.callbacks.csv_logger import CSVLogger
+from keras_core.src.callbacks.early_stopping import EarlyStopping
+from keras_core.src.callbacks.history import History
+from keras_core.src.callbacks.lambda_callback import LambdaCallback
+from keras_core.src.callbacks.learning_rate_scheduler import LearningRateScheduler
+from keras_core.src.callbacks.model_checkpoint import ModelCheckpoint
+from keras_core.src.callbacks.progbar_logger import ProgbarLogger
+from keras_core.src.callbacks.reduce_lr_on_plateau import ReduceLROnPlateau
+from keras_core.src.callbacks.remote_monitor import RemoteMonitor
+from keras_core.src.callbacks.tensorboard import TensorBoard
+from keras_core.src.callbacks.terminate_on_nan import TerminateOnNaN

lib/python3.10/site-packages/keras_core/_tf_keras/config/__init__.py

@@ -0,0 +1,21 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.backend.config import backend
+from keras_core.src.backend.config import epsilon
+from keras_core.src.backend.config import floatx
+from keras_core.src.backend.config import image_data_format
+from keras_core.src.backend.config import set_epsilon
+from keras_core.src.backend.config import set_floatx
+from keras_core.src.backend.config import set_image_data_format
+from keras_core.src.saving.serialization_lib import enable_unsafe_deserialization
+from keras_core.src.utils.io_utils import disable_interactive_logging
+from keras_core.src.utils.io_utils import enable_interactive_logging
+from keras_core.src.utils.io_utils import is_interactive_logging_enabled
+from keras_core.src.utils.traceback_utils import disable_traceback_filtering
+from keras_core.src.utils.traceback_utils import enable_traceback_filtering
+from keras_core.src.utils.traceback_utils import is_traceback_filtering_enabled

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/__init__.py

@@ -0,0 +1,14 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.datasets import boston_housing
+from keras_core.datasets import cifar10
+from keras_core.datasets import cifar100
+from keras_core.datasets import fashion_mnist
+from keras_core.datasets import imdb
+from keras_core.datasets import mnist
+from keras_core.datasets import reuters

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/boston_housing/__init__.py

@@ -0,0 +1,9 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.boston_housing import load_data
+from keras_core.src.datasets.california_housing import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/cifar10/__init__.py

@@ -0,0 +1,8 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.cifar10 import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/cifar100/__init__.py

@@ -0,0 +1,8 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.cifar100 import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/fashion_mnist/__init__.py

@@ -0,0 +1,8 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.fashion_mnist import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/imdb/__init__.py

@@ -0,0 +1,9 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.imdb import get_word_index
+from keras_core.src.datasets.imdb import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/mnist/__init__.py

@@ -0,0 +1,8 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.mnist import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/datasets/reuters/__init__.py

@@ -0,0 +1,10 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.datasets.reuters import get_label_names
+from keras_core.src.datasets.reuters import get_word_index
+from keras_core.src.datasets.reuters import load_data

lib/python3.10/site-packages/keras_core/_tf_keras/export/__init__.py

@@ -0,0 +1,8 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.export.export_lib import ExportArchive

lib/python3.10/site-packages/keras_core/_tf_keras/layers/__init__.py

@@ -0,0 +1,157 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.export.export_lib import TFSMLayer
+from keras_core.src.layers import deserialize
+from keras_core.src.layers import serialize
+from keras_core.src.layers.activations.activation import Activation
+from keras_core.src.layers.activations.elu import ELU
+from keras_core.src.layers.activations.leaky_relu import LeakyReLU
+from keras_core.src.layers.activations.prelu import PReLU
+from keras_core.src.layers.activations.relu import ReLU
+from keras_core.src.layers.activations.softmax import Softmax
+from keras_core.src.layers.attention.additive_attention import AdditiveAttention
+from keras_core.src.layers.attention.attention import Attention
+from keras_core.src.layers.attention.multi_head_attention import MultiHeadAttention
+from keras_core.src.layers.convolutional.conv1d import Conv1D
+from keras_core.src.layers.convolutional.conv1d import Conv1D as Convolution1D
+from keras_core.src.layers.convolutional.conv1d_transpose import Conv1DTranspose
+from keras_core.src.layers.convolutional.conv1d_transpose import Conv1DTranspose as Convolution1DTranspose
+from keras_core.src.layers.convolutional.conv2d import Conv2D
+from keras_core.src.layers.convolutional.conv2d import Conv2D as Convolution2D
+from keras_core.src.layers.convolutional.conv2d_transpose import Conv2DTranspose
+from keras_core.src.layers.convolutional.conv2d_transpose import Conv2DTranspose as Convolution2DTranspose
+from keras_core.src.layers.convolutional.conv3d import Conv3D
+from keras_core.src.layers.convolutional.conv3d import Conv3D as Convolution3D
+from keras_core.src.layers.convolutional.conv3d_transpose import Conv3DTranspose
+from keras_core.src.layers.convolutional.conv3d_transpose import Conv3DTranspose as Convolution3DTranspose
+from keras_core.src.layers.convolutional.depthwise_conv1d import DepthwiseConv1D
+from keras_core.src.layers.convolutional.depthwise_conv2d import DepthwiseConv2D
+from keras_core.src.layers.convolutional.separable_conv1d import SeparableConv1D
+from keras_core.src.layers.convolutional.separable_conv1d import SeparableConv1D as SeparableConvolution1D
+from keras_core.src.layers.convolutional.separable_conv2d import SeparableConv2D
+from keras_core.src.layers.convolutional.separable_conv2d import SeparableConv2D as SeparableConvolution2D
+from keras_core.src.layers.core.dense import Dense
+from keras_core.src.layers.core.einsum_dense import EinsumDense
+from keras_core.src.layers.core.embedding import Embedding
+from keras_core.src.layers.core.identity import Identity
+from keras_core.src.layers.core.input_layer import Input
+from keras_core.src.layers.core.input_layer import InputLayer
+from keras_core.src.layers.core.lambda_layer import Lambda
+from keras_core.src.layers.core.masking import Masking
+from keras_core.src.layers.core.wrapper import Wrapper
+from keras_core.src.layers.input_spec import InputSpec
+from keras_core.src.layers.layer import Layer
+from keras_core.src.layers.merging.add import Add
+from keras_core.src.layers.merging.add import add
+from keras_core.src.layers.merging.average import Average
+from keras_core.src.layers.merging.average import average
+from keras_core.src.layers.merging.concatenate import Concatenate
+from keras_core.src.layers.merging.concatenate import concatenate
+from keras_core.src.layers.merging.dot import Dot
+from keras_core.src.layers.merging.dot import dot
+from keras_core.src.layers.merging.maximum import Maximum
+from keras_core.src.layers.merging.maximum import maximum
+from keras_core.src.layers.merging.minimum import Minimum
+from keras_core.src.layers.merging.minimum import minimum
+from keras_core.src.layers.merging.multiply import Multiply
+from keras_core.src.layers.merging.multiply import multiply
+from keras_core.src.layers.merging.subtract import Subtract
+from keras_core.src.layers.merging.subtract import subtract
+from keras_core.src.layers.normalization.batch_normalization import BatchNormalization
+from keras_core.src.layers.normalization.group_normalization import GroupNormalization
+from keras_core.src.layers.normalization.layer_normalization import LayerNormalization
+from keras_core.src.layers.normalization.spectral_normalization import SpectralNormalization
+from keras_core.src.layers.normalization.unit_normalization import UnitNormalization
+from keras_core.src.layers.pooling.average_pooling1d import AveragePooling1D
+from keras_core.src.layers.pooling.average_pooling1d import AveragePooling1D as AvgPool1D
+from keras_core.src.layers.pooling.average_pooling2d import AveragePooling2D
+from keras_core.src.layers.pooling.average_pooling2d import AveragePooling2D as AvgPool2D
+from keras_core.src.layers.pooling.average_pooling3d import AveragePooling3D
+from keras_core.src.layers.pooling.average_pooling3d import AveragePooling3D as AvgPool3D
+from keras_core.src.layers.pooling.global_average_pooling1d import GlobalAveragePooling1D
+from keras_core.src.layers.pooling.global_average_pooling1d import GlobalAveragePooling1D as GlobalAvgPool1D
+from keras_core.src.layers.pooling.global_average_pooling2d import GlobalAveragePooling2D
+from keras_core.src.layers.pooling.global_average_pooling2d import GlobalAveragePooling2D as GlobalAvgPool2D
+from keras_core.src.layers.pooling.global_average_pooling3d import GlobalAveragePooling3D
+from keras_core.src.layers.pooling.global_average_pooling3d import GlobalAveragePooling3D as GlobalAvgPool3D
+from keras_core.src.layers.pooling.global_max_pooling1d import GlobalMaxPooling1D
+from keras_core.src.layers.pooling.global_max_pooling1d import GlobalMaxPooling1D as GlobalMaxPool1D
+from keras_core.src.layers.pooling.global_max_pooling2d import GlobalMaxPooling2D
+from keras_core.src.layers.pooling.global_max_pooling2d import GlobalMaxPooling2D as GlobalMaxPool2D
+from keras_core.src.layers.pooling.global_max_pooling3d import GlobalMaxPooling3D
+from keras_core.src.layers.pooling.global_max_pooling3d import GlobalMaxPooling3D as GlobalMaxPool3D
+from keras_core.src.layers.pooling.max_pooling1d import MaxPooling1D
+from keras_core.src.layers.pooling.max_pooling1d import MaxPooling1D as MaxPool1D
+from keras_core.src.layers.pooling.max_pooling2d import MaxPooling2D
+from keras_core.src.layers.pooling.max_pooling2d import MaxPooling2D as MaxPool2D
+from keras_core.src.layers.pooling.max_pooling3d import MaxPooling3D
+from keras_core.src.layers.pooling.max_pooling3d import MaxPooling3D as MaxPool3D
+from keras_core.src.layers.preprocessing.category_encoding import CategoryEncoding
+from keras_core.src.layers.preprocessing.center_crop import CenterCrop
+from keras_core.src.layers.preprocessing.discretization import Discretization
+from keras_core.src.layers.preprocessing.hashed_crossing import HashedCrossing
+from keras_core.src.layers.preprocessing.hashing import Hashing
+from keras_core.src.layers.preprocessing.integer_lookup import IntegerLookup
+from keras_core.src.layers.preprocessing.normalization import Normalization
+from keras_core.src.layers.preprocessing.random_brightness import RandomBrightness
+from keras_core.src.layers.preprocessing.random_contrast import RandomContrast
+from keras_core.src.layers.preprocessing.random_crop import RandomCrop
+from keras_core.src.layers.preprocessing.random_flip import RandomFlip
+from keras_core.src.layers.preprocessing.random_rotation import RandomRotation
+from keras_core.src.layers.preprocessing.random_translation import RandomTranslation
+from keras_core.src.layers.preprocessing.random_zoom import RandomZoom
+from keras_core.src.layers.preprocessing.rescaling import Rescaling
+from keras_core.src.layers.preprocessing.resizing import Resizing
+from keras_core.src.layers.preprocessing.string_lookup import StringLookup
+from keras_core.src.layers.preprocessing.text_vectorization import TextVectorization
+from keras_core.src.layers.regularization.activity_regularization import ActivityRegularization
+from keras_core.src.layers.regularization.dropout import Dropout
+from keras_core.src.layers.regularization.gaussian_dropout import GaussianDropout
+from keras_core.src.layers.regularization.gaussian_noise import GaussianNoise
+from keras_core.src.layers.regularization.spatial_dropout import SpatialDropout1D
+from keras_core.src.layers.regularization.spatial_dropout import SpatialDropout2D
+from keras_core.src.layers.regularization.spatial_dropout import SpatialDropout3D
+from keras_core.src.layers.reshaping.cropping1d import Cropping1D
+from keras_core.src.layers.reshaping.cropping2d import Cropping2D
+from keras_core.src.layers.reshaping.cropping3d import Cropping3D
+from keras_core.src.layers.reshaping.flatten import Flatten
+from keras_core.src.layers.reshaping.permute import Permute
+from keras_core.src.layers.reshaping.repeat_vector import RepeatVector
+from keras_core.src.layers.reshaping.reshape import Reshape
+from keras_core.src.layers.reshaping.up_sampling1d import UpSampling1D
+from keras_core.src.layers.reshaping.up_sampling2d import UpSampling2D
+from keras_core.src.layers.reshaping.up_sampling3d import UpSampling3D
+from keras_core.src.layers.reshaping.zero_padding1d import ZeroPadding1D
+from keras_core.src.layers.reshaping.zero_padding2d import ZeroPadding2D
+from keras_core.src.layers.reshaping.zero_padding3d import ZeroPadding3D
+from keras_core.src.layers.rnn.bidirectional import Bidirectional
+from keras_core.src.layers.rnn.conv_lstm1d import ConvLSTM1D
+from keras_core.src.layers.rnn.conv_lstm2d import ConvLSTM2D
+from keras_core.src.layers.rnn.conv_lstm3d import ConvLSTM3D
+from keras_core.src.layers.rnn.gru import GRU
+from keras_core.src.layers.rnn.gru import GRUCell
+from keras_core.src.layers.rnn.lstm import LSTM
+from keras_core.src.layers.rnn.lstm import LSTMCell
+from keras_core.src.layers.rnn.rnn import RNN
+from keras_core.src.layers.rnn.simple_rnn import SimpleRNN
+from keras_core.src.layers.rnn.simple_rnn import SimpleRNNCell
+from keras_core.src.layers.rnn.stacked_rnn_cells import StackedRNNCells
+from keras_core.src.layers.rnn.time_distributed import TimeDistributed
+from keras_core.src.utils.torch_utils import TorchModuleWrapper
+
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.legacy.layers import AlphaDropout
+from keras_core.src.legacy.layers import RandomHeight
+from keras_core.src.legacy.layers import RandomWidth
+from keras_core.src.legacy.layers import ThresholdedReLU

lib/python3.10/site-packages/keras_core/_tf_keras/legacy/__init__.py

@@ -0,0 +1,8 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.legacy import saving

lib/python3.10/site-packages/keras_core/_tf_keras/legacy/saving/__init__.py

@@ -0,0 +1,9 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.legacy.saving.serialization import deserialize_keras_object
+from keras_core.src.legacy.saving.serialization import serialize_keras_object

lib/python3.10/site-packages/keras_core/_tf_keras/optimizers/__init__.py

@@ -0,0 +1,24 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.optimizers import schedules
+from keras_core.src.optimizers import deserialize
+from keras_core.src.optimizers import get
+from keras_core.src.optimizers import serialize
+from keras_core.src.optimizers.adadelta import Adadelta
+from keras_core.src.optimizers.adafactor import Adafactor
+from keras_core.src.optimizers.adagrad import Adagrad
+from keras_core.src.optimizers.adam import Adam
+from keras_core.src.optimizers.adamax import Adamax
+from keras_core.src.optimizers.adamw import AdamW
+from keras_core.src.optimizers.ftrl import Ftrl
+from keras_core.src.optimizers.lion import Lion
+from keras_core.src.optimizers.loss_scale_optimizer import LossScaleOptimizer
+from keras_core.src.optimizers.nadam import Nadam
+from keras_core.src.optimizers.optimizer import Optimizer
+from keras_core.src.optimizers.rmsprop import RMSprop
+from keras_core.src.optimizers.sgd import SGD

lib/python3.10/site-packages/keras_core/_tf_keras/optimizers/schedules/__init__.py

@@ -0,0 +1,16 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.optimizers.schedules.learning_rate_schedule import CosineDecay
+from keras_core.src.optimizers.schedules.learning_rate_schedule import CosineDecayRestarts
+from keras_core.src.optimizers.schedules.learning_rate_schedule import ExponentialDecay
+from keras_core.src.optimizers.schedules.learning_rate_schedule import InverseTimeDecay
+from keras_core.src.optimizers.schedules.learning_rate_schedule import LearningRateSchedule
+from keras_core.src.optimizers.schedules.learning_rate_schedule import PiecewiseConstantDecay
+from keras_core.src.optimizers.schedules.learning_rate_schedule import PolynomialDecay
+from keras_core.src.optimizers.schedules.learning_rate_schedule import deserialize
+from keras_core.src.optimizers.schedules.learning_rate_schedule import serialize

lib/python3.10/site-packages/keras_core/_tf_keras/regularizers/__init__.py

@@ -0,0 +1,19 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.regularizers import deserialize
+from keras_core.src.regularizers import get
+from keras_core.src.regularizers import serialize
+from keras_core.src.regularizers.regularizers import L1
+from keras_core.src.regularizers.regularizers import L1 as l1
+from keras_core.src.regularizers.regularizers import L1L2
+from keras_core.src.regularizers.regularizers import L1L2 as l1_l2
+from keras_core.src.regularizers.regularizers import L2
+from keras_core.src.regularizers.regularizers import L2 as l2
+from keras_core.src.regularizers.regularizers import OrthogonalRegularizer
+from keras_core.src.regularizers.regularizers import OrthogonalRegularizer as orthogonal_regularizer
+from keras_core.src.regularizers.regularizers import Regularizer

lib/python3.10/site-packages/keras_core/_tf_keras/saving/__init__.py

@@ -0,0 +1,17 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.saving.object_registration import CustomObjectScope
+from keras_core.src.saving.object_registration import CustomObjectScope as custom_object_scope
+from keras_core.src.saving.object_registration import get_custom_objects
+from keras_core.src.saving.object_registration import get_registered_name
+from keras_core.src.saving.object_registration import get_registered_object
+from keras_core.src.saving.object_registration import register_keras_serializable
+from keras_core.src.saving.saving_api import load_model
+from keras_core.src.saving.saving_api import save_model
+from keras_core.src.saving.serialization_lib import deserialize_keras_object
+from keras_core.src.saving.serialization_lib import serialize_keras_object

lib/python3.10/site-packages/keras_core/constraints/__init__.py

@@ -0,0 +1,19 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.constraints import deserialize
+from keras_core.src.constraints import get
+from keras_core.src.constraints import serialize
+from keras_core.src.constraints.constraints import Constraint
+from keras_core.src.constraints.constraints import MaxNorm
+from keras_core.src.constraints.constraints import MaxNorm as max_norm
+from keras_core.src.constraints.constraints import MinMaxNorm
+from keras_core.src.constraints.constraints import MinMaxNorm as min_max_norm
+from keras_core.src.constraints.constraints import NonNeg
+from keras_core.src.constraints.constraints import NonNeg as non_neg
+from keras_core.src.constraints.constraints import UnitNorm
+from keras_core.src.constraints.constraints import UnitNorm as unit_norm

lib/python3.10/site-packages/keras_core/distribution/__init__.py

@@ -0,0 +1,15 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.distribution.distribution_lib import DataParallel
+from keras_core.src.distribution.distribution_lib import DeviceMesh
+from keras_core.src.distribution.distribution_lib import LayoutMap
+from keras_core.src.distribution.distribution_lib import ModelParallel
+from keras_core.src.distribution.distribution_lib import TensorLayout
+from keras_core.src.distribution.distribution_lib import distribution
+from keras_core.src.distribution.distribution_lib import list_devices
+from keras_core.src.distribution.distribution_lib import set_distribution

lib/python3.10/site-packages/keras_core/losses/__init__.py

@@ -0,0 +1,45 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.losses import deserialize
+from keras_core.src.losses import get
+from keras_core.src.losses import serialize
+from keras_core.src.losses.loss import Loss
+from keras_core.src.losses.losses import BinaryCrossentropy
+from keras_core.src.losses.losses import BinaryFocalCrossentropy
+from keras_core.src.losses.losses import CategoricalCrossentropy
+from keras_core.src.losses.losses import CategoricalFocalCrossentropy
+from keras_core.src.losses.losses import CategoricalHinge
+from keras_core.src.losses.losses import CosineSimilarity
+from keras_core.src.losses.losses import Hinge
+from keras_core.src.losses.losses import Huber
+from keras_core.src.losses.losses import KLDivergence
+from keras_core.src.losses.losses import LogCosh
+from keras_core.src.losses.losses import MeanAbsoluteError
+from keras_core.src.losses.losses import MeanAbsolutePercentageError
+from keras_core.src.losses.losses import MeanSquaredError
+from keras_core.src.losses.losses import MeanSquaredLogarithmicError
+from keras_core.src.losses.losses import Poisson
+from keras_core.src.losses.losses import SparseCategoricalCrossentropy
+from keras_core.src.losses.losses import SquaredHinge
+from keras_core.src.losses.losses import binary_crossentropy
+from keras_core.src.losses.losses import binary_focal_crossentropy
+from keras_core.src.losses.losses import categorical_crossentropy
+from keras_core.src.losses.losses import categorical_focal_crossentropy
+from keras_core.src.losses.losses import categorical_hinge
+from keras_core.src.losses.losses import cosine_similarity
+from keras_core.src.losses.losses import hinge
+from keras_core.src.losses.losses import huber
+from keras_core.src.losses.losses import kl_divergence
+from keras_core.src.losses.losses import log_cosh
+from keras_core.src.losses.losses import mean_absolute_error
+from keras_core.src.losses.losses import mean_absolute_percentage_error
+from keras_core.src.losses.losses import mean_squared_error
+from keras_core.src.losses.losses import mean_squared_logarithmic_error
+from keras_core.src.losses.losses import poisson
+from keras_core.src.losses.losses import sparse_categorical_crossentropy
+from keras_core.src.losses.losses import squared_hinge

lib/python3.10/site-packages/keras_core/mixed_precision/__init__.py

@@ -0,0 +1,14 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+
+from keras_core.src.mixed_precision.dtype_policy import DTypePolicy
+from keras_core.src.mixed_precision.dtype_policy import DTypePolicy as Policy
+from keras_core.src.mixed_precision.dtype_policy import dtype_policy
+from keras_core.src.mixed_precision.dtype_policy import dtype_policy as global_policy
+from keras_core.src.mixed_precision.dtype_policy import set_dtype_policy
+from keras_core.src.mixed_precision.dtype_policy import set_dtype_policy as set_global_policy
+from keras_core.src.optimizers.loss_scale_optimizer import LossScaleOptimizer

lib/python3.10/site-packages/keras_core/src/activations/__init__.py

@@ -0,0 +1,102 @@
+import types
+
+from keras_core.src.activations.activations import elu
+from keras_core.src.activations.activations import exponential
+from keras_core.src.activations.activations import gelu
+from keras_core.src.activations.activations import hard_sigmoid
+from keras_core.src.activations.activations import leaky_relu
+from keras_core.src.activations.activations import linear
+from keras_core.src.activations.activations import log_softmax
+from keras_core.src.activations.activations import mish
+from keras_core.src.activations.activations import relu
+from keras_core.src.activations.activations import relu6
+from keras_core.src.activations.activations import selu
+from keras_core.src.activations.activations import sigmoid
+from keras_core.src.activations.activations import silu
+from keras_core.src.activations.activations import softmax
+from keras_core.src.activations.activations import softplus
+from keras_core.src.activations.activations import softsign
+from keras_core.src.activations.activations import tanh
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.saving import object_registration
+from keras_core.src.saving import serialization_lib
+
+ALL_OBJECTS = {
+    relu,
+    leaky_relu,
+    relu6,
+    softmax,
+    elu,
+    selu,
+    softplus,
+    softsign,
+    silu,
+    gelu,
+    tanh,
+    sigmoid,
+    exponential,
+    hard_sigmoid,
+    linear,
+    mish,
+    log_softmax,
+}
+
+ALL_OBJECTS_DICT = {fn.__name__: fn for fn in ALL_OBJECTS}
+# Additional aliases
+ALL_OBJECTS_DICT["swish"] = silu
+
+
+@keras_core_export("keras_core.activations.serialize")
+def serialize(activation):
+    fn_config = serialization_lib.serialize_keras_object(activation)
+    if "config" not in fn_config:
+        raise ValueError(
+            f"Unknown activation function '{activation}' cannot be "
+            "serialized due to invalid function name. Make sure to use "
+            "an activation name that matches the references defined in "
+            "activations.py or use "
+            "`@keras_core.saving.register_keras_serializable()`"
+            "to register any custom activations. "
+            f"config={fn_config}"
+        )
+    if not isinstance(activation, types.FunctionType):
+        # Case for additional custom activations represented by objects
+        return fn_config
+    if (
+        isinstance(fn_config["config"], str)
+        and fn_config["config"] not in globals()
+    ):
+        # Case for custom activation functions from external activations modules
+        fn_config["config"] = object_registration.get_registered_name(
+            activation
+        )
+        return fn_config
+    # Case for keras.activations builtins (simply return name)
+    return fn_config["config"]
+
+
+@keras_core_export("keras_core.activations.deserialize")
+def deserialize(config, custom_objects=None):
+    """Return a Keras activation function via its config."""
+    return serialization_lib.deserialize_keras_object(
+        config,
+        module_objects=ALL_OBJECTS_DICT,
+        custom_objects=custom_objects,
+    )
+
+
+@keras_core_export("keras_core.activations.get")
+def get(identifier):
+    """Retrieve a Keras activation function via an identifier."""
+    if identifier is None:
+        return linear
+    if isinstance(identifier, (str, dict)):
+        obj = deserialize(identifier)
+    else:
+        obj = identifier
+    if callable(obj):
+        return obj
+    raise ValueError(
+        f"Could not interpret activation function identifier: {identifier}"
+    )
+

lib/python3.10/site-packages/keras_core/src/activations/activations.py

@@ -0,0 +1,440 @@
+from keras_core.src import backend
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+
+
+@keras_core_export("keras_core.activations.relu")
+def relu(x, negative_slope=0.0, max_value=None, threshold=0.0):
+    """Applies the rectified linear unit activation function.
+
+    With default values, this returns the standard ReLU activation:
+    `max(x, 0)`, the element-wise maximum of 0 and the input tensor.
+
+    Modifying default parameters allows you to use non-zero thresholds,
+    change the max value of the activation,
+    and to use a non-zero multiple of the input for values below the threshold.
+
+    Examples:
+
+    >>> x = [-10, -5, 0.0, 5, 10]
+    >>> keras_core.activations.relu(x)
+    [ 0.,  0.,  0.,  5., 10.]
+    >>> keras_core.activations.relu(x, negative_slope=0.5)
+    [-5. , -2.5,  0. ,  5. , 10. ]
+    >>> keras_core.activations.relu(x, max_value=5.)
+    [0., 0., 0., 5., 5.]
+    >>> keras_core.activations.relu(x, threshold=5.)
+    [-0., -0.,  0.,  0., 10.]
+
+    Args:
+        x: Input tensor.
+        negative_slope: A `float` that controls the slope
+            for values lower than the threshold.
+        max_value: A `float` that sets the saturation threshold (the largest
+            value the function will return).
+        threshold: A `float` giving the threshold value of the activation
+            function below which values will be damped or set to zero.
+
+    Returns:
+        A tensor with the same shape and dtype as input `x`.
+    """
+    if backend.any_symbolic_tensors((x,)):
+        return ReLU(
+            negative_slope=negative_slope,
+            max_value=max_value,
+            threshold=threshold,
+        )(x)
+    return ReLU.static_call(
+        x,
+        negative_slope=negative_slope,
+        max_value=max_value,
+        threshold=threshold,
+    )
+
+
+class ReLU(ops.Operation):
+    def __init__(
+        self, negative_slope=0.0, max_value=None, threshold=0.0, name=None
+    ):
+        super().__init__(name=name)
+        self.negative_slope = negative_slope
+        self.max_value = max_value
+        self.threshold = threshold
+
+    def call(self, x):
+        return self.static_call(
+            x,
+            negative_slope=self.negative_slope,
+            max_value=self.max_value,
+            threshold=self.threshold,
+        )
+
+    def compute_output_spec(self, x):
+        return backend.KerasTensor(x.shape, x.dtype)
+
+    @staticmethod
+    def static_call(x, negative_slope=0.0, max_value=None, threshold=0.0):
+        x = backend.convert_to_tensor(x)
+        if negative_slope != 0.0:
+            if max_value is None and threshold == 0:
+                return backend.nn.leaky_relu(x, negative_slope=negative_slope)
+
+            if threshold != 0:
+                negative_part = backend.nn.relu(-x + threshold)
+            else:
+                negative_part = backend.nn.relu(-x)
+
+        clip_max = max_value is not None
+        if threshold != 0:
+            # computes x for x > threshold else 0
+            threshold = ops.cast(threshold, dtype=x.dtype)
+            x = x * backend.cast(
+                backend.numpy.greater(x, threshold), dtype=x.dtype
+            )
+        elif max_value == 6:
+            # if no threshold, then can use nn.relu6 native op for performance
+            x = backend.nn.relu6(x)
+            clip_max = False
+        else:
+            x = backend.nn.relu(x)
+
+        if clip_max:
+            min_value = ops.cast(0.0, dtype=x.dtype)
+            max_value = ops.cast(max_value, dtype=x.dtype)
+            x = backend.numpy.clip(x, min_value, max_value)
+
+        if negative_slope != 0.0:
+            x -= negative_slope * negative_part
+        return x
+
+
+@keras_core_export("keras_core.activations.leaky_relu")
+def leaky_relu(x, negative_slope=0.2):
+    """Leaky relu activation function.
+
+    Args:
+        x: Input tensor.
+        negative_slope: A `float` that controls the slope
+            for values lower than the threshold.
+    """
+    return ops.leaky_relu(x, negative_slope=negative_slope)
+
+
+@keras_core_export("keras_core.activations.relu6")
+def relu6(x):
+    """Relu6 activation function.
+
+    It's the ReLU function, but truncated to a maximum value of 6.
+
+    Args:
+        x: Input tensor.
+    """
+    return ops.relu6(x)
+
+
+@keras_core_export("keras_core.activations.softmax")
+def softmax(x, axis=-1):
+    """Softmax converts a vector of values to a probability distribution.
+
+    The elements of the output vector are in range `[0, 1]` and sum to 1.
+
+    Each input vector is handled independently.
+    The `axis` argument sets which axis of the input the function
+    is applied along.
+
+    Softmax is often used as the activation for the last
+    layer of a classification network because the result could be interpreted as
+    a probability distribution.
+
+    The softmax of each vector x is computed as
+    `exp(x) / sum(exp(x))`.
+
+    The input values in are the log-odds of the resulting probability.
+
+    Args:
+        x : Input tensor.
+        axis: Integer, axis along which the softmax is applied.
+    """
+    output = ops.softmax(x, axis=axis)
+    # Cache the logits to use for crossentropy loss.
+    try:
+        output._keras_logits = x
+    except AttributeError:
+        # We're dealing with a C-type.
+        pass
+    return output
+
+
+@keras_core_export("keras_core.activations.elu")
+def elu(x, alpha=1.0):
+    """Exponential Linear Unit.
+
+    The exponential linear unit (ELU) with `alpha > 0` is define as:
+
+    - `x` if `x > 0`
+    - alpha * `exp(x) - 1` if `x < 0`
+
+    ELUs have negative values which pushes the mean of the activations
+    closer to zero.
+
+    Mean activations that are closer to zero enable faster learning as they
+    bring the gradient closer to the natural gradient.
+    ELUs saturate to a negative value when the argument gets smaller.
+    Saturation means a small derivative which decreases the variation
+    and the information that is propagated to the next layer.
+
+    Args:
+        x: Input tensor.
+
+    Reference:
+
+    - [Clevert et al., 2016](https://arxiv.org/abs/1511.07289)
+    """
+    return ops.elu(x, alpha=alpha)
+
+
+@keras_core_export("keras_core.activations.selu")
+def selu(x):
+    """Scaled Exponential Linear Unit (SELU).
+
+    The Scaled Exponential Linear Unit (SELU) activation function is defined as:
+
+    - `scale * x` if `x > 0`
+    - `scale * alpha * (exp(x) - 1)` if `x < 0`
+
+    where `alpha` and `scale` are pre-defined constants
+    (`alpha=1.67326324` and `scale=1.05070098`).
+
+    Basically, the SELU activation function multiplies `scale` (> 1) with the
+    output of the `keras_core.activations.elu` function to ensure a slope larger
+    than one for positive inputs.
+
+    The values of `alpha` and `scale` are
+    chosen so that the mean and variance of the inputs are preserved
+    between two consecutive layers as long as the weights are initialized
+    correctly (see `keras_core.initializers.LecunNormal` initializer)
+    and the number of input units is "large enough"
+    (see reference paper for more information).
+
+    Args:
+        x: Input tensor.
+
+    Notes:
+
+    - To be used together with the
+        `keras_core.initializers.LecunNormal` initializer.
+    - To be used together with the dropout variant
+        `keras_core.layers.AlphaDropout` (rather than regular dropout).
+
+    Reference:
+
+    - [Klambauer et al., 2017](https://arxiv.org/abs/1706.02515)
+    """
+    return ops.selu(x)
+
+
+@keras_core_export("keras_core.activations.softplus")
+def softplus(x):
+    """Softplus activation function.
+
+    It is defined as: `softplus(x) = log(exp(x) + 1)`.
+
+    Args:
+        x: Input tensor.
+    """
+    return ops.softplus(x)
+
+
+@keras_core_export("keras_core.activations.softsign")
+def softsign(x):
+    """Softsign activation function.
+
+    Softsign is defined as: `softsign(x) = x / (abs(x) + 1)`.
+
+    Args:
+        x: Input tensor.
+    """
+    return ops.softsign(x)
+
+
+@keras_core_export(
+    ["keras_core.activations.silu", "keras_core.activations.swish"]
+)
+def silu(x):
+    """Swish (or Silu) activation function.
+
+    It is defined as: `swish(x) = x * sigmoid(x)`.
+
+    The Swish (or Silu) activation function is a smooth,
+    non-monotonic function that is unbounded above and
+    bounded below.
+
+    Args:
+        x: Input tensor.
+
+    Reference:
+
+    - [Ramachandran et al., 2017](https://arxiv.org/abs/1710.05941)
+    """
+    return ops.silu(x)
+
+
+@keras_core_export("keras_core.activations.gelu")
+def gelu(x, approximate=False):
+    """Gaussian error linear unit (GELU) activation function.
+
+    The Gaussian error linear unit (GELU) is defined as:
+
+    `gelu(x) = x * P(X <= x)` where `P(X) ~ N(0, 1)`,
+    i.e. `gelu(x) = 0.5 * x * (1 + erf(x / sqrt(2)))`.
+
+    GELU weights inputs by their value, rather than gating
+    inputs by their sign as in ReLU.
+
+    Args:
+        x: Input tensor.
+        approximate: A `bool`, whether to enable approximation.
+
+    Reference:
+
+    - [Hendrycks et al., 2016](https://arxiv.org/abs/1606.08415)
+    """
+    return ops.gelu(x, approximate=approximate)
+
+
+@keras_core_export("keras_core.activations.tanh")
+def tanh(x):
+    """Hyperbolic tangent activation function.
+
+    It is defined as:
+    `tanh(x) = sinh(x) / cosh(x)`, i.e.
+    `tanh(x) = ((exp(x) - exp(-x)) / (exp(x) + exp(-x)))`.
+
+    Args:
+        x: Input tensor.
+    """
+    return ops.tanh(x)
+
+
+@keras_core_export("keras_core.activations.sigmoid")
+def sigmoid(x):
+    """Sigmoid activation function.
+
+    It is defined as: `sigmoid(x) = 1 / (1 + exp(-x))`.
+
+    For small values (<-5),
+    `sigmoid` returns a value close to zero, and for large values (>5)
+    the result of the function gets close to 1.
+
+    Sigmoid is equivalent to a 2-element softmax, where the second element is
+    assumed to be zero. The sigmoid function always returns a value between
+    0 and 1.
+
+    Args:
+        x: Input tensor.
+    """
+    output = ops.sigmoid(x)
+    # Cache the logits to use for crossentropy loss.
+    try:
+        output._keras_logits = x
+    except AttributeError:
+        # We're dealing with a C-type.
+        pass
+    return output
+
+
+@keras_core_export("keras_core.activations.exponential")
+def exponential(x):
+    """Exponential activation function.
+
+    Args:
+        x: Input tensor.
+    """
+    return ops.exp(x)
+
+
+@keras_core_export("keras_core.activations.hard_sigmoid")
+def hard_sigmoid(x):
+    """Hard sigmoid activation function.
+
+    The hard sigmoid activation is defined as:
+
+    - `0` if `if x < -2.5`
+    - `1` if `x > 2.5`
+    - `0.2 * x + 0.5` if `-2.5 <= x <= 2.5`
+
+    It's a faster, piecewise linear approximation
+    of the sigmoid activation.
+
+    Args:
+        x: Input tensor.
+
+    Reference:
+
+    - [Wikipedia "Hard sigmoid"](https://en.wikipedia.org/wiki/Hard_sigmoid)
+    """
+    return ops.hard_sigmoid(x)
+
+
+@keras_core_export("keras_core.activations.linear")
+def linear(x):
+    """Linear activation function (pass-through).
+
+    A "linear" activation is an identity function:
+    it returns the input, unmodified.
+
+    Args:
+        x: Input tensor.
+    """
+    return x
+
+
+class Mish(ops.Operation):
+    def call(self, x):
+        return self.static_call(x)
+
+    def compute_output_spec(self, x):
+        return backend.KerasTensor(x.shape, x.dtype)
+
+    @staticmethod
+    def static_call(x):
+        return x * backend.nn.tanh(backend.nn.softplus(x))
+
+
+@keras_core_export("keras_core.activations.mish")
+def mish(x):
+    """Mish activation function.
+
+    It is defined as:
+
+    `mish(x) = x * tanh(softplus(x))`
+
+    where `softplus` is defined as:
+
+    `softplus(x) = log(exp(x) + 1)`
+
+    Args:
+        x: Input tensor.
+
+    Reference:
+
+    - [Misra, 2019](https://arxiv.org/abs/1908.08681)
+    """
+    x = backend.convert_to_tensor(x)
+    return Mish.static_call(x)
+
+
+@keras_core_export("keras_core.activations.log_softmax")
+def log_softmax(x, axis=-1):
+    """Log-Softmax activation function.
+
+    Each input vector is handled independently.
+    The `axis` argument sets which axis of the input the function
+    is applied along.
+
+    Args:
+        x: Input tensor.
+        axis: Integer, axis along which the softmax is applied.
+    """
+    return ops.log_softmax(x, axis=axis)
+

lib/python3.10/site-packages/keras_core/src/constraints/__init__.py

@@ -0,0 +1,62 @@
+import inspect
+
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.constraints.constraints import Constraint
+from keras_core.src.constraints.constraints import MaxNorm
+from keras_core.src.constraints.constraints import MinMaxNorm
+from keras_core.src.constraints.constraints import NonNeg
+from keras_core.src.constraints.constraints import UnitNorm
+from keras_core.src.saving import serialization_lib
+from keras_core.src.utils.naming import to_snake_case
+
+ALL_OBJECTS = {
+    Constraint,
+    MaxNorm,
+    MinMaxNorm,
+    NonNeg,
+    UnitNorm,
+}
+
+ALL_OBJECTS_DICT = {cls.__name__: cls for cls in ALL_OBJECTS}
+ALL_OBJECTS_DICT.update(
+    {to_snake_case(cls.__name__): cls for cls in ALL_OBJECTS}
+)
+
+
+@keras_core_export("keras_core.constraints.serialize")
+def serialize(constraint):
+    return serialization_lib.serialize_keras_object(constraint)
+
+
+@keras_core_export("keras_core.constraints.deserialize")
+def deserialize(config, custom_objects=None):
+    """Return a Keras constraint object via its config."""
+    return serialization_lib.deserialize_keras_object(
+        config,
+        module_objects=ALL_OBJECTS_DICT,
+        custom_objects=custom_objects,
+    )
+
+
+@keras_core_export("keras_core.constraints.get")
+def get(identifier):
+    """Retrieve a Keras constraint object via an identifier."""
+    if identifier is None:
+        return None
+    if isinstance(identifier, dict):
+        obj = deserialize(identifier)
+    elif isinstance(identifier, str):
+        config = {"class_name": str(identifier), "config": {}}
+        obj = deserialize(config)
+    else:
+        obj = identifier
+
+    if callable(obj):
+        if inspect.isclass(obj):
+            obj = obj()
+        return obj
+    else:
+        raise ValueError(
+            f"Could not interpret constraint identifier: {identifier}"
+        )
+

lib/python3.10/site-packages/keras_core/src/constraints/constraints.py

@@ -0,0 +1,220 @@
+from keras_core.src import backend
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+
+
+@keras_core_export("keras_core.constraints.Constraint")
+class Constraint:
+    """Base class for weight constraints.
+
+    A `Constraint` instance works like a stateless function.
+    Users who subclass this
+    class should override the `__call__()` method, which takes a single
+    weight parameter and return a projected version of that parameter
+    (e.g. normalized or clipped). Constraints can be used with various Keras
+    layers via the `kernel_constraint` or `bias_constraint` arguments.
+
+    Here's a simple example of a non-negative weight constraint:
+
+    >>> class NonNegative(keras_core.constraints.Constraint):
+    ...
+    ...  def __call__(self, w):
+    ...    return w * ops.cast(ops.greater_equal(w, 0.), dtype=w.dtype)
+
+    >>> weight = ops.convert_to_tensor((-1.0, 1.0))
+    >>> NonNegative()(weight)
+    [0.,  1.]
+
+    Usage in a layer:
+
+    >>> keras_core.layers.Dense(4, kernel_constraint=NonNegative())
+    """
+
+    def __call__(self, w):
+        """Applies the constraint to the input weight variable.
+
+        By default, the inputs weight variable is not modified.
+        Users should override this method to implement their own projection
+        function.
+
+        Args:
+            w: Input weight variable.
+
+        Returns:
+            Projected variable (by default, returns unmodified inputs).
+        """
+        return w
+
+    def get_config(self):
+        """Returns a Python dict of the object config.
+
+        A constraint config is a Python dictionary (JSON-serializable) that can
+        be used to reinstantiate the same object.
+
+        Returns:
+            Python dict containing the configuration of the constraint object.
+        """
+        return {}
+
+    @classmethod
+    def from_config(cls, config):
+        """Instantiates a weight constraint from a configuration dictionary.
+
+        Example:
+
+        ```python
+        constraint = UnitNorm()
+        config = constraint.get_config()
+        constraint = UnitNorm.from_config(config)
+        ```
+
+        Args:
+            config: A Python dictionary, the output of `get_config()`.
+
+        Returns:
+            A `keras_core.constraints.Constraint` instance.
+        """
+        return cls(**config)
+
+
+@keras_core_export(
+    ["keras_core.constraints.MaxNorm", "keras_core.constraints.max_norm"]
+)
+class MaxNorm(Constraint):
+    """MaxNorm weight constraint.
+
+    Constrains the weights incident to each hidden unit
+    to have a norm less than or equal to a desired value.
+
+    Also available via the shortcut function `keras_core.constraints.max_norm`.
+
+    Args:
+        max_value: the maximum norm value for the incoming weights.
+        axis: integer, axis along which to calculate weight norms.
+            For instance, in a `Dense` layer the weight matrix
+            has shape `(input_dim, output_dim)`,
+            set `axis` to `0` to constrain each weight vector
+            of length `(input_dim,)`.
+            In a `Conv2D` layer with `data_format="channels_last"`,
+            the weight tensor has shape
+            `(rows, cols, input_depth, output_depth)`,
+            set `axis` to `[0, 1, 2]`
+            to constrain the weights of each filter tensor of size
+            `(rows, cols, input_depth)`.
+
+    """
+
+    def __init__(self, max_value=2, axis=0):
+        self.max_value = max_value
+        self.axis = axis
+
+    def __call__(self, w):
+        w = backend.convert_to_tensor(w)
+        norms = ops.sqrt(ops.sum(ops.square(w), axis=self.axis, keepdims=True))
+        desired = ops.clip(norms, 0, self.max_value)
+        return w * (desired / (backend.epsilon() + norms))
+
+    def get_config(self):
+        return {"max_value": self.max_value, "axis": self.axis}
+
+
+@keras_core_export(
+    ["keras_core.constraints.NonNeg", "keras_core.constraints.non_neg"]
+)
+class NonNeg(Constraint):
+    """Constrains the weights to be non-negative."""
+
+    def __call__(self, w):
+        w = backend.convert_to_tensor(w)
+        return w * ops.cast(ops.greater_equal(w, 0.0), dtype=w.dtype)
+
+
+@keras_core_export(
+    ["keras_core.constraints.UnitNorm", "keras_core.constraints.unit_norm"]
+)
+class UnitNorm(Constraint):
+    """Constrains the weights incident to each hidden unit to have unit norm.
+
+    Args:
+        axis: integer, axis along which to calculate weight norms.
+            For instance, in a `Dense` layer the weight matrix
+            has shape `(input_dim, output_dim)`,
+            set `axis` to `0` to constrain each weight vector
+            of length `(input_dim,)`.
+            In a `Conv2D` layer with `data_format="channels_last"`,
+            the weight tensor has shape
+            `(rows, cols, input_depth, output_depth)`,
+            set `axis` to `[0, 1, 2]`
+            to constrain the weights of each filter tensor of size
+            `(rows, cols, input_depth)`.
+    """
+
+    def __init__(self, axis=0):
+        self.axis = axis
+
+    def __call__(self, w):
+        w = backend.convert_to_tensor(w)
+        return w / (
+            backend.epsilon()
+            + ops.sqrt(ops.sum(ops.square(w), axis=self.axis, keepdims=True))
+        )
+
+    def get_config(self):
+        return {"axis": self.axis}
+
+
+@keras_core_export(
+    ["keras_core.constraints.MinMaxNorm", "keras_core.constraints.min_max_norm"]
+)
+class MinMaxNorm(Constraint):
+    """MinMaxNorm weight constraint.
+
+    Constrains the weights incident to each hidden unit
+    to have the norm between a lower bound and an upper bound.
+
+    Args:
+        min_value: the minimum norm for the incoming weights.
+        max_value: the maximum norm for the incoming weights.
+        rate: rate for enforcing the constraint: weights will be
+            rescaled to yield
+            `(1 - rate) * norm + rate * norm.clip(min_value, max_value)`.
+            Effectively, this means that rate=1.0 stands for strict
+            enforcement of the constraint, while rate<1.0 means that
+            weights will be rescaled at each step to slowly move
+            towards a value inside the desired interval.
+        axis: integer, axis along which to calculate weight norms.
+            For instance, in a `Dense` layer the weight matrix
+            has shape `(input_dim, output_dim)`,
+            set `axis` to `0` to constrain each weight vector
+            of length `(input_dim,)`.
+            In a `Conv2D` layer with `data_format="channels_last"`,
+            the weight tensor has shape
+            `(rows, cols, input_depth, output_depth)`,
+            set `axis` to `[0, 1, 2]`
+            to constrain the weights of each filter tensor of size
+            `(rows, cols, input_depth)`.
+    """
+
+    def __init__(self, min_value=0.0, max_value=1.0, rate=1.0, axis=0):
+        self.min_value = min_value
+        self.max_value = max_value
+        self.rate = rate
+        self.axis = axis
+
+    def __call__(self, w):
+        w = backend.convert_to_tensor(w)
+        norms = ops.sqrt(ops.sum(ops.square(w), axis=self.axis, keepdims=True))
+        desired = (
+            self.rate * ops.clip(norms, self.min_value, self.max_value)
+            + (1 - self.rate) * norms
+        )
+        return w * (desired / (backend.epsilon() + norms))
+
+    def get_config(self):
+        return {
+            "min_value": self.min_value,
+            "max_value": self.max_value,
+            "rate": self.rate,
+            "axis": self.axis,
+        }
+

lib/python3.10/site-packages/keras_core/src/distribution/__init__.py

@@ -0,0 +1 @@
+

lib/python3.10/site-packages/keras_core/src/distribution/distribution_lib.py

@@ -0,0 +1,508 @@
+"""Unified high level distribution APIs across backends.
+
+!!!DO NOT USE!!! Currently under development and APIs are not final.
+
+Currently only the JAX backend has been implemented. The TensorFlow backend
+will be implemented in the future (via tf.dtensor API).
+"""
+
+import collections
+import contextlib
+import re
+import warnings
+
+import numpy as np
+
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.backend import distribution_lib
+from keras_core.src.backend.common import global_state
+
+DEFAULT_BATCH_DIM_NAME = "batch"
+GLOBAL_ATTRIBUTE_NAME = "distribution"
+
+
+@keras_core_export("keras_core.distribution.list_devices")
+def list_devices(device_type=None):
+    """Return all the available devices based on the device type.
+
+    Note: in a distributed setting, global devices are returned.
+
+    Args:
+        device_type: string, one of `"cpu"`, `"gpu"` or `"tpu"`.
+            Defaults to `"gpu"` or `"tpu"` if available when
+            `device_type` is not provided. Otherwise
+            will return the `"cpu"` devices.
+
+    Return:
+        List of devices that are available for distribute computation.
+    """
+    return distribution_lib.list_devices(device_type)
+
+
+@keras_core_export("keras_core.distribution.DeviceMesh")
+class DeviceMesh:
+    """A cluster of computation devices for distributed computation.
+
+    This API is aligned with `jax.sharding.Mesh` and `tf.dtensor.Mesh`, which
+    represents the computation devices in the global context.
+
+    See more details in [jax.sharding.Mesh](
+        https://jax.readthedocs.io/en/latest/jax.sharding.html#jax.sharding.Mesh)
+    and [tf.dtensor.Mesh](
+        https://www.tensorflow.org/api_docs/python/tf/experimental/dtensor/Mesh).
+
+    Args:
+        shape: tuple of list of integers. The shape of the overall
+            `DeviceMesh`, e.g. `(8,)` for a data parallel only distribution,
+            or `(4, 2)` for a model+data parallel distribution.
+        axis_names: List of string. The logical name of the each axis for
+            the `DeviceMesh`. The length of the `axis_names` should match to
+            the rank of the `shape`. The `axis_names` will be used to
+            match/create the `TensorLayout` when distribute the data and
+            variables.
+        devices: Optional list of devices. Defaults to all the available
+            devices locally from `keras_core.distribution.list_devices()`.
+    """
+
+    def __init__(
+        self,
+        shape,
+        axis_names,
+        devices=None,
+    ):
+        if not shape or not axis_names:
+            raise ValueError(
+                "Shape and axis_names cannot be empty. Received: "
+                f"shape={shape}, axis_names={axis_names}"
+            )
+
+        if len(shape) != len(axis_names):
+            raise ValueError(
+                "Shape and axis_names should have same size. "
+                f"Received: shape={shape}, axis_names={axis_names}"
+            )
+        if devices is None:
+            devices = list_devices()
+        devices = np.array(devices)
+        if np.prod(shape) != np.prod(devices.shape):
+            raise ValueError(
+                "Shape does not match the number of devices. "
+                f"Received: shape={shape}; devices.shape="
+                f"{devices.shape}"
+            )
+
+        self._shape = shape
+        self._axis_names = axis_names
+        self._devices = np.reshape(devices, shape)
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def axis_names(self):
+        return self._axis_names
+
+    @property
+    def devices(self):
+        return self._devices
+
+
+@keras_core_export("keras_core.distribution.TensorLayout")
+class TensorLayout:
+    """A layout to apply to a tensor.
+
+    This API is aligned with `jax.sharding.NamedSharding`
+    and `tf.dtensor.Layout`.
+
+    See more details in [jax.sharding.NamedSharding](
+        https://jax.readthedocs.io/en/latest/jax.sharding.html#jax.sharding.NamedSharding)
+    and [tf.dtensor.Layout](
+        https://www.tensorflow.org/api_docs/python/tf/experimental/dtensor/Layout).
+
+    Args:
+        axes: list of strings that should map to the `axis_names` in
+            a `DeviceMesh`. For any dimentions that doesn't need any sharding,
+            A `None` can be used a placeholder.
+        device_mesh: Optional `DeviceMesh` that will be used to create
+            the layout. The actual mapping of tensor to physical device
+            is not known until the mesh is specified.
+    """
+
+    def __init__(self, axes, device_mesh=None):
+        self._axes = axes
+        self._device_mesh = device_mesh
+        self._validate_axes()
+
+    @property
+    def axes(self):
+        return self._axes
+
+    @property
+    def device_mesh(self):
+        return self._device_mesh
+
+    @device_mesh.setter
+    def device_mesh(self, device_mesh):
+        if self._device_mesh is not None:
+            raise ValueError(
+                "Cannot override device mesh value. Existing "
+                f"value is {self._device_mesh}"
+            )
+        self._device_mesh = device_mesh
+        self._validate_axes()
+
+    def _validate_axes(self):
+        if self._device_mesh:
+            valid_axis_names = set(self._device_mesh.axis_names)
+            axis_names = set(self._axes) - set([None])
+            if axis_names - valid_axis_names:
+                raise ValueError(
+                    "Invalid axis names for Layout. Valid axis "
+                    f"names: {valid_axis_names}, Got {axis_names}"
+                )
+
+
+class Distribution:
+    """Base class for variable distribution strategies.
+
+    A `Distribution` has following key functionalities:
+
+    1. Distribute the model variables to a `DeviceMesh`.
+    2. Distribute the input data to a `DeviceMesh`.
+
+    It can create a context scope so that the framework to properly detect the
+    `Distribution` and distribute the variable/data accordingly.
+
+    Args:
+        device_mesh: A `DeviceMesh` instance.
+    """
+
+    def __init__(self, device_mesh):
+        self._device_mesh = device_mesh
+
+    def get_data_layout(self, data_shape):
+        """Retrieve the `TensorLayout` for the input data.
+
+        Args:
+            data_shape: shape for the input data in list or tuple format.
+
+        Returns:
+            The `TensorLayout` for the data, which can be used by
+            `backend.distribute_value()` to redistribute a input data.
+        """
+        raise NotImplementedError()
+
+    def get_variable_layout(self, variable):
+        """Retrieve the `TensorLayout` for the variable.
+
+        Args:
+            variable: A `KerasVariable` instance.
+
+        return:
+            The `TensorLayout` for the variable, which can be used by
+            `backend.distribute_value()` to redistribute a variable.
+        """
+        raise NotImplementedError()
+
+    @contextlib.contextmanager
+    def scope(self):
+        """Context manager to make the `Distribution` current."""
+        original_scope = distribution()
+        set_distribution(self)
+        try:
+            yield
+        finally:
+            set_distribution(original_scope)
+
+    @property
+    def device_mesh(self):
+        return self._device_mesh
+
+
+@keras_core_export("keras_core.distribution.DataParallel")
+class DataParallel(Distribution):
+    """Distribution for data parallelism.
+
+    You can choose to create this instance by either specifing
+    the `device_mesh` or `devices` arguments (but not both).
+
+    The `device_mesh` argument is expected to be a `DeviceMesh` instance,
+    and is expected to be 1D only. In case that the mesh has multiple axes,
+    then the first axis will be treated as the data parallel dimension
+    (and a warning will be raised).
+
+    When a list of `devices` are provided, they will be used to construct a
+    1D mesh.
+
+    When both `mesh` and `devices` are absent, then `list_devices()`
+    will be used to detect any available devices and create a 1D mesh from
+    them.
+
+    Args:
+        device_mesh: Optional `DeviceMesh` instance.
+        devices: Optional list of devices.
+    """
+
+    def __init__(self, device_mesh=None, devices=None):
+        if device_mesh:
+            self._initialize_with_device_mesh(device_mesh)
+        elif devices:
+            self._initialize_mesh_from_devices(devices)
+        else:
+            self._initialize_mesh_from_list_devices()
+
+        self._batch_dim_name = self.device_mesh.axis_names[0]
+
+    def _initialize_with_device_mesh(self, device_mesh):
+        if not isinstance(device_mesh, DeviceMesh):
+            raise ValueError(
+                "Expect `mesh` to be an instance of `DeviceMesh`. "
+                f"Received: mesh={device_mesh} (of type {type(device_mesh)})"
+            )
+        super().__init__(device_mesh)
+        if self.device_mesh.devices.ndim != 1:
+            warnings.warn(
+                "Expect the input mesh to be 1D, but received "
+                "mesh.devices.ndim=%d. "
+                "The first axis will be used for data-parallel sharding.",
+                device_mesh.devices.ndim,
+            )
+
+    def _initialize_mesh_from_devices(self, devices):
+        devices = np.array(devices)
+        device_mesh = DeviceMesh(
+            shape=devices.shape,
+            axis_names=[DEFAULT_BATCH_DIM_NAME],
+            devices=devices,
+        )
+        super().__init__(device_mesh)
+
+    def _initialize_mesh_from_list_devices(self):
+        devices = np.array(list_devices())
+        device_mesh = DeviceMesh(
+            shape=devices.shape,
+            axis_names=[DEFAULT_BATCH_DIM_NAME],
+            devices=devices,
+        )
+        super().__init__(device_mesh)
+
+    def get_data_layout(self, data_shape):
+        data_shard_spec = [None] * len(data_shape)
+        data_shard_spec[0] = self._batch_dim_name  # Shard on the first dim
+        return TensorLayout(data_shard_spec, self.device_mesh)
+
+    def get_variable_layout(self, variable):
+        variable_shard_spec = [None] * len(variable.shape)
+        return TensorLayout(variable_shard_spec, self.device_mesh)
+
+
+@keras_core_export("keras_core.distribution.ModelParallel")
+class ModelParallel(Distribution):
+    """Distribution that shards model variables.
+
+    Compare to `DataParallel` which replicates the variables across all devices,
+    `ModelParallel` allows you to shard variables in addition to the input data.
+
+    To construct a `ModelParallel` distribution, you need to provide a
+    `DeviceMesh` and a `LayoutMap`.
+
+    1. `DeviceMesh` contains physcial device information. The axis names in
+        the mesh will be used to map the variable and data layout.
+    2. `LayoutMap` contains the mapping between variable paths to their
+        corresponding `TensorLayout`.
+
+    Example:
+
+    ```python
+    devices = list_devices()    # Assume there are 8 devices.
+
+    # Create a mesh with 2 devices for data parallelism and 4 devices for
+    # model parallelism.
+    device_mesh = DeviceMesh(shape=(2, 4), axis_names=('batch', 'model'),
+                             devices=devices)
+    # Create a layout map that shard the `Dense` layer and `Conv2D`
+    # layer variables on the last dimension.
+    # Based on the `device_mesh`, this means the variables
+    # will be split across 4 devices. Any other variable that doesn't
+    # match any key in the layout map will be fully replicated.
+    layout_map = LayoutMap(device_mesh)
+    layout_map['.*dense.*kernel'] = TensorLayout([None, 'model'])
+    layout_map['.*dense.*bias'] = TensorLayout(['model'])
+    layout_map['.*conv2d.*kernel'] = TensorLayout([None, None, None, 'model'])
+    layout_map['.*conv2d.*bias'] = TensorLayout(['model'])
+
+    distribution = ModelParallel(device_mesh=device_mesh,
+                                 layout_map=layout_map,
+                                 batch_dim_name='batch')
+    # Set the global distribution, or via `with distribution.scope():`
+    set_distribution(distribution)
+
+    model = model_creation()
+    model.compile()
+    model.fit(data)
+    ```
+
+    You can quickly update the device mesh shape to change the sharding factor
+    of the variables. E.g.
+    ```
+    # With only the shape change for the device mesh, the variables will be
+    # sharded across 8 devices instead of 4, which further reduces the memory
+    # footprint of variables on each of the device.
+    device_mesh = DeviceMesh(shape=(1, 8), axis_names=('batch', 'model'),
+                             devices=devices)
+    ```
+
+    To figure out a proper layout mapping rule for all the model variables, you
+    can first list out all the model variable paths, which will be used as the
+    key to map the variables to `TensorLayout`.
+
+    e.g.
+    ```
+    model = create_model()
+    for v in model.variables:
+        print(v.path)
+    ```
+
+    Args:
+        device_mesh: `DeviceMesh` instance for physical device and its
+            logical mapping.
+        layout_map: `LayoutMap` instance which map the variable path to the
+            corresponding `TensorLayout`. The axis names of the
+            `TensorLayout`s should match to the axis names in the
+            device_mesh, or exception will be raised.
+        batch_dim_name: optional string, the axis name in the `device_mesh`
+            that will be used to distribute data. If unspecified, the
+            first axis from the `device_mesh` will be used.
+    """
+
+    def __init__(self, device_mesh, layout_map, batch_dim_name=None):
+        super().__init__(device_mesh)
+        self._layout_map = layout_map
+        self._batch_dim_name = batch_dim_name or self.device_mesh.axis_names[0]
+
+    def get_data_layout(self, data_shape):
+        data_shard_spec = [None] * len(data_shape)
+        data_shard_spec[0] = self._batch_dim_name  # Shard on the first dim
+        return TensorLayout(data_shard_spec, self.device_mesh)
+
+    def get_variable_layout(self, variable):
+        variable_layout = self._layout_map[variable.path]
+        if variable_layout is not None:
+            return variable_layout
+        variable_shard_spec = [None] * len(variable.shape)
+        return TensorLayout(variable_shard_spec, self.device_mesh)
+
+
+@keras_core_export("keras_core.distribution.LayoutMap")
+class LayoutMap(collections.abc.MutableMapping):
+    """A dict-like object that maps string to `TensorLayout` instances.
+
+    `LayoutMap` uses a string as key and a `TensorLayout` as value. There is a
+    behavior difference between a normal Python dict and this class. The string
+    key will be treated as a regex when retrieving the value. See the docstring
+    of `get` for more details.
+
+    See below for a usage example. You can define the naming schema
+    of the `TensorLayout`, and then retrieve the corresponding
+    `TensorLayout` instance.
+
+    In the normal case, the key to query is usually the `variable.path`, which
+    is the idenifier of the variable.
+
+    ```python
+    layout_map = LayoutMap(device_mesh=None)
+    layout_map['.*dense.*kernel'] = layout_2d
+    layout_map['.*dense.*bias'] = layout_1d
+    layout_map['.*conv2d.*kernel'] = layout_4d
+    layout_map['.*conv2d.*bias'] = layout_1d
+
+    layout_1 = layout_map['dense_1.kernel']             # layout_1 == layout_2d
+    layout_2 = layout_map['dense_1.bias']               # layout_2 == layout_1d
+    layout_3 = layout_map['dense_2.kernel']             # layout_3 == layout_2d
+    layout_4 = layout_map['dense_2.bias']               # layout_4 == layout_1d
+    layout_5 = layout_map['my_model/conv2d_123/kernel'] # layout_5 == layout_4d
+    layout_6 = layout_map['my_model/conv2d_123/bias']   # layout_6 == layout_1d
+    layout_7 = layout_map['my_model/conv3d_1/kernel']   # layout_7 == None
+    layout_8 = layout_map['my_model/conv3d_1/bias']     # layout_8 == None
+    ```
+
+    Args:
+        device_mesh: An optional `DeviceMesh` that can be used to populate the
+            `TensorLayout.device_mesh` if `TensorLayout.device_mesh` is not set.
+    """
+
+    def __init__(self, device_mesh=None):
+        self._layout_map = collections.OrderedDict()
+        self._device_mesh = device_mesh
+
+    def __getitem__(self, key):
+        """Retrieves the corresponding layout by the string key.
+
+        When there isn't an exact match, all the existing keys in the layout map
+        will be treated as a regex and map against the input key again. The
+        first match will be returned, based on the key insertion order. Returns
+        `None` if there isn't any match found.
+
+        Args:
+            key: String key to query a layout.
+
+        Returns:
+            Corresponding layout based on the query.
+        """
+        if key in self._layout_map:
+            return self._layout_map[key]
+
+        for k in self._layout_map:
+            if re.match(k, key):
+                return self._layout_map[k]
+        return None
+
+    def __setitem__(self, key, layout):
+        if key in self._layout_map:
+            raise ValueError(
+                f"{key} already exist in the LayoutMap with "
+                f"value {self._layout_map[key]}. Please make sure to "
+                "not use duplicated keys."
+            )
+        if not isinstance(layout, TensorLayout):
+            raise ValueError(
+                f"{layout} should be a TensorLayout type, got {type(layout)}"
+            )
+        self._maybe_populate_device_mesh(layout)
+        self._layout_map[key] = layout
+
+    def __delitem__(self, key):
+        # let the dict to handle the key missing error
+        return self._layout_map.pop(key)
+
+    def __len__(self):
+        return len(self._layout_map)
+
+    def __iter__(self):
+        return iter(self._layout_map)
+
+    @property
+    def device_mesh(self):
+        return self._device_mesh
+
+    def _maybe_populate_device_mesh(self, layout):
+        if layout.device_mesh is None and self.device_mesh is not None:
+            layout.device_mesh = self.device_mesh
+
+
+@keras_core_export("keras_core.distribution.distribution")
+def distribution():
+    """Retrieve the current distribution from global context."""
+    return global_state.get_global_attribute(GLOBAL_ATTRIBUTE_NAME)
+
+
+@keras_core_export("keras_core.distribution.set_distribution")
+def set_distribution(value):
+    """Set the distribution as the global distribution setting.
+
+    Args:
+        value: a `Distribution` instance.
+    """
+    global_state.set_global_attribute(GLOBAL_ATTRIBUTE_NAME, value)
+

lib/python3.10/site-packages/keras_core/src/initializers/__init__.py

@@ -0,0 +1,120 @@
+import inspect
+
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.initializers.constant_initializers import Constant
+from keras_core.src.initializers.constant_initializers import Identity
+from keras_core.src.initializers.constant_initializers import Ones
+from keras_core.src.initializers.constant_initializers import Zeros
+from keras_core.src.initializers.initializer import Initializer
+from keras_core.src.initializers.random_initializers import GlorotNormal
+from keras_core.src.initializers.random_initializers import GlorotUniform
+from keras_core.src.initializers.random_initializers import HeNormal
+from keras_core.src.initializers.random_initializers import HeUniform
+from keras_core.src.initializers.random_initializers import LecunNormal
+from keras_core.src.initializers.random_initializers import LecunUniform
+from keras_core.src.initializers.random_initializers import OrthogonalInitializer
+from keras_core.src.initializers.random_initializers import RandomNormal
+from keras_core.src.initializers.random_initializers import RandomUniform
+from keras_core.src.initializers.random_initializers import TruncatedNormal
+from keras_core.src.initializers.random_initializers import VarianceScaling
+from keras_core.src.saving import serialization_lib
+from keras_core.src.utils.naming import to_snake_case
+
+ALL_OBJECTS = {
+    Initializer,
+    Constant,
+    Ones,
+    Zeros,
+    GlorotNormal,
+    GlorotUniform,
+    HeNormal,
+    HeUniform,
+    LecunNormal,
+    LecunUniform,
+    RandomNormal,
+    TruncatedNormal,
+    RandomUniform,
+    VarianceScaling,
+    OrthogonalInitializer,
+}
+
+ALL_OBJECTS_DICT = {cls.__name__: cls for cls in ALL_OBJECTS}
+ALL_OBJECTS_DICT.update(
+    {to_snake_case(cls.__name__): cls for cls in ALL_OBJECTS}
+)
+# Aliases
+ALL_OBJECTS_DICT.update(
+    {
+        "uniform": RandomUniform,
+        "normal": RandomNormal,
+        "orthogonal": OrthogonalInitializer,
+        "one": Ones,
+        "zero": Zeros,
+    }
+)
+
+
+@keras_core_export("keras_core.initializers.serialize")
+def serialize(initializer):
+    """Returns the initializer configuration as a Python dict."""
+    return serialization_lib.serialize_keras_object(initializer)
+
+
+@keras_core_export("keras_core.initializers.deserialize")
+def deserialize(config, custom_objects=None):
+    """Returns a Keras initializer object via its configuration."""
+    return serialization_lib.deserialize_keras_object(
+        config,
+        module_objects=ALL_OBJECTS_DICT,
+        custom_objects=custom_objects,
+    )
+
+
+@keras_core_export("keras_core.initializers.get")
+def get(identifier):
+    """Retrieves a Keras initializer object via an identifier.
+
+    The `identifier` may be the string name of a initializers function or class
+    (case-sensitively).
+
+    >>> identifier = 'Ones'
+    >>> keras_core.initializers.deserialize(identifier)
+    <...keras_core.initializers.initializers.Ones...>
+
+    You can also specify `config` of the initializer to this function by passing
+    dict containing `class_name` and `config` as an identifier. Also note that
+    the `class_name` must map to a `Initializer` class.
+
+    >>> cfg = {'class_name': 'Ones', 'config': {}}
+    >>> keras_core.initializers.deserialize(cfg)
+    <...keras_core.initializers.initializers.Ones...>
+
+    In the case that the `identifier` is a class, this method will return a new
+    instance of the class by its constructor.
+
+    Args:
+        identifier: String or dict that contains the initializer name or
+            configurations.
+
+    Returns:
+        Initializer instance base on the input identifier.
+    """
+    if identifier is None:
+        return None
+    if isinstance(identifier, dict):
+        obj = deserialize(identifier)
+    elif isinstance(identifier, str):
+        config = {"class_name": str(identifier), "config": {}}
+        obj = deserialize(config)
+    else:
+        obj = identifier
+
+    if callable(obj):
+        if inspect.isclass(obj):
+            obj = obj()
+        return obj
+    else:
+        raise ValueError(
+            f"Could not interpret initializer identifier: {identifier}"
+        )
+

lib/python3.10/site-packages/keras_core/src/initializers/constant_initializers.py

@@ -0,0 +1,154 @@
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.backend import standardize_dtype
+from keras_core.src.initializers.initializer import Initializer
+
+
+@keras_core_export(
+    ["keras_core.initializers.Constant", "keras_core.initializers.constant"]
+)
+class Constant(Initializer):
+    """Initializer that generates tensors with constant values.
+
+    Only scalar values are allowed.
+    The constant value provided must be convertible to the dtype requested
+    when calling the initializer.
+
+    Examples:
+
+    >>> # Standalone usage:
+    >>> initializer = Constant(10.)
+    >>> values = initializer(shape=(2, 2))
+
+    >>> # Usage in a Keras layer:
+    >>> initializer = Constant(10.)
+    >>> layer = Dense(3, kernel_initializer=initializer)
+
+    Args:
+        value: A Python scalar.
+    """
+
+    def __init__(self, value=0.0):
+        self.value = value
+
+    def __call__(self, shape, dtype=None):
+        dtype = standardize_dtype(dtype)
+        return ops.cast(self.value, dtype=dtype) * ops.ones(
+            shape=shape, dtype=dtype
+        )
+
+    def get_config(self):
+        return {"value": self.value}
+
+
+@keras_core_export(
+    ["keras_core.initializers.Zeros", "keras_core.initializers.zeros"]
+)
+class Zeros(Initializer):
+    """Initializer that generates tensors initialized to 0.
+
+    Examples:
+
+    >>> # Standalone usage:
+    >>> initializer = Zeros()
+    >>> values = initializer(shape=(2, 2))
+
+    >>> # Usage in a Keras layer:
+    >>> initializer = Zeros()
+    >>> layer = Dense(units=3, kernel_initializer=initializer)
+    """
+
+    def __call__(self, shape, dtype=None):
+        """Returns a tensor object initialized as specified by the initializer.
+
+        Args:
+            shape: Shape of the tensor.
+            dtype: Optional dtype of the tensor. Only numeric or boolean dtypes
+                are supported. If not specified, `keras_core.backend.floatx()`
+                is used, which default to `float32` unless you configured it
+                otherwise (via `keras_core.backend.set_floatx(float_dtype)`).
+        """
+        dtype = standardize_dtype(dtype)
+        return ops.zeros(shape, dtype=dtype)
+
+
+@keras_core_export(
+    ["keras_core.initializers.Ones", "keras_core.initializers.ones"]
+)
+class Ones(Initializer):
+    """Initializer that generates tensors initialized to 1.
+
+    Also available via the shortcut function `ones`.
+
+    Examples:
+
+    >>> # Standalone usage:
+    >>> initializer = Ones()
+    >>> values = initializer(shape=(2, 2))
+
+    >>> # Usage in a Keras layer:
+    >>> initializer = Ones()
+    >>> layer = Dense(3, kernel_initializer=initializer)
+    """
+
+    def __call__(self, shape, dtype=None):
+        """Returns a tensor object initialized as specified by the initializer.
+
+        Args:
+            shape: Shape of the tensor.
+            dtype: Optional dtype of the tensor. Only numeric or boolean dtypes
+                are supported. If not specified, `keras_core.backend.floatx()`
+                is used, which default to `float32` unless you configured it
+                otherwise (via `keras_core.backend.set_floatx(float_dtype)`).
+        """
+        dtype = standardize_dtype(dtype)
+        return ops.ones(shape, dtype=dtype)
+
+
+@keras_core_export(
+    [
+        "keras_core.initializers.IdentityInitializer",
+        "keras_core.initializers.Identity",
+        "keras_core.initializers.identity",
+    ]
+)
+class Identity(Initializer):
+    """Initializer that generates the identity matrix.
+
+    Only usable for generating 2D matrices.
+
+    Examples:
+
+    >>> # Standalone usage:
+    >>> initializer = Identity()
+    >>> values = initializer(shape=(2, 2))
+
+    >>> # Usage in a Keras layer:
+    >>> initializer = Identity()
+    >>> layer = Dense(3, kernel_initializer=initializer)
+
+    Args:
+        gain: Multiplicative factor to apply to the identity matrix.
+    """
+
+    def __init__(self, gain=1.0):
+        self.gain = gain
+
+    def __call__(self, shape, dtype=None):
+        """Returns a tensor object initialized as specified by the initializer.
+
+        Args:
+            shape: Shape of the tensor.
+            dtype: Optional dtype of the tensor. Only numeric or boolean dtypes
+                are supported. If not specified, `keras_core.backend.floatx()`
+                is used, which default to `float32` unless you configured it
+                otherwise (via `keras_core.backend.set_floatx(float_dtype)`).
+        """
+        if len(shape) != 2:
+            raise ValueError(
+                "Identity matrix initializer can only be used for 2D matrices. "
+                f"Received: shape={shape} of rank {len(shape)}."
+            )
+        dtype = standardize_dtype(dtype)
+        return self.gain * ops.eye(*shape, dtype=dtype)
+

lib/python3.10/site-packages/keras_core/src/initializers/initializer.py

@@ -0,0 +1,84 @@
+from keras_core.src.api_export import keras_core_export
+
+
+@keras_core_export(
+    ["keras_core.Initializer", "keras_core.initializers.Initializer"]
+)
+class Initializer:
+    """Initializer base class: all Keras initializers inherit from this class.
+
+    Initializers should implement a `__call__()` method with the following
+    signature:
+
+    ```python
+    def __call__(self, shape, dtype=None, **kwargs):
+        # returns a tensor of shape `shape` and dtype `dtype`
+        # containing values drawn from a distribution of your choice.
+    ```
+
+    Optionally, you an also implement the method `get_config()` and the class
+    method `from_config` in order to support serialization -- just like with
+    any Keras object.
+
+    Here's a simple example: a random normal initializer.
+
+    ```python
+    class ExampleRandomNormal(Initializer):
+        def __init__(self, mean, stddev):
+            self.mean = mean
+            self.stddev = stddev
+
+        def __call__(self, shape, dtype=None, **kwargs):
+            return keras_core.random.normal(
+                shape, mean=self.mean, stddev=self.stddev, dtype=dtype
+            )
+
+        def get_config(self):  # To support serialization
+            return {"mean": self.mean, "stddev": self.stddev}
+    ```
+
+    Note that we don't have to implement `from_config()` in the example above
+    since the constructor arguments of the class the keys in the config returned
+    by `get_config()` are the same. In this case, the default `from_config()`
+    works fine.
+    """
+
+    def __call__(self, shape, dtype=None):
+        """Returns a tensor object initialized as specified by the initializer.
+
+        Args:
+            shape: Shape of the tensor.
+            dtype: Optional dtype of the tensor.
+        """
+        raise NotImplementedError(
+            "Initializer subclasses must implement the `__call__()` method."
+        )
+
+    def get_config(self):
+        """Returns the initializer's configuration as a JSON-serializable dict.
+
+        Returns:
+            A JSON-serializable Python dict.
+        """
+        return {}
+
+    @classmethod
+    def from_config(cls, config):
+        """Instantiates an initializer from a configuration dictionary.
+
+        Example:
+
+        ```python
+        initializer = RandomUniform(-1, 1)
+        config = initializer.get_config()
+        initializer = RandomUniform.from_config(config)
+        ```
+
+        Args:
+            config: A Python dictionary, the output of `get_config()`.
+
+        Returns:
+            An `Initializer` instance.
+        """
+        return cls(**config)
+

lib/python3.10/site-packages/keras_core/src/losses/__init__.py

@@ -0,0 +1,174 @@
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.losses.loss import Loss
+from keras_core.src.losses.losses import BinaryCrossentropy
+from keras_core.src.losses.losses import CategoricalCrossentropy
+from keras_core.src.losses.losses import CategoricalHinge
+from keras_core.src.losses.losses import CosineSimilarity
+from keras_core.src.losses.losses import Hinge
+from keras_core.src.losses.losses import Huber
+from keras_core.src.losses.losses import KLDivergence
+from keras_core.src.losses.losses import LogCosh
+from keras_core.src.losses.losses import LossFunctionWrapper
+from keras_core.src.losses.losses import MeanAbsoluteError
+from keras_core.src.losses.losses import MeanAbsolutePercentageError
+from keras_core.src.losses.losses import MeanSquaredError
+from keras_core.src.losses.losses import MeanSquaredLogarithmicError
+from keras_core.src.losses.losses import Poisson
+from keras_core.src.losses.losses import SparseCategoricalCrossentropy
+from keras_core.src.losses.losses import SquaredHinge
+from keras_core.src.losses.losses import binary_crossentropy
+from keras_core.src.losses.losses import categorical_crossentropy
+from keras_core.src.losses.losses import categorical_hinge
+from keras_core.src.losses.losses import cosine_similarity
+from keras_core.src.losses.losses import hinge
+from keras_core.src.losses.losses import huber
+from keras_core.src.losses.losses import kl_divergence
+from keras_core.src.losses.losses import log_cosh
+from keras_core.src.losses.losses import mean_absolute_error
+from keras_core.src.losses.losses import mean_absolute_percentage_error
+from keras_core.src.losses.losses import mean_squared_error
+from keras_core.src.losses.losses import mean_squared_logarithmic_error
+from keras_core.src.losses.losses import poisson
+from keras_core.src.losses.losses import sparse_categorical_crossentropy
+from keras_core.src.losses.losses import squared_hinge
+from keras_core.src.saving import serialization_lib
+
+ALL_OBJECTS = {
+    # Base
+    Loss,
+    LossFunctionWrapper,
+    # Probabilistic
+    KLDivergence,
+    Poisson,
+    BinaryCrossentropy,
+    CategoricalCrossentropy,
+    SparseCategoricalCrossentropy,
+    # Regression
+    MeanSquaredError,
+    MeanAbsoluteError,
+    MeanAbsolutePercentageError,
+    MeanSquaredLogarithmicError,
+    CosineSimilarity,
+    LogCosh,
+    Huber,
+    # Hinge
+    Hinge,
+    SquaredHinge,
+    CategoricalHinge,
+    # Probabilistic
+    kl_divergence,
+    poisson,
+    binary_crossentropy,
+    categorical_crossentropy,
+    sparse_categorical_crossentropy,
+    # Regression
+    mean_squared_error,
+    mean_absolute_error,
+    mean_absolute_percentage_error,
+    mean_squared_logarithmic_error,
+    cosine_similarity,
+    log_cosh,
+    huber,
+    # Hinge
+    hinge,
+    squared_hinge,
+    categorical_hinge,
+}
+
+ALL_OBJECTS_DICT = {cls.__name__: cls for cls in ALL_OBJECTS}
+ALL_OBJECTS_DICT.update(
+    {
+        "bce": binary_crossentropy,
+        "BCE": binary_crossentropy,
+        "kld": kl_divergence,
+        "KLD": kl_divergence,
+        "mae": mean_absolute_error,
+        "MAE": mean_absolute_error,
+        "mse": mean_squared_error,
+        "MSE": mean_squared_error,
+        "mape": mean_absolute_percentage_error,
+        "MAPE": mean_absolute_percentage_error,
+        "msle": mean_squared_logarithmic_error,
+        "MSLE": mean_squared_logarithmic_error,
+    }
+)
+
+
+@keras_core_export("keras_core.losses.serialize")
+def serialize(loss):
+    """Serializes loss function or `Loss` instance.
+
+    Args:
+        loss: A Keras `Loss` instance or a loss function.
+
+    Returns:
+        Loss configuration dictionary.
+    """
+    return serialization_lib.serialize_keras_object(loss)
+
+
+@keras_core_export("keras_core.losses.deserialize")
+def deserialize(name, custom_objects=None):
+    """Deserializes a serialized loss class/function instance.
+
+    Args:
+        name: Loss configuration.
+        custom_objects: Optional dictionary mapping names (strings) to custom
+          objects (classes and functions) to be considered during
+          deserialization.
+
+    Returns:
+        A Keras `Loss` instance or a loss function.
+    """
+    return serialization_lib.deserialize_keras_object(
+        name,
+        module_objects=ALL_OBJECTS_DICT,
+        custom_objects=custom_objects,
+    )
+
+
+@keras_core_export("keras_core.losses.get")
+def get(identifier):
+    """Retrieves a Keras loss as a `function`/`Loss` class instance.
+
+    The `identifier` may be the string name of a loss function or `Loss` class.
+
+    >>> loss = losses.get("categorical_crossentropy")
+    >>> type(loss)
+    <class 'function'>
+    >>> loss = losses.get("CategoricalCrossentropy")
+    >>> type(loss)
+    <class '...CategoricalCrossentropy'>
+
+    You can also specify `config` of the loss to this function by passing dict
+    containing `class_name` and `config` as an identifier. Also note that the
+    `class_name` must map to a `Loss` class
+
+    >>> identifier = {"class_name": "CategoricalCrossentropy",
+    ...               "config": {"from_logits": True}}
+    >>> loss = losses.get(identifier)
+    >>> type(loss)
+    <class '...CategoricalCrossentropy'>
+
+    Args:
+        identifier: A loss identifier. One of None or string name of a loss
+            function/class or loss configuration dictionary or a loss function
+            or a loss class instance.
+
+    Returns:
+        A Keras loss as a `function`/ `Loss` class instance.
+    """
+    if identifier is None:
+        return None
+    if isinstance(identifier, dict):
+        obj = deserialize(identifier)
+    elif isinstance(identifier, str):
+        obj = deserialize(identifier)
+    else:
+        obj = identifier
+
+    if callable(obj):
+        return obj
+    else:
+        raise ValueError(f"Could not interpret loss identifier: {identifier}")
+

lib/python3.10/site-packages/keras_core/src/losses/loss.py

@@ -0,0 +1,174 @@
+import tree
+
+from keras_core.src import backend
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.utils.naming import auto_name
+
+
+@keras_core_export(["keras_core.Loss", "keras_core.losses.Loss"])
+class Loss:
+    """Loss base class.
+
+    To be implemented by subclasses:
+
+    * `call()`: Contains the logic for loss calculation using `y_true`,
+        `y_pred`.
+
+    Example subclass implementation:
+
+    ```python
+    class MeanSquaredError(Loss):
+        def call(self, y_true, y_pred):
+            return ops.mean(ops.square(y_pred - y_true), axis=-1)
+    ```
+    """
+
+    def __init__(self, name=None, reduction="sum_over_batch_size", dtype=None):
+        self.name = name or auto_name(self.__class__.__name__)
+        self.reduction = standardize_reduction(reduction)
+        self.dtype = dtype or backend.floatx()
+
+    def __call__(self, y_true, y_pred, sample_weight=None):
+        in_mask = getattr(y_pred, "_keras_mask", None)
+
+        with ops.name_scope(self.name):
+            y_pred = tree.map_structure(
+                lambda x: ops.convert_to_tensor(x, dtype=self.dtype), y_pred
+            )
+            y_true = tree.map_structure(
+                lambda x: ops.convert_to_tensor(x, dtype=self.dtype), y_true
+            )
+
+            losses = self.call(y_true, y_pred)
+            out_mask = getattr(losses, "_keras_mask", None)
+
+            if in_mask is not None and out_mask is not None:
+                mask = in_mask & out_mask
+            elif in_mask is not None:
+                mask = in_mask
+            elif out_mask is not None:
+                mask = out_mask
+            else:
+                mask = None
+
+            return reduce_weighted_values(
+                losses,
+                sample_weight=sample_weight,
+                mask=mask,
+                reduction=self.reduction,
+                dtype=self.dtype,
+            )
+
+    def call(self, y_true, y_pred):
+        raise NotImplementedError
+
+    def get_config(self):
+        return {"name": self.name, "reduction": self.reduction}
+
+    @classmethod
+    def from_config(cls, config):
+        return cls(**config)
+
+
+def standardize_reduction(reduction):
+    allowed = {"sum_over_batch_size", "sum", None, "none"}
+    if reduction not in allowed:
+        raise ValueError(
+            "Invalid value for argument `reduction`. "
+            f"Expected on of {allowed}. Received: "
+            f"reduction={reduction}"
+        )
+    return reduction
+
+
+def squeeze_to_same_rank(x1, x2):
+    """Squeeze last dim if ranks differ from expected by exactly 1."""
+    x1_rank = len(x1.shape)
+    x2_rank = len(x2.shape)
+    if x1_rank == x2_rank:
+        return x1, x2
+    if x1_rank == x2_rank + 1:
+        if x1.shape[-1] == 1:
+            x1 = ops.squeeze(x1, axis=-1)
+    if x2_rank == x1_rank + 1:
+        if x2.shape[-1] == 1:
+            x2 = ops.squeeze(x2, axis=-1)
+    return x1, x2
+
+
+def reduce_values(values, reduction="sum_over_batch_size"):
+    if (
+        reduction is None
+        or reduction == "none"
+        or tuple(values.shape) == ()
+        or tuple(values.shape) == (0,)
+    ):
+        return values
+    loss = ops.sum(values)
+    if reduction == "sum_over_batch_size":
+        loss /= ops.cast(
+            ops.prod(ops.convert_to_tensor(ops.shape(values), dtype="int32")),
+            loss.dtype,
+        )
+    return loss
+
+
+def reduce_weighted_values(
+    values,
+    sample_weight=None,
+    mask=None,
+    reduction="sum_over_batch_size",
+    dtype=None,
+):
+    reduction = standardize_reduction(reduction)
+
+    values = ops.convert_to_tensor(values, dtype=dtype)
+    if sample_weight is not None:
+        sample_weight = ops.convert_to_tensor(sample_weight, dtype=dtype)
+    if mask is not None:
+        mask = ops.convert_to_tensor(mask, dtype=dtype)
+
+    # Merge mask and sample weight into sample weight.
+    sample_weight = apply_mask(
+        sample_weight, mask, dtype=values.dtype, reduction=reduction
+    )
+
+    if sample_weight is not None:
+        sample_weight = ops.cast(sample_weight, values.dtype)
+        # Update dimensions of `sample_weight` to match `losses`.
+        values, sample_weight = squeeze_to_same_rank(values, sample_weight)
+        values = values * sample_weight
+
+    # Apply reduction function to the individual weighted losses.
+    loss = reduce_values(values, reduction)
+    return loss
+
+
+def apply_mask(sample_weight, mask, dtype, reduction):
+    """Applies any mask on predictions to sample weights."""
+    if mask is not None:
+        mask = ops.cast(mask, dtype=dtype)
+        if reduction == "sum_over_batch_size":
+            # Valid entries have weight `total/valid`, while invalid ones
+            # have 0. When summed over batch, they will be reduced to:
+            #
+            # mean(loss * sample_weight * total / valid)
+            #   = sum(loss * sample_weight * total / valid) / total
+            #   = sum(loss * sample_weight) / total * total / valid
+            #   = sum(loss * sample_weight) / valid
+            total = ops.cast(
+                ops.prod(ops.convert_to_tensor(ops.shape(mask), dtype="int32")),
+                dtype,
+            )
+            valid = ops.sum(mask)  # May be 0!
+            mask *= total / (valid + backend.epsilon())
+
+        if sample_weight is not None:
+            sample_weight = ops.cast(sample_weight, dtype=dtype)
+            mask, sample_weight = squeeze_to_same_rank(mask, sample_weight)
+            sample_weight *= mask
+        else:
+            sample_weight = mask
+    return sample_weight
+

lib/python3.10/site-packages/keras_core/src/losses/losses.py

@@ -0,0 +1,1861 @@
+import warnings
+
+from keras_core.src import backend
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.losses.loss import Loss
+from keras_core.src.losses.loss import squeeze_to_same_rank
+from keras_core.src.saving import serialization_lib
+from keras_core.src.utils.numerical_utils import normalize
+
+
+class LossFunctionWrapper(Loss):
+    def __init__(
+        self, fn, reduction="sum_over_batch_size", name=None, **kwargs
+    ):
+        super().__init__(reduction=reduction, name=name)
+        self.fn = fn
+        self._fn_kwargs = kwargs
+
+    def call(self, y_true, y_pred):
+        y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+        return self.fn(y_true, y_pred, **self._fn_kwargs)
+
+    def get_config(self):
+        base_config = super().get_config()
+        config = {"fn": serialization_lib.serialize_keras_object(self.fn)}
+        config.update(serialization_lib.serialize_keras_object(self._fn_kwargs))
+        return {**base_config, **config}
+
+    @classmethod
+    def from_config(cls, config):
+        if "fn" in config:
+            config = serialization_lib.deserialize_keras_object(config)
+        return cls(**config)
+
+
+@keras_core_export("keras_core.losses.MeanSquaredError")
+class MeanSquaredError(LossFunctionWrapper):
+    """Computes the mean of squares of errors between labels and predictions.
+
+    Formula:
+
+    ```python
+    loss = mean(square(y_true - y_pred))
+    ```
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(
+        self, reduction="sum_over_batch_size", name="mean_squared_error"
+    ):
+        super().__init__(mean_squared_error, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.MeanAbsoluteError")
+class MeanAbsoluteError(LossFunctionWrapper):
+    """Computes the mean of absolute difference between labels and predictions.
+
+    Formula:
+
+    ```python
+    loss = mean(abs(y_true - y_pred))
+    ```
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(
+        self, reduction="sum_over_batch_size", name="mean_absolute_error"
+    ):
+        super().__init__(mean_absolute_error, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.MeanAbsolutePercentageError")
+class MeanAbsolutePercentageError(LossFunctionWrapper):
+    """Computes the mean absolute percentage error between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = 100 * mean(abs((y_true - y_pred) / y_true))
+    ```
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(
+        self,
+        reduction="sum_over_batch_size",
+        name="mean_absolute_percentage_error",
+    ):
+        super().__init__(
+            mean_absolute_percentage_error, reduction=reduction, name=name
+        )
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.MeanSquaredLogarithmicError")
+class MeanSquaredLogarithmicError(LossFunctionWrapper):
+    """Computes the mean squared logarithmic error between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = mean(square(log(y_true + 1) - log(y_pred + 1)))
+    ```
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(
+        self,
+        reduction="sum_over_batch_size",
+        name="mean_squared_logarithmic_error",
+    ):
+        super().__init__(
+            mean_squared_logarithmic_error, reduction=reduction, name=name
+        )
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.CosineSimilarity")
+class CosineSimilarity(LossFunctionWrapper):
+    """Computes the cosine similarity between `y_true` & `y_pred`.
+
+    Note that it is a number between -1 and 1. When it is a negative number
+    between -1 and 0, 0 indicates orthogonality and values closer to -1
+    indicate greater similarity. This makes it usable as a loss function in a
+    setting where you try to maximize the proximity between predictions and
+    targets. If either `y_true` or `y_pred` is a zero vector, cosine similarity
+    will be 0 regardless of the proximity between predictions and targets.
+
+    Formula:
+
+    ```python
+    loss = -sum(l2_norm(y_true) * l2_norm(y_pred))
+    ```
+
+    Args:
+        axis: The axis along which the cosine similarity is computed
+            (the features axis). Defaults to `-1`.
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(
+        self,
+        axis=-1,
+        reduction="sum_over_batch_size",
+        name="cosine_similarity",
+    ):
+        super().__init__(
+            cosine_similarity, reduction=reduction, name=name, axis=axis
+        )
+
+
+@keras_core_export("keras_core.losses.Huber")
+class Huber(LossFunctionWrapper):
+    """Computes the Huber loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    for x in error:
+        if abs(x) <= delta:
+            loss.append(0.5 * x^2)
+        elif abs(x) > delta:
+            loss.append(delta * abs(x) - 0.5 * delta^2)
+
+    loss = mean(loss, axis=-1)
+    ```
+    See: [Huber loss](https://en.wikipedia.org/wiki/Huber_loss).
+
+    Args:
+        delta: A float, the point where the Huber loss function changes from a
+            quadratic to linear.
+        reduction: Type of reduction to apply to loss. Options are `"sum"`,
+            `"sum_over_batch_size"` or `None`. Defaults to
+            `"sum_over_batch_size"`.
+        name: Optional name for the instance.
+    """
+
+    def __init__(
+        self,
+        delta=1.0,
+        reduction="sum_over_batch_size",
+        name="huber_loss",
+    ):
+        super().__init__(huber, name=name, reduction=reduction, delta=delta)
+
+
+@keras_core_export("keras_core.losses.LogCosh")
+class LogCosh(LossFunctionWrapper):
+    """Computes the logarithm of the hyperbolic cosine of the prediction error.
+
+    Formula:
+
+    ```python
+    error = y_pred - y_true
+    logcosh = mean(log((exp(error) + exp(-error))/2), axis=-1)`
+    ```
+    where x is the error `y_pred - y_true`.
+
+    Args:
+        reduction: Type of reduction to apply to loss. Options are `"sum"`,
+            `"sum_over_batch_size"` or `None`. Defaults to
+            `"sum_over_batch_size"`.
+        name: Optional name for the instance.
+    """
+
+    def __init__(self, reduction="sum_over_batch_size", name="log_cosh"):
+        super().__init__(log_cosh, name=name, reduction=reduction)
+
+
+@keras_core_export("keras_core.losses.Hinge")
+class Hinge(LossFunctionWrapper):
+    """Computes the hinge loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = maximum(1 - y_true * y_pred, 0)
+    ```
+
+    `y_true` values are expected to be -1 or 1. If binary (0 or 1) labels are
+    provided we will convert them to -1 or 1.
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(self, reduction="sum_over_batch_size", name="hinge"):
+        super().__init__(hinge, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.SquaredHinge")
+class SquaredHinge(LossFunctionWrapper):
+    """Computes the squared hinge loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = square(maximum(1 - y_true * y_pred, 0))
+    ```
+
+    `y_true` values are expected to be -1 or 1. If binary (0 or 1) labels are
+    provided we will convert them to -1 or 1.
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(self, reduction="sum_over_batch_size", name="squared_hinge"):
+        super().__init__(squared_hinge, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.CategoricalHinge")
+class CategoricalHinge(LossFunctionWrapper):
+    """Computes the categorical hinge loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = maximum(neg - pos + 1, 0)
+    ```
+
+    where `neg=maximum((1-y_true)*y_pred)` and `pos=sum(y_true*y_pred)`
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(
+        self, reduction="sum_over_batch_size", name="categorical_hinge"
+    ):
+        super().__init__(categorical_hinge, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.KLDivergence")
+class KLDivergence(LossFunctionWrapper):
+    """Computes Kullback-Leibler divergence loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = y_true * log(y_true / y_pred)
+    ```
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(self, reduction="sum_over_batch_size", name="kl_divergence"):
+        super().__init__(kl_divergence, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.Poisson")
+class Poisson(LossFunctionWrapper):
+    """Computes the Poisson loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = y_pred - y_true * log(y_pred)
+    ```
+
+    Args:
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+    """
+
+    def __init__(self, reduction="sum_over_batch_size", name="poisson"):
+        super().__init__(poisson, reduction=reduction, name=name)
+
+    def get_config(self):
+        return Loss.get_config(self)
+
+
+@keras_core_export("keras_core.losses.BinaryCrossentropy")
+class BinaryCrossentropy(LossFunctionWrapper):
+    """Computes the cross-entropy loss between true labels and predicted labels.
+
+    Use this cross-entropy loss for binary (0 or 1) classification applications.
+    The loss function requires the following inputs:
+
+    - `y_true` (true label): This is either 0 or 1.
+    - `y_pred` (predicted value): This is the model's prediction, i.e, a single
+        floating-point value which either represents a
+        [logit](https://en.wikipedia.org/wiki/Logit), (i.e, value in [-inf, inf]
+        when `from_logits=True`) or a probability (i.e, value in [0., 1.] when
+        `from_logits=False`).
+
+    Args:
+        from_logits: Whether to interpret `y_pred` as a tensor of
+            [logit](https://en.wikipedia.org/wiki/Logit) values. By default, we
+            assume that `y_pred` is probabilities (i.e., values in [0, 1]).
+        label_smoothing: Float in range [0, 1]. When 0, no smoothing occurs.
+            When > 0, we compute the loss between the predicted labels
+            and a smoothed version of the true labels, where the smoothing
+            squeezes the labels towards 0.5. Larger values of
+            `label_smoothing` correspond to heavier smoothing.
+        axis: The axis along which to compute crossentropy (the features axis).
+            Defaults to `-1`.
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+
+    Examples:
+
+    **Recommended Usage:** (set `from_logits=True`)
+
+    With `compile()` API:
+
+    ```python
+    model.compile(
+        loss=keras_core.losses.BinaryCrossentropy(from_logits=True),
+        ...
+    )
+    ```
+
+    As a standalone function:
+
+    >>> # Example 1: (batch_size = 1, number of samples = 4)
+    >>> y_true = [0, 1, 0, 0]
+    >>> y_pred = [-18.6, 0.51, 2.94, -12.8]
+    >>> bce = keras_core.losses.BinaryCrossentropy(from_logits=True)
+    >>> bce(y_true, y_pred)
+    0.865
+
+    >>> # Example 2: (batch_size = 2, number of samples = 4)
+    >>> y_true = [[0, 1], [0, 0]]
+    >>> y_pred = [[-18.6, 0.51], [2.94, -12.8]]
+    >>> # Using default 'auto'/'sum_over_batch_size' reduction type.
+    >>> bce = keras_core.losses.BinaryCrossentropy(from_logits=True)
+    >>> bce(y_true, y_pred)
+    0.865
+    >>> # Using 'sample_weight' attribute
+    >>> bce(y_true, y_pred, sample_weight=[0.8, 0.2])
+    0.243
+    >>> # Using 'sum' reduction` type.
+    >>> bce = keras_core.losses.BinaryCrossentropy(from_logits=True,
+    ...     reduction="sum")
+    >>> bce(y_true, y_pred)
+    1.730
+    >>> # Using 'none' reduction type.
+    >>> bce = keras_core.losses.BinaryCrossentropy(from_logits=True,
+    ...     reduction=None)
+    >>> bce(y_true, y_pred)
+    array([0.235, 1.496], dtype=float32)
+
+    **Default Usage:** (set `from_logits=False`)
+
+    >>> # Make the following updates to the above "Recommended Usage" section
+    >>> # 1. Set `from_logits=False`
+    >>> keras_core.losses.BinaryCrossentropy() # OR ...('from_logits=False')
+    >>> # 2. Update `y_pred` to use probabilities instead of logits
+    >>> y_pred = [0.6, 0.3, 0.2, 0.8] # OR [[0.6, 0.3], [0.2, 0.8]]
+    """
+
+    def __init__(
+        self,
+        from_logits=False,
+        label_smoothing=0.0,
+        axis=-1,
+        reduction="sum_over_batch_size",
+        name="binary_crossentropy",
+    ):
+        super().__init__(
+            binary_crossentropy,
+            name=name,
+            reduction=reduction,
+            from_logits=from_logits,
+            label_smoothing=label_smoothing,
+            axis=axis,
+        )
+        self.from_logits = from_logits
+        self.label_smoothing = label_smoothing
+        self.axis = axis
+
+    def get_config(self):
+        return {
+            "name": self.name,
+            "reduction": self.reduction,
+            "from_logits": self.from_logits,
+            "label_smoothing": self.label_smoothing,
+            "axis": self.axis,
+        }
+
+
+@keras_core_export("keras_core.losses.BinaryFocalCrossentropy")
+class BinaryFocalCrossentropy(LossFunctionWrapper):
+    """Computes focal cross-entropy loss between true labels and predictions.
+
+    Binary cross-entropy loss is often used for binary (0 or 1) classification
+    tasks. The loss function requires the following inputs:
+
+    - `y_true` (true label): This is either 0 or 1.
+    - `y_pred` (predicted value): This is the model's prediction, i.e, a single
+        floating-point value which either represents a
+        [logit](https://en.wikipedia.org/wiki/Logit), (i.e, value in [-inf, inf]
+        when `from_logits=True`) or a probability (i.e, value in `[0., 1.]` when
+        `from_logits=False`).
+
+    According to [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf), it
+    helps to apply a "focal factor" to down-weight easy examples and focus more
+    on hard examples. By default, the focal tensor is computed as follows:
+
+    `focal_factor = (1 - output) ** gamma` for class 1
+    `focal_factor = output ** gamma` for class 0
+    where `gamma` is a focusing parameter. When `gamma=0`, this function is
+    equivalent to the binary crossentropy loss.
+
+    Args:
+        apply_class_balancing: A bool, whether to apply weight balancing on the
+            binary classes 0 and 1.
+        alpha: A weight balancing factor for class 1, default is `0.25` as
+            mentioned in reference [Lin et al., 2018](
+            https://arxiv.org/pdf/1708.02002.pdf).  The weight for class 0 is
+            `1.0 - alpha`.
+        gamma: A focusing parameter used to compute the focal factor, default is
+            `2.0` as mentioned in the reference
+            [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf).
+        from_logits: Whether to interpret `y_pred` as a tensor of
+            [logit](https://en.wikipedia.org/wiki/Logit) values. By default, we
+            assume that `y_pred` are probabilities (i.e., values in `[0, 1]`).
+        label_smoothing: Float in `[0, 1]`. When `0`, no smoothing occurs.
+            When > `0`, we compute the loss between the predicted labels
+            and a smoothed version of the true labels, where the smoothing
+            squeezes the labels towards `0.5`.
+            Larger values of `label_smoothing` correspond to heavier smoothing.
+        axis: The axis along which to compute crossentropy (the features axis).
+            Defaults to `-1`.
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+
+    Examples:
+
+    With the `compile()` API:
+
+    ```python
+    model.compile(
+        loss=keras_core.losses.BinaryFocalCrossentropy(
+            gamma=2.0, from_logits=True),
+        ...
+    )
+    ```
+
+    As a standalone function:
+
+    >>> # Example 1: (batch_size = 1, number of samples = 4)
+    >>> y_true = [0, 1, 0, 0]
+    >>> y_pred = [-18.6, 0.51, 2.94, -12.8]
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...    gamma=2, from_logits=True)
+    >>> loss(y_true, y_pred)
+    0.691
+
+    >>> # Apply class weight
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     apply_class_balancing=True, gamma=2, from_logits=True)
+    >>> loss(y_true, y_pred)
+    0.51
+
+    >>> # Example 2: (batch_size = 2, number of samples = 4)
+    >>> y_true = [[0, 1], [0, 0]]
+    >>> y_pred = [[-18.6, 0.51], [2.94, -12.8]]
+    >>> # Using default 'auto'/'sum_over_batch_size' reduction type.
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     gamma=3, from_logits=True)
+    >>> loss(y_true, y_pred)
+    0.647
+
+    >>> # Apply class weight
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...      apply_class_balancing=True, gamma=3, from_logits=True)
+    >>> loss(y_true, y_pred)
+    0.482
+
+    >>> # Using 'sample_weight' attribute with focal effect
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     gamma=3, from_logits=True)
+    >>> loss(y_true, y_pred, sample_weight=[0.8, 0.2])
+    0.133
+
+    >>> # Apply class weight
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...      apply_class_balancing=True, gamma=3, from_logits=True)
+    >>> loss(y_true, y_pred, sample_weight=[0.8, 0.2])
+    0.097
+
+    >>> # Using 'sum' reduction` type.
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     gamma=4, from_logits=True,
+    ...     reduction="sum")
+    >>> loss(y_true, y_pred)
+    1.222
+
+    >>> # Apply class weight
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     apply_class_balancing=True, gamma=4, from_logits=True,
+    ...     reduction="sum")
+    >>> loss(y_true, y_pred)
+    0.914
+
+    >>> # Using 'none' reduction type.
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     gamma=5, from_logits=True,
+    ...     reduction=None)
+    >>> loss(y_true, y_pred)
+    array([0.0017 1.1561], dtype=float32)
+
+    >>> # Apply class weight
+    >>> loss = keras_core.losses.BinaryFocalCrossentropy(
+    ...     apply_class_balancing=True, gamma=5, from_logits=True,
+    ...     reduction=None)
+    >>> loss(y_true, y_pred)
+    array([0.0004 0.8670], dtype=float32)
+    """
+
+    def __init__(
+        self,
+        apply_class_balancing=False,
+        alpha=0.25,
+        gamma=2.0,
+        from_logits=False,
+        label_smoothing=0.0,
+        axis=-1,
+        reduction="sum_over_batch_size",
+        name="binary_focal_crossentropy",
+    ):
+        super().__init__(
+            binary_focal_crossentropy,
+            apply_class_balancing=apply_class_balancing,
+            alpha=alpha,
+            gamma=gamma,
+            name=name,
+            reduction=reduction,
+            from_logits=from_logits,
+            label_smoothing=label_smoothing,
+            axis=axis,
+        )
+        self.from_logits = from_logits
+        self.label_smoothing = label_smoothing
+        self.axis = axis
+        self.apply_class_balancing = apply_class_balancing
+        self.alpha = alpha
+        self.gamma = gamma
+
+    def get_config(self):
+        return {
+            "name": self.name,
+            "reduction": self.reduction,
+            "from_logits": self.from_logits,
+            "label_smoothing": self.label_smoothing,
+            "axis": self.axis,
+            "apply_class_balancing": self.apply_class_balancing,
+            "alpha": self.alpha,
+            "gamma": self.gamma,
+        }
+
+
+@keras_core_export("keras_core.losses.CategoricalCrossentropy")
+class CategoricalCrossentropy(LossFunctionWrapper):
+    """Computes the crossentropy loss between the labels and predictions.
+
+    Use this crossentropy loss function when there are two or more label
+    classes. We expect labels to be provided in a `one_hot` representation. If
+    you want to provide labels as integers, please use
+    `SparseCategoricalCrossentropy` loss. There should be `num_classes` floating
+    point values per feature, i.e., the shape of both `y_pred` and `y_true` are
+    `[batch_size, num_classes]`.
+
+    Args:
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability distribution.
+        label_smoothing: Float in [0, 1]. When > 0, label values are smoothed,
+            meaning the confidence on label values are relaxed. For example, if
+            `0.1`, use `0.1 / num_classes` for non-target labels and
+            `0.9 + 0.1 / num_classes` for target labels.
+        axis: The axis along which to compute crossentropy (the features
+            axis). Defaults to `-1`.
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+
+    Examples:
+
+    Standalone usage:
+
+    >>> y_true = [[0, 1, 0], [0, 0, 1]]
+    >>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
+    >>> # Using 'auto'/'sum_over_batch_size' reduction type.
+    >>> cce = keras_core.losses.CategoricalCrossentropy()
+    >>> cce(y_true, y_pred)
+    1.177
+
+    >>> # Calling with 'sample_weight'.
+    >>> cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
+    0.814
+
+    >>> # Using 'sum' reduction type.
+    >>> cce = keras_core.losses.CategoricalCrossentropy(
+    ...     reduction="sum")
+    >>> cce(y_true, y_pred)
+    2.354
+
+    >>> # Using 'none' reduction type.
+    >>> cce = keras_core.losses.CategoricalCrossentropy(
+    ...     reduction=None)
+    >>> cce(y_true, y_pred)
+    array([0.0513, 2.303], dtype=float32)
+
+    Usage with the `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss=keras_core.losses.CategoricalCrossentropy())
+    ```
+    """
+
+    def __init__(
+        self,
+        from_logits=False,
+        label_smoothing=0.0,
+        axis=-1,
+        reduction="sum_over_batch_size",
+        name="categorical_crossentropy",
+    ):
+        super().__init__(
+            categorical_crossentropy,
+            name=name,
+            reduction=reduction,
+            from_logits=from_logits,
+            label_smoothing=label_smoothing,
+            axis=axis,
+        )
+        self.from_logits = from_logits
+        self.label_smoothing = label_smoothing
+        self.axis = axis
+
+    def get_config(self):
+        return {
+            "name": self.name,
+            "reduction": self.reduction,
+            "from_logits": self.from_logits,
+            "label_smoothing": self.label_smoothing,
+            "axis": self.axis,
+        }
+
+
+@keras_core_export("keras_core.losses.CategoricalFocalCrossentropy")
+class CategoricalFocalCrossentropy(LossFunctionWrapper):
+    """Computes the alpha balanced focal crossentropy loss.
+
+    Use this crossentropy loss function when there are two or more label
+    classes and if you want to handle class imbalance without using
+    `class_weights`. We expect labels to be provided in a `one_hot`
+    representation.
+
+    According to [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf), it
+    helps to apply a focal factor to down-weight easy examples and focus more on
+    hard examples. The general formula for the focal loss (FL)
+    is as follows:
+
+    `FL(p_t) = (1 - p_t) ** gamma * log(p_t)`
+
+    where `p_t` is defined as follows:
+    `p_t = output if y_true == 1, else 1 - output`
+
+    `(1 - p_t) ** gamma` is the `modulating_factor`, where `gamma` is a focusing
+    parameter. When `gamma` = 0, there is no focal effect on the cross entropy.
+    `gamma` reduces the importance given to simple examples in a smooth manner.
+
+    The authors use alpha-balanced variant of focal loss (FL) in the paper:
+    `FL(p_t) = -alpha * (1 - p_t) ** gamma * log(p_t)`
+
+    where `alpha` is the weight factor for the classes. If `alpha` = 1, the
+    loss won't be able to handle class imbalance properly as all
+    classes will have the same weight. This can be a constant or a list of
+    constants. If alpha is a list, it must have the same length as the number
+    of classes.
+
+    The formula above can be generalized to:
+    `FL(p_t) = alpha * (1 - p_t) ** gamma * CrossEntropy(y_true, y_pred)`
+
+    where minus comes from `CrossEntropy(y_true, y_pred)` (CE).
+
+    Extending this to multi-class case is straightforward:
+    `FL(p_t) = alpha * (1 - p_t) ** gamma * CategoricalCE(y_true, y_pred)`
+
+    In the snippet below, there is `num_classes` floating pointing values per
+    example. The shape of both `y_pred` and `y_true` are
+    `(batch_size, num_classes)`.
+
+    Args:
+        alpha: A weight balancing factor for all classes, default is `0.25` as
+            mentioned in the reference. It can be a list of floats or a scalar.
+            In the multi-class case, alpha may be set by inverse class
+            frequency by using `compute_class_weight` from `sklearn.utils`.
+        gamma: A focusing parameter, default is `2.0` as mentioned in the
+            reference. It helps to gradually reduce the importance given to
+            simple (easy) examples in a smooth manner.
+        from_logits: Whether `output` is expected to be a logits tensor. By
+            default, we consider that `output` encodes a probability
+            distribution.
+        label_smoothing: Float in [0, 1]. When > 0, label values are smoothed,
+            meaning the confidence on label values are relaxed. For example, if
+            `0.1`, use `0.1 / num_classes` for non-target labels and
+            `0.9 + 0.1 / num_classes` for target labels.
+        axis: The axis along which to compute crossentropy (the features
+            axis). Defaults to `-1`.
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+
+    Examples:
+
+    Standalone usage:
+
+    >>> y_true = [[0., 1., 0.], [0., 0., 1.]]
+    >>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
+    >>> # Using 'auto'/'sum_over_batch_size' reduction type.
+    >>> cce = keras_core.losses.CategoricalFocalCrossentropy()
+    >>> cce(y_true, y_pred)
+    0.23315276
+
+    >>> # Calling with 'sample_weight'.
+    >>> cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
+    0.1632
+
+    >>> # Using 'sum' reduction type.
+    >>> cce = keras_core.losses.CategoricalFocalCrossentropy(
+    ...     reduction="sum")
+    >>> cce(y_true, y_pred)
+    0.46631
+
+    >>> # Using 'none' reduction type.
+    >>> cce = keras_core.losses.CategoricalFocalCrossentropy(
+    ...     reduction=None)
+    >>> cce(y_true, y_pred)
+    array([3.2058331e-05, 4.6627346e-01], dtype=float32)
+
+    Usage with the `compile()` API:
+
+    ```python
+    model.compile(optimizer='adam',
+                  loss=keras_core.losses.CategoricalFocalCrossentropy())
+    ```
+    """
+
+    def __init__(
+        self,
+        alpha=0.25,
+        gamma=2.0,
+        from_logits=False,
+        label_smoothing=0.0,
+        axis=-1,
+        reduction="sum_over_batch_size",
+        name="categorical_focal_crossentropy",
+    ):
+        """Initializes `CategoricalFocalCrossentropy` instance."""
+        super().__init__(
+            categorical_focal_crossentropy,
+            alpha=alpha,
+            gamma=gamma,
+            name=name,
+            reduction=reduction,
+            from_logits=from_logits,
+            label_smoothing=label_smoothing,
+            axis=axis,
+        )
+        self.from_logits = from_logits
+        self.label_smoothing = label_smoothing
+        self.axis = axis
+        self.alpha = alpha
+        self.gamma = gamma
+
+    def get_config(self):
+        return {
+            "name": self.name,
+            "reduction": self.reduction,
+            "from_logits": self.from_logits,
+            "label_smoothing": self.label_smoothing,
+            "axis": self.axis,
+            "alpha": self.alpha,
+            "gamma": self.gamma,
+        }
+
+
+@keras_core_export("keras_core.losses.SparseCategoricalCrossentropy")
+class SparseCategoricalCrossentropy(LossFunctionWrapper):
+    """Computes the crossentropy loss between the labels and predictions.
+
+    Use this crossentropy loss function when there are two or more label
+    classes.  We expect labels to be provided as integers. If you want to
+    provide labels using `one-hot` representation, please use
+    `CategoricalCrossentropy` loss.  There should be `# classes` floating point
+    values per feature for `y_pred` and a single floating point value per
+    feature for `y_true`.
+
+    In the snippet below, there is a single floating point value per example for
+    `y_true` and `num_classes` floating pointing values per example for
+    `y_pred`. The shape of `y_true` is `[batch_size]` and the shape of `y_pred`
+    is `[batch_size, num_classes]`.
+
+    Args:
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability distribution.
+        reduction: Type of reduction to apply to the loss. In almost all cases
+            this should be `"sum_over_batch_size"`.
+            Supported options are `"sum"`, `"sum_over_batch_size"` or `None`.
+        name: Optional name for the loss instance.
+
+    Examples:
+
+    >>> y_true = [1, 2]
+    >>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
+    >>> # Using 'auto'/'sum_over_batch_size' reduction type.
+    >>> scce = keras_core.losses.SparseCategoricalCrossentropy()
+    >>> scce(y_true, y_pred)
+    1.177
+
+    >>> # Calling with 'sample_weight'.
+    >>> scce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
+    0.814
+
+    >>> # Using 'sum' reduction type.
+    >>> scce = keras_core.losses.SparseCategoricalCrossentropy(
+    ...     reduction="sum")
+    >>> scce(y_true, y_pred)
+    2.354
+
+    >>> # Using 'none' reduction type.
+    >>> scce = keras_core.losses.SparseCategoricalCrossentropy(
+    ...     reduction=None)
+    >>> scce(y_true, y_pred)
+    array([0.0513, 2.303], dtype=float32)
+
+    Usage with the `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss=keras_core.losses.SparseCategoricalCrossentropy())
+    ```
+    """
+
+    def __init__(
+        self,
+        from_logits=False,
+        ignore_class=None,
+        reduction="sum_over_batch_size",
+        name="sparse_categorical_crossentropy",
+    ):
+        super().__init__(
+            sparse_categorical_crossentropy,
+            name=name,
+            reduction=reduction,
+            from_logits=from_logits,
+            ignore_class=ignore_class,
+        )
+        self.from_logits = from_logits
+        self.ignore_class = ignore_class
+
+    def get_config(self):
+        return {
+            "name": self.name,
+            "reduction": self.reduction,
+            "from_logits": self.from_logits,
+            "ignore_class": self.ignore_class,
+        }
+
+
+def convert_binary_labels_to_hinge(y_true):
+    """Converts binary labels into -1/1 for hinge loss/metric calculation."""
+    are_zeros = ops.equal(y_true, 0)
+    are_ones = ops.equal(y_true, 1)
+    is_binary = ops.all((ops.logical_or(are_zeros, are_ones)))
+
+    def _convert_binary_labels():
+        # Convert the binary labels to -1 or 1.
+        return 2.0 * y_true - 1.0
+
+    def _return_labels_unconverted():
+        # Returns the labels unchanged if they are non-binary
+        return y_true
+
+    updated_y_true = ops.cond(
+        is_binary, _convert_binary_labels, _return_labels_unconverted
+    )
+    return updated_y_true
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.hinge",
+        "keras_core.losses.hinge",
+    ]
+)
+def hinge(y_true, y_pred):
+    """Computes the hinge loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = mean(maximum(1 - y_true * y_pred, 0), axis=-1)
+    ```
+
+    Args:
+        y_true: The ground truth values. `y_true` values are expected to be -1
+            or 1. If binary (0 or 1) labels are provided they will be converted
+            to -1 or 1 with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Hinge loss values with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.choice([-1, 1], size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.hinge(y_true, y_pred)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, dtype=y_pred.dtype)
+    y_true = ops.convert_to_tensor(y_true)
+    y_true = convert_binary_labels_to_hinge(y_true)
+    return ops.mean(ops.maximum(1.0 - y_true * y_pred, 0.0), axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.squared_hinge",
+        "keras_core.losses.squared_hinge",
+    ]
+)
+def squared_hinge(y_true, y_pred):
+    """Computes the squared hinge loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = mean(square(maximum(1 - y_true * y_pred, 0)), axis=-1)
+    ```
+
+    Args:
+        y_true: The ground truth values. `y_true` values are expected to be -1
+            or 1. If binary (0 or 1) labels are provided we will convert them
+            to -1 or 1 with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Squared hinge loss values with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.choice([-1, 1], size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.squared_hinge(y_true, y_pred)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, y_pred.dtype)
+    y_true = convert_binary_labels_to_hinge(y_true)
+    return ops.mean(
+        ops.square(ops.maximum(1.0 - y_true * y_pred, 0.0)), axis=-1
+    )
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.categorical_hinge",
+        "keras_core.losses.categorical_hinge",
+    ]
+)
+def categorical_hinge(y_true, y_pred):
+    """Computes the categorical hinge loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = maximum(neg - pos + 1, 0)
+    ```
+
+    where `neg=maximum((1-y_true)*y_pred)` and `pos=sum(y_true*y_pred)`
+
+    Args:
+        y_true: The ground truth values. `y_true` values are expected to be
+            either `{-1, +1}` or `{0, 1}` (i.e. a one-hot-encoded tensor) with
+            shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Categorical hinge loss values with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.randint(0, 3, size=(2,))
+    >>> y_true = np.eye(np.max(y_true) + 1)[y_true]
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.categorical_hinge(y_true, y_pred)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, y_pred.dtype)
+    pos = ops.sum(y_true * y_pred, axis=-1)
+    neg = ops.max((1.0 - y_true) * y_pred, axis=-1)
+    zero = ops.cast(0.0, y_pred.dtype)
+    return ops.maximum(neg - pos + 1.0, zero)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.mean_squared_error",
+        "keras_core.losses.mean_squared_error",
+        # Legacy aliases
+        "keras_core._legacy.losses.mse",
+        "keras_core._legacy.losses.MSE",
+        "keras_core._legacy.metrics.mse",
+        "keras_core._legacy.metrics.MSE",
+    ]
+)
+def mean_squared_error(y_true, y_pred):
+    """Computes the mean squared error between labels and predictions.
+
+    Formula:
+
+    ```python
+    loss = mean(square(y_true - y_pred), axis=-1)
+    ```
+
+    Example:
+
+    >>> y_true = np.random.randint(0, 2, size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.mean_squared_error(y_true, y_pred)
+
+    Args:
+        y_true: Ground truth values with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Mean squared error values with shape = `[batch_size, d0, .. dN-1]`.
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    return ops.mean(ops.square(y_true - y_pred), axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.mean_absolute_error",
+        "keras_core.losses.mean_absolute_error",
+        # Legacy aliases
+        "keras_core._legacy.losses.MAE",
+        "keras_core._legacy.losses.mae",
+        "keras_core._legacy.metrics.MAE",
+        "keras_core._legacy.metrics.mae",
+    ]
+)
+def mean_absolute_error(y_true, y_pred):
+    """Computes the mean absolute error between labels and predictions.
+
+    ```python
+    loss = mean(abs(y_true - y_pred), axis=-1)
+    ```
+
+    Args:
+        y_true: Ground truth values with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Mean absolute error values with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.randint(0, 2, size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.mean_absolute_error(y_true, y_pred)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    return ops.mean(ops.abs(y_true - y_pred), axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.mean_absolute_percentage_error",
+        "keras_core.losses.mean_absolute_percentage_error",
+        # Legacy aliases
+        "keras_core._legacy.losses.mape",
+        "keras_core._legacy.losses.MAPE",
+        "keras_core._legacy.metrics.mape",
+        "keras_core._legacy.metrics.MAPE",
+    ]
+)
+def mean_absolute_percentage_error(y_true, y_pred):
+    """Computes the mean absolute percentage error between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = 100 * mean(abs((y_true - y_pred) / y_true), axis=-1)
+    ```
+
+    Division by zero is prevented by dividing by `maximum(y_true, epsilon)`
+    where `epsilon = keras_core.backend.epsilon()`
+    (default to `1e-7`).
+
+    Args:
+        y_true: Ground truth values with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Mean absolute percentage error values with shape = `[batch_size, d0, ..
+        dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.random(size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.mean_absolute_percentage_error(y_true, y_pred)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    epsilon = ops.convert_to_tensor(backend.epsilon())
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    diff = ops.abs((y_true - y_pred) / ops.maximum(ops.abs(y_true), epsilon))
+    return 100.0 * ops.mean(diff, axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.mean_squared_logarithmic_error",
+        "keras_core.losses.mean_squared_logarithmic_error",
+        # Legacy aliases
+        "keras_core._legacy.losses.msle",
+        "keras_core._legacy.losses.MSLE",
+        "keras_core._legacy.metrics.msle",
+        "keras_core._legacy.metrics.MSLE",
+    ]
+)
+def mean_squared_logarithmic_error(y_true, y_pred):
+    """Computes the mean squared logarithmic error between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = mean(square(log(y_true + 1) - log(y_pred + 1)), axis=-1)
+    ```
+
+    Note that `y_pred` and `y_true` cannot be less or equal to 0. Negative
+    values and 0 values will be replaced with `keras_core.backend.epsilon()`
+    (default to `1e-7`).
+
+    Args:
+        y_true: Ground truth values with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Mean squared logarithmic error values with shape = `[batch_size, d0, ..
+        dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.randint(0, 2, size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.mean_squared_logarithmic_error(y_true, y_pred)
+    """
+    epsilon = ops.convert_to_tensor(backend.epsilon())
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    first_log = ops.log(ops.maximum(y_pred, epsilon) + 1.0)
+    second_log = ops.log(ops.maximum(y_true, epsilon) + 1.0)
+    return ops.mean(ops.square(first_log - second_log), axis=-1)
+
+
+@keras_core_export("keras_core.losses.cosine_similarity")
+def cosine_similarity(y_true, y_pred, axis=-1):
+    """Computes the cosine similarity between labels and predictions.
+
+    Formula:
+    ```python
+    loss = -sum(l2_norm(y_true) * l2_norm(y_pred))
+    ```
+
+    Note that it is a number between -1 and 1. When it is a negative number
+    between -1 and 0, 0 indicates orthogonality and values closer to -1
+    indicate greater similarity. This makes it usable as a loss function in a
+    setting where you try to maximize the proximity between predictions and
+    targets. If either `y_true` or `y_pred` is a zero vector, cosine
+    similarity will be 0 regardless of the proximity between predictions
+    and targets.
+
+    Args:
+        y_true: Tensor of true targets.
+        y_pred: Tensor of predicted targets.
+        axis: Axis along which to determine similarity. Defaults to `-1`.
+
+    Returns:
+        Cosine similarity tensor.
+
+    Example:
+
+    >>> y_true = [[0., 1.], [1., 1.], [1., 1.]]
+    >>> y_pred = [[1., 0.], [1., 1.], [-1., -1.]]
+    >>> loss = keras_core.losses.cosine_similarity(y_true, y_pred, axis=-1)
+    [-0., -0.99999994, 0.99999994]
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    y_pred = normalize(y_pred, axis=axis)
+    y_true = normalize(y_true, axis=axis)
+    return -ops.sum(y_true * y_pred, axis=axis)
+
+
+@keras_core_export(["keras_core.losses.huber", "keras_core.metrics.huber"])
+def huber(y_true, y_pred, delta=1.0):
+    """Computes Huber loss value.
+
+    Formula:
+    ```python
+    for x in error:
+        if abs(x) <= delta:
+            loss.append(0.5 * x^2)
+        elif abs(x) > delta:
+            loss.append(delta * abs(x) - 0.5 * delta^2)
+
+    loss = mean(loss, axis=-1)
+    ```
+    See: [Huber loss](https://en.wikipedia.org/wiki/Huber_loss).
+
+    Example:
+
+    >>> y_true = [[0, 1], [0, 0]]
+    >>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
+    >>> loss = keras_core.losses.huber(y_true, y_pred)
+    0.155
+
+
+    Args:
+        y_true: tensor of true targets.
+        y_pred: tensor of predicted targets.
+        delta: A float, the point where the Huber loss function changes from a
+            quadratic to linear. Defaults to `1.0`.
+
+    Returns:
+        Tensor with one scalar loss entry per sample.
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    delta = ops.convert_to_tensor(delta)
+    error = ops.subtract(y_pred, y_true)
+    abs_error = ops.abs(error)
+    half = ops.convert_to_tensor(0.5, dtype=abs_error.dtype)
+    return ops.mean(
+        ops.where(
+            abs_error <= delta,
+            half * ops.square(error),
+            delta * abs_error - half * ops.square(delta),
+        ),
+        axis=-1,
+    )
+
+
+@keras_core_export(
+    [
+        "keras_core.losses.log_cosh",
+        "keras_core.metrics.log_cosh",
+        # Legacy aliases
+        "keras_core._legacy.losses.logcosh",
+        "keras_core._legacy.metrics.logcosh",
+    ]
+)
+def log_cosh(y_true, y_pred):
+    """Logarithm of the hyperbolic cosine of the prediction error.
+
+    Formula:
+    ```python
+    loss = mean(log(cosh(y_pred - y_true)), axis=-1)
+    ```
+
+    Note that `log(cosh(x))` is approximately equal to `(x ** 2) / 2` for small
+    `x` and to `abs(x) - log(2)` for large `x`. This means that 'logcosh' works
+    mostly like the mean squared error, but will not be so strongly affected by
+    the occasional wildly incorrect prediction.
+
+    Example:
+
+    >>> y_true = [[0., 1.], [0., 0.]]
+    >>> y_pred = [[1., 1.], [0., 0.]]
+    >>> loss = keras_core.losses.log_cosh(y_true, y_pred)
+    0.108
+
+    Args:
+        y_true: Ground truth values with shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values with shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Logcosh error values with shape = `[batch_size, d0, .. dN-1]`.
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    log2 = ops.convert_to_tensor(ops.log(2.0), dtype=y_pred.dtype)
+
+    def _logcosh(x):
+        return x + ops.softplus(x * -2.0) - log2
+
+    return ops.mean(_logcosh(y_pred - y_true), axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.kl_divergence",
+        "keras_core.losses.kl_divergence",
+        # Legacy aliases
+        "keras_core._legacy.losses.KLD",
+        "keras_core._legacy.losses.kld",
+        "keras_core._legacy.losses.kullback_leibler_divergence",
+        "keras_core._legacy.metrics.KLD",
+        "keras_core._legacy.metrics.kld",
+        "keras_core._legacy.metrics.kullback_leibler_divergence",
+    ]
+)
+def kl_divergence(y_true, y_pred):
+    """Computes Kullback-Leibler divergence loss between `y_true` & `y_pred`.
+
+    Formula:
+
+    ```python
+    loss = y_true * log(y_true / y_pred)
+    ```
+
+    Args:
+        y_true: Tensor of true targets.
+        y_pred: Tensor of predicted targets.
+
+    Returns:
+        KL Divergence loss values with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.randint(0, 2, size=(2, 3)).astype(np.float32)
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.kl_divergence(y_true, y_pred)
+    >>> assert loss.shape == (2,)
+    >>> y_true = ops.clip(y_true, 1e-7, 1)
+    >>> y_pred = ops.clip(y_pred, 1e-7, 1)
+    >>> assert np.array_equal(
+    ...     loss, np.sum(y_true * np.log(y_true / y_pred), axis=-1))
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, y_pred.dtype)
+    y_true = ops.clip(y_true, backend.epsilon(), 1)
+    y_pred = ops.clip(y_pred, backend.epsilon(), 1)
+    return ops.sum(y_true * ops.log(y_true / y_pred), axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.poisson",
+        "keras_core.losses.poisson",
+    ]
+)
+def poisson(y_true, y_pred):
+    """Computes the Poisson loss between y_true and y_pred.
+
+    Formula:
+
+    ```python
+    loss = y_pred - y_true * log(y_pred)
+    ```
+
+    Args:
+        y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.
+
+    Returns:
+        Poisson loss values with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = np.random.randint(0, 2, size=(2, 3))
+    >>> y_pred = np.random.random(size=(2, 3))
+    >>> loss = keras_core.losses.poisson(y_true, y_pred)
+    >>> assert loss.shape == (2,)
+    >>> y_pred = y_pred + 1e-7
+    >>> assert np.allclose(
+    ...     loss, np.mean(y_pred - y_true * np.log(y_pred), axis=-1),
+    ...     atol=1e-5)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    epsilon = ops.convert_to_tensor(backend.epsilon())
+    return ops.mean(y_pred - y_true * ops.log(y_pred + epsilon), axis=-1)
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.categorical_crossentropy",
+        "keras_core.losses.categorical_crossentropy",
+    ]
+)
+def categorical_crossentropy(
+    y_true, y_pred, from_logits=False, label_smoothing=0.0, axis=-1
+):
+    """Computes the categorical crossentropy loss.
+
+    Args:
+        y_true: Tensor of one-hot true targets.
+        y_pred: Tensor of predicted targets.
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability distribution.
+        label_smoothing: Float in [0, 1]. If > `0` then smooth the labels. For
+            example, if `0.1`, use `0.1 / num_classes` for non-target labels
+            and `0.9 + 0.1 / num_classes` for target labels.
+        axis: Defaults to `-1`. The dimension along which the entropy is
+            computed.
+
+    Returns:
+        Categorical crossentropy loss value.
+
+    Example:
+
+    >>> y_true = [[0, 1, 0], [0, 0, 1]]
+    >>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
+    >>> loss = keras_core.losses.categorical_crossentropy(y_true, y_pred)
+    >>> assert loss.shape == (2,)
+    >>> loss
+    array([0.0513, 2.303], dtype=float32)
+    """
+    if isinstance(axis, bool):
+        raise ValueError(
+            "`axis` must be of type `int`. "
+            f"Received: axis={axis} of type {type(axis)}"
+        )
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, y_pred.dtype)
+
+    if y_pred.shape[-1] == 1:
+        warnings.warn(
+            "In loss categorical_crossentropy, expected "
+            "y_pred.shape to be (batch_size, num_classes) "
+            f"with num_classes > 1. Received: y_pred.shape={y_pred.shape}. "
+            "Consider using 'binary_crossentropy' if you only have 2 classes.",
+            SyntaxWarning,
+            stacklevel=2,
+        )
+
+    if label_smoothing:
+        num_classes = ops.cast(ops.shape(y_true)[-1], y_pred.dtype)
+        y_true = y_true * (1.0 - label_smoothing) + (
+            label_smoothing / num_classes
+        )
+
+    return ops.categorical_crossentropy(
+        y_true, y_pred, from_logits=from_logits, axis=axis
+    )
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.categorical_focal_crossentropy",
+        "keras_core.losses.categorical_focal_crossentropy",
+    ]
+)
+def categorical_focal_crossentropy(
+    y_true,
+    y_pred,
+    alpha=0.25,
+    gamma=2.0,
+    from_logits=False,
+    label_smoothing=0.0,
+    axis=-1,
+):
+    """Computes the categorical focal crossentropy loss.
+
+    Args:
+        y_true: Tensor of one-hot true targets.
+        y_pred: Tensor of predicted targets.
+        alpha: A weight balancing factor for all classes, default is `0.25` as
+            mentioned in the reference. It can be a list of floats or a scalar.
+            In the multi-class case, alpha may be set by inverse class
+            frequency by using `compute_class_weight` from `sklearn.utils`.
+        gamma: A focusing parameter, default is `2.0` as mentioned in the
+            reference. It helps to gradually reduce the importance given to
+            simple examples in a smooth manner. When `gamma` = 0, there is
+            no focal effect on the categorical crossentropy.
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability
+            distribution.
+        label_smoothing: Float in [0, 1]. If > `0` then smooth the labels. For
+            example, if `0.1`, use `0.1 / num_classes` for non-target labels
+            and `0.9 + 0.1 / num_classes` for target labels.
+        axis: Defaults to `-1`. The dimension along which the entropy is
+            computed.
+
+    Returns:
+        Categorical focal crossentropy loss value.
+
+    Example:
+
+    >>> y_true = [[0, 1, 0], [0, 0, 1]]
+    >>> y_pred = [[0.05, 0.9, 0.05], [0.1, 0.85, 0.05]]
+    >>> loss = keras_core.losses.categorical_focal_crossentropy(y_true, y_pred)
+    >>> assert loss.shape == (2,)
+    >>> loss
+    array([2.63401289e-04, 6.75912094e-01], dtype=float32)
+    """
+    if isinstance(axis, bool):
+        raise ValueError(
+            "`axis` must be of type `int`. "
+            f"Received: axis={axis} of type {type(axis)}"
+        )
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, y_pred.dtype)
+
+    if y_pred.shape[-1] == 1:
+        warnings.warn(
+            "In loss categorical_focal_crossentropy, expected "
+            "y_pred.shape to be (batch_size, num_classes) "
+            f"with num_classes > 1. Received: y_pred.shape={y_pred.shape}. "
+            "Consider using 'binary_crossentropy' if you only have 2 classes.",
+            SyntaxWarning,
+            stacklevel=2,
+        )
+
+    if label_smoothing:
+        num_classes = ops.cast(ops.shape(y_true)[-1], y_pred.dtype)
+        y_true = y_true * (1.0 - label_smoothing) + (
+            label_smoothing / num_classes
+        )
+
+    if from_logits:
+        y_pred = ops.softmax(y_pred, axis=axis)
+
+    # Adjust the predictions so that the probability of
+    # each class for every sample adds up to 1
+    # This is needed to ensure that the cross entropy is
+    # computed correctly.
+    output = y_pred / ops.sum(y_pred, axis=axis, keepdims=True)
+    output = ops.clip(output, backend.epsilon(), 1.0 - backend.epsilon())
+
+    # Calculate cross entropy
+    cce = -y_true * ops.log(output)
+
+    # Calculate factors
+    modulating_factor = ops.power(1.0 - output, gamma)
+    weighting_factor = ops.multiply(modulating_factor, alpha)
+
+    # Apply weighting factor
+    focal_cce = ops.multiply(weighting_factor, cce)
+    focal_cce = ops.sum(focal_cce, axis=axis)
+    return focal_cce
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.sparse_categorical_crossentropy",
+        "keras_core.losses.sparse_categorical_crossentropy",
+    ]
+)
+def sparse_categorical_crossentropy(
+    y_true, y_pred, from_logits=False, ignore_class=None, axis=-1
+):
+    """Computes the sparse categorical crossentropy loss.
+
+    Args:
+        y_true: Ground truth values.
+        y_pred: The predicted values.
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability distribution.
+        ignore_class: Optional integer. The ID of a class to be ignored during
+            loss computation. This is useful, for example, in segmentation
+            problems featuring a "void" class (commonly -1 or 255) in
+            segmentation maps. By default (`ignore_class=None`), all classes are
+            considered.
+        axis: Defaults to `-1`. The dimension along which the entropy is
+            computed.
+
+    Returns:
+        Sparse categorical crossentropy loss value.
+
+    Examples:
+
+    >>> y_true = [1, 2]
+    >>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
+    >>> loss = keras_core.losses.sparse_categorical_crossentropy(y_true, y_pred)
+    >>> assert loss.shape == (2,)
+    >>> loss
+    array([0.0513, 2.303], dtype=float32)
+    """
+
+    if ignore_class is not None:
+        res_shape = ops.shape(y_pred)[:-1]
+        valid_mask = ops.not_equal(y_true, ops.cast(ignore_class, y_pred.dtype))
+        y_true = y_true * ops.cast(valid_mask, y_true.dtype)
+        y_pred = y_pred * ops.cast(
+            ops.expand_dims(valid_mask, -1), y_pred.dtype
+        )
+
+    res = ops.sparse_categorical_crossentropy(
+        y_true,
+        y_pred,
+        from_logits=from_logits,
+        axis=axis,
+    )
+
+    if ignore_class is not None:
+        valid_mask = ops.reshape(valid_mask, res_shape)
+        res = ops.where(valid_mask, res, 0.0)
+
+        try:
+            res._keras_mask = valid_mask
+        except AttributeError:
+            pass
+
+    return res
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.binary_crossentropy",
+        "keras_core.losses.binary_crossentropy",
+    ]
+)
+def binary_crossentropy(
+    y_true, y_pred, from_logits=False, label_smoothing=0.0, axis=-1
+):
+    """Computes the binary crossentropy loss.
+
+    Args:
+        y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`.
+        y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`.
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability distribution.
+        label_smoothing: Float in `[0, 1]`. If > `0` then smooth the labels by
+            squeezing them towards 0.5, that is,
+            using `1. - 0.5 * label_smoothing` for the target class
+            and `0.5 * label_smoothing` for the non-target class.
+        axis: The axis along which the mean is computed. Defaults to `-1`.
+
+    Returns:
+        Binary crossentropy loss value. shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = [[0, 1], [0, 0]]
+    >>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
+    >>> loss = keras_core.losses.binary_crossentropy(y_true, y_pred)
+    >>> assert loss.shape == (2,)
+    >>> loss
+    array([0.916 , 0.714], dtype=float32)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, y_pred.dtype)
+
+    if label_smoothing:
+        y_true = y_true * (1.0 - label_smoothing) + 0.5 * label_smoothing
+
+    return ops.mean(
+        ops.binary_crossentropy(y_true, y_pred, from_logits=from_logits),
+        axis=axis,
+    )
+
+
+@keras_core_export(
+    [
+        "keras_core.metrics.binary_focal_crossentropy",
+        "keras_core.losses.binary_focal_crossentropy",
+    ]
+)
+def binary_focal_crossentropy(
+    y_true,
+    y_pred,
+    apply_class_balancing=False,
+    alpha=0.25,
+    gamma=2.0,
+    from_logits=False,
+    label_smoothing=0.0,
+    axis=-1,
+):
+    """Computes the binary focal crossentropy loss.
+
+    According to [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf), it
+    helps to apply a focal factor to down-weight easy examples and focus more on
+    hard examples. By default, the focal tensor is computed as follows:
+
+    `focal_factor = (1 - output) ** gamma` for class 1
+    `focal_factor = output ** gamma` for class 0
+    where `gamma` is a focusing parameter. When `gamma` = 0, there is no focal
+    effect on the binary crossentropy loss.
+
+    If `apply_class_balancing == True`, this function also takes into account a
+    weight balancing factor for the binary classes 0 and 1 as follows:
+
+    `weight = alpha` for class 1 (`target == 1`)
+    `weight = 1 - alpha` for class 0
+    where `alpha` is a float in the range of `[0, 1]`.
+
+    Args:
+        y_true: Ground truth values, of shape `(batch_size, d0, .. dN)`.
+        y_pred: The predicted values, of shape `(batch_size, d0, .. dN)`.
+        apply_class_balancing: A bool, whether to apply weight balancing on the
+            binary classes 0 and 1.
+        alpha: A weight balancing factor for class 1, default is `0.25` as
+            mentioned in the reference. The weight for class 0 is `1.0 - alpha`.
+        gamma: A focusing parameter, default is `2.0` as mentioned in the
+            reference.
+        from_logits: Whether `y_pred` is expected to be a logits tensor. By
+            default, we assume that `y_pred` encodes a probability distribution.
+        label_smoothing: Float in `[0, 1]`. If > `0` then smooth the labels by
+            squeezing them towards 0.5, that is,
+            using `1. - 0.5 * label_smoothing` for the target class
+            and `0.5 * label_smoothing` for the non-target class.
+        axis: The axis along which the mean is computed. Defaults to `-1`.
+
+    Returns:
+        Binary focal crossentropy loss value
+        with shape = `[batch_size, d0, .. dN-1]`.
+
+    Example:
+
+    >>> y_true = [[0, 1], [0, 0]]
+    >>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
+    >>> loss = keras_core.losses.binary_focal_crossentropy(
+    ...        y_true, y_pred, gamma=2)
+    >>> assert loss.shape == (2,)
+    >>> loss
+    array([0.330, 0.206], dtype=float32)
+    """
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.cast(y_true, y_pred.dtype)
+
+    if label_smoothing:
+        y_true = y_true * (1.0 - label_smoothing) + 0.5 * label_smoothing
+
+    if from_logits:
+        y_pred = ops.sigmoid(y_pred)
+
+    bce = ops.binary_crossentropy(
+        target=y_true,
+        output=y_pred,
+        from_logits=False,
+    )
+
+    # Calculate focal factor
+    p_t = y_true * y_pred + (1 - y_true) * (1 - y_pred)
+    focal_factor = ops.power(1.0 - p_t, gamma)
+
+    focal_bce = focal_factor * bce
+
+    if apply_class_balancing:
+        weight = y_true * alpha + (1 - y_true) * (1 - alpha)
+        focal_bce = weight * focal_bce
+
+    return ops.mean(focal_bce, axis=axis)
+

lib/python3.10/site-packages/keras_core/src/metrics/__init__.py

@@ -0,0 +1,203 @@
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.metrics.accuracy_metrics import Accuracy
+from keras_core.src.metrics.accuracy_metrics import BinaryAccuracy
+from keras_core.src.metrics.accuracy_metrics import CategoricalAccuracy
+from keras_core.src.metrics.accuracy_metrics import SparseCategoricalAccuracy
+from keras_core.src.metrics.accuracy_metrics import SparseTopKCategoricalAccuracy
+from keras_core.src.metrics.accuracy_metrics import TopKCategoricalAccuracy
+from keras_core.src.metrics.confusion_metrics import AUC
+from keras_core.src.metrics.confusion_metrics import FalseNegatives
+from keras_core.src.metrics.confusion_metrics import FalsePositives
+from keras_core.src.metrics.confusion_metrics import Precision
+from keras_core.src.metrics.confusion_metrics import PrecisionAtRecall
+from keras_core.src.metrics.confusion_metrics import Recall
+from keras_core.src.metrics.confusion_metrics import RecallAtPrecision
+from keras_core.src.metrics.confusion_metrics import SensitivityAtSpecificity
+from keras_core.src.metrics.confusion_metrics import SpecificityAtSensitivity
+from keras_core.src.metrics.confusion_metrics import TrueNegatives
+from keras_core.src.metrics.confusion_metrics import TruePositives
+from keras_core.src.metrics.f_score_metrics import F1Score
+from keras_core.src.metrics.f_score_metrics import FBetaScore
+from keras_core.src.metrics.hinge_metrics import CategoricalHinge
+from keras_core.src.metrics.hinge_metrics import Hinge
+from keras_core.src.metrics.hinge_metrics import SquaredHinge
+from keras_core.src.metrics.iou_metrics import BinaryIoU
+from keras_core.src.metrics.iou_metrics import IoU
+from keras_core.src.metrics.iou_metrics import MeanIoU
+from keras_core.src.metrics.iou_metrics import OneHotIoU
+from keras_core.src.metrics.iou_metrics import OneHotMeanIoU
+from keras_core.src.metrics.metric import Metric
+from keras_core.src.metrics.probabilistic_metrics import BinaryCrossentropy
+from keras_core.src.metrics.probabilistic_metrics import CategoricalCrossentropy
+from keras_core.src.metrics.probabilistic_metrics import KLDivergence
+from keras_core.src.metrics.probabilistic_metrics import Poisson
+from keras_core.src.metrics.probabilistic_metrics import (
+    SparseCategoricalCrossentropy,
+)
+from keras_core.src.metrics.reduction_metrics import Mean
+from keras_core.src.metrics.reduction_metrics import MeanMetricWrapper
+from keras_core.src.metrics.reduction_metrics import Sum
+from keras_core.src.metrics.regression_metrics import CosineSimilarity
+from keras_core.src.metrics.regression_metrics import LogCoshError
+from keras_core.src.metrics.regression_metrics import MeanAbsoluteError
+from keras_core.src.metrics.regression_metrics import MeanAbsolutePercentageError
+from keras_core.src.metrics.regression_metrics import MeanSquaredError
+from keras_core.src.metrics.regression_metrics import MeanSquaredLogarithmicError
+from keras_core.src.metrics.regression_metrics import R2Score
+from keras_core.src.metrics.regression_metrics import RootMeanSquaredError
+from keras_core.src.saving import serialization_lib
+from keras_core.src.utils.naming import to_snake_case
+
+ALL_OBJECTS = {
+    # Base
+    Metric,
+    Mean,
+    Sum,
+    MeanMetricWrapper,
+    # Regression
+    MeanSquaredError,
+    RootMeanSquaredError,
+    MeanAbsoluteError,
+    MeanAbsolutePercentageError,
+    MeanSquaredLogarithmicError,
+    CosineSimilarity,
+    LogCoshError,
+    R2Score,
+    # Classification
+    AUC,
+    FalseNegatives,
+    FalsePositives,
+    Precision,
+    PrecisionAtRecall,
+    Recall,
+    RecallAtPrecision,
+    SensitivityAtSpecificity,
+    SpecificityAtSensitivity,
+    TrueNegatives,
+    TruePositives,
+    # Hinge
+    Hinge,
+    SquaredHinge,
+    CategoricalHinge,
+    # Probabilistic
+    KLDivergence,
+    Poisson,
+    BinaryCrossentropy,
+    CategoricalCrossentropy,
+    SparseCategoricalCrossentropy,
+    # Accuracy
+    Accuracy,
+    BinaryAccuracy,
+    CategoricalAccuracy,
+    SparseCategoricalAccuracy,
+    TopKCategoricalAccuracy,
+    SparseTopKCategoricalAccuracy,
+    # F-Score
+    F1Score,
+    FBetaScore,
+    # IoU
+    IoU,
+    BinaryIoU,
+    MeanIoU,
+    OneHotIoU,
+    OneHotMeanIoU,
+}
+ALL_OBJECTS_DICT = {cls.__name__: cls for cls in ALL_OBJECTS}
+ALL_OBJECTS_DICT.update(
+    {to_snake_case(cls.__name__): cls for cls in ALL_OBJECTS}
+)
+# TODO: Align with `tf.keras` and set the name attribute of metrics
+# with the key name. Currently it uses default name of class definitions.
+ALL_OBJECTS_DICT.update(
+    {
+        "bce": BinaryCrossentropy,
+        "BCE": BinaryCrossentropy,
+        "mse": MeanSquaredError,
+        "MSE": MeanSquaredError,
+        "mae": MeanAbsoluteError,
+        "MAE": MeanAbsoluteError,
+        "mape": MeanAbsolutePercentageError,
+        "MAPE": MeanAbsolutePercentageError,
+        "msle": MeanSquaredLogarithmicError,
+        "MSLE": MeanSquaredLogarithmicError,
+    }
+)
+
+
+@keras_core_export("keras_core.metrics.serialize")
+def serialize(metric):
+    """Serializes metric function or `Metric` instance.
+
+    Args:
+        metric: A Keras `Metric` instance or a metric function.
+
+    Returns:
+        Metric configuration dictionary.
+    """
+    return serialization_lib.serialize_keras_object(metric)
+
+
+@keras_core_export("keras_core.metrics.deserialize")
+def deserialize(config, custom_objects=None):
+    """Deserializes a serialized metric class/function instance.
+
+    Args:
+        config: Metric configuration.
+        custom_objects: Optional dictionary mapping names (strings)
+            to custom objects (classes and functions) to be
+            considered during deserialization.
+
+    Returns:
+        A Keras `Metric` instance or a metric function.
+    """
+    return serialization_lib.deserialize_keras_object(
+        config,
+        module_objects=ALL_OBJECTS_DICT,
+        custom_objects=custom_objects,
+    )
+
+
+@keras_core_export("keras_core.metrics.get")
+def get(identifier):
+    """Retrieves a Keras metric as a `function`/`Metric` class instance.
+
+    The `identifier` may be the string name of a metric function or class.
+
+    >>> metric = metrics.get("categorical_crossentropy")
+    >>> type(metric)
+    <class 'function'>
+    >>> metric = metrics.get("CategoricalCrossentropy")
+    >>> type(metric)
+    <class '...metrics.CategoricalCrossentropy'>
+
+    You can also specify `config` of the metric to this function by passing dict
+    containing `class_name` and `config` as an identifier. Also note that the
+    `class_name` must map to a `Metric` class
+
+    >>> identifier = {"class_name": "CategoricalCrossentropy",
+    ...               "config": {"from_logits": True}}
+    >>> metric = metrics.get(identifier)
+    >>> type(metric)
+    <class '...metrics.CategoricalCrossentropy'>
+
+    Args:
+        identifier: A metric identifier. One of None or string name of a metric
+            function/class or metric configuration dictionary or a metric
+            function or a metric class instance
+
+    Returns:
+        A Keras metric as a `function`/ `Metric` class instance.
+    """
+    if identifier is None:
+        return None
+    if isinstance(identifier, dict):
+        obj = deserialize(identifier)
+    elif isinstance(identifier, str):
+        obj = deserialize(identifier)
+    else:
+        obj = identifier
+    if callable(obj):
+        return obj
+    else:
+        raise ValueError(f"Could not interpret metric identifier: {identifier}")
+

lib/python3.10/site-packages/keras_core/src/metrics/accuracy_metrics.py

@@ -0,0 +1,444 @@
+from keras_core.src import backend
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.losses.loss import squeeze_to_same_rank
+from keras_core.src.metrics import reduction_metrics
+
+
+def accuracy(y_true, y_pred):
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_pred.dtype)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    return ops.mean(
+        ops.cast(ops.equal(y_true, y_pred), dtype=backend.floatx()),
+        axis=-1,
+    )
+
+
+@keras_core_export("keras_core.metrics.Accuracy")
+class Accuracy(reduction_metrics.MeanMetricWrapper):
+    """Calculates how often predictions equal labels.
+
+    This metric creates two local variables, `total` and `count` that are used
+    to compute the frequency with which `y_pred` matches `y_true`. This
+    frequency is ultimately returned as `binary accuracy`: an idempotent
+    operation that simply divides `total` by `count`.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.Accuracy()
+    >>> m.update_state([[1], [2], [3], [4]], [[0], [2], [3], [4]])
+    >>> m.result()
+    0.75
+
+    >>> m.reset_state()
+    >>> m.update_state([[1], [2], [3], [4]], [[0], [2], [3], [4]],
+    ...                sample_weight=[1, 1, 0, 0])
+    >>> m.result()
+    0.5
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='binary_crossentropy',
+                  metrics=[keras_core.metrics.Accuracy()])
+    ```
+    """
+
+    def __init__(self, name="accuracy", dtype=None):
+        super().__init__(fn=accuracy, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+
+
+@keras_core_export("keras_core.metrics.binary_accuracy")
+def binary_accuracy(y_true, y_pred, threshold=0.5):
+    y_true = ops.convert_to_tensor(y_true)
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true, y_pred = squeeze_to_same_rank(y_true, y_pred)
+    threshold = ops.cast(threshold, y_pred.dtype)
+    y_pred = ops.cast(y_pred > threshold, y_true.dtype)
+    return ops.mean(
+        ops.cast(ops.equal(y_true, y_pred), dtype=backend.floatx()),
+        axis=-1,
+    )
+
+
+@keras_core_export("keras_core.metrics.BinaryAccuracy")
+class BinaryAccuracy(reduction_metrics.MeanMetricWrapper):
+    """Calculates how often predictions match binary labels.
+
+    This metric creates two local variables, `total` and `count` that are used
+    to compute the frequency with which `y_pred` matches `y_true`. This
+    frequency is ultimately returned as `binary accuracy`: an idempotent
+    operation that simply divides `total` by `count`.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+        threshold: (Optional) Float representing the threshold for deciding
+        whether prediction values are 1 or 0.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.BinaryAccuracy()
+    >>> m.update_state([[1], [1], [0], [0]], [[0.98], [1], [0], [0.6]])
+    >>> m.result()
+    0.75
+
+    >>> m.reset_state()
+    >>> m.update_state([[1], [1], [0], [0]], [[0.98], [1], [0], [0.6]],
+    ...                sample_weight=[1, 0, 0, 1])
+    >>> m.result()
+    0.5
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='binary_crossentropy',
+                  metrics=[keras_core.metrics.BinaryAccuracy()])
+    ```
+    """
+
+    def __init__(self, name="binary_accuracy", dtype=None):
+        super().__init__(fn=binary_accuracy, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+
+
+@keras_core_export("keras_core.metrics.categorical_accuracy")
+def categorical_accuracy(y_true, y_pred):
+    y_true = ops.argmax(y_true, axis=-1)
+
+    reshape_matches = False
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_true.dtype)
+
+    y_true_org_shape = ops.shape(y_true)
+    y_pred_rank = len(y_pred.shape)
+    y_true_rank = len(y_true.shape)
+
+    # If the shape of y_true is (num_samples, 1), squeeze to (num_samples,)
+    if (
+        (y_true_rank is not None)
+        and (y_pred_rank is not None)
+        and (len(y_true.shape) == len(y_pred.shape))
+    ):
+        y_true = ops.squeeze(y_true, -1)
+        reshape_matches = True
+    y_pred = ops.argmax(y_pred, axis=-1)
+
+    # If the predicted output and actual output types don't match, force cast
+    # them to match.
+    if y_pred.dtype != y_true.dtype:
+        y_pred = ops.cast(y_pred, dtype=y_true.dtype)
+    matches = ops.cast(ops.equal(y_true, y_pred), backend.floatx())
+    if reshape_matches:
+        matches = ops.reshape(matches, new_shape=y_true_org_shape)
+    return matches
+
+
+@keras_core_export("keras_core.metrics.CategoricalAccuracy")
+class CategoricalAccuracy(reduction_metrics.MeanMetricWrapper):
+    """Calculates how often predictions match one-hot labels.
+
+    You can provide logits of classes as `y_pred`, since argmax of
+    logits and probabilities are same.
+
+    This metric creates two local variables, `total` and `count` that are used
+    to compute the frequency with which `y_pred` matches `y_true`. This
+    frequency is ultimately returned as `categorical accuracy`: an idempotent
+    operation that simply divides `total` by `count`.
+
+    `y_pred` and `y_true` should be passed in as vectors of probabilities,
+    rather than as labels. If necessary, use `ops.one_hot` to expand `y_true` as
+    a vector.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.CategoricalAccuracy()
+    >>> m.update_state([[0, 0, 1], [0, 1, 0]], [[0.1, 0.9, 0.8],
+    ...                 [0.05, 0.95, 0]])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([[0, 0, 1], [0, 1, 0]], [[0.1, 0.9, 0.8],
+    ...                 [0.05, 0.95, 0]],
+    ...                sample_weight=[0.7, 0.3])
+    >>> m.result()
+    0.3
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='categorical_crossentropy',
+                  metrics=[keras_core.metrics.CategoricalAccuracy()])
+    ```
+    """
+
+    def __init__(self, name="categorical_accuracy", dtype=None):
+        super().__init__(fn=categorical_accuracy, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+
+
+@keras_core_export("keras_core.metrics.sparse_categorical_accuracy")
+def sparse_categorical_accuracy(y_true, y_pred):
+    reshape_matches = False
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_true.dtype)
+    y_true_org_shape = ops.shape(y_true)
+    y_pred_rank = len(y_pred.shape)
+    y_true_rank = len(y_true.shape)
+
+    # If the shape of y_true is (num_samples, 1), squeeze to (num_samples,)
+    if (
+        (y_true_rank is not None)
+        and (y_pred_rank is not None)
+        and (len(y_true.shape) == len(y_pred.shape))
+    ):
+        y_true = ops.squeeze(y_true, -1)
+        reshape_matches = True
+    y_pred = ops.argmax(y_pred, axis=-1)
+
+    # If the predicted output and actual output types don't match, force cast
+    # them to match.
+    if y_pred.dtype != y_true.dtype:
+        y_pred = ops.cast(y_pred, y_true.dtype)
+    matches = ops.cast(ops.equal(y_true, y_pred), backend.floatx())
+    if reshape_matches:
+        matches = ops.reshape(matches, new_shape=y_true_org_shape)
+    # if shape is (num_samples, 1) squeeze
+    if len(matches.shape) > 1 and matches.shape[-1] == 1:
+        matches = ops.squeeze(matches, -1)
+    return matches
+
+
+@keras_core_export("keras_core.metrics.SparseCategoricalAccuracy")
+class SparseCategoricalAccuracy(reduction_metrics.MeanMetricWrapper):
+    """Calculates how often predictions match integer labels.
+
+    ```python
+    acc = np.dot(sample_weight, np.equal(y_true, np.argmax(y_pred, axis=1))
+    ```
+
+    You can provide logits of classes as `y_pred`, since argmax of
+    logits and probabilities are same.
+
+    This metric creates two local variables, `total` and `count` that are used
+    to compute the frequency with which `y_pred` matches `y_true`. This
+    frequency is ultimately returned as `sparse categorical accuracy`: an
+    idempotent operation that simply divides `total` by `count`.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.SparseCategoricalAccuracy()
+    >>> m.update_state([[2], [1]], [[0.1, 0.6, 0.3], [0.05, 0.95, 0]])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([[2], [1]], [[0.1, 0.6, 0.3], [0.05, 0.95, 0]],
+    ...                sample_weight=[0.7, 0.3])
+    >>> m.result()
+    0.3
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='sparse_categorical_crossentropy',
+                  metrics=[keras_core.metrics.SparseCategoricalAccuracy()])
+    ```
+    """
+
+    def __init__(self, name="sparse_categorical_accuracy", dtype=None):
+        super().__init__(fn=sparse_categorical_accuracy, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+
+
+@keras_core_export("keras_core.metrics.top_k_categorical_accuracy")
+def top_k_categorical_accuracy(y_true, y_pred, k=5):
+    reshape_matches = False
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_true.dtype)
+    y_true = ops.argmax(y_true, axis=-1)
+    y_true_rank = len(y_true.shape)
+    y_pred_rank = len(y_pred.shape)
+    y_true_org_shape = ops.shape(y_true)
+
+    # Flatten y_pred to (batch_size, num_samples) and y_true to (num_samples,)
+    if (y_true_rank is not None) and (y_pred_rank is not None):
+        if y_pred_rank > 2:
+            y_pred = ops.reshape(y_pred, [-1, y_pred.shape[-1]])
+        if y_true_rank > 1:
+            reshape_matches = True
+            y_true = ops.reshape(y_true, [-1])
+
+    matches = ops.cast(
+        ops.in_top_k(ops.cast(y_true, "int32"), y_pred, k=k),
+        dtype=backend.floatx(),
+    )
+
+    # returned matches is expected to have same shape as y_true input
+    if reshape_matches:
+        matches = ops.reshape(matches, new_shape=y_true_org_shape)
+
+    return matches
+
+
+@keras_core_export("keras_core.metrics.TopKCategoricalAccuracy")
+class TopKCategoricalAccuracy(reduction_metrics.MeanMetricWrapper):
+    """Computes how often targets are in the top `K` predictions.
+
+    Args:
+        k: (Optional) Number of top elements to look at for computing accuracy.
+            Defaults to `5`.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.TopKCategoricalAccuracy(k=1)
+    >>> m.update_state([[0, 0, 1], [0, 1, 0]],
+    ...                [[0.1, 0.9, 0.8], [0.05, 0.95, 0]])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([[0, 0, 1], [0, 1, 0]],
+    ...                [[0.1, 0.9, 0.8], [0.05, 0.95, 0]],
+    ...                sample_weight=[0.7, 0.3])
+    >>> m.result()
+    0.3
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='categorical_crossentropy',
+                  metrics=[keras_core.metrics.TopKCategoricalAccuracy()])
+    ```
+    """
+
+    def __init__(self, k=5, name="top_k_categorical_accuracy", dtype=None):
+        super().__init__(
+            fn=top_k_categorical_accuracy,
+            name=name,
+            dtype=dtype,
+            k=k,
+        )
+        self.k = k
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype, "k": self.k}
+
+
+@keras_core_export("keras_core.metrics.sparse_top_k_categorical_accuracy")
+def sparse_top_k_categorical_accuracy(y_true, y_pred, k=5):
+    reshape_matches = False
+    y_pred = ops.convert_to_tensor(y_pred)
+    y_true = ops.convert_to_tensor(y_true, dtype=y_true.dtype)
+    y_true_rank = len(y_true.shape)
+    y_pred_rank = len(y_pred.shape)
+    y_true_org_shape = ops.shape(y_true)
+
+    # Flatten y_pred to (batch_size, num_samples) and y_true to (num_samples,)
+    if (y_true_rank is not None) and (y_pred_rank is not None):
+        if y_pred_rank > 2:
+            y_pred = ops.reshape(y_pred, [-1, y_pred.shape[-1]])
+        if y_true_rank > 1:
+            reshape_matches = True
+            y_true = ops.reshape(y_true, [-1])
+
+    matches = ops.cast(
+        ops.in_top_k(ops.cast(y_true, "int32"), y_pred, k=k),
+        dtype=backend.floatx(),
+    )
+
+    # returned matches is expected to have same shape as y_true input
+    if reshape_matches:
+        matches = ops.reshape(matches, new_shape=y_true_org_shape)
+
+    return matches
+
+
+@keras_core_export("keras_core.metrics.SparseTopKCategoricalAccuracy")
+class SparseTopKCategoricalAccuracy(reduction_metrics.MeanMetricWrapper):
+    """Computes how often integer targets are in the top `K` predictions.
+
+    Args:
+        k: (Optional) Number of top elements to look at for computing accuracy.
+            Defaults to `5`.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.SparseTopKCategoricalAccuracy(k=1)
+    >>> m.update_state([2, 1], [[0.1, 0.9, 0.8], [0.05, 0.95, 0]])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([2, 1], [[0.1, 0.9, 0.8], [0.05, 0.95, 0]],
+    ...                sample_weight=[0.7, 0.3])
+    >>> m.result()
+    0.3
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='sparse_categorical_crossentropy',
+                  metrics=[keras_core.metrics.SparseTopKCategoricalAccuracy()])
+    ```
+    """
+
+    def __init__(
+        self, k=5, name="sparse_top_k_categorical_accuracy", dtype=None
+    ):
+        super().__init__(
+            fn=sparse_top_k_categorical_accuracy,
+            name=name,
+            dtype=dtype,
+            k=k,
+        )
+        self.k = k
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype, "k": self.k}
+

lib/python3.10/site-packages/keras_core/src/metrics/confusion_metrics.py

@@ -0,0 +1,1575 @@
+import numpy as np
+
+from keras_core.src import activations
+from keras_core.src import backend
+from keras_core.src import initializers
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.metrics import metrics_utils
+from keras_core.src.metrics.metric import Metric
+from keras_core.src.utils.python_utils import to_list
+
+
+class _ConfusionMatrixConditionCount(Metric):
+    """Calculates the number of the given confusion matrix condition.
+
+    Args:
+        confusion_matrix_cond: One of `metrics_utils.ConfusionMatrix`
+            conditions.
+        thresholds: (Optional) Defaults to `0.5`. A float value or a python list
+            / tuple of float threshold values in `[0, 1]`. A threshold is
+            compared with prediction values to determine the truth value of
+            predictions (i.e., above the threshold is `True`, below is `False`).
+            One metric value is generated for each threshold value.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+    """
+
+    def __init__(
+        self, confusion_matrix_cond, thresholds=None, name=None, dtype=None
+    ):
+        super().__init__(name=name, dtype=dtype)
+        self._confusion_matrix_cond = confusion_matrix_cond
+        self.init_thresholds = thresholds
+        self.thresholds = metrics_utils.parse_init_thresholds(
+            thresholds, default_threshold=0.5
+        )
+        self._thresholds_distributed_evenly = (
+            metrics_utils.is_evenly_distributed_thresholds(self.thresholds)
+        )
+        self.accumulator = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="accumulator",
+        )
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        """Accumulates the metric statistics.
+
+        Args:
+            y_true: The ground truth values.
+            y_pred: The predicted values.
+            sample_weight: Optional weighting of each example. Defaults to `1`.
+                Can be a tensor whose rank is either 0, or the same rank as
+                `y_true`, and must be broadcastable to `y_true`.
+        """
+        return metrics_utils.update_confusion_matrix_variables(
+            {self._confusion_matrix_cond: self.accumulator},
+            y_true,
+            y_pred,
+            thresholds=self.thresholds,
+            thresholds_distributed_evenly=self._thresholds_distributed_evenly,
+            sample_weight=sample_weight,
+        )
+
+    def result(self):
+        if len(self.thresholds) == 1:
+            result = self.accumulator[0]
+        else:
+            result = self.accumulator
+        return backend.convert_to_tensor(result)
+
+    def get_config(self):
+        config = {"thresholds": self.init_thresholds}
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+@keras_core_export("keras_core.metrics.FalsePositives")
+class FalsePositives(_ConfusionMatrixConditionCount):
+    """Calculates the number of false positives.
+
+    If `sample_weight` is given, calculates the sum of the weights of
+    false positives. This metric creates one local variable, `accumulator`
+    that is used to keep track of the number of false positives.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        thresholds: (Optional) Defaults to `0.5`. A float value, or a Python
+            list/tuple of float threshold values in `[0, 1]`. A threshold is
+            compared with prediction values to determine the truth value of
+            predictions (i.e., above the threshold is `True`, below is `False`).
+            If used with a loss function that sets `from_logits=True` (i.e. no
+            sigmoid applied to predictions), `thresholds` should be set to 0.
+            One metric value is generated for each threshold value.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.FalsePositives()
+    >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1])
+    >>> m.result()
+    2.0
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1], sample_weight=[0, 0, 1, 0])
+    >>> m.result()
+    1.0
+    """
+
+    def __init__(self, thresholds=None, name=None, dtype=None):
+        super().__init__(
+            confusion_matrix_cond=metrics_utils.ConfusionMatrix.FALSE_POSITIVES,
+            thresholds=thresholds,
+            name=name,
+            dtype=dtype,
+        )
+
+
+@keras_core_export("keras_core.metrics.FalseNegatives")
+class FalseNegatives(_ConfusionMatrixConditionCount):
+    """Calculates the number of false negatives.
+
+    If `sample_weight` is given, calculates the sum of the weights of
+    false negatives. This metric creates one local variable, `accumulator`
+    that is used to keep track of the number of false negatives.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        thresholds: (Optional) Defaults to `0.5`. A float value, or a Python
+            list/tuple of float threshold values in `[0, 1]`. A threshold is
+            compared with prediction values to determine the truth value of
+            predictions (i.e., above the threshold is `True`, below is `False`).
+            If used with a loss function that sets `from_logits=True` (i.e. no
+            sigmoid applied to predictions), `thresholds` should be set to 0.
+            One metric value is generated for each threshold value.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.FalseNegatives()
+    >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0])
+    >>> m.result()
+    2.0
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0], sample_weight=[0, 0, 1, 0])
+    >>> m.result()
+    1.0
+    """
+
+    def __init__(self, thresholds=None, name=None, dtype=None):
+        super().__init__(
+            confusion_matrix_cond=metrics_utils.ConfusionMatrix.FALSE_NEGATIVES,
+            thresholds=thresholds,
+            name=name,
+            dtype=dtype,
+        )
+
+
+@keras_core_export("keras_core.metrics.TrueNegatives")
+class TrueNegatives(_ConfusionMatrixConditionCount):
+    """Calculates the number of true negatives.
+
+    If `sample_weight` is given, calculates the sum of the weights of
+    true negatives. This metric creates one local variable, `accumulator`
+    that is used to keep track of the number of true negatives.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        thresholds: (Optional) Defaults to `0.5`. A float value, or a Python
+            list/tuple of float threshold values in `[0, 1]`. A threshold is
+            compared with prediction values to determine the truth value of
+            predictions (i.e., above the threshold is `True`, below is `False`).
+            If used with a loss function that sets `from_logits=True` (i.e. no
+            sigmoid applied to predictions), `thresholds` should be set to 0.
+            One metric value is generated for each threshold value.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.TrueNegatives()
+    >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0])
+    >>> m.result()
+    2.0
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0], sample_weight=[0, 0, 1, 0])
+    >>> m.result()
+    1.0
+    """
+
+    def __init__(self, thresholds=None, name=None, dtype=None):
+        super().__init__(
+            confusion_matrix_cond=metrics_utils.ConfusionMatrix.TRUE_NEGATIVES,
+            thresholds=thresholds,
+            name=name,
+            dtype=dtype,
+        )
+
+
+@keras_core_export("keras_core.metrics.TruePositives")
+class TruePositives(_ConfusionMatrixConditionCount):
+    """Calculates the number of true positives.
+
+    If `sample_weight` is given, calculates the sum of the weights of
+    true positives. This metric creates one local variable, `true_positives`
+    that is used to keep track of the number of true positives.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        thresholds: (Optional) Defaults to `0.5`. A float value, or a Python
+            list/tuple of float threshold values in `[0, 1]`. A threshold is
+            compared with prediction values to determine the truth value of
+            predictions (i.e., above the threshold is `True`, below is `False`).
+            If used with a loss function that sets `from_logits=True` (i.e. no
+            sigmoid applied to predictions), `thresholds` should be set to 0.
+            One metric value is generated for each threshold value.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.TruePositives()
+    >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])
+    >>> m.result()
+    2.0
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])
+    >>> m.result()
+    1.0
+    """
+
+    def __init__(self, thresholds=None, name=None, dtype=None):
+        super().__init__(
+            confusion_matrix_cond=metrics_utils.ConfusionMatrix.TRUE_POSITIVES,
+            thresholds=thresholds,
+            name=name,
+            dtype=dtype,
+        )
+
+
+@keras_core_export("keras_core.metrics.Precision")
+class Precision(Metric):
+    """Computes the precision of the predictions with respect to the labels.
+
+    The metric creates two local variables, `true_positives` and
+    `false_positives` that are used to compute the precision. This value is
+    ultimately returned as `precision`, an idempotent operation that simply
+    divides `true_positives` by the sum of `true_positives` and
+    `false_positives`.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    If `top_k` is set, we'll calculate precision as how often on average a class
+    among the top-k classes with the highest predicted values of a batch entry
+    is correct and can be found in the label for that entry.
+
+    If `class_id` is specified, we calculate precision by considering only the
+    entries in the batch for which `class_id` is above the threshold and/or in
+    the top-k highest predictions, and computing the fraction of them for which
+    `class_id` is indeed a correct label.
+
+    Args:
+        thresholds: (Optional) A float value, or a Python list/tuple of float
+            threshold values in `[0, 1]`. A threshold is compared with
+            prediction values to determine the truth value of predictions (i.e.,
+            above the threshold is `True`, below is `False`). If used with a
+            loss function that sets `from_logits=True` (i.e. no sigmoid applied
+            to predictions), `thresholds` should be set to 0. One metric value
+            is generated for each threshold value. If neither `thresholds` nor
+            `top_k` are set, the default is to calculate precision with
+            `thresholds=0.5`.
+        top_k: (Optional) Unset by default. An int value specifying the top-k
+            predictions to consider when calculating precision.
+        class_id: (Optional) Integer class ID for which we want binary metrics.
+            This must be in the half-open interval `[0, num_classes)`, where
+            `num_classes` is the last dimension of predictions.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.Precision()
+    >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])
+    >>> m.result()
+    0.6666667
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])
+    >>> m.result()
+    1.0
+
+    >>> # With top_k=2, it will calculate precision over y_true[:2]
+    >>> # and y_pred[:2]
+    >>> m = keras_core.metrics.Precision(top_k=2)
+    >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1])
+    >>> m.result()
+    0.0
+
+    >>> # With top_k=4, it will calculate precision over y_true[:4]
+    >>> # and y_pred[:4]
+    >>> m = keras_core.metrics.Precision(top_k=4)
+    >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1])
+    >>> m.result()
+    0.5
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='mse',
+                  metrics=[keras_core.metrics.Precision()])
+    ```
+
+    Usage with a loss with `from_logits=True`:
+
+    ```python
+    model.compile(optimizer='adam',
+                  loss=keras_core.losses.BinaryCrossentropy(from_logits=True),
+                  metrics=[keras_core.metrics.Precision(thresholds=0)])
+    ```
+    """
+
+    def __init__(
+        self, thresholds=None, top_k=None, class_id=None, name=None, dtype=None
+    ):
+        super().__init__(name=name, dtype=dtype)
+        self.init_thresholds = thresholds
+        self.top_k = top_k
+        self.class_id = class_id
+
+        default_threshold = 0.5 if top_k is None else metrics_utils.NEG_INF
+        self.thresholds = metrics_utils.parse_init_thresholds(
+            thresholds, default_threshold=default_threshold
+        )
+        self._thresholds_distributed_evenly = (
+            metrics_utils.is_evenly_distributed_thresholds(self.thresholds)
+        )
+        self.true_positives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="true_positives",
+        )
+        self.false_positives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="false_positives",
+        )
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        """Accumulates true positive and false positive statistics.
+
+        Args:
+            y_true: The ground truth values, with the same dimensions as
+                `y_pred`. Will be cast to `bool`.
+            y_pred: The predicted values. Each element must be in the range
+                `[0, 1]`.
+            sample_weight: Optional weighting of each example. Defaults to `1`.
+                Can be a tensor whose rank is either 0, or the same rank as
+                `y_true`, and must be broadcastable to `y_true`.
+        """
+        metrics_utils.update_confusion_matrix_variables(
+            {
+                metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives,  # noqa: E501
+            },
+            y_true,
+            y_pred,
+            thresholds=self.thresholds,
+            thresholds_distributed_evenly=self._thresholds_distributed_evenly,
+            top_k=self.top_k,
+            class_id=self.class_id,
+            sample_weight=sample_weight,
+        )
+
+    def result(self):
+        result = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_positives + backend.epsilon(),
+        )
+        return result[0] if len(self.thresholds) == 1 else result
+
+    def reset_state(self):
+        num_thresholds = len(to_list(self.thresholds))
+        self.true_positives.assign(ops.zeros((num_thresholds,)))
+        self.false_positives.assign(ops.zeros((num_thresholds,)))
+
+    def get_config(self):
+        config = {
+            "thresholds": self.init_thresholds,
+            "top_k": self.top_k,
+            "class_id": self.class_id,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+@keras_core_export("keras_core.metrics.Recall")
+class Recall(Metric):
+    """Computes the recall of the predictions with respect to the labels.
+
+    This metric creates two local variables, `true_positives` and
+    `false_negatives`, that are used to compute the recall. This value is
+    ultimately returned as `recall`, an idempotent operation that simply divides
+    `true_positives` by the sum of `true_positives` and `false_negatives`.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    If `top_k` is set, recall will be computed as how often on average a class
+    among the labels of a batch entry is in the top-k predictions.
+
+    If `class_id` is specified, we calculate recall by considering only the
+    entries in the batch for which `class_id` is in the label, and computing the
+    fraction of them for which `class_id` is above the threshold and/or in the
+    top-k predictions.
+
+    Args:
+        thresholds: (Optional) A float value, or a Python list/tuple of float
+            threshold values in `[0, 1]`. A threshold is compared with
+            prediction values to determine the truth value of predictions (i.e.,
+            above the threshold is `True`, below is `False`). If used with a
+            loss function that sets `from_logits=True` (i.e. no sigmoid
+            applied to predictions), `thresholds` should be set to 0.
+            One metric value is generated for each threshold value.
+            If neither `thresholds` nor `top_k` are set,
+            the default is to calculate recall with `thresholds=0.5`.
+        top_k: (Optional) Unset by default. An int value specifying the top-k
+            predictions to consider when calculating recall.
+        class_id: (Optional) Integer class ID for which we want binary metrics.
+            This must be in the half-open interval `[0, num_classes)`, where
+            `num_classes` is the last dimension of predictions.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.Recall()
+    >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])
+    >>> m.result()
+    0.6666667
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])
+    >>> m.result()
+    1.0
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(optimizer='sgd',
+                  loss='mse',
+                  metrics=[keras_core.metrics.Recall()])
+    ```
+
+    Usage with a loss with `from_logits=True`:
+
+    ```python
+    model.compile(optimizer='adam',
+                  loss=keras_core.losses.BinaryCrossentropy(from_logits=True),
+                  metrics=[keras_core.metrics.Recall(thresholds=0)])
+    ```
+    """
+
+    def __init__(
+        self, thresholds=None, top_k=None, class_id=None, name=None, dtype=None
+    ):
+        super().__init__(name=name, dtype=dtype)
+        self.init_thresholds = thresholds
+        self.top_k = top_k
+        self.class_id = class_id
+
+        default_threshold = 0.5 if top_k is None else metrics_utils.NEG_INF
+        self.thresholds = metrics_utils.parse_init_thresholds(
+            thresholds, default_threshold=default_threshold
+        )
+        self._thresholds_distributed_evenly = (
+            metrics_utils.is_evenly_distributed_thresholds(self.thresholds)
+        )
+        self.true_positives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="true_positives",
+        )
+        self.false_negatives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="false_negatives",
+        )
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        """Accumulates true positive and false negative statistics.
+
+        Args:
+            y_true: The ground truth values, with the same dimensions as
+                `y_pred`. Will be cast to `bool`.
+            y_pred: The predicted values. Each element must be in the range
+                `[0, 1]`.
+            sample_weight: Optional weighting of each example. Defaults to `1`.
+                Can be a tensor whose rank is either 0, or the same rank as
+                `y_true`, and must be broadcastable to `y_true`.
+        """
+        metrics_utils.update_confusion_matrix_variables(
+            {
+                metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives,  # noqa: E501
+            },
+            y_true,
+            y_pred,
+            thresholds=self.thresholds,
+            thresholds_distributed_evenly=self._thresholds_distributed_evenly,
+            top_k=self.top_k,
+            class_id=self.class_id,
+            sample_weight=sample_weight,
+        )
+
+    def result(self):
+        result = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_negatives + backend.epsilon(),
+        )
+        return result[0] if len(self.thresholds) == 1 else result
+
+    def reset_state(self):
+        num_thresholds = len(to_list(self.thresholds))
+        self.true_positives.assign(ops.zeros((num_thresholds,)))
+        self.false_negatives.assign(ops.zeros((num_thresholds,)))
+
+    def get_config(self):
+        config = {
+            "thresholds": self.init_thresholds,
+            "top_k": self.top_k,
+            "class_id": self.class_id,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+class SensitivitySpecificityBase(Metric):
+    """Abstract base class for computing sensitivity and specificity.
+
+    For additional information about specificity and sensitivity, see
+    [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity).
+    """
+
+    def __init__(
+        self, value, num_thresholds=200, class_id=None, name=None, dtype=None
+    ):
+        super().__init__(name=name, dtype=dtype)
+        if num_thresholds <= 0:
+            raise ValueError(
+                "Argument `num_thresholds` must be an integer > 0. "
+                f"Received: num_thresholds={num_thresholds}"
+            )
+        self.value = value
+        self.class_id = class_id
+
+        # Compute `num_thresholds` thresholds in [0, 1]
+        if num_thresholds == 1:
+            self.thresholds = [0.5]
+            self._thresholds_distributed_evenly = False
+        else:
+            thresholds = [
+                (i + 1) * 1.0 / (num_thresholds - 1)
+                for i in range(num_thresholds - 2)
+            ]
+            self.thresholds = [0.0] + thresholds + [1.0]
+            self._thresholds_distributed_evenly = True
+
+        self.true_positives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="true_positives",
+        )
+        self.false_positives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="false_positives",
+        )
+        self.true_negatives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="true_negatives",
+        )
+        self.false_negatives = self.add_variable(
+            shape=(len(self.thresholds),),
+            initializer=initializers.Zeros(),
+            name="false_negatives",
+        )
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        """Accumulates confusion matrix statistics.
+
+        Args:
+            y_true: The ground truth values.
+            y_pred: The predicted values.
+            sample_weight: Optional weighting of each example. Defaults to `1`.
+                Can be a tensor whose rank is either 0, or the same rank as
+                `y_true`, and must be broadcastable to `y_true`.
+        """
+        metrics_utils.update_confusion_matrix_variables(
+            {
+                metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.TRUE_NEGATIVES: self.true_negatives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives,  # noqa: E501
+            },
+            y_true,
+            y_pred,
+            thresholds=self.thresholds,
+            thresholds_distributed_evenly=self._thresholds_distributed_evenly,
+            class_id=self.class_id,
+            sample_weight=sample_weight,
+        )
+
+    def reset_state(self):
+        num_thresholds = len(self.thresholds)
+        self.true_positives.assign(ops.zeros((num_thresholds,)))
+        self.false_positives.assign(ops.zeros((num_thresholds,)))
+        self.true_negatives.assign(ops.zeros((num_thresholds,)))
+        self.false_negatives.assign(ops.zeros((num_thresholds,)))
+
+    def get_config(self):
+        config = {"class_id": self.class_id}
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+    def _find_max_under_constraint(self, constrained, dependent, predicate):
+        """Returns the maximum of dependent_statistic that satisfies the
+        constraint.
+
+        Args:
+            constrained: Over these values the constraint is specified. A rank-1
+                tensor.
+            dependent: From these values the maximum that satiesfies the
+                constraint is selected. Values in this tensor and in
+                `constrained` are linked by having the same threshold at each
+                position, hence this tensor must have the same shape.
+            predicate: A binary boolean functor to be applied to arguments
+                `constrained` and `self.value`, e.g. `ops.greater`.
+
+        Returns:
+            maximal dependent value, if no value satisfies the constraint 0.0.
+        """
+        feasible = backend.convert_to_numpy(
+            ops.nonzero(predicate(constrained, self.value))
+        )
+
+        print(feasible)
+        feasible_exists = ops.greater(ops.size(feasible), 0)
+        max_dependent = ops.max(ops.take(dependent, feasible), initial=0)
+
+        return ops.where(feasible_exists, max_dependent, 0.0)
+
+
+@keras_core_export("keras_core.metrics.SensitivityAtSpecificity")
+class SensitivityAtSpecificity(SensitivitySpecificityBase):
+    """Computes best sensitivity where specificity is >= specified value.
+
+    `Sensitivity` measures the proportion of actual positives that are correctly
+    identified as such `(tp / (tp + fn))`.
+    `Specificity` measures the proportion of actual negatives that are correctly
+    identified as such `(tn / (tn + fp))`.
+
+    This metric creates four local variables, `true_positives`,
+    `true_negatives`, `false_positives` and `false_negatives` that are used to
+    compute the sensitivity at the given specificity. The threshold for the
+    given specificity value is computed and used to evaluate the corresponding
+    sensitivity.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    If `class_id` is specified, we calculate precision by considering only the
+    entries in the batch for which `class_id` is above the threshold
+    predictions, and computing the fraction of them for which `class_id` is
+    indeed a correct label.
+
+    For additional information about specificity and sensitivity, see
+    [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity).
+
+    Args:
+        specificity: A scalar value in range `[0, 1]`.
+        num_thresholds: (Optional) Defaults to 200. The number of thresholds to
+            use for matching the given specificity.
+        class_id: (Optional) Integer class ID for which we want binary metrics.
+            This must be in the half-open interval `[0, num_classes)`, where
+            `num_classes` is the last dimension of predictions.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.SensitivityAtSpecificity(0.5)
+    >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],
+    ...                sample_weight=[1, 1, 2, 2, 1])
+    >>> m.result()
+    0.333333
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(
+        optimizer='sgd',
+        loss='mse',
+        metrics=[keras_core.metrics.SensitivityAtSpecificity()])
+    ```
+    """
+
+    def __init__(
+        self,
+        specificity,
+        num_thresholds=200,
+        class_id=None,
+        name=None,
+        dtype=None,
+    ):
+        if specificity < 0 or specificity > 1:
+            raise ValueError(
+                "Argument `specificity` must be in the range [0, 1]. "
+                f"Received: specificity={specificity}"
+            )
+        self.specificity = specificity
+        self.num_thresholds = num_thresholds
+        super().__init__(
+            specificity,
+            num_thresholds=num_thresholds,
+            class_id=class_id,
+            name=name,
+            dtype=dtype,
+        )
+
+    def result(self):
+        sensitivities = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_negatives + backend.epsilon(),
+        )
+        specificities = ops.divide(
+            self.true_negatives,
+            self.true_negatives + self.false_positives + backend.epsilon(),
+        )
+        return self._find_max_under_constraint(
+            specificities, sensitivities, ops.greater_equal
+        )
+
+    def get_config(self):
+        config = {
+            "num_thresholds": self.num_thresholds,
+            "specificity": self.specificity,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+@keras_core_export("keras_core.metrics.SpecificityAtSensitivity")
+class SpecificityAtSensitivity(SensitivitySpecificityBase):
+    """Computes best specificity where sensitivity is >= specified value.
+
+    `Sensitivity` measures the proportion of actual positives that are correctly
+    identified as such `(tp / (tp + fn))`.
+    `Specificity` measures the proportion of actual negatives that are correctly
+    identified as such `(tn / (tn + fp))`.
+
+    This metric creates four local variables, `true_positives`,
+    `true_negatives`, `false_positives` and `false_negatives` that are used to
+    compute the specificity at the given sensitivity. The threshold for the
+    given sensitivity value is computed and used to evaluate the corresponding
+    specificity.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    If `class_id` is specified, we calculate precision by considering only the
+    entries in the batch for which `class_id` is above the threshold
+    predictions, and computing the fraction of them for which `class_id` is
+    indeed a correct label.
+
+    For additional information about specificity and sensitivity, see
+    [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity).
+
+    Args:
+        sensitivity: A scalar value in range `[0, 1]`.
+        num_thresholds: (Optional) Defaults to 200. The number of thresholds to
+            use for matching the given sensitivity.
+        class_id: (Optional) Integer class ID for which we want binary metrics.
+            This must be in the half-open interval `[0, num_classes)`, where
+            `num_classes` is the last dimension of predictions.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.SpecificityAtSensitivity(0.5)
+    >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])
+    >>> m.result()
+    0.66666667
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],
+    ...                sample_weight=[1, 1, 2, 2, 2])
+    >>> m.result()
+    0.5
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(
+        optimizer='sgd',
+        loss='mse',
+        metrics=[keras_core.metrics.SpecificityAtSensitivity()])
+    ```
+    """
+
+    def __init__(
+        self,
+        sensitivity,
+        num_thresholds=200,
+        class_id=None,
+        name=None,
+        dtype=None,
+    ):
+        if sensitivity < 0 or sensitivity > 1:
+            raise ValueError(
+                "Argument `sensitivity` must be in the range [0, 1]. "
+                f"Received: sensitivity={sensitivity}"
+            )
+        self.sensitivity = sensitivity
+        self.num_thresholds = num_thresholds
+        super().__init__(
+            sensitivity,
+            num_thresholds=num_thresholds,
+            class_id=class_id,
+            name=name,
+            dtype=dtype,
+        )
+
+    def result(self):
+        sensitivities = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_negatives + backend.epsilon(),
+        )
+        specificities = ops.divide(
+            self.true_negatives,
+            self.true_negatives + self.false_positives + backend.epsilon(),
+        )
+        return self._find_max_under_constraint(
+            sensitivities, specificities, ops.greater_equal
+        )
+
+    def get_config(self):
+        config = {
+            "num_thresholds": self.num_thresholds,
+            "sensitivity": self.sensitivity,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+@keras_core_export("keras_core.metrics.PrecisionAtRecall")
+class PrecisionAtRecall(SensitivitySpecificityBase):
+    """Computes best precision where recall is >= specified value.
+
+    This metric creates four local variables, `true_positives`,
+    `true_negatives`, `false_positives` and `false_negatives` that are used to
+    compute the precision at the given recall. The threshold for the given
+    recall value is computed and used to evaluate the corresponding precision.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    If `class_id` is specified, we calculate precision by considering only the
+    entries in the batch for which `class_id` is above the threshold
+    predictions, and computing the fraction of them for which `class_id` is
+    indeed a correct label.
+
+    Args:
+        recall: A scalar value in range `[0, 1]`.
+        num_thresholds: (Optional) Defaults to 200. The number of thresholds to
+            use for matching the given recall.
+        class_id: (Optional) Integer class ID for which we want binary metrics.
+            This must be in the half-open interval `[0, num_classes)`, where
+            `num_classes` is the last dimension of predictions.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.PrecisionAtRecall(0.5)
+    >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],
+    ...                sample_weight=[2, 2, 2, 1, 1])
+    >>> m.result()
+    0.33333333
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(
+        optimizer='sgd',
+        loss='mse',
+        metrics=[keras_core.metrics.PrecisionAtRecall(recall=0.8)])
+    ```
+    """
+
+    def __init__(
+        self, recall, num_thresholds=200, class_id=None, name=None, dtype=None
+    ):
+        if recall < 0 or recall > 1:
+            raise ValueError(
+                "Argument `recall` must be in the range [0, 1]. "
+                f"Received: recall={recall}"
+            )
+        self.recall = recall
+        self.num_thresholds = num_thresholds
+        super().__init__(
+            value=recall,
+            num_thresholds=num_thresholds,
+            class_id=class_id,
+            name=name,
+            dtype=dtype,
+        )
+
+    def result(self):
+        recalls = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_negatives + backend.epsilon(),
+        )
+        precisions = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_positives + backend.epsilon(),
+        )
+        return self._find_max_under_constraint(
+            recalls, precisions, ops.greater_equal
+        )
+
+    def get_config(self):
+        config = {"num_thresholds": self.num_thresholds, "recall": self.recall}
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+@keras_core_export("keras_core.metrics.RecallAtPrecision")
+class RecallAtPrecision(SensitivitySpecificityBase):
+    """Computes best recall where precision is >= specified value.
+
+    For a given score-label-distribution the required precision might not
+    be achievable, in this case 0.0 is returned as recall.
+
+    This metric creates four local variables, `true_positives`,
+    `true_negatives`, `false_positives` and `false_negatives` that are used to
+    compute the recall at the given precision. The threshold for the given
+    precision value is computed and used to evaluate the corresponding recall.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    If `class_id` is specified, we calculate precision by considering only the
+    entries in the batch for which `class_id` is above the threshold
+    predictions, and computing the fraction of them for which `class_id` is
+    indeed a correct label.
+
+    Args:
+        precision: A scalar value in range `[0, 1]`.
+            num_thresholds: (Optional) Defaults to 200. The number of thresholds
+            to use for matching the given precision.
+        class_id: (Optional) Integer class ID for which we want binary metrics.
+            This must be in the half-open interval `[0, num_classes)`, where
+            `num_classes` is the last dimension of predictions.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.RecallAtPrecision(0.8)
+    >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9])
+    >>> m.result()
+    0.5
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9],
+    ...                sample_weight=[1, 0, 0, 1])
+    >>> m.result()
+    1.0
+
+    Usage with `compile()` API:
+
+    ```python
+    model.compile(
+        optimizer='sgd',
+        loss='mse',
+        metrics=[keras_core.metrics.RecallAtPrecision(precision=0.8)])
+    ```
+    """
+
+    def __init__(
+        self,
+        precision,
+        num_thresholds=200,
+        class_id=None,
+        name=None,
+        dtype=None,
+    ):
+        if precision < 0 or precision > 1:
+            raise ValueError(
+                "Argument `precision` must be in the range [0, 1]. "
+                f"Received: precision={precision}"
+            )
+        self.precision = precision
+        self.num_thresholds = num_thresholds
+        super().__init__(
+            value=precision,
+            num_thresholds=num_thresholds,
+            class_id=class_id,
+            name=name,
+            dtype=dtype,
+        )
+
+    def result(self):
+        recalls = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_negatives + backend.epsilon(),
+        )
+        precisions = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_positives + backend.epsilon(),
+        )
+        return self._find_max_under_constraint(
+            precisions, recalls, ops.greater_equal
+        )
+
+    def get_config(self):
+        config = {
+            "num_thresholds": self.num_thresholds,
+            "precision": self.precision,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+
+@keras_core_export("keras_core.metrics.AUC")
+class AUC(Metric):
+    """Approximates the AUC (Area under the curve) of the ROC or PR curves.
+
+    The AUC (Area under the curve) of the ROC (Receiver operating
+    characteristic; default) or PR (Precision Recall) curves are quality
+    measures of binary classifiers. Unlike the accuracy, and like cross-entropy
+    losses, ROC-AUC and PR-AUC evaluate all the operational points of a model.
+
+    This class approximates AUCs using a Riemann sum. During the metric
+    accumulation phrase, predictions are accumulated within predefined buckets
+    by value. The AUC is then computed by interpolating per-bucket averages.
+    These buckets define the evaluated operational points.
+
+    This metric creates four local variables, `true_positives`,
+    `true_negatives`, `false_positives` and `false_negatives` that are used to
+    compute the AUC.  To discretize the AUC curve, a linearly spaced set of
+    thresholds is used to compute pairs of recall and precision values. The area
+    under the ROC-curve is therefore computed using the height of the recall
+    values by the false positive rate, while the area under the PR-curve is the
+    computed using the height of the precision values by the recall.
+
+    This value is ultimately returned as `auc`, an idempotent operation that
+    computes the area under a discretized curve of precision versus recall
+    values (computed using the aforementioned variables). The `num_thresholds`
+    variable controls the degree of discretization with larger numbers of
+    thresholds more closely approximating the true AUC. The quality of the
+    approximation may vary dramatically depending on `num_thresholds`. The
+    `thresholds` parameter can be used to manually specify thresholds which
+    split the predictions more evenly.
+
+    For a best approximation of the real AUC, `predictions` should be
+    distributed approximately uniformly in the range `[0, 1]` (if
+    `from_logits=False`). The quality of the AUC approximation may be poor if
+    this is not the case. Setting `summation_method` to 'minoring' or 'majoring'
+    can help quantify the error in the approximation by providing lower or upper
+    bound estimate of the AUC.
+
+    If `sample_weight` is `None`, weights default to 1.
+    Use `sample_weight` of 0 to mask values.
+
+    Args:
+        num_thresholds: (Optional) The number of thresholds to
+            use when discretizing the roc curve. Values must be > 1.
+            Defaults to `200`.
+        curve: (Optional) Specifies the name of the curve to be computed,
+            `'ROC'` (default) or `'PR'` for the Precision-Recall-curve.
+        summation_method: (Optional) Specifies the [Riemann summation method](
+              https://en.wikipedia.org/wiki/Riemann_sum) used.
+              'interpolation' (default) applies mid-point summation scheme for
+              `ROC`.  For PR-AUC, interpolates (true/false) positives but not
+              the ratio that is precision (see Davis & Goadrich 2006 for
+              details); 'minoring' applies left summation for increasing
+              intervals and right summation for decreasing intervals; 'majoring'
+              does the opposite.
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+        thresholds: (Optional) A list of floating point values to use as the
+            thresholds for discretizing the curve. If set, the `num_thresholds`
+            parameter is ignored. Values should be in `[0, 1]`. Endpoint
+            thresholds equal to {`-epsilon`, `1+epsilon`} for a small positive
+            epsilon value will be automatically included with these to correctly
+            handle predictions equal to exactly 0 or 1.
+        multi_label: boolean indicating whether multilabel data should be
+            treated as such, wherein AUC is computed separately for each label
+            and then averaged across labels, or (when `False`) if the data
+            should be flattened into a single label before AUC computation. In
+            the latter case, when multilabel data is passed to AUC, each
+            label-prediction pair is treated as an individual data point. Should
+            be set to False for multi-class data.
+        num_labels: (Optional) The number of labels, used when `multi_label` is
+            True. If `num_labels` is not specified, then state variables get
+            created on the first call to `update_state`.
+        label_weights: (Optional) list, array, or tensor of non-negative weights
+            used to compute AUCs for multilabel data. When `multi_label` is
+            True, the weights are applied to the individual label AUCs when they
+            are averaged to produce the multi-label AUC. When it's False, they
+            are used to weight the individual label predictions in computing the
+            confusion matrix on the flattened data. Note that this is unlike
+            `class_weights` in that `class_weights` weights the example
+            depending on the value of its label, whereas `label_weights` depends
+            only on the index of that label before flattening; therefore
+            `label_weights` should not be used for multi-class data.
+        from_logits: boolean indicating whether the predictions (`y_pred` in
+        `update_state`) are probabilities or sigmoid logits. As a rule of thumb,
+        when using a keras loss, the `from_logits` constructor argument of the
+        loss should match the AUC `from_logits` constructor argument.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.AUC(num_thresholds=3)
+    >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9])
+    >>> # threshold values are [0 - 1e-7, 0.5, 1 + 1e-7]
+    >>> # tp = [2, 1, 0], fp = [2, 0, 0], fn = [0, 1, 2], tn = [0, 2, 2]
+    >>> # tp_rate = recall = [1, 0.5, 0], fp_rate = [1, 0, 0]
+    >>> # auc = ((((1 + 0.5) / 2) * (1 - 0)) + (((0.5 + 0) / 2) * (0 - 0)))
+    >>> #     = 0.75
+    >>> m.result()
+    0.75
+
+    >>> m.reset_state()
+    >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9],
+    ...                sample_weight=[1, 0, 0, 1])
+    >>> m.result()
+    1.0
+
+    Usage with `compile()` API:
+
+    ```python
+    # Reports the AUC of a model outputting a probability.
+    model.compile(optimizer='sgd',
+                  loss=keras_core.losses.BinaryCrossentropy(),
+                  metrics=[keras_core.metrics.AUC()])
+
+    # Reports the AUC of a model outputting a logit.
+    model.compile(optimizer='sgd',
+                  loss=keras_core.losses.BinaryCrossentropy(from_logits=True),
+                  metrics=[keras_core.metrics.AUC(from_logits=True)])
+    ```
+    """
+
+    def __init__(
+        self,
+        num_thresholds=200,
+        curve="ROC",
+        summation_method="interpolation",
+        name=None,
+        dtype=None,
+        thresholds=None,
+        multi_label=False,
+        num_labels=None,
+        label_weights=None,
+        from_logits=False,
+    ):
+        # Validate configurations.
+        if isinstance(curve, metrics_utils.AUCCurve) and curve not in list(
+            metrics_utils.AUCCurve
+        ):
+            raise ValueError(
+                f'Invalid `curve` argument value "{curve}". '
+                f"Expected one of: {list(metrics_utils.AUCCurve)}"
+            )
+        if isinstance(
+            summation_method, metrics_utils.AUCSummationMethod
+        ) and summation_method not in list(metrics_utils.AUCSummationMethod):
+            raise ValueError(
+                "Invalid `summation_method` "
+                f'argument value "{summation_method}". '
+                f"Expected one of: {list(metrics_utils.AUCSummationMethod)}"
+            )
+
+        # Update properties.
+        self._init_from_thresholds = thresholds is not None
+        if thresholds is not None:
+            # If specified, use the supplied thresholds.
+            self.num_thresholds = len(thresholds) + 2
+            thresholds = sorted(thresholds)
+            self._thresholds_distributed_evenly = (
+                metrics_utils.is_evenly_distributed_thresholds(
+                    np.array([0.0] + thresholds + [1.0])
+                )
+            )
+        else:
+            if num_thresholds <= 1:
+                raise ValueError(
+                    "Argument `num_thresholds` must be an integer > 1. "
+                    f"Received: num_thresholds={num_thresholds}"
+                )
+
+            # Otherwise, linearly interpolate (num_thresholds - 2) thresholds in
+            # (0, 1).
+            self.num_thresholds = num_thresholds
+            thresholds = [
+                (i + 1) * 1.0 / (num_thresholds - 1)
+                for i in range(num_thresholds - 2)
+            ]
+            self._thresholds_distributed_evenly = True
+
+        # Add an endpoint "threshold" below zero and above one for either
+        # threshold method to account for floating point imprecisions.
+        self._thresholds = np.array(
+            [0.0 - backend.epsilon()] + thresholds + [1.0 + backend.epsilon()]
+        )
+
+        if isinstance(curve, metrics_utils.AUCCurve):
+            self.curve = curve
+        else:
+            self.curve = metrics_utils.AUCCurve.from_str(curve)
+        if isinstance(summation_method, metrics_utils.AUCSummationMethod):
+            self.summation_method = summation_method
+        else:
+            self.summation_method = metrics_utils.AUCSummationMethod.from_str(
+                summation_method
+            )
+        super().__init__(name=name, dtype=dtype)
+
+        # Handle multilabel arguments.
+        self.multi_label = multi_label
+        self.num_labels = num_labels
+        if label_weights is not None:
+            label_weights = ops.array(label_weights, dtype=self.dtype)
+            self.label_weights = label_weights
+
+        else:
+            self.label_weights = None
+
+        self._from_logits = from_logits
+
+        self._built = False
+        if self.multi_label:
+            if num_labels:
+                shape = [None, num_labels]
+                self._build(shape)
+        else:
+            if num_labels:
+                raise ValueError(
+                    "`num_labels` is needed only when `multi_label` is True."
+                )
+            self._build(None)
+
+    @property
+    def thresholds(self):
+        """The thresholds used for evaluating AUC."""
+        return list(self._thresholds)
+
+    def _build(self, shape):
+        """Initialize TP, FP, TN, and FN tensors, given the shape of the
+        data."""
+        if self.multi_label:
+            if len(shape) != 2:
+                raise ValueError(
+                    "`y_pred` must have rank 2 when `multi_label=True`. "
+                    f"Found rank {len(shape)}. "
+                    f"Full shape received for `y_pred`: {shape}"
+                )
+            self._num_labels = shape[1]
+            variable_shape = [self.num_thresholds, self._num_labels]
+        else:
+            variable_shape = [self.num_thresholds]
+
+        self._build_input_shape = shape
+        # Create metric variables
+        self.true_positives = self.add_variable(
+            shape=variable_shape,
+            initializer=initializers.Zeros(),
+            name="true_positives",
+        )
+        self.false_positives = self.add_variable(
+            shape=variable_shape,
+            initializer=initializers.Zeros(),
+            name="false_positives",
+        )
+        self.true_negatives = self.add_variable(
+            shape=variable_shape,
+            initializer=initializers.Zeros(),
+            name="true_negatives",
+        )
+        self.false_negatives = self.add_variable(
+            shape=variable_shape,
+            initializer=initializers.Zeros(),
+            name="false_negatives",
+        )
+
+        self._built = True
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        """Accumulates confusion matrix statistics.
+
+        Args:
+            y_true: The ground truth values.
+            y_pred: The predicted values.
+            sample_weight: Optional weighting of each example. Can
+                be a tensor whose rank is either 0, or the same rank as
+                `y_true`, and must be broadcastable to `y_true`. Defaults to
+                `1`.
+        """
+        if not self._built:
+            self._build(y_pred.shape)
+
+        if self.multi_label or (self.label_weights is not None):
+            # y_true should have shape (number of examples, number of labels).
+            shapes = [(y_true, ("N", "L"))]
+            if self.multi_label:
+                # TP, TN, FP, and FN should all have shape
+                # (number of thresholds, number of labels).
+                shapes.extend(
+                    [
+                        (self.true_positives, ("T", "L")),
+                        (self.true_negatives, ("T", "L")),
+                        (self.false_positives, ("T", "L")),
+                        (self.false_negatives, ("T", "L")),
+                    ]
+                )
+            if self.label_weights is not None:
+                # label_weights should be of length equal to the number of
+                # labels.
+                shapes.append((self.label_weights, ("L",)))
+
+        # Only forward label_weights to update_confusion_matrix_variables when
+        # multi_label is False. Otherwise the averaging of individual label AUCs
+        # is handled in AUC.result
+        label_weights = None if self.multi_label else self.label_weights
+
+        if self._from_logits:
+            y_pred = activations.sigmoid(y_pred)
+
+        metrics_utils.update_confusion_matrix_variables(
+            {
+                metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.TRUE_NEGATIVES: self.true_negatives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives,  # noqa: E501
+                metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives,  # noqa: E501
+            },
+            y_true,
+            y_pred,
+            self._thresholds,
+            thresholds_distributed_evenly=self._thresholds_distributed_evenly,
+            sample_weight=sample_weight,
+            multi_label=self.multi_label,
+            label_weights=label_weights,
+        )
+
+    def interpolate_pr_auc(self):
+        """Interpolation formula inspired by section 4 of Davis & Goadrich 2006.
+
+        https://www.biostat.wisc.edu/~page/rocpr.pdf
+
+        Note here we derive & use a closed formula not present in the paper
+        as follows:
+
+            Precision = TP / (TP + FP) = TP / P
+
+        Modeling all of TP (true positive), FP (false positive) and their sum
+        P = TP + FP (predicted positive) as varying linearly within each
+        interval [A, B] between successive thresholds, we get
+
+            Precision slope = dTP / dP
+                            = (TP_B - TP_A) / (P_B - P_A)
+                            = (TP - TP_A) / (P - P_A)
+            Precision = (TP_A + slope * (P - P_A)) / P
+
+        The area within the interval is (slope / total_pos_weight) times
+
+            int_A^B{Precision.dP} = int_A^B{(TP_A + slope * (P - P_A)) * dP / P}
+            int_A^B{Precision.dP} = int_A^B{slope * dP + intercept * dP / P}
+
+        where intercept = TP_A - slope * P_A = TP_B - slope * P_B, resulting in
+
+            int_A^B{Precision.dP} = TP_B - TP_A + intercept * log(P_B / P_A)
+
+        Bringing back the factor (slope / total_pos_weight) we'd put aside, we
+        get
+
+            slope * [dTP + intercept *  log(P_B / P_A)] / total_pos_weight
+
+        where dTP == TP_B - TP_A.
+
+        Note that when P_A == 0 the above calculation simplifies into
+
+            int_A^B{Precision.dTP} = int_A^B{slope * dTP}
+                                   = slope * (TP_B - TP_A)
+
+        which is really equivalent to imputing constant precision throughout the
+        first bucket having >0 true positives.
+
+        Returns:
+            pr_auc: an approximation of the area under the P-R curve.
+        """
+
+        dtp = (
+            self.true_positives[: self.num_thresholds - 1]
+            - self.true_positives[1:]
+        )
+        p = ops.add(self.true_positives, self.false_positives)
+        dp = p[: self.num_thresholds - 1] - p[1:]
+        prec_slope = ops.divide(dtp, ops.maximum(dp, backend.epsilon()))
+        intercept = self.true_positives[1:] - ops.multiply(prec_slope, p[1:])
+
+        safe_p_ratio = ops.where(
+            ops.logical_and(p[: self.num_thresholds - 1] > 0, p[1:] > 0),
+            ops.divide(
+                p[: self.num_thresholds - 1],
+                ops.maximum(p[1:], backend.epsilon()),
+            ),
+            ops.ones_like(p[1:]),
+        )
+
+        pr_auc_increment = ops.divide(
+            prec_slope * (dtp + intercept * ops.log(safe_p_ratio)),
+            ops.maximum(
+                self.true_positives[1:] + self.false_negatives[1:],
+                backend.epsilon(),
+            ),
+        )
+
+        if self.multi_label:
+            by_label_auc = ops.sum(pr_auc_increment, axis=0)
+            if self.label_weights is None:
+                # Evenly weighted average of the label AUCs.
+                return ops.mean(by_label_auc)
+            else:
+                # Weighted average of the label AUCs.
+                return ops.divide(
+                    ops.sum(ops.multiply(by_label_auc, self.label_weights)),
+                    ops.maximum(ops.sum(self.label_weights), backend.epsilon()),
+                )
+        else:
+            return ops.sum(pr_auc_increment)
+
+    def result(self):
+        if (
+            self.curve == metrics_utils.AUCCurve.PR
+            and self.summation_method
+            == metrics_utils.AUCSummationMethod.INTERPOLATION
+        ):
+            # This use case is different and is handled separately.
+            return self.interpolate_pr_auc()
+
+        # Set `x` and `y` values for the curves based on `curve` config.
+        recall = ops.divide(
+            self.true_positives,
+            ops.maximum(
+                ops.add(self.true_positives, self.false_negatives),
+                backend.epsilon(),
+            ),
+        )
+        if self.curve == metrics_utils.AUCCurve.ROC:
+            fp_rate = ops.divide(
+                self.false_positives,
+                ops.maximum(
+                    ops.add(self.false_positives, self.true_negatives),
+                    backend.epsilon(),
+                ),
+            )
+            x = fp_rate
+            y = recall
+        else:  # curve == 'PR'.
+            precision = ops.divide(
+                self.true_positives,
+                ops.maximum(
+                    ops.add(self.true_positives, self.false_positives),
+                    backend.epsilon(),
+                ),
+            )
+            x = recall
+            y = precision
+
+        # Find the rectangle heights based on `summation_method`.
+        if (
+            self.summation_method
+            == metrics_utils.AUCSummationMethod.INTERPOLATION
+        ):
+            # Note: the case ('PR', 'interpolation') has been handled above.
+            heights = (y[: self.num_thresholds - 1] + y[1:]) / 2.0
+        elif self.summation_method == metrics_utils.AUCSummationMethod.MINORING:
+            heights = ops.minimum(y[: self.num_thresholds - 1], y[1:])
+        # self.summation_method = metrics_utils.AUCSummationMethod.MAJORING:
+        else:
+            heights = ops.maximum(y[: self.num_thresholds - 1], y[1:])
+
+        # Sum up the areas of all the rectangles.
+        if self.multi_label:
+            riemann_terms = ops.multiply(
+                x[: self.num_thresholds - 1] - x[1:], heights
+            )
+            by_label_auc = ops.sum(riemann_terms, axis=0)
+
+            if self.label_weights is None:
+                # Unweighted average of the label AUCs.
+                return ops.mean(by_label_auc)
+            else:
+                # Weighted average of the label AUCs.
+                return ops.divide(
+                    ops.sum(ops.multiply(by_label_auc, self.label_weights)),
+                    ops.maximum(ops.sum(self.label_weights), backend.epsilon()),
+                )
+        else:
+            return ops.sum(
+                ops.multiply(x[: self.num_thresholds - 1] - x[1:], heights)
+            )
+
+    def reset_state(self):
+        if self._built:
+            if self.multi_label:
+                variable_shape = (self.num_thresholds, self._num_labels)
+            else:
+                variable_shape = (self.num_thresholds,)
+
+            self.true_positives.assign(ops.zeros(variable_shape))
+            self.false_positives.assign(ops.zeros(variable_shape))
+            self.true_negatives.assign(ops.zeros(variable_shape))
+            self.false_negatives.assign(ops.zeros(variable_shape))
+
+    def get_config(self):
+        label_weights = self.label_weights
+        config = {
+            "num_thresholds": self.num_thresholds,
+            "curve": self.curve.value,
+            "summation_method": self.summation_method.value,
+            "multi_label": self.multi_label,
+            "num_labels": self.num_labels,
+            "label_weights": label_weights,
+            "from_logits": self._from_logits,
+        }
+        # optimization to avoid serializing a large number of generated
+        # thresholds
+        if self._init_from_thresholds:
+            # We remove the endpoint thresholds as an inverse of how the
+            # thresholds were initialized. This ensures that a metric
+            # initialized from this config has the same thresholds.
+            config["thresholds"] = self.thresholds[1:-1]
+        base_config = super().get_config()
+        return {**base_config, **config}
+

lib/python3.10/site-packages/keras_core/src/metrics/f_score_metrics.py

@@ -0,0 +1,319 @@
+from keras_core.src import backend
+from keras_core.src import initializers
+from keras_core.src import ops
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.metrics.metric import Metric
+
+
+@keras_core_export("keras_core.metrics.FBetaScore")
+class FBetaScore(Metric):
+    """Computes F-Beta score.
+
+    Formula:
+
+    ```python
+    b2 = beta ** 2
+    f_beta_score = (1 + b2) * (precision * recall) / (precision * b2 + recall)
+    ```
+    This is the weighted harmonic mean of precision and recall.
+    Its output range is `[0, 1]`. It works for both multi-class
+    and multi-label classification.
+
+    Args:
+        average: Type of averaging to be performed across per-class results
+            in the multi-class case.
+            Acceptable values are `None`, `"micro"`, `"macro"` and
+            `"weighted"`. Defaults to `None`.
+            If `None`, no averaging is performed and `result()` will return
+            the score for each class.
+            If `"micro"`, compute metrics globally by counting the total
+            true positives, false negatives and false positives.
+            If `"macro"`, compute metrics for each label,
+            and return their unweighted mean.
+            This does not take label imbalance into account.
+            If `"weighted"`, compute metrics for each label,
+            and return their average weighted by support
+            (the number of true instances for each label).
+            This alters `"macro"` to account for label imbalance.
+            It can result in an score that is not between precision and recall.
+        beta: Determines the weight of given to recall
+            in the harmonic mean between precision and recall (see pseudocode
+            equation above). Defaults to `1`.
+        threshold: Elements of `y_pred` greater than `threshold` are
+            converted to be 1, and the rest 0. If `threshold` is
+            `None`, the argmax of `y_pred` is converted to 1, and the rest to 0.
+        name: Optional. String name of the metric instance.
+        dtype: Optional. Data type of the metric result.
+
+    Returns:
+        F-Beta Score: float.
+
+    Example:
+
+    >>> metric = keras_core.metrics.FBetaScore(beta=2.0, threshold=0.5)
+    >>> y_true = np.array([[1, 1, 1],
+    ...                    [1, 0, 0],
+    ...                    [1, 1, 0]], np.int32)
+    >>> y_pred = np.array([[0.2, 0.6, 0.7],
+    ...                    [0.2, 0.6, 0.6],
+    ...                    [0.6, 0.8, 0.0]], np.float32)
+    >>> metric.update_state(y_true, y_pred)
+    >>> result = metric.result()
+    >>> result
+    [0.3846154 , 0.90909094, 0.8333334 ]
+    """
+
+    def __init__(
+        self,
+        average=None,
+        beta=1.0,
+        threshold=None,
+        name="fbeta_score",
+        dtype=None,
+    ):
+        super().__init__(name=name, dtype=dtype)
+
+        if average not in (None, "micro", "macro", "weighted"):
+            raise ValueError(
+                "Invalid `average` argument value. Expected one of: "
+                "{None, 'micro', 'macro', 'weighted'}. "
+                f"Received: average={average}"
+            )
+
+        if not isinstance(beta, float):
+            raise ValueError(
+                "Invalid `beta` argument value. "
+                "It should be a Python float. "
+                f"Received: beta={beta} of type '{type(beta)}'"
+            )
+        if beta <= 0.0:
+            raise ValueError(
+                "Invalid `beta` argument value. "
+                "It should be > 0. "
+                f"Received: beta={beta}"
+            )
+
+        if threshold is not None:
+            if not isinstance(threshold, float):
+                raise ValueError(
+                    "Invalid `threshold` argument value. "
+                    "It should be a Python float. "
+                    f"Received: threshold={threshold} "
+                    f"of type '{type(threshold)}'"
+                )
+            if threshold > 1.0 or threshold <= 0.0:
+                raise ValueError(
+                    "Invalid `threshold` argument value. "
+                    "It should verify 0 < threshold <= 1. "
+                    f"Received: threshold={threshold}"
+                )
+
+        self.average = average
+        self.beta = beta
+        self.threshold = threshold
+        self.axis = None
+        self._built = False
+
+        if self.average != "micro":
+            self.axis = 0
+
+    def _build(self, y_true_shape, y_pred_shape):
+        if len(y_pred_shape) != 2 or len(y_true_shape) != 2:
+            raise ValueError(
+                "FBetaScore expects 2D inputs with shape "
+                "(batch_size, output_dim). Received input "
+                f"shapes: y_pred.shape={y_pred_shape} and "
+                f"y_true.shape={y_true_shape}."
+            )
+        if y_pred_shape[-1] is None or y_true_shape[-1] is None:
+            raise ValueError(
+                "FBetaScore expects 2D inputs with shape "
+                "(batch_size, output_dim), with output_dim fully "
+                "defined (not None). Received input "
+                f"shapes: y_pred.shape={y_pred_shape} and "
+                f"y_true.shape={y_true_shape}."
+            )
+        num_classes = y_pred_shape[-1]
+        if self.average != "micro":
+            init_shape = num_classes
+        else:
+            init_shape = ()
+
+        def _add_zeros_variable(name):
+            return self.add_variable(
+                name=name,
+                shape=init_shape,
+                initializer=initializers.Zeros(),
+                dtype=self.dtype,
+            )
+
+        self.true_positives = _add_zeros_variable("true_positives")
+        self.false_positives = _add_zeros_variable("false_positives")
+        self.false_negatives = _add_zeros_variable("false_negatives")
+        self.intermediate_weights = _add_zeros_variable("intermediate_weights")
+        self._built = True
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        y_true = ops.convert_to_tensor(y_true, dtype=self.dtype)
+        y_pred = ops.convert_to_tensor(y_pred, dtype=self.dtype)
+        if not self._built:
+            self._build(y_true.shape, y_pred.shape)
+
+        if self.threshold is None:
+            threshold = ops.max(y_pred, axis=-1, keepdims=True)
+            # make sure [0, 0, 0] doesn't become [1, 1, 1]
+            # Use abs(x) > eps, instead of x != 0 to check for zero
+            y_pred = ops.logical_and(
+                y_pred >= threshold, ops.abs(y_pred) > 1e-9
+            )
+        else:
+            y_pred = y_pred > self.threshold
+
+        y_pred = ops.cast(y_pred, dtype=self.dtype)
+        y_true = ops.cast(y_true, dtype=self.dtype)
+        if sample_weight is not None:
+            sample_weight = ops.convert_to_tensor(
+                sample_weight, dtype=self.dtype
+            )
+
+        def _weighted_sum(val, sample_weight):
+            if sample_weight is not None:
+                val = ops.multiply(val, ops.expand_dims(sample_weight, 1))
+            return ops.sum(val, axis=self.axis)
+
+        self.true_positives.assign(
+            self.true_positives + _weighted_sum(y_pred * y_true, sample_weight)
+        )
+        self.false_positives.assign(
+            self.false_positives
+            + _weighted_sum(y_pred * (1 - y_true), sample_weight)
+        )
+        self.false_negatives.assign(
+            self.false_negatives
+            + _weighted_sum((1 - y_pred) * y_true, sample_weight)
+        )
+        self.intermediate_weights.assign(
+            self.intermediate_weights + _weighted_sum(y_true, sample_weight)
+        )
+
+    def result(self):
+        precision = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_positives + backend.epsilon(),
+        )
+        recall = ops.divide(
+            self.true_positives,
+            self.true_positives + self.false_negatives + backend.epsilon(),
+        )
+
+        precision = ops.convert_to_tensor(precision, dtype=self.dtype)
+        recall = ops.convert_to_tensor(recall, dtype=self.dtype)
+
+        mul_value = precision * recall
+        add_value = ((self.beta**2) * precision) + recall
+        mean = ops.divide(mul_value, add_value + backend.epsilon())
+        f1_score = mean * (1 + (self.beta**2))
+
+        if self.average == "weighted":
+            weights = ops.divide(
+                self.intermediate_weights,
+                ops.sum(self.intermediate_weights) + backend.epsilon(),
+            )
+            f1_score = ops.sum(f1_score * weights)
+
+        elif self.average is not None:  # [micro, macro]
+            f1_score = ops.mean(f1_score)
+
+        return f1_score
+
+    def get_config(self):
+        """Returns the serializable config of the metric."""
+
+        config = {
+            "name": self.name,
+            "dtype": self.dtype,
+            "average": self.average,
+            "beta": self.beta,
+            "threshold": self.threshold,
+        }
+
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+    def reset_state(self):
+        for v in self.variables:
+            v.assign(ops.zeros(v.shape, dtype=v.dtype))
+
+
+@keras_core_export("keras_core.metrics.F1Score")
+class F1Score(FBetaScore):
+    r"""Computes F-1 Score.
+
+    Formula:
+
+    ```python
+    f1_score = 2 * (precision * recall) / (precision + recall)
+    ```
+    This is the harmonic mean of precision and recall.
+    Its output range is `[0, 1]`. It works for both multi-class
+    and multi-label classification.
+
+    Args:
+        average: Type of averaging to be performed on data.
+            Acceptable values are `None`, `"micro"`, `"macro"`
+            and `"weighted"`. Defaults to `None`.
+            If `None`, no averaging is performed and `result()` will return
+            the score for each class.
+            If `"micro"`, compute metrics globally by counting the total
+            true positives, false negatives and false positives.
+            If `"macro"`, compute metrics for each label,
+            and return their unweighted mean.
+            This does not take label imbalance into account.
+            If `"weighted"`, compute metrics for each label,
+            and return their average weighted by support
+            (the number of true instances for each label).
+            This alters `"macro"` to account for label imbalance.
+            It can result in an score that is not between precision and recall.
+        threshold: Elements of `y_pred` greater than `threshold` are
+            converted to be 1, and the rest 0. If `threshold` is
+            `None`, the argmax of `y_pred` is converted to 1, and the rest to 0.
+        name: Optional. String name of the metric instance.
+        dtype: Optional. Data type of the metric result.
+
+    Returns:
+        F-1 Score: float.
+
+    Example:
+
+    >>> metric = keras_core.metrics.F1Score(threshold=0.5)
+    >>> y_true = np.array([[1, 1, 1],
+    ...                    [1, 0, 0],
+    ...                    [1, 1, 0]], np.int32)
+    >>> y_pred = np.array([[0.2, 0.6, 0.7],
+    ...                    [0.2, 0.6, 0.6],
+    ...                    [0.6, 0.8, 0.0]], np.float32)
+    >>> metric.update_state(y_true, y_pred)
+    >>> result = metric.result()
+    array([0.5      , 0.8      , 0.6666667], dtype=float32)
+    """
+
+    def __init__(
+        self,
+        average=None,
+        threshold=None,
+        name="f1_score",
+        dtype=None,
+    ):
+        super().__init__(
+            average=average,
+            beta=1.0,
+            threshold=threshold,
+            name=name,
+            dtype=dtype,
+        )
+
+    def get_config(self):
+        base_config = super().get_config()
+        del base_config["beta"]
+        return base_config
+

lib/python3.10/site-packages/keras_core/src/metrics/hinge_metrics.py

@@ -0,0 +1,95 @@
+from keras_core.src.api_export import keras_core_export
+from keras_core.src.losses.losses import categorical_hinge
+from keras_core.src.losses.losses import hinge
+from keras_core.src.losses.losses import squared_hinge
+from keras_core.src.metrics import reduction_metrics
+
+
+@keras_core_export("keras_core.metrics.Hinge")
+class Hinge(reduction_metrics.MeanMetricWrapper):
+    """Computes the hinge metric between `y_true` and `y_pred`.
+
+    `y_true` values are expected to be -1 or 1. If binary (0 or 1) labels are
+    provided we will convert them to -1 or 1.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.Hinge()
+    >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
+    >>> m.result()
+    1.3
+    >>> m.reset_state()
+    >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]],
+    ...                sample_weight=[1, 0])
+    >>> m.result()
+    1.1
+    """
+
+    def __init__(self, name="hinge", dtype=None):
+        super().__init__(fn=hinge, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+
+
+@keras_core_export("keras_core.metrics.SquaredHinge")
+class SquaredHinge(reduction_metrics.MeanMetricWrapper):
+    """Computes the hinge metric between `y_true` and `y_pred`.
+
+    `y_true` values are expected to be -1 or 1. If binary (0 or 1) labels are
+    provided we will convert them to -1 or 1.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+
+    >>> m = keras_core.metrics.SquaredHinge()
+    >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
+    >>> m.result()
+    1.86
+    >>> m.reset_state()
+    >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]],
+    ...                sample_weight=[1, 0])
+    >>> m.result()
+    1.46
+    """
+
+    def __init__(self, name="squared_hinge", dtype=None):
+        super().__init__(fn=squared_hinge, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+
+
+@keras_core_export("keras_core.metrics.CategoricalHinge")
+class CategoricalHinge(reduction_metrics.MeanMetricWrapper):
+    """Computes the categorical hinge metric between `y_true` and `y_pred`.
+
+    Args:
+        name: (Optional) string name of the metric instance.
+        dtype: (Optional) data type of the metric result.
+
+    Standalone usage:
+    >>> m = keras_core.metrics.CategoricalHinge()
+    >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
+    >>> m.result().numpy()
+    1.4000001
+    >>> m.reset_state()
+    >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]],
+    ...                sample_weight=[1, 0])
+    >>> m.result()
+    1.2
+    """
+
+    def __init__(self, name="categorical_hinge", dtype=None):
+        super().__init__(fn=categorical_hinge, name=name, dtype=dtype)
+
+    def get_config(self):
+        return {"name": self.name, "dtype": self.dtype}
+