keras-nightly 3.12.0.dev2025082103__py3-none-any.whl → 3.12.0.dev2025082303__py3-none-any.whl

keras/src/applications/mobilenet_v2.py

@@ -369,11 +369,8 @@ def MobileNetV2(
     if weights == "imagenet":
         if include_top:
             model_name = (
-                "mobilenet_v2_weights_tf_dim_ordering_tf_kernels_"
-                + str(float(alpha))
-                + "_"
-                + str(rows)
-                + ".h5"
+                "mobilenet_v2_weights_tf_dim_ordering_tf_kernels"
+                f"_{float(alpha)}_{rows}.h5"
             )
             weight_path = BASE_WEIGHT_PATH + model_name
             weights_path = file_utils.get_file(
@@ -382,11 +379,7 @@ def MobileNetV2(
         else:
             model_name = (
                 "mobilenet_v2_weights_tf_dim_ordering_tf_kernels_"
-                + str(float(alpha))
-                + "_"
-                + str(rows)
-                + "_no_top"
-                + ".h5"
+                f"{float(alpha)}_{rows}_no_top.h5"
             )
             weight_path = BASE_WEIGHT_PATH + model_name
             weights_path = file_utils.get_file(
@@ -419,22 +412,22 @@ def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id):
             padding="same",
             use_bias=False,
             activation=None,
-            name=prefix + "expand",
+            name=f"{prefix}expand",
         )(x)
         x = layers.BatchNormalization(
             axis=channel_axis,
             epsilon=1e-3,
             momentum=0.999,
-            name=prefix + "expand_BN",
+            name=f"{prefix}expand_BN",
         )(x)
-        x = layers.ReLU(6.0, name=prefix + "expand_relu")(x)
+        x = layers.ReLU(6.0, name=f"{prefix}expand_relu")(x)
     else:
         prefix = "expanded_conv_"
 
     # Depthwise 3x3 convolution.
     if stride == 2:
         x = layers.ZeroPadding2D(
-            padding=imagenet_utils.correct_pad(x, 3), name=prefix + "pad"
+            padding=imagenet_utils.correct_pad(x, 3), name=f"{prefix}pad"
         )(x)
     x = layers.DepthwiseConv2D(
         kernel_size=3,
@@ -442,16 +435,16 @@ def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id):
         activation=None,
         use_bias=False,
         padding="same" if stride == 1 else "valid",
-        name=prefix + "depthwise",
+        name=f"{prefix}depthwise",
     )(x)
     x = layers.BatchNormalization(
         axis=channel_axis,
         epsilon=1e-3,
         momentum=0.999,
-        name=prefix + "depthwise_BN",
+        name=f"{prefix}depthwise_BN",
     )(x)
 
-    x = layers.ReLU(6.0, name=prefix + "depthwise_relu")(x)
+    x = layers.ReLU(6.0, name=f"{prefix}depthwise_relu")(x)
 
     # Project with a pointwise 1x1 convolution.
     x = layers.Conv2D(
@@ -460,17 +453,17 @@ def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id):
         padding="same",
         use_bias=False,
         activation=None,
-        name=prefix + "project",
+        name=f"{prefix}project",
     )(x)
     x = layers.BatchNormalization(
         axis=channel_axis,
         epsilon=1e-3,
         momentum=0.999,
-        name=prefix + "project_BN",
+        name=f"{prefix}project_BN",
     )(x)
 
     if in_channels == pointwise_filters and stride == 1:
-        return layers.Add(name=prefix + "add")([inputs, x])
+        return layers.Add(name=f"{prefix}add")([inputs, x])
     return x
 
 

keras/src/applications/mobilenet_v3.py

@@ -385,10 +385,10 @@ def MobileNetV3(
             model_type, "_minimalistic" if minimalistic else "", str(alpha)
         )
         if include_top:
-            file_name = "weights_mobilenet_v3_" + model_name + ".h5"
+            file_name = f"weights_mobilenet_v3_{model_name}.h5"
             file_hash = WEIGHTS_HASHES[model_name][0]
         else:
