feat: manual dtype casting removal

ivy/functional/backends/paddle/activations.py

@@ -14,35 +14,27 @@
 # local
 import ivy.functional.backends.paddle as paddle_backend
 import ivy
-from ivy.func_wrapper import with_unsupported_device_and_dtypes
+from ivy.func_wrapper import (
+    with_unsupported_device_and_dtypes,
+    with_supported_dtypes,
+    with_supported_device_and_dtypes,
+)
 from . import backend_version
 
 
-unsupported_dtypes = [
-    paddle.int8,
-    paddle.int16,
-    paddle.int32,
-    paddle.int64,
-    paddle.uint8,
-    paddle.float16,
-    paddle.complex64,
-    paddle.complex128,
-    paddle.bool,
-]
-
-
-def relu(
-    x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None
-) -> paddle.Tensor:
-    if x.dtype in unsupported_dtypes:
-        if paddle.is_complex(x):
-            return paddle.complex(F.relu(x.real()), F.relu(x.imag()))
-        return F.relu(x.cast("float32")).cast(x.dtype)
+@with_supported_dtypes(
+    {"2.5.1 and below": ("float32", "float64", "complex")},
+    backend_version,
+)
+def relu(x: paddle.Tensor, /, *, out: Optional[paddle.Tensor] = None) -> paddle.Tensor:
+    if paddle.is_complex(x):
+        return paddle.complex(F.relu(x.real()), F.relu(x.imag()))
     return F.relu(x)
 
 
-@with_unsupported_device_and_dtypes(
-    {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version
+@with_supported_device_and_dtypes(
+    {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}},
+    backend_version,
 )
 def leaky_relu(
     x: paddle.Tensor,
@@ -52,18 +44,17 @@ def leaky_relu(
     complex_mode="jax",
     out: Optional[paddle.Tensor] = None,
 ) -> paddle.Tensor:
-    if x.dtype in unsupported_dtypes:
-        if paddle.is_complex(x):
-            return paddle.complex(
-                F.leaky_relu(x.real(), negative_slope=alpha),
-                F.leaky_relu(x.imag(), negative_slope=alpha),
-            )
-        return F.leaky_relu(x.cast("float32"), negative_slope=alpha).cast(x.dtype)
+    if paddle.is_complex(x):
+        return paddle.complex(
+            F.leaky_relu(x.real(), negative_slope=alpha),
+            F.leaky_relu(x.imag(), negative_slope=alpha),
+        )
     return F.leaky_relu(x, negative_slope=alpha)
 
 
-@with_unsupported_device_and_dtypes(
-    {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version
+@with_supported_device_and_dtypes(
+    {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}},
+    backend_version,
 )
 def gelu(
     x: paddle.Tensor,
@@ -82,26 +73,23 @@ def gelu(
             * x
             * (1 + paddle_backend.tanh(sqrt_2_over_pi * (x + 0.044715 * x * x * x)))
         )
-    if x.dtype in unsupported_dtypes:
-        return F.gelu(x.cast("float32"), approximate=approximate).cast(x.dtype)
     return F.gelu(x, approximate=approximate)
 
 
-@with_unsupported_device_and_dtypes(
-    {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version
+@with_supported_device_and_dtypes(
+    {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}},
+    backend_version,
 )
 def sigmoid(
     x: paddle.Tensor, /, *, complex_mode="jax", out: Optional[paddle.Tensor] = None
 ) -> paddle.Tensor:
     if paddle.is_complex(x):
         return 1.0 / (1.0 + paddle_backend.exp(-x))
-    if x.dtype in unsupported_dtypes:
-        return F.sigmoid(x.cast("float32")).cast(x.dtype)
     return F.sigmoid(x)
 
 
 @with_unsupported_device_and_dtypes(
-    {"2.5.2 and below": {"cpu": ("float16", "bfloat16")}}, backend_version
+    {"2.5.2 and below": {"cpu": ("bfloat16", "float16")}}, backend_version
 )
 def softmax(
     x: paddle.Tensor,
@@ -183,8 +171,9 @@ def log_softmax(
     return ret
 
 
-@with_unsupported_device_and_dtypes(
-    {"2.5.2 and below": {"cpu": ("bfloat16",)}}, backend_version
+@with_supported_device_and_dtypes(
+    {"2.5.2 and below": {"cpu": ("float32", "float64", "complex")}},
+    backend_version,
 )
 def mish(
     x: paddle.Tensor,
@@ -193,10 +182,8 @@ def mish(
     complex_mode: Literal["split", "magnitude", "jax"] = "jax",
     out: Optional[paddle.Tensor] = None,
 ) -> paddle.Tensor:
-    if x.dtype in unsupported_dtypes:
-        if paddle.is_complex(x):
-            return x * paddle_backend.tanh(paddle_backend.log1p(paddle_backend.exp(x)))
-        return F.mish(x.cast("float32")).cast(x.dtype)
+    if paddle.is_complex(x):
+        return x * paddle_backend.tanh(paddle_backend.log1p(paddle_backend.exp(x)))
     return F.mish(x)
 
 

ivy/functional/backends/paddle/data_type.py

@@ -5,7 +5,9 @@
 import ivy.functional.backends.paddle as paddle_backend
 import numpy as np
 import ivy
+from ivy.func_wrapper import with_unsupported_dtypes
 from ivy.functional.ivy.data_type import _handle_nestable_dtype_info
+from . import backend_version
 
 
 ivy_dtype_dict = {
@@ -139,6 +141,18 @@ def broadcast_arrays(*arrays: paddle.Tensor) -> List[paddle.Tensor]:
     return result
 
 
+@with_unsupported_dtypes(
+    {
+        "2.5.1 and below": (
+            "uint8",
+            "int8",
+            "int16",
+            "float16",
+            "bfloat16",
+        )
+    },
+    backend_version,
+)
 def broadcast_to(
     x: paddle.Tensor,
     /,
@@ -157,15 +171,7 @@ def broadcast_to(
     if x.ndim > len(shape):
         x = x.reshape([-1])
 
-    if x.dtype in [
-        paddle.int8,
-        paddle.int16,
-        paddle.uint8,
-        paddle.float16,
-        paddle.bfloat16,
-    ]:
-        return paddle.broadcast_to(x.cast("float32"), shape).cast(x.dtype)
-    elif x.dtype in [paddle.complex64, paddle.complex128]:
+    if x.dtype in [paddle.complex64, paddle.complex128]:
         x_real = paddle.broadcast_to(x.real(), shape)
         x_imag = paddle.broadcast_to(x.imag(), shape)
         return paddle.complex(x_real, x_imag)