added erf op to math.py

keras_core/backend/jax/math.py

@@ -248,3 +248,7 @@ def istft(
 
 def rsqrt(x):
     return jax.lax.rsqrt(x)
+
+
+def erf(x):
+    return jnp.erf(x)

keras_core/backend/numpy/math.py

@@ -302,3 +302,7 @@ def istft(
 
 def rsqrt(x):
     return 1.0 / np.sqrt(x)
+
+
+def erf(x):
+    return scipy.special.erf(x)

keras_core/backend/tensorflow/math.py

@@ -239,3 +239,7 @@ def istft(
 
 def rsqrt(x):
     return tf.math.rsqrt(x)
+
+
+def erf(x):
+    return tf.math.erf(x)

keras_core/backend/torch/math.py

@@ -408,3 +408,9 @@ def istft(
 def rsqrt(x):
     x = convert_to_tensor(x)
     return torch.rsqrt(x)
+
+
+def erf(x):
+    if not isinstance(x, torch.Tensor):
+        x = torch.tensor(x)
+    return torch.erf(x)

keras_core/ops/math.py

@@ -929,3 +929,41 @@ def rsqrt(x):
         return Rsqrt().symbolic_call(x)
     x = backend.convert_to_tensor(x)
     return backend.math.rsqrt(x)
+
+
+class Erf(Operation):
+    """Computes the error function of x element-wise.
+
+    Args:
+        input_tensor: A tensor of type `float32` or `float64`.
+
+    Returns:
+        A tensor of the same shape and type as `input_tensor`.
+
+    Examples:
+
+    # Basic usage
+    >>> x = np.array([-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0])
+    >>> y = Erf()(x)
+    # Using `float32` data type
+    >>> x_float32 = np.array([-3.0, -2.0], dtype=np.float32)
+    >>> y_float32 = Erf()(x_float32)
+    # Using large values
+    >>> x_large = np.array([1e10, -1e10])
+    >>> y_large = Erf()(x_large)
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def compute_output_spec(self, input_tensor):
+        return KerasTensor(shape=input_tensor.shape, dtype=input_tensor.dtype)
+
+    def call(self, input_tensor):
+        return backend.erf(input_tensor)
+
+
+@keras_core_export("keras_core.ops.erf")
+def erf(x):
+    """Functional interface to the `Erf` operation."""
+    return Erf()(x)

keras_core/ops/math_test.py

@@ -835,3 +835,41 @@ def test_rsqrt(self):
         x = np.array([[1, 4, 9], [16, 25, 36]], dtype="float32")
         self.assertAllClose(kmath.rsqrt(x), 1 / np.sqrt(x))
         self.assertAllClose(kmath.Rsqrt()(x), 1 / np.sqrt(x))
+
+    def test_erf_operation_basic(self):
+        # Sample values for testing
+        sample_values = np.array([-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0])
+
+        # Expected output using numpy's approximation of the error function
+        expected_output = (2 / np.sqrt(np.pi)) * np.vectorize(math.erf)(
+            sample_values
+        )
+
+        # Output from the erf operation in keras_core
+        output_from_erf_op = kmath.erf(sample_values).numpy()
+
+        # Assert that the outputs are close
+        self.assertAllClose(expected_output, output_from_erf_op, atol=1e-5)
+
+    def test_erf_operation_dtype(self):
+        # Test for float32 and float64 data types
+        for dtype in [np.float32, np.float64]:
+            sample_values = np.array(
+                [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0], dtype=dtype
+            )
+            expected_output = (2 / np.sqrt(np.pi)) * np.vectorize(math.erf)(
+                sample_values
+            )
+            output_from_erf_op = kmath.erf(sample_values).numpy()
+            self.assertAllClose(expected_output, output_from_erf_op, atol=1e-5)
+
+    def test_erf_operation_edge_cases(self):
+        # Test for edge cases
+        edge_values = np.array([1e10, -1e10, 1e-10, -1e-10], dtype=np.float64)
+        expected_edge_output = (2 / np.sqrt(np.pi)) * np.vectorize(math.erf)(
+            edge_values
+        )
+        output_from_edge_erf_op = kmath.erf(edge_values).numpy()
+        self.assertAllClose(
+            expected_edge_output, output_from_edge_erf_op, atol=1e-5
+        )