-            file_name = "weights_mobilenet_v3_" + model_name + "_no_top_v2.h5"
+            file_name = f"weights_mobilenet_v3_{model_name}_no_top_v2.h5"
             file_hash = WEIGHTS_HASHES[model_name][1]
         weights_path = file_utils.get_file(
             file_name,
@@ -570,23 +570,23 @@ def _depth(v, divisor=8, min_value=None):
 
 def _se_block(inputs, filters, se_ratio, prefix):
     x = layers.GlobalAveragePooling2D(
-        keepdims=True, name=prefix + "squeeze_excite_avg_pool"
+        keepdims=True, name=f"{prefix}squeeze_excite_avg_pool"
     )(inputs)
     x = layers.Conv2D(
         _depth(filters * se_ratio),
         kernel_size=1,
         padding="same",
-        name=prefix + "squeeze_excite_conv",
+        name=f"{prefix}squeeze_excite_conv",
     )(x)
-    x = layers.ReLU(name=prefix + "squeeze_excite_relu")(x)
+    x = layers.ReLU(name=f"{prefix}squeeze_excite_relu")(x)
     x = layers.Conv2D(
         filters,
         kernel_size=1,
         padding="same",
-        name=prefix + "squeeze_excite_conv_1",
+        name=f"{prefix}squeeze_excite_conv_1",
     )(x)
     x = hard_sigmoid(x)
-    x = layers.Multiply(name=prefix + "squeeze_excite_mul")([inputs, x])
+    x = layers.Multiply(name=f"{prefix}squeeze_excite_mul")([inputs, x])
     return x
 
 
@@ -605,33 +605,33 @@ def _inverted_res_block(
             kernel_size=1,
             padding="same",
             use_bias=False,
-            name=prefix + "expand",
+            name=f"{prefix}expand",
         )(x)
         x = layers.BatchNormalization(
             axis=channel_axis,
             epsilon=1e-3,
             momentum=0.999,
-            name=prefix + "expand_bn",
+            name=f"{prefix}expand_bn",
         )(x)
         x = activation(x)
 
     if stride == 2:
         x = layers.ZeroPadding2D(
             padding=imagenet_utils.correct_pad(x, kernel_size),
-            name=prefix + "depthwise_pad",
+            name=f"{prefix}depthwise_pad",
         )(x)
     x = layers.DepthwiseConv2D(
         kernel_size,
         strides=stride,
         padding="same" if stride == 1 else "valid",
         use_bias=False,
-        name=prefix + "depthwise",
+        name=f"{prefix}depthwise",
     )(x)
     x = layers.BatchNormalization(
         axis=channel_axis,
         epsilon=1e-3,
         momentum=0.999,
-        name=prefix + "depthwise_bn",
+        name=f"{prefix}depthwise_bn",
     )(x)
     x = activation(x)
 
@@ -643,17 +643,17 @@ def _inverted_res_block(
         kernel_size=1,
         padding="same",
         use_bias=False,
-        name=prefix + "project",
+        name=f"{prefix}project",
     )(x)
     x = layers.BatchNormalization(
         axis=channel_axis,
         epsilon=1e-3,
         momentum=0.999,
-        name=prefix + "project_bn",
+        name=f"{prefix}project_bn",
     )(x)
 
     if stride == 1 and infilters == filters:
-        x = layers.Add(name=prefix + "add")([shortcut, x])
+        x = layers.Add(name=f"{prefix}add")([shortcut, x])
     return x
 
 

keras/src/applications/nasnet.py

@@ -11,10 +11,10 @@ from keras.src.utils import file_utils
 BASE_WEIGHTS_PATH = (
     "https://storage.googleapis.com/tensorflow/keras-applications/nasnet/"
 )
-NASNET_MOBILE_WEIGHT_PATH = BASE_WEIGHTS_PATH + "NASNet-mobile.h5"
-NASNET_MOBILE_WEIGHT_PATH_NO_TOP = BASE_WEIGHTS_PATH + "NASNet-mobile-no-top.h5"
-NASNET_LARGE_WEIGHT_PATH = BASE_WEIGHTS_PATH + "NASNet-large.h5"
-NASNET_LARGE_WEIGHT_PATH_NO_TOP = BASE_WEIGHTS_PATH + "NASNet-large-no-top.h5"
+NASNET_MOBILE_WEIGHT_PATH = f"{BASE_WEIGHTS_PATH}NASNet-mobile.h5"
+NASNET_MOBILE_WEIGHT_PATH_NO_TOP = f"{BASE_WEIGHTS_PATH}NASNet-mobile-no-top.h5"
+NASNET_LARGE_WEIGHT_PATH = f"{BASE_WEIGHTS_PATH}NASNet-large.h5"
+NASNET_LARGE_WEIGHT_PATH_NO_TOP = f"{BASE_WEIGHTS_PATH}NASNet-large-no-top.h5"
 
 
 def NASNet(
@@ -137,10 +137,9 @@ def NASNet(
         and weights == "imagenet"
     ):
         raise ValueError(
-            "When specifying the input shape of a NASNet"
-            " and loading `ImageNet` weights, "
-            "the input_shape argument must be static "
-            "(no None entries). Got: `input_shape=" + str(input_shape) + "`."
+            "When specifying the input shape of a NASNet and loading "
+            "`ImageNet` weights, the input_shape argument must be static"
+            f" (no None entries). Got: `input_shape={input_shape}`."
         )
 
     if default_size is None:

keras/src/applications/resnet.py

@@ -196,16 +196,16 @@ def ResNet(
     # Load weights.
     if (weights == "imagenet") and (weights_name in WEIGHTS_HASHES):
         if include_top:
-            file_name = weights_name + "_weights_tf_dim_ordering_tf_kernels.h5"
+            file_name = f"{weights_name}_weights_tf_dim_ordering_tf_kernels.h5"
             file_hash = WEIGHTS_HASHES[weights_name][0]
         else:
             file_name = (
-                weights_name + "_weights_tf_dim_ordering_tf_kernels_notop.h5"
+                f"{weights_name}_weights_tf_dim_ordering_tf_kernels_notop.h5"
             )
             file_hash = WEIGHTS_HASHES[weights_name][1]
         weights_path = file_utils.get_file(
             file_name,
-            BASE_WEIGHTS_PATH + file_name,
+            f"{BASE_WEIGHTS_PATH}{file_name}",
             cache_subdir="models",
             file_hash=file_hash,
         )
@@ -241,35 +241,35 @@ def residual_block_v1(
 
     if conv_shortcut:
         shortcut = layers.Conv2D(
-            4 * filters, 1, strides=stride, name=name + "_0_conv"
+            4 * filters, 1, strides=stride, name=f"{name}_0_conv"
         )(x)
         shortcut = layers.BatchNormalization(
-            axis=bn_axis, epsilon=1.001e-5, name=name + "_0_bn"
+            axis=bn_axis, epsilon=1.001e-5, name=f"{name}_0_bn"
         )(shortcut)
     else:
         shortcut = x
 
-    x = layers.Conv2D(filters, 1, strides=stride, name=name + "_1_conv")(x)
+    x = layers.Conv2D(filters, 1, strides=stride, name=f"{name}_1_conv")(x)
     x = layers.BatchNormalization(
-        axis=bn_axis, epsilon=1.001e-5, name=name + "_1_bn"
+        axis=bn_axis, epsilon=1.001e-5, name=f"{name}_1_bn"
     )(x)
-    x = layers.Activation("relu", name=name + "_1_relu")(x)
+    x = layers.Activation("relu", name=f"{name}_1_relu")(x)
 
     x = layers.Conv2D(
-        filters, kernel_size, padding="SAME", name=name + "_2_conv"
+        filters, kernel_size, padding="SAME", name=f"{name}_2_conv"
     )(x)
     x = layers.BatchNormalization(
-        axis=bn_axis, epsilon=1.001e-5, name=name + "_2_bn"
+        axis=bn_axis, epsilon=1.001e-5, name=f"{name}_2_bn"
     )(x)
-    x = layers.Activation("relu", name=name + "_2_relu")(x)
+    x = layers.Activation("relu", name=f"{name}_2_relu")(x)
 
-    x = layers.Conv2D(4 * filters, 1, name=name + "_3_conv")(x)
+    x = layers.Conv2D(4 * filters, 1, name=f"{name}_3_conv")(x)
     x = layers.BatchNormalization(
-        axis=bn_axis, epsilon=1.001e-5, name=name + "_3_bn"
+        axis=bn_axis, epsilon=1.001e-5, name=f"{name}_3_bn"
     )(x)
 
-    x = layers.Add(name=name + "_add")([shortcut, x])
-    x = layers.Activation("relu", name=name + "_out")(x)
+    x = layers.Add(name=f"{name}_add")([shortcut, x])
+    x = layers.Activation("relu", name=f"{name}_out")(x)
     return x
 
 
@@ -287,10 +287,10 @@ def stack_residual_blocks_v1(x, filters, blocks, stride1=2, name=None):
         Output tensor for the stacked blocks.
     """
 
-    x = residual_block_v1(x, filters, stride=stride1, name=name + "_block1")
+    x = residual_block_v1(x, filters, stride=stride1, name=f"{name}_block1")
     for i in range(2, blocks + 1):
         x = residual_block_v1(
-            x, filters, conv_shortcut=False, name=name + "_block" + str(i)
+            x, filters, conv_shortcut=False, name=f"{name}_block{i}"
         )
     return x
 
@@ -319,13 +319,13 @@ def residual_block_v2(
         bn_axis = 1
 
     preact = layers.BatchNormalization(
-        axis=bn_axis, epsilon=1.001e-5, name=name + "_preact_bn"
+        axis=bn_axis, epsilon=1.001e-5, name=f"{name}_preact_bn"
     )(x)
-    preact = layers.Activation("relu", name=name + "_preact_relu")(preact)
+    preact = layers.Activation("relu", name=f"{name}_preact_relu")(preact)
 
     if conv_shortcut:
         shortcut = layers.Conv2D(
-            4 * filters, 1, strides=stride, name=name + "_0_conv"
+            4 * filters, 1, strides=stride, name=f"{name}_0_conv"
         )(preact)
     else:
         shortcut = (
@@ -333,28 +333,28 @@ def residual_block_v2(
         )
 
     x = layers.Conv2D(
-        filters, 1, strides=1, use_bias=False, name=name + "_1_conv"
+        filters, 1, strides=1, use_bias=False, name=f"{name}_1_conv"
     )(preact)
     x = layers.BatchNormalization(
-        axis=bn_axis, epsilon=1.001e-5, name=name + "_1_bn"
+        axis=bn_axis, epsilon=1.001e-5, name=f"{name}_1_bn"
     )(x)
-    x = layers.Activation("relu", name=name + "_1_relu")(x)
+    x = layers.Activation("relu", name=f"{name}_1_relu")(x)
 
-    x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=name + "_2_pad")(x)
+    x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=f"{name}_2_pad")(x)
     x = layers.Conv2D(
         filters,
         kernel_size,
         strides=stride,
         use_bias=False,
-        name=name + "_2_conv",
+        name=f"{name}_2_conv",
     )(x)
     x = layers.BatchNormalization(
-        axis=bn_axis, epsilon=1.001e-5, name=name + "_2_bn"
+        axis=bn_axis, epsilon=1.001e-5, name=f"{name}_2_bn"
     )(x)
-    x = layers.Activation("relu", name=name + "_2_relu")(x)
+    x = layers.Activation("relu", name=f"{name}_2_relu")(x)
 
-    x = layers.Conv2D(4 * filters, 1, name=name + "_3_conv")(x)
-    x = layers.Add(name=name + "_out")([shortcut, x])
+    x = layers.Conv2D(4 * filters, 1, name=f"{name}_3_conv")(x)
+    x = layers.Add(name=f"{name}_out")([shortcut, x])
     return x
 
 
@@ -372,11 +372,11 @@ def stack_residual_blocks_v2(x, filters, blocks, stride1=2, name=None):
         Output tensor for the stacked blocks.
     """
 
-    x = residual_block_v2(x, filters, conv_shortcut=True, name=name + "_block1")
+    x = residual_block_v2(x, filters, conv_shortcut=True, name=f"{name}_block1")
     for i in range(2, blocks):
-        x = residual_block_v2(x, filters, name=name + "_block" + str(i))
+        x = residual_block_v2(x, filters, name=f"{name}_block{i}")
     x = residual_block_v2(
-        x, filters, stride=stride1, name=name + "_block" + str(blocks)
+        x, filters, stride=stride1, name=f"{name}_block{str(blocks)}"
     )
     return x
 

keras/src/applications/xception.py

@@ -212,40 +212,40 @@ def Xception(
 
     for i in range(8):
         residual = x
-        prefix = "block" + str(i + 5)
+        prefix = f"block{i + 5}"
 
-        x = layers.Activation("relu", name=prefix + "_sepconv1_act")(x)
+        x = layers.Activation("relu", name=f"{prefix}_sepconv1_act")(x)
         x = layers.SeparableConv2D(
             728,
             (3, 3),
             padding="same",
             use_bias=False,
-            name=prefix + "_sepconv1",
+            name=f"{prefix}_sepconv1",
         )(x)
         x = layers.BatchNormalization(
-            axis=channel_axis, name=prefix + "_sepconv1_bn"
+            axis=channel_axis, name=f"{prefix}_sepconv1_bn"
         )(x)
-        x = layers.Activation("relu", name=prefix + "_sepconv2_act")(x)
+        x = layers.Activation("relu", name=f"{prefix}_sepconv2_act")(x)
         x = layers.SeparableConv2D(
             728,
             (3, 3),
             padding="same",
             use_bias=False,
-            name=prefix + "_sepconv2",
+            name=f"{prefix}_sepconv2",
         )(x)
         x = layers.BatchNormalization(
-            axis=channel_axis, name=prefix + "_sepconv2_bn"
+            axis=channel_axis, name=f"{prefix}_sepconv2_bn"
         )(x)
-        x = layers.Activation("relu", name=prefix + "_sepconv3_act")(x)
+        x = layers.Activation("relu", name=f"{prefix}_sepconv3_act")(x)
         x = layers.SeparableConv2D(
             728,
             (3, 3),
             padding="same",
             use_bias=False,
-            name=prefix + "_sepconv3",
+            name=f"{prefix}_sepconv3",
         )(x)
         x = layers.BatchNormalization(
-            axis=channel_axis, name=prefix + "_sepconv3_bn"
+            axis=channel_axis, name=f"{prefix}_sepconv3_bn"
         )(x)
 
         x = layers.add([x, residual])

keras/src/backend/common/dtypes.py

@@ -225,11 +225,11 @@ def _resolve_weak_type(dtype, precision="32"):
     if dtype_indicator == "b":
         return "bool"
     elif dtype_indicator == "i":
-        return "int" + precision
+        return f"int{precision}"
     elif dtype_indicator == "u":
-        return "uint" + precision
+        return f"uint{precision}"
     else:
-        return "float" + precision
+        return f"float{precision}"
 
 
 BIT64_TO_BIT16_DTYPE = {
@@ -244,6 +244,7 @@ BIT64_TO_BIT32_DTYPE = {
     "int64": "int32",
     "uint64": "uint32",
     "float64": "float32",
+    "complex128": "complex64",
 }
 
 
@@ -275,6 +276,10 @@ def _lattice_result_type(*args):
     precision = config.floatx()[-2:]
     if out_weak_type:
         out_dtype = _resolve_weak_type(out_dtype, precision=precision)
+
+    # Force to be 32-bit dtype when encountering 64-bit dtype.
+    # TODO(hongyu): Add a config to enable 64-bit dtypes.
+    out_dtype = BIT64_TO_BIT32_DTYPE.get(out_dtype, out_dtype)
     return out_dtype
 
 

keras/src/backend/common/variables.py

@@ -1,3 +1,5 @@
+import os.path
+
 import numpy as np
 
 from keras.src import backend
@@ -142,7 +144,7 @@ class Variable:
         self._name = name
         parent_path = current_path()
         if parent_path:
-            self._path = current_path() + "/" + name
+            self._path = os.path.join(current_path(), name)
         else:
             self._path = name
         self._shape = None

keras/src/backend/jax/export.py

@@ -159,7 +159,7 @@ class JaxExportArchive:
                     poly_shape.append("batch")
                 else:
                     poly_shape.append(next(dim_names))
-            return "(" + ", ".join(poly_shape) + ")"
+            return f"({', '.join(poly_shape)})"
 
         return tree.map_structure(convert_shape, struct)
 

keras/src/backend/jax/numpy.py

@@ -58,6 +58,12 @@ def heaviside(x1, x2):
     return jnp.heaviside(x1, x2)
 
 
+def hypot(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.hypot(x1, x2)
+
+
 def kaiser(x, beta):
     x = convert_to_tensor(x)
     return cast(jnp.kaiser(x, beta), config.floatx())

keras/src/backend/jax/trainer.py

@@ -504,7 +504,7 @@ class JAXTrainer(base_trainer.Trainer):
                         _use_cached_eval_dataset=True,
                     )
                     val_logs = {
-                        "val_" + name: val for name, val in val_logs.items()
+                        f"val_{name}": val for name, val in val_logs.items()
                     }
                     epoch_logs.update(val_logs)
 

keras/src/backend/numpy/numpy.py

@@ -372,6 +372,9 @@ def bincount(x, weights=None, minlength=0, sparse=False):
 def bitwise_and(x, y):
     x = convert_to_tensor(x)
     y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = x.astype(dtype)
+    y = y.astype(dtype)
     return np.bitwise_and(x, y)
 
 
@@ -387,12 +390,18 @@ def bitwise_not(x):
 def bitwise_or(x, y):
     x = convert_to_tensor(x)
     y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = x.astype(dtype)
+    y = y.astype(dtype)
     return np.bitwise_or(x, y)
 
 
 def bitwise_xor(x, y):
     x = convert_to_tensor(x)
     y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = x.astype(dtype)
+    y = y.astype(dtype)
     return np.bitwise_xor(x, y)
 
 
@@ -400,6 +409,9 @@ def bitwise_left_shift(x, y):
     x = convert_to_tensor(x)
     if not isinstance(y, int):
         y = convert_to_tensor(y)
+        dtype = dtypes.result_type(x.dtype, y.dtype)
+        x = x.astype(dtype)
+        y = y.astype(dtype)
     return np.left_shift(x, y)
 
 
@@ -411,6 +423,9 @@ def bitwise_right_shift(x, y):
     x = convert_to_tensor(x)
     if not isinstance(y, int):
         y = convert_to_tensor(y)
+        dtype = dtypes.result_type(x.dtype, y.dtype)
+        x = x.astype(dtype)
+        y = y.astype(dtype)
     return np.right_shift(x, y)
 
 
@@ -665,6 +680,19 @@ def hstack(xs):
     return np.hstack(xs)
 
 
+def hypot(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    if dtype in ["int8", "int16", "int32", "uint8", "uint16", "uint32"]:
+        dtype = config.floatx()
+    elif dtype in ["int64"]:
+        dtype = "float64"
+
+    return np.hypot(x1, x2).astype(dtype)
+
+
 def identity(n, dtype=None):
     dtype = dtype or config.floatx()
     return np.identity(n, dtype=dtype)

keras/src/backend/openvino/numpy.py

@@ -687,7 +687,7 @@ def diff(a, n=1, axis=-1):
     if n == 0:
         return OpenVINOKerasTensor(get_ov_output(a))
     if n < 0:
-        raise ValueError("order must be non-negative but got " + repr(n))
+        raise ValueError(f"order must be non-negative but got {repr(n)}")
     a = get_ov_output(a)
     a_type = a.get_element_type()
     if isinstance(a, np.ndarray):
@@ -902,6 +902,10 @@ def hstack(xs):
     return OpenVINOKerasTensor(ov_opset.concat(elems, axis).output(0))
 
 
+def hypot(x1, x2):
+    raise NotImplementedError("`hypot` is not supported with openvino backend")
+
+
 def identity(n, dtype=None):
     n = get_ov_output(n)
     dtype = Type.f32 if dtype is None else dtype

keras/src/backend/tensorflow/numpy.py

@@ -1559,6 +1559,28 @@ def hstack(xs):
     return tf.concat(xs, axis=1)
 
 
+def hypot(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    if dtype in ["int8", "int16", "int32", "uint8", "uint16", "uint32"]:
+        dtype = config.floatx()
+    elif dtype in ["int64"]:
+        dtype = "float64"
+
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+
+    x1_abs = tf.abs(x1)
+    x2_abs = tf.abs(x2)
+    max_val = tf.maximum(x1_abs, x2_abs)
+    min_val = tf.minimum(x1_abs, x2_abs)
+
+    ratio = tf.math.divide_no_nan(min_val, max_val)
+    return max_val * tf.sqrt(1.0 + tf.square(ratio))
+
+
 def identity(n, dtype=None):
     return eye(N=n, M=n, dtype=dtype)